X-Git-Url: http://nitlanguage.org diff --git a/src/compiler/java_compiler.nit b/src/compiler/java_compiler.nit index 85613cf..60aea2b 100644 --- a/src/compiler/java_compiler.nit +++ b/src/compiler/java_compiler.nit @@ -25,6 +25,7 @@ module java_compiler import rapid_type_analysis +import transform import frontend redef class ToolContext @@ -35,9 +36,12 @@ redef class ToolContext # Where to output tmp files var opt_compile_dir = new OptionString("Directory used to generate temporary files", "--compile-dir") + # Compile using ant instead of make (faster, but no error display) + var opt_ant = new OptionBool("Batch with ant (faster, but no error display)", "--ant") + redef init do super - option_context.add_option(opt_output, opt_compile_dir) + option_context.add_option(opt_output, opt_compile_dir, opt_ant) end end @@ -71,7 +75,11 @@ redef class ModelBuilder time0 = time1 toolcontext.info("*** COMPILING JAVA ***", 1) - build_with_make(compiler, jfiles) + if toolcontext.opt_ant.value then + build_with_ant(compiler, jfiles) + else + build_with_make(compiler, jfiles) + end write_shell_script(compiler) time1 = get_time @@ -82,14 +90,32 @@ redef class ModelBuilder fun write_java_files(compiler: JavaCompiler): Array[String] do var jfiles = new Array[String] for f in compiler.files do - var file = new FileWriter.open("{compiler.compile_dir}/{f.filename}") + var filepath = "{compiler.compile_dir}/{f.filename}" + var file = cache_file(filepath) for line in f.lines do file.write(line) - file.close + close_cache(filepath, file) jfiles.add(f.filename) end return jfiles end + # Cache a file as `{filepath}.tmp` and replace the original if different + private fun cache_file(filepath: String): FileWriter do + if toolcontext.opt_ant.value and filepath.file_exists then + return new FileWriter.open("{filepath}.tmp") + else + return new FileWriter.open(filepath) + end + end + + # Close the writer and move tmp file to original if modified + private fun close_cache(filepath: String, file: FileWriter) do + file.close + if "{filepath}.tmp".file_exists then + sys.system("if ! diff {filepath}.tmp {filepath} > /dev/null; then mv {filepath}.tmp {filepath}; else rm {filepath}.tmp; fi") + end + end + # Compile Java generated files using `make` fun build_with_make(compiler: JavaCompiler, jfiles: Array[String]) do write_manifest(compiler) @@ -106,6 +132,23 @@ redef class ModelBuilder if res != 0 then toolcontext.error(null, "make failed! Error code: {res}.") end + # Compile Java sources using `ant` + fun build_with_ant(compiler: JavaCompiler, jfiles: Array[String]) do + compile_antfile(compiler, jfiles) + var outname = compiler.outname.to_path.filename + var antpath = "{compiler.compile_dir}/{outname}.xml" + self.toolcontext.info("ant jar -f {antpath}", 2) + var res + if self.toolcontext.verbose_level >= 3 then + res = sys.system("ant jar -f {antpath} 2>&1") + else + res = sys.system("ant jar -f {antpath} 2>&1 > /dev/null") + end + if res != 0 then + toolcontext.error(null, "ant compile failed! Error code: {res}.") + end + end + # Write the Makefile used to compile Java generated files into an executable jar fun write_makefile(compiler: JavaCompiler, jfiles: Array[String]) do # list class files from jfiles @@ -136,6 +179,31 @@ redef class ModelBuilder toolcontext.info("Generated makefile: {makename}", 2) end + # The Ant `build.xml` script used to compile build the final jar + fun compile_antfile(compiler: JavaCompiler, jfiles: Array[String]) do + var compile_dir = compiler.compile_dir + var outname = compiler.outname.to_path.filename + var outpath = (sys.getcwd / compiler.outname).simplify_path + var antname = "{compile_dir}/{outname}.xml" + var antfile = new FileWriter.open(antname) + var jname = compiler.mainmodule.jname + antfile.write("") + antfile.write(" ") + antfile.write(" ") + antfile.write(" ") + antfile.write(" ") + antfile.write(" ") + antfile.write(" ") + antfile.write(" ") + antfile.write(" ") + antfile.write(" ") + antfile.write(" ") + antfile.write(" ") + antfile.write("") + antfile.close + toolcontext.info("Generated antfile: {antname}", 2) + end + # Write the Java manifest file private fun write_manifest(compiler: JavaCompiler) do var compile_dir = compiler.compile_dir @@ -217,8 +285,8 @@ class JavaCompiler # compile method structures compile_mmethods_to_java - # TODO compile main - modelbuilder.toolcontext.info("NOT YET IMPLEMENTED", 0) + # compile main + compile_main_function end # Prepare the boxes used to represent Java primitive types @@ -260,6 +328,30 @@ class JavaCompiler end end end + + # Generate Java main that call Sys.main + fun compile_main_function do + var v = new_visitor("{mainmodule.jname}_Main.java") + v.add("public class {mainmodule.jname}_Main \{") + v.add(" public static void main(String[] args) \{") + + var main_type = mainmodule.sys_type + if main_type != null then + var mainmodule = v.compiler.mainmodule + var glob_sys = v.init_instance(main_type) + var main_init = mainmodule.try_get_primitive_method("init", main_type.mclass) + if main_init != null then + v.send(main_init, [glob_sys]) + end + var main_method = mainmodule.try_get_primitive_method("run", main_type.mclass) or else + mainmodule.try_get_primitive_method("main", main_type.mclass) + if main_method != null then + v.send(main_method, [glob_sys]) + end + end + v.add(" \}") + v.add("\}") + end end # The class visiting the AST @@ -300,6 +392,26 @@ class JavaCompilerVisitor end end + # Return an unique and stable identifier associated with an escapemark + fun escapemark_name(e: nullable EscapeMark): String do + assert e != null + var frame = self.frame + assert frame != null + if frame.escapemark_names.has_key(e) then return frame.escapemark_names[e] + var name = e.name + if name == null then name = "label" + name = get_name(name) + frame.escapemark_names[e] = name + return name + end + + # Insert a C label for associated with an escapemark + fun add_escape_label(e: nullable EscapeMark) do + if e == null then return + if e.escapes.is_empty then return + add("BREAK_{escapemark_name(e)}: ") + end + # Variables handling # Registered variables @@ -414,8 +526,8 @@ class JavaCompilerVisitor res.add(null_instance) continue end - if param.is_vararg and map.vararg_decl > 0 then - var vararg = exprs.sub(j, map.vararg_decl) + if param.is_vararg and args[i].vararg_decl > 0 then + var vararg = exprs.sub(j, args[i].vararg_decl) var elttype = param.mtype var arg = self.vararg_instance(mpropdef, recv, vararg, elttype) res.add(arg) @@ -566,6 +678,11 @@ class JavaCompilerVisitor return res end + # Generate a super call from a method definition + fun supercall(m: MMethodDef, recvtype: MClassType, args: Array[RuntimeVariable]): nullable RuntimeVariable do + return table_send(m, args) + end + # Generate a monomorphic send for the method `m`, the type `t` and the arguments `args` fun monomorphic_send(m: MMethod, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable do assert t isa MClassType @@ -584,6 +701,14 @@ class JavaCompilerVisitor # Compile a statement (if any) fun stmt(nexpr: nullable AExpr) do if nexpr == null then return + if nexpr.mtype == null and not nexpr.is_typed then + # Untyped expression. + # Might mean dead code or invalid code + # so aborts + add_abort("FATAL: bad statement executed.") + return + end + var old = self.current_node current_node = nexpr nexpr.stmt(self) @@ -601,6 +726,19 @@ class JavaCompilerVisitor res = nexpr.expr(self) end + if res == null then + # Untyped expression. + # Might mean dead code or invalid code. + # so aborts + add_abort("FATAL: bad expression executed.") + # and return a placebo result to please the C compiler + if mtype == null then mtype = compiler.mainmodule.object_type + res = null_instance + + self.current_node = old + return res + end + if mtype != null then mtype = anchor(mtype) res = autobox(res, mtype) @@ -610,6 +748,11 @@ class JavaCompilerVisitor return res end + # Alias for `self.expr(nexpr, self.bool_type)` + fun expr_bool(nexpr: AExpr): RuntimeVariable do + return expr(nexpr, compiler.mainmodule.bool_type) + end + # Correctly assign a left and a right value # Boxing and unboxing is performed if required fun assign(left, right: RuntimeVariable) do @@ -641,6 +784,13 @@ class JavaCompilerVisitor # Used by aborts, asserts, casts, etc. fun add_abort(message: String) do add("System.err.print(\"Runtime error: {message}\");") + add_raw_abort + end + + # Abort without displaying the cause. + # + # Used to customizable errors. + private fun add_raw_abort do var node = current_node if node != null then add("System.err.print(\" ({node.location.short_location})\");") @@ -649,6 +799,15 @@ class JavaCompilerVisitor add("System.exit(1);") end + # Add a dynamic cast + fun add_cast(value: RuntimeVariable, mtype: MType) do + var res = type_test(value, mtype) + add("if (!{res}) \{") + add("System.err.print(\"Runtime error: Cast failed. Expected `{mtype.to_s.escape_to_c}`, got `\" + {value}.rtclass.class_name + \"`\");") + add_raw_abort + add("\}") + end + # Types handling # Anchor a type to the main module and the current receiver @@ -706,6 +865,34 @@ class JavaCompilerVisitor return k == interface_kind or t.is_java_primitive end + # Generate a polymorphic subtype test + fun type_test(value: RuntimeVariable, mtype: MType): RuntimeVariable do + add("/* {value.inspect} isa {mtype} */") + var res = self.new_var(compiler.mainmodule.bool_type) + + # check color is in table + var maybenull = (value.mcasttype isa MNullableType or value.mcasttype isa MNullType) + if maybenull then + add("if({value} == null || {value}.is_null()) \{") + add("{res} = true && {mtype isa MNullableType};") + add("\} else \{") + end + if mtype isa MNullableType then mtype = mtype.mtype + var mclass = mtype.as(MClassType).mclass + add("{res} = {value}.rtclass.supers.get(\"{mclass.jname}\") == {mclass.rt_name}.get{mclass.rt_name}();") + if maybenull then + add("\}") + end + return res + end + + # Generate the code required to dynamically check if 2 objects share the same runtime type + fun is_same_type_test(value1, value2: RuntimeVariable): RuntimeVariable do + var res = self.new_var(compiler.mainmodule.bool_type) + add("{res} = {value1}.rtclass == {value2}.rtclass;") + return res + end + # Native instances # Generate an integer value @@ -754,6 +941,189 @@ class JavaCompilerVisitor # TODO return array_instance(varargs, elttype) end + # Nit instances + + # Generate a alloc-instance + init-attributes + fun init_instance(mtype: MClassType): RuntimeVariable do + var rt_name = mtype.mclass.rt_name + var res = new_expr("new RTVal({rt_name}.get{rt_name}())", mtype) + generate_init_attr(self, res, mtype) + return res + end + + # Generate code that initialize the attributes on a new instance + fun generate_init_attr(v: JavaCompilerVisitor, recv: RuntimeVariable, mtype: MClassType) do + var cds = mtype.collect_mclassdefs(v.compiler.mainmodule).to_a + v.compiler.mainmodule.linearize_mclassdefs(cds) + for cd in cds do + for npropdef in v.compiler.modelbuilder.collect_attr_propdef(cd) do + npropdef.init_expr(v, recv) + end + end + end + + # Generate a Nit "is" for two runtime_variables + fun equal_test(value1, value2: RuntimeVariable): RuntimeVariable do + var res = new_var(compiler.mainmodule.bool_type) + if value2.mtype.is_java_primitive and not value1.mtype.is_java_primitive then + var tmp = value1 + value1 = value2 + value2 = tmp + end + if value1.mtype.is_java_primitive then + if value2.mtype == value1.mtype then + add("{res} = {value1} == {value2}; /* == with two primitives */") + else if value2.mtype.is_java_primitive then + add("{res} = true; /* incompatible types {value1.mtype} vs. {value2.mtype}*/") + # else if value1.mtype.is_tagged then + # add("{res} = ({value2} != NULL) && ({autobox(value2, value1.mtype)} == {value1});") + else + var rt_name = value1.mtype.as(MClassType).mclass.rt_name + add("{res} = ({value2} != null) && ({value2}.rtclass == {rt_name}.get{rt_name}());") + add("if ({res}) \{") + add("{res} = ({self.autobox(value2, value1.mtype)} == {value1});") + add("\}") + end + return res + end + var maybe_null = true + var test = new Array[String] + var t1 = value1.mcasttype + if t1 isa MNullableType then + test.add("{value1} != null && !{value1}.is_null()") + t1 = t1.mtype + else + maybe_null = false + end + var t2 = value2.mcasttype + if t2 isa MNullableType then + test.add("{value2} != null && !{value2}.is_null()") + t2 = t2.mtype + else + maybe_null = false + end + + var incompatible = false + var primitive + if t1.is_java_primitive then + primitive = t1 + if t1 == t2 then + # No need to compare class + else if t2.is_java_primitive then + incompatible = true + else if can_be_primitive(value2) then + if t1.is_java_primitive then + self.add("{res} = {value1} == {value2}; /* t1 is primitive and t2 can be */") + return res + end + # if not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then + # test.add("(!{extract_tag(value2)})") + # end + test.add("{value1}.rtclass == {value2}.rtclass") + else + incompatible = true + end + else if t2.is_java_primitive then + primitive = t2 + if can_be_primitive(value1) then + if t2.is_java_primitive then + self.add("{res} = {value1} == {value2}; /* t2 is primitive and t1 can be */") + return res + end + test.add("{value1}.rtclass == {value2}.rtclass") + else + incompatible = true + end + else + primitive = null + end + + if incompatible then + if maybe_null then + self.add("{res} = {value1} == {value2}; /* incompatible types {t1} vs. {t2}; but may be NULL*/") + return res + else + self.add("{res} = false; /* incompatible types {t1} vs. {t2}; cannot be NULL */") + return res + end + end + if primitive != null then + if primitive.is_java_primitive then + self.add("{res} = {value1} == {value2};") + return res + end + test.add("({value1}.value == {value2}.value") + else if can_be_primitive(value1) and can_be_primitive(value2) then + test.add("{value1}.rtclass == {value2}.rtclass") + var s = new Array[String] + for b in compiler.box_kinds do + var rt_name = b.mclass.rt_name + s.add "({value1}.rtclass == {rt_name}.get{rt_name}()) && ({value1}.value.equals({value2}.value))" + if b.mclass.name == "Float" then + s.add "({value1}.rtclass == RTClass_kernel_Float.getRTClass_kernel_Float() && {value1}.rtclass == {value2}.rtclass && Math.abs((double)({value1}.value)) == 0.0 && Math.abs((double)({value2}.value)) == 0.0)" + end + end + if s.is_empty then + self.add("{res} = {value1} == {value2}; /* both can be primitive */") + return res + end + test.add("({s.join(" || ")})") + else + self.add("{res} = {value1} == {value2}; /* no primitives */") + return res + end + self.add("{res} = {value1} == {value2} || ({test.join(" && ")});") + return res + end + + # Attributes + + # Generate a polymorphic attribute is_set test + fun isset_attribute(a: MAttribute, recv: RuntimeVariable): RuntimeVariable do + # TODO self.check_recv_notnull(recv) + var res = new_var(compiler.mainmodule.bool_type) + + # What is the declared type of the attribute? + var mtype = a.intro.static_mtype.as(not null) + var intromclassdef = a.intro.mclassdef + mtype = mtype.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true) + + if mtype isa MNullableType then + add("{res} = true; /* easy isset: {a} on {recv.inspect} */") + return res + end + add("{res} = {recv}.attrs.get(\"{a.jname}\") != null; /* {a} on {recv.inspect} */") + return res + end + + # Generate a polymorphic attribute read + fun read_attribute(a: MAttribute, recv: RuntimeVariable): RuntimeVariable do + # TODO check_recv_notnull(recv) + # TODO compile_check(v) + # What is the declared type of the attribute? + var ret = a.intro.static_mtype.as(not null) + var intromclassdef = a.intro.mclassdef + ret = ret.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true) + + # Check for Uninitialized attribute + if not ret isa MNullableType then check_attribute(a, recv) + + return new_expr("{recv}.attrs.get(\"{a.jname}\")", ret) + end + + # Generate a polymorphic attribute write + fun write_attribute(a: MAttribute, recv: RuntimeVariable, value: RuntimeVariable) do + # TODO check_recv_notnull(recv) + add "{recv}.attrs.put(\"{a.jname}\", {autobox(value, compiler.mainmodule.object_type)});" + end + + # Check uninitialized attribute + fun check_attribute(a: MAttribute, recv: RuntimeVariable) do + add "if({recv}.attrs.get(\"{a.jname}\") == null) \{" + add_abort "Uninitialized attribute {a.name}" + add "\}" + end + # Utils # Display a info message @@ -910,6 +1280,10 @@ class JavaStaticFrame # The label at the end of the property var returnlabel: nullable String = null is writable + + # Labels associated to a each escapemarks. + # Because of inlinings, escape-marks must be associated to their context (the frame) + private var escapemark_names = new HashMap[EscapeMark, String] end redef class Location @@ -927,7 +1301,7 @@ redef class MType # Is the associated Java type a primitive one? # - # ENSURE `result == (java_type != "Object")` + # ENSURE `result == (java_type != "RTVal")` var is_java_primitive: Bool is lazy do return java_type != "RTVal" end @@ -944,7 +1318,7 @@ redef class MClassType return "double" else if mclass.name == "Byte" then return "byte" - else if mclass.name == "NativeString" then + else if mclass.name == "CString" then return "String" else if mclass.name == "NativeArray" then return "Array" @@ -956,7 +1330,7 @@ end redef class MClass # Runtime name - private fun rt_name: String do return "RTClass_{intro.mmodule.jname}_{jname}" + private fun rt_name: String do return "RTClass_{intro_mmodule.jname}_{jname}" # Generate a Java RTClass for a Nit MClass fun compile_to_java(v: JavaCompilerVisitor) do @@ -1053,41 +1427,120 @@ redef class MMethodDef var modelbuilder = v.compiler.modelbuilder var node = modelbuilder.mpropdef2node(self) + var recv = mclassdef.bound_mtype + var arguments = new Array[RuntimeVariable] + var frame = new JavaStaticFrame(v, self, recv, arguments) + v.frame = frame + + var selfvar = v.decl_var("self", recv) + arguments.add(selfvar) + var boxed = v.new_expr("args[0]", v.compiler.mainmodule.object_type) + v.add "{selfvar} = {v.autobox(boxed, recv)};" + + var msignature = self.msignature + var ret = null + if msignature != null then + ret = msignature.return_mtype + if ret != null then + var retvar = v.decl_var("ret", ret) + if ret.name == "Int" then v.add "{retvar} = 0;" + if ret.name == "Float" then v.add "{retvar} = 0.0;" + if ret.name == "Bool" then v.add "{retvar} = false;" + if ret.name == "Char" then v.add "{retvar} = 0;" + if ret.name == "Byte" then v.add "{retvar} = 0;" + frame.returnvar = retvar + end + end + frame.returnlabel = v.get_name("RET_LABEL") + + v.current_node = node if is_abstract then v.add_abort("Abstract method `{mproperty.name}` called on `\" + {selfvar}.rtclass.class_name +\"`") v.add("return null;") return end + v.current_node = null + + v.add("{frame.returnlabel.as(not null)}: \{") if node isa APropdef then - node.compile_to_java(v, self) + node.compile_to_java(v, self, arguments) else if node isa AClassdef then - # TODO compile attributes - v.info("NOT YET IMPLEMENTED attribute handling") + node.compile_to_java(v, self, arguments) else abort end + v.add("\}") + if ret != null then + v.add("return {v.autobox(frame.returnvar.as(not null), v.compiler.mainmodule.object_type)};") + else + v.add("return null;") + end + end +end + +redef class AClassdef + private fun compile_to_java(v: JavaCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable]) do + if mpropdef.mproperty.is_root_init then + if not mpropdef.is_intro then + v.supercall(mpropdef, arguments.first.mtype.as(MClassType), arguments) + end + else + abort + end end end redef class APropdef # Compile that property definition to java code - fun compile_to_java(v: JavaCompilerVisitor, mpropdef: MMethodDef) do + fun compile_to_java(v: JavaCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable]) do v.info("NOT YET IMPLEMENTED {class_name}::compile_to_java") - v.add("return null;") end end redef class AMethPropdef - redef fun compile_to_java(v, mpropdef) do - # TODO Call the implicit super-init + redef fun compile_to_java(v, mpropdef, arguments) do + if mpropdef.msignature != null then + var i = 0 + for mparam in mpropdef.msignature.as(not null).mparameters do + var variable = n_signature.as(not null).n_params[i].variable + if variable == null then continue + var argvar = v.variable(variable) + v.assign(argvar, v.new_expr("args[{i + 1}]", v.compiler.mainmodule.object_type)) + arguments.add(argvar) + i += 1 + end + end + # Call the implicit super-init + var auto_super_inits = self.auto_super_inits + if auto_super_inits != null then + var args = [arguments.first] + for auto_super_init in auto_super_inits do + assert auto_super_init.mproperty != mpropdef.mproperty + args.clear + for i in [0..auto_super_init.msignature.arity+1[ do + args.add(arguments[i]) + end + assert auto_super_init.mproperty != mpropdef.mproperty + v.compile_callsite(auto_super_init, args) + end + end + if auto_super_call then + v.supercall(mpropdef, arguments.first.mtype.as(MClassType), arguments) + end + + compile_inside_to_java(v, mpropdef, arguments) + end + + # Compile the inside of the method body + private fun compile_inside_to_java(v: JavaCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable]) do # Compile intern methods if mpropdef.is_intern then - v.info("NOT YET IMPLEMENTED {class_name}::compile_intern") - # TODO if compile_intern_to_java(v, mpropdef, arguments) then return + if compile_intern_to_java(v, mpropdef, arguments) then return + v.info("NOT YET IMPLEMENTED compile_intern for {mpropdef}") v.ret(v.null_instance) return end @@ -1099,6 +1552,352 @@ redef class AMethPropdef return end end + + # Compile an intern method using Java primitives + fun compile_intern_to_java(v: JavaCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable]): Bool do + var pname = mpropdef.mproperty.name + var cname = mpropdef.mclassdef.mclass.name + var ret = mpropdef.msignature.as(not null).return_mtype + if cname == "Int" then + if pname == "output" then + v.add("System.out.println({arguments[0]});") + v.ret(v.null_instance) + return true + else if pname == "object_id" then + v.ret(arguments.first) + return true + else if pname == "+" then + v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null))) + return true + else if pname == "-" then + v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null))) + return true + else if pname == "unary -" then + v.ret(v.new_expr("-{arguments[0]}", ret.as(not null))) + return true + else if pname == "unary +" then + v.ret(arguments[0]) + return true + else if pname == "*" then + v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null))) + return true + else if pname == "/" then + v.ret(v.new_expr("{arguments[0]} / {arguments[1]}", ret.as(not null))) + return true + else if pname == "%" then + v.ret(v.new_expr("{arguments[0]} % {arguments[1]}", ret.as(not null))) + return true + else if pname == "<<" then + v.ret(v.new_expr("{arguments[0]} << {arguments[1]}", ret.as(not null))) + return true + else if pname == ">>" then + v.ret(v.new_expr("{arguments[0]} >> {arguments[1]}", ret.as(not null))) + return true + else if pname == "==" then + v.ret(v.equal_test(arguments[0], arguments[1])) + return true + else if pname == "!=" then + var res = v.equal_test(arguments[0], arguments[1]) + v.ret(v.new_expr("!{res}", ret.as(not null))) + return true + else if pname == "<" then + v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null))) + return true + else if pname == ">" then + v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null))) + return true + else if pname == "<=" then + v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null))) + return true + else if pname == ">=" then + v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null))) + return true + else if pname == "to_f" then + v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null))) + return true + else if pname == "to_b" then + v.ret(v.new_expr("(byte){arguments[0]}", ret.as(not null))) + return true + else if pname == "ascii" then + v.ret(v.new_expr("(char){arguments[0]}", ret.as(not null))) + return true + end + else if cname == "Char" then + if pname == "output" then + v.add("System.out.print({arguments[0]});") + v.ret(v.null_instance) + return true + else if pname == "object_id" then + v.ret(v.new_expr("(int){arguments[0]}", ret.as(not null))) + return true + else if pname == "successor" then + v.ret(v.new_expr("(char)({arguments[0]} + {arguments[1]})", ret.as(not null))) + return true + else if pname == "predecessor" then + v.ret(v.new_expr("(char)({arguments[0]} - {arguments[1]})", ret.as(not null))) + return true + else if pname == "==" then + v.ret(v.equal_test(arguments[0], arguments[1])) + return true + else if pname == "!=" then + var res = v.equal_test(arguments[0], arguments[1]) + v.ret(v.new_expr("!{res}", ret.as(not null))) + return true + else if pname == "<" then + v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null))) + return true + else if pname == ">" then + v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null))) + return true + else if pname == "<=" then + v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null))) + return true + else if pname == ">=" then + v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null))) + return true + else if pname == "to_i" then + v.ret(v.new_expr("(int){arguments[0]}", ret.as(not null))) + return true + else if pname == "ascii" then + v.ret(v.new_expr("(int){arguments[0]}", ret.as(not null))) + return true + end + else if cname == "Byte" then + if pname == "output" then + v.add("System.out.println({arguments[0]});") + v.ret(v.null_instance) + return true + else if pname == "object_id" then + v.ret(v.new_expr("(int){arguments[0]}", ret.as(not null))) + return true + else if pname == "+" then + v.ret(v.new_expr("(byte)({arguments[0]} + {arguments[1]})", ret.as(not null))) + return true + else if pname == "-" then + v.ret(v.new_expr("(byte)({arguments[0]} - {arguments[1]})", ret.as(not null))) + return true + else if pname == "unary -" then + v.ret(v.new_expr("(byte)(-{arguments[0]})", ret.as(not null))) + return true + else if pname == "unary +" then + v.ret(arguments[0]) + return true + else if pname == "*" then + v.ret(v.new_expr("(byte)({arguments[0]} * {arguments[1]})", ret.as(not null))) + return true + else if pname == "/" then + v.ret(v.new_expr("(byte)({arguments[0]} / {arguments[1]})", ret.as(not null))) + return true + else if pname == "%" then + v.ret(v.new_expr("(byte)({arguments[0]} % {arguments[1]})", ret.as(not null))) + return true + else if pname == "<<" then + v.ret(v.new_expr("(byte)({arguments[0]} << {arguments[1]})", ret.as(not null))) + return true + else if pname == ">>" then + v.ret(v.new_expr("(byte)({arguments[0]} >> {arguments[1]})", ret.as(not null))) + return true + else if pname == "==" then + v.ret(v.equal_test(arguments[0], arguments[1])) + return true + else if pname == "!=" then + var res = v.equal_test(arguments[0], arguments[1]) + v.ret(v.new_expr("!{res}", ret.as(not null))) + return true + else if pname == "<" then + v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null))) + return true + else if pname == ">" then + v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null))) + return true + else if pname == "<=" then + v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null))) + return true + else if pname == ">=" then + v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null))) + return true + else if pname == "to_i" then + v.ret(v.new_expr("(int){arguments[0]}", ret.as(not null))) + return true + else if pname == "to_f" then + v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null))) + return true + else if pname == "ascii" then + v.ret(v.new_expr("{arguments[0]}", ret.as(not null))) + return true + end + else if cname == "Bool" then + if pname == "output" then + v.add("System.out.println({arguments[0]});") + v.ret(v.null_instance) + return true + else if pname == "object_id" then + v.ret(v.new_expr("{arguments[0]}?1:0", ret.as(not null))) + return true + else if pname == "==" then + v.ret(v.equal_test(arguments[0], arguments[1])) + return true + else if pname == "!=" then + var res = v.equal_test(arguments[0], arguments[1]) + v.ret(v.new_expr("!{res}", ret.as(not null))) + return true + end + else if cname == "Float" then + if pname == "output" then + v.add "if({arguments[0]} == Double.POSITIVE_INFINITY) \{" + v.add "System.out.println(\"inf\");" + v.add "\} else if({arguments[0]} == Double.POSITIVE_INFINITY) \{" + v.add "System.out.println(\"-inf\");" + v.add "\} else \{" + var df = v.get_name("df") + v.add "java.text.DecimalFormat {df} = new java.text.DecimalFormat(\"0.000000\");" + v.add "System.out.println({df}.format({arguments[0]}));" + v.add "\}" + v.ret(v.null_instance) + return true + else if pname == "object_id" then + v.ret(v.new_expr("(int){arguments[0]}", ret.as(not null))) + return true + else if pname == "+" then + v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null))) + return true + else if pname == "-" then + v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null))) + return true + else if pname == "unary -" then + v.ret(v.new_expr("-{arguments[0]}", ret.as(not null))) + return true + else if pname == "unary +" then + v.ret(arguments[0]) + return true + else if pname == "succ" then + v.ret(v.new_expr("{arguments[0]} + 1", ret.as(not null))) + return true + else if pname == "prec" then + v.ret(v.new_expr("{arguments[0]} - 1", ret.as(not null))) + return true + else if pname == "*" then + v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null))) + return true + else if pname == "/" then + v.ret(v.new_expr("{arguments[0]} / {arguments[1]}", ret.as(not null))) + return true + else if pname == "==" then + v.ret(v.equal_test(arguments[0], arguments[1])) + return true + else if pname == "!=" then + var res = v.equal_test(arguments[0], arguments[1]) + v.ret(v.new_expr("!{res}", ret.as(not null))) + return true + else if pname == "<" then + v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null))) + return true + else if pname == ">" then + v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null))) + return true + else if pname == "<=" then + v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null))) + return true + else if pname == ">=" then + v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null))) + return true + else if pname == "to_i" then + v.ret(v.new_expr("(int){arguments[0]}", ret.as(not null))) + return true + else if pname == "to_b" then + v.ret(v.new_expr("(byte){arguments[0]}", ret.as(not null))) + return true + end + end + if pname == "exit" then + v.add("System.exit({arguments[1]});") + v.ret(v.null_instance) + return true + else if pname == "sys" then + # TODO singleton + var main_type = v.compiler.mainmodule.sys_type.as(not null) + var sys = main_type.mclass + v.ret(v.new_expr("new RTVal({sys.rt_name}.get{sys.rt_name}())", main_type)) + return true + else if pname == "object_id" then + v.ret(v.new_expr("{arguments[0]}.hashCode()", ret.as(not null))) + return true + else if pname == "is_same_type" then + v.ret(v.is_same_type_test(arguments[0], arguments[1])) + return true + else if pname == "is_same_instance" then + v.ret(v.equal_test(arguments[0], arguments[1])) + return true + else if pname == "output_class_name" then + v.add("System.out.println({arguments[0]}.rtclass.class_name);") + v.ret(v.null_instance) + return true + end + return false + end +end + +redef class AAttrPropdef + redef fun compile_to_java(v, mpropdef, arguments) do + v.current_node = self + if mpropdef == mreadpropdef then + compile_getter(v, mpropdef, arguments) + else if mpropdef == mwritepropdef then + compile_setter(v, mpropdef, arguments) + else + abort + end + v.current_node = null + end + + # Compile the setter method + private fun compile_setter(v: JavaCompilerVisitor, mpropdef: MPropDef, arguments: Array[RuntimeVariable]) do + var mtype = v.compiler.mainmodule.object_type + var recv = arguments.first + var val = v.new_expr("args[1]", mtype) + v.write_attribute(self.mpropdef.as(not null).mproperty, recv, val) + v.ret v.null_instance + end + + # Compile the getter method + private fun compile_getter(v: JavaCompilerVisitor, mpropdef: MPropDef, arguments: Array[RuntimeVariable]) do + var recv = arguments.first + v.ret v.read_attribute(self.mpropdef.as(not null).mproperty, recv) + end + + private fun init_expr(v: JavaCompilerVisitor, recv: RuntimeVariable) do + if has_value and not is_lazy and not n_expr isa ANullExpr then evaluate_expr(v, recv) + end + + # Evaluate, store and return the default value of the attribute + private fun evaluate_expr(v: JavaCompilerVisitor, recv: RuntimeVariable): RuntimeVariable do + var old = v.frame + var frame = new JavaStaticFrame(v, self.mreadpropdef.as(not null), recv.mcasttype.undecorate.as(MClassType), [recv]) + v.frame = frame + + var value + var mtype = self.mtype + assert mtype != null + + var nexpr = self.n_expr + var nblock = self.n_block + if nexpr != null then + value = v.expr(nexpr, mtype) + else if nblock != null then + value = v.new_var(mtype) + frame.returnvar = value + frame.returnlabel = v.get_name("RET_LABEL") + v.add("{frame.returnlabel.as(not null)}: \{") + v.stmt(nblock) + v.add("\}") + else + abort + end + + v.write_attribute(self.mpropdef.as(not null).mproperty, recv, value) + v.frame = old + return value + end end redef class AExpr @@ -1139,6 +1938,71 @@ redef class ASendExpr end end +redef class ANewExpr + redef fun expr(v) + do + var mtype = self.recvtype + assert mtype != null + + if mtype.mclass.name == "NativeArray" then + # TODO handle native arrays + v.info("NOT YET IMPLEMENTED new NativeArray") + end + + var recv = v.init_instance(mtype) + + var callsite = self.callsite + if callsite == null then return recv + + var args = v.varargize(callsite.mpropdef, callsite.signaturemap, recv, self.n_args.n_exprs) + var res2 = v.compile_callsite(callsite, args) + if res2 != null then + return res2 + end + return recv + end +end + +redef class ASuperExpr + redef fun expr(v) + do + var frame = v.frame + assert frame != null + var recv = frame.arguments.first + + var callsite = self.callsite + if callsite != null then + var args + + if self.n_args.n_exprs.is_empty then + # Add automatic arguments for the super init call + args = [recv] + for i in [0..callsite.msignature.arity[ do + args.add(frame.arguments[i+1]) + end + else + args = v.varargize(callsite.mpropdef, callsite.signaturemap, recv, self.n_args.n_exprs) + end + + # Super init call + var res = v.compile_callsite(callsite, args) + return res + end + + var mpropdef = self.mpropdef.as(not null) + + var args + if self.n_args.n_exprs.is_empty then + args = frame.arguments + else + args = v.varargize(mpropdef, signaturemap, recv, self.n_args.n_exprs) + end + + # Standard call-next-method + return v.supercall(mpropdef, recv.mtype.as(MClassType), args) + end +end + redef class ASelfExpr redef fun expr(v) do return v.frame.as(not null).arguments.first end @@ -1147,6 +2011,44 @@ redef class AImplicitSelfExpr redef fun expr(v) do return v.frame.as(not null).arguments.first end +redef class AAttrExpr + redef fun expr(v) do + var recv = v.expr(self.n_expr, null) + var mproperty = self.mproperty.as(not null) + return v.read_attribute(mproperty, recv) + end +end + +redef class AAttrAssignExpr + redef fun expr(v) do + var recv = v.expr(self.n_expr, null) + var i = v.expr(self.n_value, null) + var mproperty = self.mproperty.as(not null) + v.write_attribute(mproperty, recv, i) + return i + end +end + +redef class AAttrReassignExpr + redef fun stmt(v) do + var recv = v.expr(self.n_expr, null) + var value = v.expr(self.n_value, null) + var mproperty = self.mproperty.as(not null) + var attr = v.read_attribute(mproperty, recv) + var res = v.compile_callsite(self.reassign_callsite.as(not null), [attr, value]) + assert res != null + v.write_attribute(mproperty, recv, res) + end +end + +redef class AIssetAttrExpr + redef fun expr(v) do + var recv = v.expr(self.n_expr, null) + var mproperty = self.mproperty.as(not null) + return v.isset_attribute(mproperty, recv) + end +end + redef class AReturnExpr redef fun stmt(v) do var nexpr = self.n_expr @@ -1160,6 +2062,66 @@ redef class AReturnExpr end end +redef class AIfExpr + redef fun stmt(v) do + var cond = v.expr_bool(self.n_expr) + v.add("if ({cond})\{") + v.stmt(self.n_then) + v.add("\} else \{") + v.stmt(self.n_else) + v.add("\}") + end + + redef fun expr(v) do + var res = v.new_var(self.mtype.as(not null)) + var cond = v.expr_bool(self.n_expr) + v.add("if ({cond})\{") + v.assign(res, v.expr(self.n_then.as(not null), null)) + v.add("\} else \{") + v.assign(res, v.expr(self.n_else.as(not null), null)) + v.add("\}") + return res + end +end + +redef class ADoExpr + redef fun stmt(v) + do + v.add_escape_label(break_mark) + v.add "\{" + v.stmt(self.n_block) + v.add "\}" + end +end + +redef class AWhileExpr + redef fun stmt(v) + do + v.add_escape_label(break_mark) + v.add_escape_label(continue_mark) + v.add("for(;;) \{") + var cond = v.expr_bool(self.n_expr) + v.add("if (!{cond}) break;") + v.stmt(self.n_block) + v.add("\}") + end +end + +redef class ALoopExpr + redef fun stmt(v) + do + v.add_escape_label(break_mark) + v.add_escape_label(continue_mark) + v.add("for(;;) \{") + v.stmt(self.n_block) + v.add("\}") + end +end + +redef class AEscapeExpr + redef fun stmt(v) do v.add("break BREAK_{v.escapemark_name(escapemark)};") +end + redef class AVardeclExpr redef fun stmt(v) do var variable = self.variable.as(not null) @@ -1187,12 +2149,97 @@ redef class AVarAssignExpr end end -redef class AIntExpr - redef fun expr(v) do return v.int_instance(self.value.as(not null)) + +redef class AAssertExpr + redef fun stmt(v) do + var cond = v.expr_bool(self.n_expr) + v.add("if (!{cond}) \{") + v.stmt(self.n_else) + var nid = self.n_id + if nid != null then + v.add_abort("Assert '{nid.text}' failed") + else + v.add_abort("Assert failed") + end + v.add("\}") + end +end + +redef class AImpliesExpr + redef fun expr(v) do + var res = v.new_var(mtype.as(not null)) + var i1 = v.expr_bool(n_expr) + v.add("if (!{i1}) \{") + v.add("{res} = true;") + v.add("\} else \{") + var i2 = v.expr_bool(n_expr2) + v.add("{res} = {i2};") + v.add("\}") + return res + end end -redef class AByteExpr - redef fun expr(v) do return v.byte_instance(self.value.as(not null)) +redef class AOrElseExpr + redef fun expr(v) + do + var res = v.new_var(self.mtype.as(not null)) + var i1 = v.expr(self.n_expr, null) + v.add("if ({i1} != null && !{i1}.is_null()) \{") + v.assign(res, i1) + v.add("\} else \{") + var i2 = v.expr(self.n_expr2, null) + v.assign(res, i2) + v.add("\}") + return res + end +end + +redef class AOrExpr + redef fun expr(v) do + var res = v.new_var(self.mtype.as(not null)) + var i1 = v.expr_bool(self.n_expr) + v.add("if ({i1}) \{") + v.add("{res} = true;") + v.add("\} else \{") + var i2 = v.expr_bool(self.n_expr2) + v.add("{res} = {i2};") + v.add("\}") + return res + end +end + +redef class AAndExpr + redef fun expr(v) do + var res = v.new_var(self.mtype.as(not null)) + var i1 = v.expr_bool(self.n_expr) + v.add("if (!{i1}) \{") + v.add("{res} = false;") + v.add("\} else \{") + var i2 = v.expr_bool(self.n_expr2) + v.add("{res} = {i2};") + v.add("\}") + return res + end +end + +redef class ANotExpr + redef fun expr(v) do + var cond = v.expr_bool(self.n_expr) + return v.new_expr("!{cond}", self.mtype.as(not null)) + end +end + +redef class AIntegerExpr + redef fun expr(v) do + if value isa Int then + return v.int_instance(self.value.as(Int)) + else if value isa Byte then + return v.byte_instance(self.value.as(Byte)) + else + # Should not happen + abort + end + end end redef class AFloatExpr @@ -1215,6 +2262,41 @@ redef class ANullExpr redef fun expr(v) do return v.null_instance end +redef class AAsCastExpr + redef fun expr(v) + do + var i = v.expr(n_expr, null) + v.add_cast(i, mtype.as(not null)) + return i + end +end + +redef class AAsNotnullExpr + redef fun expr(v) do + var i = v.expr(n_expr, null) + if i.mtype.is_java_primitive then return i + + v.add("if ({i} == null || {i}.is_null()) \{") + v.add_abort("Cast failed") + v.add("\}") + return i + end +end + +redef class AIsaExpr + redef fun expr(v) + do + var i = v.expr(self.n_expr, null) + var cast_type = self.cast_type + if cast_type == null then return null # no-no on broken node + return v.type_test(i, cast_type) + end +end + +redef class AParExpr + redef fun expr(v) do return v.expr(self.n_expr, null) +end + redef class AAbortExpr redef fun stmt(v) do v.add_abort("Aborted") end