import literal
import typing
import auto_super_init
+import platform
+import c_tools
# Add compiling options
redef class ToolContext
var opt_output: OptionString = new OptionString("Output file", "-o", "--output")
# --no-cc
var opt_no_cc: OptionBool = new OptionBool("Do not invoke C compiler", "--no-cc")
+ # --no-main
+ var opt_no_main: OptionBool = new OptionBool("Do not generate main entry point", "--no-main")
+ # --cc-paths
+ var opt_cc_path: OptionArray = new OptionArray("Set include path for C header files (may be used more than once)", "--cc-path")
# --make-flags
var opt_make_flags: OptionString = new OptionString("Additional options to make", "--make-flags")
+ # --compile-dir
+ var opt_compile_dir: OptionString = new OptionString("Directory used to generate temporary files", "--compile-dir")
# --hardening
var opt_hardening: OptionBool = new OptionBool("Generate contracts in the C code against bugs in the compiler", "--hardening")
# --no-shortcut-range
var opt_no_shortcut_range: OptionBool = new OptionBool("Always insantiate a range and its iterator on 'for' loops", "--no-shortcut-range")
# --no-check-covariance
var opt_no_check_covariance: OptionBool = new OptionBool("Disable type tests of covariant parameters (dangerous)", "--no-check-covariance")
- # --no-check-initialization
- var opt_no_check_initialization: OptionBool = new OptionBool("Disable isset tests at the end of constructors (dangerous)", "--no-check-initialization")
+ # --no-check-attr-isset
+ var opt_no_check_attr_isset: OptionBool = new OptionBool("Disable isset tests before each attribute access (dangerous)", "--no-check-attr-isset")
# --no-check-assert
var opt_no_check_assert: OptionBool = new OptionBool("Disable the evaluation of explicit 'assert' and 'as' (dangerous)", "--no-check-assert")
# --no-check-autocast
var opt_no_check_other: OptionBool = new OptionBool("Disable implicit tests: unset attribute, null receiver (dangerous)", "--no-check-other")
# --typing-test-metrics
var opt_typing_test_metrics: OptionBool = new OptionBool("Enable static and dynamic count of all type tests", "--typing-test-metrics")
+ # --invocation-metrics
+ var opt_invocation_metrics: OptionBool = new OptionBool("Enable static and dynamic count of all method invocations", "--invocation-metrics")
+ # --isset-checks-metrics
+ var opt_isset_checks_metrics: OptionBool = new OptionBool("Enable static and dynamic count of isset checks before attributes access", "--isset-checks-metrics")
+ # --stacktrace
+ var opt_stacktrace: OptionString = new OptionString("Control the generation of stack traces", "--stacktrace")
+ # --no-gcc-directives
+ var opt_no_gcc_directive = new OptionArray("Disable a advanced gcc directives for optimization", "--no-gcc-directive")
+ # --release
+ var opt_release = new OptionBool("Compile in release mode and finalize application", "--release")
redef init
do
super
- self.option_context.add_option(self.opt_output, self.opt_no_cc, self.opt_make_flags, self.opt_hardening, self.opt_no_shortcut_range)
- self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_initialization, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_other)
- self.option_context.add_option(self.opt_typing_test_metrics)
+ self.option_context.add_option(self.opt_output, self.opt_no_cc, self.opt_no_main, self.opt_make_flags, self.opt_compile_dir, self.opt_hardening, self.opt_no_shortcut_range)
+ self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_attr_isset, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_other)
+ self.option_context.add_option(self.opt_typing_test_metrics, self.opt_invocation_metrics, self.opt_isset_checks_metrics)
+ self.option_context.add_option(self.opt_stacktrace)
+ self.option_context.add_option(self.opt_no_gcc_directive)
+ self.option_context.add_option(self.opt_release)
+ end
+
+ redef fun process_options(args)
+ do
+ super
+
+ var st = opt_stacktrace.value
+ if st == null or st == "none" or st == "libunwind" or st == "nitstack" then
+ # Fine, do nothing
+ else if st == "auto" then
+ # Default just unset
+ opt_stacktrace.value = null
+ else
+ print "Error: unknown value `{st}` for --stacktrace. Use `none`, `libunwind`, `nitstack` or `auto`."
+ exit(1)
+ end
end
end
redef class ModelBuilder
+ # The compilation directory
+ var compile_dir: String
+
+ # Simple indirection to `Toolchain::write_and_make`
protected fun write_and_make(compiler: AbstractCompiler)
do
+ var platform = compiler.mainmodule.target_platform
+ var toolchain
+ if platform == null then
+ toolchain = new MakefileToolchain(toolcontext)
+ else
+ toolchain = platform.toolchain(toolcontext)
+ end
+ compile_dir = toolchain.compile_dir
+ toolchain.write_and_make compiler
+ end
+end
+
+redef class Platform
+ fun toolchain(toolcontext: ToolContext): Toolchain is abstract
+end
+
+class Toolchain
+ var toolcontext: ToolContext
+
+ fun compile_dir: String
+ do
+ var compile_dir = toolcontext.opt_compile_dir.value
+ if compile_dir == null then compile_dir = ".nit_compile"
+ return compile_dir
+ end
+
+ fun write_and_make(compiler: AbstractCompiler) is abstract
+end
+
+class MakefileToolchain
+ super Toolchain
+ # The list of directories to search for included C headers (-I for C compilers)
+ # The list is initially set with :
+ # * the toolcontext --cc-path option
+ # * the NIT_CC_PATH environment variable
+ # * `toolcontext.nit_dir`
+ # Path can be added (or removed) by the client
+ var cc_paths = new Array[String]
+
+ protected fun gather_cc_paths
+ do
+ # Look for the the Nit clib path
+ var path_env = toolcontext.nit_dir
+ if path_env != null then
+ var libname = "{path_env}/clib"
+ if libname.file_exists then cc_paths.add(libname)
+ end
+
+ if cc_paths.is_empty then
+ toolcontext.error(null, "Cannot determine the nit clib path. define envvar NIT_DIR.")
+ end
+
+ # Add user defined cc_paths
+ cc_paths.append(toolcontext.opt_cc_path.value)
+
+ path_env = "NIT_CC_PATH".environ
+ if not path_env.is_empty then
+ cc_paths.append(path_env.split_with(':'))
+ end
+ end
+
+ redef fun write_and_make(compiler)
+ do
+ gather_cc_paths
+
var mainmodule = compiler.mainmodule
+ var compile_dir = compile_dir
# Generate the .h and .c files
# A single C file regroups many compiled rumtime functions
# Note that we do not try to be clever an a small change in a Nit source file may change the content of all the generated .c files
var time0 = get_time
+ self.toolcontext.info("*** WRITING C ***", 1)
+
+ compile_dir.mkdir
+
+ var cfiles = new Array[String]
+ write_files(compiler, compile_dir, cfiles)
+
+ # Generate the Makefile
+
+ write_makefile(compiler, compile_dir, cfiles)
+
+ var time1 = get_time
+ self.toolcontext.info("*** END WRITING C: {time1-time0} ***", 2)
+
+ # Execute the Makefile
+
+ if self.toolcontext.opt_no_cc.value then return
+
+ time0 = time1
+ self.toolcontext.info("*** COMPILING C ***", 1)
+
+ compile_c_code(compiler, compile_dir)
+
+ time1 = get_time
+ self.toolcontext.info("*** END COMPILING C: {time1-time0} ***", 2)
+ end
+
+ fun write_files(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String])
+ do
+ if self.toolcontext.opt_stacktrace.value == "nitstack" then compiler.build_c_to_nit_bindings
+
+ var platform = compiler.mainmodule.target_platform
+ var cc_opt_with_libgc = "-DWITH_LIBGC"
+ if platform != null and not platform.supports_libgc then cc_opt_with_libgc = ""
+
+ # Add gc_choser.h to aditionnal bodies
+ var gc_chooser = new ExternCFile("gc_chooser.c", cc_opt_with_libgc)
+ compiler.extern_bodies.add(gc_chooser)
+ compiler.files_to_copy.add "{cc_paths.first}/gc_chooser.c"
+ compiler.files_to_copy.add "{cc_paths.first}/gc_chooser.h"
- var outname = self.toolcontext.opt_output.value
- if outname == null then
- outname = "{mainmodule.name}.bin"
+ # FFI
+ var m2m = toolcontext.modelbuilder.mmodule2nmodule
+ for m in compiler.mainmodule.in_importation.greaters do
+ compiler.finalize_ffi_for_module(m)
end
- var hfilename = ".nit_compile/{mainmodule.name}.1.h"
- var h = new OFStream.open(hfilename)
+ # Copy original .[ch] files to compile_dir
+ for src in compiler.files_to_copy do
+ var basename = src.basename("")
+ var dst = "{compile_dir}/{basename}"
+ src.file_copy_to dst
+ end
+
+ var hfilename = compiler.header.file.name + ".h"
+ var hfilepath = "{compile_dir}/{hfilename}"
+ var h = new OFStream.open(hfilepath)
for l in compiler.header.decl_lines do
h.write l
h.write "\n"
end
+ for l in compiler.header.lines do
+ h.write l
+ h.write "\n"
+ end
h.close
- var cfiles = new Array[String]
-
- var file: nullable OFStream = null
- var count = 0
-
- ".nit_compile".mkdir
- var i = 0
- for vis in compiler.visitors do
- count += vis.lines.length
- if file == null or count > 10000 or vis.file_break then
- i += 1
- if file != null then file.close
- var cfilename = ".nit_compile/{mainmodule.name}.{i}.c"
- cfiles.add(cfilename)
- file = new OFStream.open(cfilename)
- file.write "#include \"{mainmodule.name}.1.h\"\n"
- count = vis.lines.length
+ for f in compiler.files do
+ var i = 0
+ var hfile: nullable OFStream = null
+ var count = 0
+ var cfilename = "{f.name}.0.h"
+ var cfilepath = "{compile_dir}/{cfilename}"
+ hfile = new OFStream.open(cfilepath)
+ hfile.write "#include \"{hfilename}\"\n"
+ for key in f.required_declarations do
+ if not compiler.provided_declarations.has_key(key) then
+ var node = compiler.requirers_of_declarations.get_or_null(key)
+ if node != null then
+ node.debug "No provided declaration for {key}"
+ else
+ print "No provided declaration for {key}"
+ end
+ abort
+ end
+ hfile.write compiler.provided_declarations[key]
+ hfile.write "\n"
end
- if vis != compiler.header then
+ hfile.close
+ var file: nullable OFStream = null
+ for vis in f.writers do
+ if vis == compiler.header then continue
+ var total_lines = vis.lines.length + vis.decl_lines.length
+ if total_lines == 0 then continue
+ count += total_lines
+ if file == null or count > 10000 then
+ i += 1
+ if file != null then file.close
+ cfilename = "{f.name}.{i}.c"
+ cfilepath = "{compile_dir}/{cfilename}"
+ self.toolcontext.info("new C source files to compile: {cfilepath}", 3)
+ cfiles.add(cfilename)
+ file = new OFStream.open(cfilepath)
+ file.write "#include \"{f.name}.0.h\"\n"
+ count = total_lines
+ end
for l in vis.decl_lines do
file.write l
file.write "\n"
end
+ for l in vis.lines do
+ file.write l
+ file.write "\n"
+ end
end
- for l in vis.lines do
- file.write l
- file.write "\n"
- end
+ if file != null then file.close
end
- if file != null then file.close
self.toolcontext.info("Total C source files to compile: {cfiles.length}", 2)
+ end
- # Generate the Makefile
+ fun makefile_name(mainmodule: MModule): String do return "{mainmodule.name}.mk"
+
+ fun default_outname(mainmodule: MModule): String do return mainmodule.name
+
+ fun write_makefile(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String])
+ do
+ var mainmodule = compiler.mainmodule
+
+ var outname = self.toolcontext.opt_output.value or else default_outname(mainmodule)
+
+ var orig_dir=".." # FIXME only works if `compile_dir` is a subdirectory of cwd
+ var outpath = orig_dir.join_path(outname).simplify_path
+ var makename = makefile_name(mainmodule)
+ var makepath = "{compile_dir}/{makename}"
+ var makefile = new OFStream.open(makepath)
- var makename = ".nit_compile/{mainmodule.name}.mk"
- var makefile = new OFStream.open(makename)
+ var cc_includes = ""
+ for p in cc_paths do
+ cc_includes += " -I \"" + p + "\""
+ end
+
+ var linker_options = new HashSet[String]
+ var m2m = toolcontext.modelbuilder.mmodule2nmodule
+ for m in mainmodule.in_importation.greaters do
+ var libs = m.collect_linker_libs
+ if libs != null then linker_options.add_all(libs)
+ end
- makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nLDFLAGS ?= \nLDLIBS ?= -lm -lgc\n\n")
- makefile.write("all: {outname}\n\n")
+ var ost = toolcontext.opt_stacktrace.value
+ if ost == "libunwind" or ost == "nitstack" then linker_options.add("-lunwind")
+
+ makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lm -lgc {linker_options.join(" ")}\n\n")
+ makefile.write("all: {outpath}\n\n")
var ofiles = new Array[String]
+ var dep_rules = new Array[String]
# Compile each generated file
for f in cfiles do
var o = f.strip_extension(".c") + ".o"
- makefile.write("{o}: {f}\n\t$(CC) $(CFLAGS) -D NONITCNI -c -o {o} {f}\n\n")
+ makefile.write("{o}: {f}\n\t$(CC) $(CFLAGS) $(CINCL) -c -o {o} {f}\n\n")
ofiles.add(o)
+ dep_rules.add(o)
end
+
+ var java_files = new Array[ExternFile]
+
# Compile each required extern body into a specific .o
for f in compiler.extern_bodies do
- i += 1
- var o = ".nit_compile/{mainmodule.name}.{i}.o"
- makefile.write("{o}: {f}\n\t$(CC) $(CFLAGS) -D NONITCNI -c -o {o} {f}\n\n")
- ofiles.add(o)
+ var o = f.makefile_rule_name
+ var ff = f.filename.basename("")
+ makefile.write("{o}: {ff}\n")
+ makefile.write("\t{f.makefile_rule_content}\n\n")
+ dep_rules.add(f.makefile_rule_name)
+
+ if f.compiles_to_o_file then ofiles.add(o)
+ if f.add_to_jar then java_files.add(f)
end
+
+ if not java_files.is_empty then
+ var jar_file = "{outpath}.jar"
+
+ var class_files_array = new Array[String]
+ for f in java_files do class_files_array.add(f.makefile_rule_name)
+ var class_files = class_files_array.join(" ")
+
+ makefile.write("{jar_file}: {class_files}\n")
+ makefile.write("\tjar cf {jar_file} {class_files}\n\n")
+ dep_rules.add jar_file
+ end
+
# Link edition
- makefile.write("{outname}: {ofiles.join(" ")}\n\t$(CC) $(LDFLAGS) -o {outname} {ofiles.join(" ")} $(LDLIBS)\n\n")
+ makefile.write("{outpath}: {dep_rules.join(" ")}\n\t$(CC) $(LDFLAGS) -o {outpath} {ofiles.join(" ")} $(LDLIBS)\n\n")
# Clean
makefile.write("clean:\n\trm {ofiles.join(" ")} 2>/dev/null\n\n")
makefile.close
- self.toolcontext.info("Generated makefile: {makename}", 2)
-
- var time1 = get_time
- self.toolcontext.info("*** END COMPILING TO C: {time1-time0} ***", 2)
-
- # Execute the Makefile
+ self.toolcontext.info("Generated makefile: {makepath}", 2)
+ end
- if self.toolcontext.opt_no_cc.value then return
+ fun compile_c_code(compiler: AbstractCompiler, compile_dir: String)
+ do
+ var makename = makefile_name(compiler.mainmodule)
- time0 = time1
- self.toolcontext.info("*** COMPILING C ***", 1)
var makeflags = self.toolcontext.opt_make_flags.value
if makeflags == null then makeflags = ""
- self.toolcontext.info("make -B -f {makename} -j 4 {makeflags}", 2)
+ self.toolcontext.info("make -B -C {compile_dir} -f {makename} -j 4 {makeflags}", 2)
var res
if self.toolcontext.verbose_level >= 3 then
- res = sys.system("make -B -f {makename} -j 4 {makeflags} 2>&1")
+ res = sys.system("make -B -C {compile_dir} -f {makename} -j 4 {makeflags} 2>&1")
else
- res = sys.system("make -B -f {makename} -j 4 {makeflags} 2>&1 >/dev/null")
+ res = sys.system("make -B -C {compile_dir} -f {makename} -j 4 {makeflags} 2>&1 >/dev/null")
end
if res != 0 then
toolcontext.error(null, "make failed! Error code: {res}.")
end
-
- time1 = get_time
- self.toolcontext.info("*** END COMPILING C: {time1-time0} ***", 2)
end
end
abstract class AbstractCompiler
type VISITOR: AbstractCompilerVisitor
- # The main module of the program
- var mainmodule: MModule protected writable
+ # Table corresponding c_names to nit names (methods)
+ var names = new HashMap[String, String]
+
+ # The main module of the program currently compiled
+ # Is assigned during the separate compilation
+ var mainmodule: MModule writable
+
+ # The real main module of the program
+ var realmainmodule: MModule
# The modeulbuilder used to know the model and the AST
var modelbuilder: ModelBuilder protected writable
init(mainmodule: MModule, modelbuilder: ModelBuilder)
do
self.mainmodule = mainmodule
+ self.realmainmodule = mainmodule
self.modelbuilder = modelbuilder
end
# Force the creation of a new file
# The point is to avoid contamination between must-be-compiled-separately files
- fun new_file
+ fun new_file(name: String): CodeFile
do
- var v = self.new_visitor
- v.file_break = true
+ var f = new CodeFile(name)
+ self.files.add(f)
+ return f
end
- # The list of all associated visitors
+ # The list of all associated files
# Used to generate .c files
- # FIXME: should not be vistors but just somewhere to store lines
- var visitors: List[VISITOR] = new List[VISITOR]
+ var files: List[CodeFile] = new List[CodeFile]
# Initialize a visitor specific for a compiler engine
fun new_visitor: VISITOR is abstract
# Where global declaration are stored (the main .h)
- #
- # FIXME: should not be a visitor but just somewhere to store lines
- # FIXME: should not have a global .h since it does not help recompilations
- var header: VISITOR writable
+ var header: CodeWriter writable
+
+ # Provide a declaration that can be requested (before or latter) by a visitor
+ fun provide_declaration(key: String, s: String)
+ do
+ if self.provided_declarations.has_key(key) then
+ assert self.provided_declarations[key] == s
+ end
+ self.provided_declarations[key] = s
+ end
+
+ private var provided_declarations = new HashMap[String, String]
+
+ private var requirers_of_declarations = new HashMap[String, ANode]
+
+ # Builds the .c and .h files to be used when generating a Stack Trace
+ # Binds the generated C function names to Nit function names
+ fun build_c_to_nit_bindings
+ do
+ var compile_dir = modelbuilder.compile_dir
+
+ var stream = new OFStream.open("{compile_dir}/c_functions_hash.c")
+ stream.write("#include <string.h>\n")
+ stream.write("#include <stdlib.h>\n")
+ stream.write("#include \"c_functions_hash.h\"\n")
+ stream.write("typedef struct C_Nit_Names\{char* name; char* nit_name;\}C_Nit_Names;\n")
+ stream.write("const char* get_nit_name(register const char* procproc, register unsigned int len)\{\n")
+ stream.write("char* procname = malloc(len+1);")
+ stream.write("memcpy(procname, procproc, len);")
+ stream.write("procname[len] = '\\0';")
+ stream.write("static const C_Nit_Names map[{names.length}] = \{\n")
+ for i in names.keys do
+ stream.write("\{\"")
+ stream.write(i)
+ stream.write("\",\"")
+ stream.write(names[i])
+ stream.write("\"\},\n")
+ end
+ stream.write("\};\n")
+ stream.write("int i;")
+ stream.write("for(i = 0; i < {names.length}; i++)\{")
+ stream.write("if(strcmp(procname,map[i].name) == 0)\{")
+ stream.write("free(procname);")
+ stream.write("return map[i].nit_name;")
+ stream.write("\}")
+ stream.write("\}")
+ stream.write("free(procname);")
+ stream.write("return NULL;")
+ stream.write("\}\n")
+ stream.close
+
+ stream = new OFStream.open("{compile_dir}/c_functions_hash.h")
+ stream.write("const char* get_nit_name(register const char* procname, register unsigned int len);\n")
+ stream.close
+
+ extern_bodies.add(new ExternCFile("{compile_dir}/c_functions_hash.c", ""))
+ end
# Compile C headers
# This method call compile_header_strucs method that has to be refined
fun compile_header do
var v = self.header
+ var toolctx = modelbuilder.toolcontext
self.header.add_decl("#include <stdlib.h>")
self.header.add_decl("#include <stdio.h>")
self.header.add_decl("#include <string.h>")
- self.header.add_decl("#ifndef NOBOEHM")
- self.header.add_decl("#include <gc/gc.h>")
- self.header.add_decl("#ifdef NOBOEHM_ATOMIC")
- self.header.add_decl("#undef GC_MALLOC_ATOMIC")
- self.header.add_decl("#define GC_MALLOC_ATOMIC(x) GC_MALLOC(x)")
- self.header.add_decl("#endif /*NOBOEHM_ATOMIC*/")
- self.header.add_decl("#else /*NOBOEHM*/")
- self.header.add_decl("#define GC_MALLOC(x) calloc(1, (x))")
- self.header.add_decl("#define GC_MALLOC_ATOMIC(x) calloc(1, (x))")
- self.header.add_decl("#endif /*NOBOEHM*/")
+ self.header.add_decl("#include \"gc_chooser.h\"")
+ self.header.add_decl("#ifdef ANDROID")
+ self.header.add_decl(" #include <android/log.h>")
+ self.header.add_decl(" #define PRINT_ERROR(...) (void)__android_log_print(ANDROID_LOG_WARN, \"Nit\", __VA_ARGS__)")
+ self.header.add_decl("#else")
+ self.header.add_decl(" #define PRINT_ERROR(...) fprintf(stderr, __VA_ARGS__)")
+ self.header.add_decl("#endif")
compile_header_structs
+ compile_nitni_structs
+
+ var gccd_disable = modelbuilder.toolcontext.opt_no_gcc_directive.value
+ if gccd_disable.has("noreturn") or gccd_disable.has("all") then
+ # Signal handler function prototype
+ self.header.add_decl("void show_backtrace(int);")
+ else
+ self.header.add_decl("void show_backtrace(int) __attribute__ ((noreturn));")
+ end
+
+ if gccd_disable.has("likely") or gccd_disable.has("all") then
+ self.header.add_decl("#define likely(x) (x)")
+ self.header.add_decl("#define unlikely(x) (x)")
+ else if gccd_disable.has("correct-likely") then
+ # invert the `likely` definition
+ # Used by masochists to bench the worst case
+ self.header.add_decl("#define likely(x) __builtin_expect((x),0)")
+ self.header.add_decl("#define unlikely(x) __builtin_expect((x),1)")
+ else
+ self.header.add_decl("#define likely(x) __builtin_expect((x),1)")
+ self.header.add_decl("#define unlikely(x) __builtin_expect((x),0)")
+ end
- # Global variable used by the legacy native interface
+ # Global variable used by intern methods
self.header.add_decl("extern int glob_argc;")
self.header.add_decl("extern char **glob_argv;")
self.header.add_decl("extern val *glob_sys;")
end
- # Declaration of structures the live Nit types
+ # Declaration of structures for live Nit types
protected fun compile_header_structs is abstract
+ # Declaration of structures for nitni undelying the FFI
+ protected fun compile_nitni_structs is abstract
+
# Generate the main C function.
# This function:
# * allocate the Sys object if it exists
fun compile_main_function
do
var v = self.new_visitor
+ v.add_decl("#include <signal.h>")
+ var ost = modelbuilder.toolcontext.opt_stacktrace.value
+ var platform = mainmodule.target_platform
+
+ if ost == null then
+ if platform != null and not platform.supports_libunwind then
+ ost = "none"
+ else
+ ost = "nitstack"
+ end
+ modelbuilder.toolcontext.opt_stacktrace.value = ost
+ end
+
+ if platform != null and platform.no_main then modelbuilder.toolcontext.opt_no_main.value = true
+
+ if ost == "nitstack" or ost == "libunwind" then
+ v.add_decl("#define UNW_LOCAL_ONLY")
+ v.add_decl("#include <libunwind.h>")
+ if ost == "nitstack" then
+ v.add_decl("#include \"c_functions_hash.h\"")
+ end
+ end
v.add_decl("int glob_argc;")
v.add_decl("char **glob_argv;")
v.add_decl("val *glob_sys;")
v.compiler.header.add_decl("extern long count_type_test_skipped_{tag};")
end
end
- v.add_decl("int main(int argc, char** argv) \{")
+
+ if self.modelbuilder.toolcontext.opt_invocation_metrics.value then
+ v.add_decl("long count_invoke_by_tables;")
+ v.add_decl("long count_invoke_by_direct;")
+ v.add_decl("long count_invoke_by_inline;")
+ v.compiler.header.add_decl("extern long count_invoke_by_tables;")
+ v.compiler.header.add_decl("extern long count_invoke_by_direct;")
+ v.compiler.header.add_decl("extern long count_invoke_by_inline;")
+ end
+
+ if self.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
+ v.add_decl("long count_attr_reads = 0;")
+ v.add_decl("long count_isset_checks = 0;")
+ v.compiler.header.add_decl("extern long count_attr_reads;")
+ v.compiler.header.add_decl("extern long count_isset_checks;")
+ end
+
+ v.add_decl("void sig_handler(int signo)\{")
+ v.add_decl("PRINT_ERROR(\"Caught signal : %s\\n\", strsignal(signo));")
+ v.add_decl("show_backtrace(signo);")
+ v.add_decl("\}")
+
+ v.add_decl("void show_backtrace (int signo) \{")
+ if ost == "nitstack" or ost == "libunwind" then
+ v.add_decl("char* opt = getenv(\"NIT_NO_STACK\");")
+ v.add_decl("unw_cursor_t cursor;")
+ v.add_decl("if(opt==NULL)\{")
+ v.add_decl("unw_context_t uc;")
+ v.add_decl("unw_word_t ip;")
+ v.add_decl("char* procname = malloc(sizeof(char) * 100);")
+ v.add_decl("unw_getcontext(&uc);")
+ v.add_decl("unw_init_local(&cursor, &uc);")
+ v.add_decl("PRINT_ERROR(\"-------------------------------------------------\\n\");")
+ v.add_decl("PRINT_ERROR(\"-- Stack Trace ------------------------------\\n\");")
+ v.add_decl("PRINT_ERROR(\"-------------------------------------------------\\n\");")
+ v.add_decl("while (unw_step(&cursor) > 0) \{")
+ v.add_decl(" unw_get_proc_name(&cursor, procname, 100, &ip);")
+ if ost == "nitstack" then
+ v.add_decl(" const char* recv = get_nit_name(procname, strlen(procname));")
+ v.add_decl(" if (recv != NULL)\{")
+ v.add_decl(" PRINT_ERROR(\"` %s\\n\", recv);")
+ v.add_decl(" \}else\{")
+ v.add_decl(" PRINT_ERROR(\"` %s\\n\", procname);")
+ v.add_decl(" \}")
+ else
+ v.add_decl(" PRINT_ERROR(\"` %s \\n\",procname);")
+ end
+ v.add_decl("\}")
+ v.add_decl("PRINT_ERROR(\"-------------------------------------------------\\n\");")
+ v.add_decl("free(procname);")
+ v.add_decl("\}")
+ end
+ v.add_decl("exit(signo);")
+ v.add_decl("\}")
+
+ if modelbuilder.toolcontext.opt_no_main.value then
+ v.add_decl("int nit_main(int argc, char** argv) \{")
+ else
+ v.add_decl("int main(int argc, char** argv) \{")
+ end
+
+ v.add("signal(SIGABRT, sig_handler);")
+ v.add("signal(SIGFPE, sig_handler);")
+ v.add("signal(SIGILL, sig_handler);")
+ v.add("signal(SIGINT, sig_handler);")
+ v.add("signal(SIGTERM, sig_handler);")
+ v.add("signal(SIGSEGV, sig_handler);")
+ v.add("signal(SIGPIPE, sig_handler);")
+
v.add("glob_argc = argc; glob_argv = argv;")
+ v.add("initialize_gc_option();")
var main_type = mainmodule.sys_type
if main_type != null then
var mainmodule = v.compiler.mainmodule
var glob_sys = v.init_instance(main_type)
v.add("glob_sys = {glob_sys};")
- var main_init = mainmodule.try_get_primitive_method("init", 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("main", main_type)
+ var main_method = mainmodule.try_get_primitive_method("main", main_type.mclass)
if main_method != null then
v.send(main_method, [glob_sys])
end
v.add("printf(\"\\t%ld (%.2f%%)\\n\", count_type_test_total_{tag}, 100.0*count_type_test_total_{tag}/count_type_test_total_total);")
end
end
- v.add("return 0;")
- v.add("\}")
- end
- # look for a needed .h and .c file for a given .nit source-file
- # FIXME: bad API, parameter should be a MModule, not its source-file
- fun add_extern(file: String)
- do
- file = file.strip_extension(".nit")
- var tryfile = file + ".nit.h"
- if tryfile.file_exists then
- self.header.add_decl("#include \"{"..".join_path(tryfile)}\"")
+ if self.modelbuilder.toolcontext.opt_invocation_metrics.value then
+ v.add_decl("long count_invoke_total;")
+ v.add("count_invoke_total = count_invoke_by_tables + count_invoke_by_direct + count_invoke_by_inline;")
+ v.add("printf(\"# dynamic count_invocation: total %ld\\n\", count_invoke_total);")
+ v.add("printf(\"by table: %ld (%.2f%%)\\n\", count_invoke_by_tables, 100.0*count_invoke_by_tables/count_invoke_total);")
+ v.add("printf(\"direct: %ld (%.2f%%)\\n\", count_invoke_by_direct, 100.0*count_invoke_by_direct/count_invoke_total);")
+ v.add("printf(\"inlined: %ld (%.2f%%)\\n\", count_invoke_by_inline, 100.0*count_invoke_by_inline/count_invoke_total);")
end
- tryfile = file + "_nit.h"
- if tryfile.file_exists then
- self.header.add_decl("#include \"{"..".join_path(tryfile)}\"")
- end
- tryfile = file + ".nit.c"
- if tryfile.file_exists then
- self.extern_bodies.add(tryfile)
- end
- tryfile = file + "_nit.c"
- if tryfile.file_exists then
- self.extern_bodies.add(tryfile)
+
+ if self.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
+ v.add("printf(\"# dynamic attribute reads: %ld\\n\", count_attr_reads);")
+ v.add("printf(\"# dynamic isset checks: %ld\\n\", count_isset_checks);")
end
+
+ v.add("return 0;")
+ v.add("\}")
end
- # List of additional .c files required to compile (native interface)
- var extern_bodies = new ArraySet[String]
+ # List of additional files required to compile (FFI)
+ var extern_bodies = new Array[ExternFile]
- # Generate code that check if an instance is correctly initialized
- fun generate_check_init_instance(mtype: MClassType) is abstract
+ # List of source files to copy over to the compile dir
+ var files_to_copy = new Array[String]
+
+ # This is used to avoid adding an extern file more than once
+ private var seen_extern = new ArraySet[String]
# Generate code that initialize the attributes on a new instance
fun generate_init_attr(v: VISITOR, recv: RuntimeVariable, mtype: MClassType)
# Display stats about compilation process
# Metrics used:
- # * type tests against resolved types (x isa Collection[Animal])
- # * type tests against unresolved types (x isa Collection[E])
+ # * type tests against resolved types (`x isa Collection[Animal]`)
+ # * type tests against unresolved types (`x isa Collection[E]`)
# * type tests skipped
# * type tests total
# *
end
end
+ fun finalize_ffi_for_module(mmodule: MModule) do mmodule.finalize_ffi(self)
+
# Division facility
# Avoid division by zero by returning the string "n/a"
fun div(a,b:Int):String
end
end
+# A file unit (may be more than one file if
+# A file unit aim to be autonomous and is made or one or more `CodeWriter`s
+class CodeFile
+ var name: String
+ var writers = new Array[CodeWriter]
+ var required_declarations = new HashSet[String]
+end
+
+# Where to store generated lines
+class CodeWriter
+ var file: CodeFile
+ var lines: List[String] = new List[String]
+ var decl_lines: List[String] = new List[String]
+
+ # Add a line in the main part of the generated C
+ fun add(s: String) do self.lines.add(s)
+
+ # Add a line in the
+ # (used for local or global declaration)
+ fun add_decl(s: String) do self.decl_lines.add(s)
+
+ init(file: CodeFile)
+ do
+ self.file = file
+ file.writers.add(self)
+ end
+end
+
# A visitor on the AST of property definition that generate the C code.
abstract class AbstractCompilerVisitor
# The current visited AST node
var current_node: nullable ANode writable = null
- # The current Frame
+ # The current `Frame`
var frame: nullable Frame writable
# Alias for self.compiler.mainmodule.object_type
# Alias for self.compiler.mainmodule.bool_type
fun bool_type: MClassType do return self.compiler.mainmodule.bool_type
- var file_break: Bool = false
+ var writer: CodeWriter
init(compiler: COMPILER)
do
self.compiler = compiler
- compiler.visitors.add(self)
+ self.writer = new CodeWriter(compiler.files.last)
end
- # Force to get the primitive class named `name' or abort
+ # Force to get the primitive class named `name` or abort
fun get_class(name: String): MClass do return self.compiler.mainmodule.get_primitive_class(name)
- # Force to get the primitive property named `name' in the instance `recv' or abort
+ # Force to get the primitive property named `name` in the instance `recv` or abort
fun get_property(name: String, recv: MType): MMethod
do
- return self.compiler.modelbuilder.force_get_primitive_method(self.current_node.as(not null), name, recv, self.compiler.mainmodule)
+ assert recv isa MClassType
+ return self.compiler.modelbuilder.force_get_primitive_method(self.current_node.as(not null), name, recv.mclass, self.compiler.mainmodule)
end
fun compile_callsite(callsite: CallSite, args: Array[RuntimeVariable]): nullable RuntimeVariable
return self.send(callsite.mproperty, args)
end
+ fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable is abstract
+
fun calloc_array(ret_type: MType, arguments: Array[RuntimeVariable]) is abstract
fun native_array_def(pname: String, ret_type: nullable MType, arguments: Array[RuntimeVariable]) is abstract
- # Transform varargs, in raw arguments, into a single argument of type Array
+ # Transform varargs, in raw arguments, into a single argument of type `Array`
# Note: this method modify the given `args`
# If there is no vararg, then `args` is not modified.
fun varargize(mpropdef: MPropDef, msignature: MSignature, args: Array[RuntimeVariable])
# Unsafely cast a value to a new type
# ie the result share the same C variable but my have a different mcasttype
- # NOTE: if the adaptation is useless then `value' is returned as it.
- # ENSURE: return.name == value.name
+ # NOTE: if the adaptation is useless then `value` is returned as it.
+ # ENSURE: `result.name == value.name`
fun autoadapt(value: RuntimeVariable, mtype: MType): RuntimeVariable
do
mtype = self.anchor(mtype)
fun adapt_signature(m: MMethodDef, args: Array[RuntimeVariable]) is abstract
# Box or unbox a value to another type iff a C type conversion is needed
- # ENSURE: result.mtype.ctype == mtype.ctype
+ # ENSURE: `result.mtype.ctype == mtype.ctype`
fun autobox(value: RuntimeVariable, mtype: MType): RuntimeVariable is abstract
# Generate a polymorphic subtype test
# Generate a static call on a method definition
fun call(m: MMethodDef, recvtype: MClassType, args: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
- # Generate a polymorphic send for the method `m' and the arguments `args'
+ # Generate a polymorphic send for the method `m` and the arguments `args`
fun send(m: MMethod, args: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
- # Generate a monomorphic send for the method `m', the type `t' and the arguments `args'
+ # 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
return self.call(propdef, t, args)
end
+ # Generate a monomorphic super send from the method `m`, the type `t` and the arguments `args`
+ fun monomorphic_super_send(m: MMethodDef, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable
+ do
+ assert t isa MClassType
+ m = m.lookup_next_definition(self.compiler.mainmodule, t)
+ return self.call(m, t, args)
+ end
+
# Attributes handling
# Generate a polymorphic attribute is_set test
var maybenull = recv.mcasttype isa MNullableType or recv.mcasttype isa MNullType
if maybenull then
- self.add("if ({recv} == NULL) \{")
- self.add_abort("Reciever is null")
+ self.add("if (unlikely({recv} == NULL)) \{")
+ self.add_abort("Receiver is null")
self.add("\}")
end
end
- # Generate a check-init-instance
- fun check_init_instance(recv: RuntimeVariable, mtype: MClassType) is abstract
-
# Names handling
private var names: HashSet[String] = new HashSet[String]
private var last: Int = 0
- # Return a new name based on `s' and unique in the visitor
+ # Return a new name based on `s` and unique in the visitor
fun get_name(s: String): String
do
if not self.names.has(s) then
private var escapemark_names = new HashMap[EscapeMark, String]
# Return a "const char*" variable associated to the classname of the dynamic type of an object
- # NOTE: we do not return a RuntimeVariable "NativeString" as the class may not exist in the module/program
+ # NOTE: we do not return a `RuntimeVariable` "NativeString" as the class may not exist in the module/program
fun class_name_string(value: RuntimeVariable): String is abstract
# Variables handling
self.add("if ({name}) \{")
self.add("{res} = {name};")
self.add("\} else \{")
- var nat = self.new_var(self.get_class("NativeString").mclass_type)
+ var native_mtype = self.get_class("NativeString").mclass_type
+ var nat = self.new_var(native_mtype)
self.add("{nat} = \"{string.escape_to_c}\";")
- var res2 = self.init_instance(mtype)
- self.add("{res} = {res2};")
var length = self.int_instance(string.length)
- self.send(self.get_property("with_native", mtype), [res, nat, length])
- self.check_init_instance(res, mtype)
+ self.add("{res} = {self.send(self.get_property("to_s_with_length", native_mtype), [nat, length]).as(not null)};")
self.add("{name} = {res};")
self.add("\}")
return res
# Code generation
- private var lines: List[String] = new List[String]
- private var decl_lines: List[String] = new List[String]
-
# Add a line in the main part of the generated C
- fun add(s: String) do self.lines.add(s)
+ fun add(s: String) do self.writer.lines.add(s)
# Add a line in the
# (used for local or global declaration)
- fun add_decl(s: String) do self.decl_lines.add(s)
+ fun add_decl(s: String) do self.writer.decl_lines.add(s)
+
+ # Request the presence of a global declaration
+ fun require_declaration(key: String)
+ do
+ var reqs = self.writer.file.required_declarations
+ if reqs.has(key) then return
+ reqs.add(key)
+ var node = current_node
+ if node != null then compiler.requirers_of_declarations[key] = node
+ end
+
+ # Add a declaration in the local-header
+ # The declaration is ensured to be present once
+ fun declare_once(s: String)
+ do
+ self.compiler.provide_declaration(s, s)
+ self.require_declaration(s)
+ end
- # Return a new local runtime_variable initialized with the C expression `cexpr'.
+ # look for a needed .h and .c file for a given .nit source-file
+ # FIXME: bad API, parameter should be a `MModule`, not its source-file
+ fun add_extern(file: String)
+ do
+ file = file.strip_extension(".nit")
+ var tryfile = file + ".nit.h"
+ if tryfile.file_exists then
+ self.declare_once("#include \"{tryfile.basename("")}\"")
+ self.compiler.files_to_copy.add(tryfile)
+ end
+ tryfile = file + "_nit.h"
+ if tryfile.file_exists then
+ self.declare_once("#include \"{tryfile.basename("")}\"")
+ self.compiler.files_to_copy.add(tryfile)
+ end
+
+ if self.compiler.seen_extern.has(file) then return
+ self.compiler.seen_extern.add(file)
+ tryfile = file + ".nit.c"
+ if not tryfile.file_exists then
+ tryfile = file + "_nit.c"
+ if not tryfile.file_exists then return
+ end
+ var f = new ExternCFile(tryfile.basename(""), "")
+ self.compiler.extern_bodies.add(f)
+ self.compiler.files_to_copy.add(tryfile)
+ end
+
+ # Return a new local runtime_variable initialized with the C expression `cexpr`.
fun new_expr(cexpr: String, mtype: MType): RuntimeVariable
do
var res = new_var(mtype)
# used by aborts, asserts, casts, etc.
fun add_abort(message: String)
do
+ self.add("PRINT_ERROR(\"Runtime error: %s\", \"{message.escape_to_c}\");")
+ add_raw_abort
+ end
+
+ fun add_raw_abort
+ do
if self.current_node != null and self.current_node.location.file != null then
- self.add("fprintf(stderr, \"Runtime error: %s (%s:%d)\\n\", \"{message.escape_to_c}\", \"{self.current_node.location.file.filename.escape_to_c}\", {current_node.location.line_start});")
+ self.add("PRINT_ERROR(\" (%s:%d)\\n\", \"{self.current_node.location.file.filename.escape_to_c}\", {current_node.location.line_start});")
else
- self.add("fprintf(stderr, \"Runtime error: %s\\n\", \"{message.escape_to_c}\");")
+ self.add("PRINT_ERROR(\"\\n\");")
end
- self.add("exit(1);")
+ self.add("show_backtrace(1);")
+ end
+
+ # Add a dynamic cast
+ fun add_cast(value: RuntimeVariable, mtype: MType, tag: String)
+ do
+ var res = self.type_test(value, mtype, tag)
+ self.add("if (unlikely(!{res})) \{")
+ var cn = self.class_name_string(value)
+ self.add("PRINT_ERROR(\"Runtime error: Cast failed. Expected `%s`, got `%s`\", \"{mtype.to_s.escape_to_c}\", {cn});")
+ self.add_raw_abort
+ self.add("\}")
end
- # Generate a return with the value `s'
+ # Generate a return with the value `s`
fun ret(s: RuntimeVariable)
do
self.assign(self.frame.returnvar.as(not null), s)
res = autoadapt(res, nexpr.mtype.as(not null))
var implicit_cast_to = nexpr.implicit_cast_to
if implicit_cast_to != null and not self.compiler.modelbuilder.toolcontext.opt_no_check_autocast.value then
- var castres = self.type_test(res, implicit_cast_to, "auto")
- self.add("if (!{castres}) \{")
- self.add_abort("Cast failed")
- self.add("\}")
+ add_cast(res, implicit_cast_to, "auto")
res = autoadapt(res, implicit_cast_to)
end
self.current_node = old
return res
end
- # Alias for `self.expr(nexpr, self.bool_type)'
+ # Alias for `self.expr(nexpr, self.bool_type)`
fun expr_bool(nexpr: AExpr): RuntimeVariable do return expr(nexpr, bool_type)
# Safely show a debug message on the current node and repeat the message in the C code as a comment
# May inline the body or generate a C function call
fun call(v: VISITOR, arguments: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
- # Generate the code for the RuntimeFunction
+ # Generate the code for the `AbstractRuntimeFunction`
# Warning: compile more than once compilation makes CC unhappy
fun compile_to_c(compiler: COMPILER) is abstract
end
# A runtime variable hold a runtime value in C.
# Runtime variables are associated to Nit local variables and intermediate results in Nit expressions.
#
-# The tricky point is that a single C variable can be associated to more than one RuntimeVariable because the static knowledge of the type of an expression can vary in the C code.
+# The tricky point is that a single C variable can be associated to more than one `RuntimeVariable` because the static knowledge of the type of an expression can vary in the C code.
class RuntimeVariable
# The name of the variable in the C code
var name: String
end
end
-# A frame correspond to a visited property in a GlobalCompilerVisitor
+# A frame correspond to a visited property in a `GlobalCompilerVisitor`
class Frame
type VISITOR: AbstractCompilerVisitor
var returnlabel: nullable String writable = null
end
-redef class String
- # Mangle a string to be a unique valid C identifier
- fun to_cmangle: String
- do
- var res = new Buffer
- var underscore = false
- for c in self do
- if (c >= 'a' and c <= 'z') or (c >='A' and c <= 'Z') then
- res.add(c)
- underscore = false
- continue
- end
- if underscore then
- res.append('_'.ascii.to_s)
- res.add('d')
- end
- if c >= '0' and c <= '9' then
- res.add(c)
- underscore = false
- else if c == '_' then
- res.add(c)
- underscore = true
- else
- res.add('_')
- res.append(c.ascii.to_s)
- res.add('d')
- underscore = false
- end
- end
- return res.to_s
- end
-
- # Escape " \ ' and non printable characters for literal C strings or characters
- fun escape_to_c: String
- do
- var b = new Buffer
- for c in self do
- if c == '\n' then
- b.append("\\n")
- else if c == '\0' then
- b.append("\\0")
- else if c == '"' then
- b.append("\\\"")
- else if c == '\'' then
- b.append("\\\'")
- else if c == '\\' then
- b.append("\\\\")
- else if c.ascii < 32 then
- b.append("\\{c.ascii.to_base(8, false)}")
- else
- b.add(c)
- end
- end
- return b.to_s
- end
-end
-
redef class MType
# Return the C type associated to a given Nit static type
fun ctype: String do return "val*"
# Can the body be inlined?
fun can_inline(v: VISITOR): Bool
do
+ if is_abstract then return true
var modelbuilder = v.compiler.modelbuilder
if modelbuilder.mpropdef2npropdef.has_key(self) then
var npropdef = modelbuilder.mpropdef2npropdef[self]
# generate the cast
# note that v decides if and how to implements the cast
v.add("/* Covariant cast for argument {i} ({self.msignature.mparameters[i].name}) {arguments[i+1].inspect} isa {mtype} */")
- var cond = v.type_test(arguments[i+1], mtype, "covariance")
- v.add("if (!{cond}) \{")
- v.add_abort("Cast failed")
- v.add("\}")
+ v.add_cast(arguments[i+1], mtype, "covariance")
end
end
end
redef class APropdef
fun compile_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
do
- v.add("printf(\"NOT YET IMPLEMENTED {class_name} {mpropdef} at {location.to_s}\\n\");")
+ v.add("PRINT_ERROR(\"NOT YET IMPLEMENTED {class_name} {mpropdef} at {location.to_s}\\n\");")
debug("Not yet implemented")
end
fun can_inline: Bool do return true
end
-redef class AConcreteMethPropdef
+redef class AMethPropdef
redef fun compile_to_c(v, mpropdef, arguments)
do
- for i in [0..mpropdef.msignature.arity[ do
- var variable = self.n_signature.n_params[i].variable.as(not null)
- v.assign(v.variable(variable), arguments[i+1])
+ if mpropdef.is_abstract then
+ var cn = v.class_name_string(arguments.first)
+ v.add("PRINT_ERROR(\"Runtime error: Abstract method `%s` called on `%s`\", \"{mpropdef.mproperty.name.escape_to_c}\", {cn});")
+ v.add_raw_abort
+ return
end
+
# Call the implicit super-init
var auto_super_inits = self.auto_super_inits
if auto_super_inits != null then
- var selfarg = [arguments.first]
+ var args = [arguments.first]
for auto_super_init in auto_super_inits do
- if auto_super_init.intro.msignature.arity == 0 then
- v.send(auto_super_init, selfarg)
- else
- v.send(auto_super_init, arguments)
+ args.clear
+ for i in [0..auto_super_init.msignature.arity+1[ do
+ args.add(arguments[i])
end
+ v.compile_callsite(auto_super_init, args)
+ end
+ end
+
+ var n_block = n_block
+ if n_block != null then
+ for i in [0..mpropdef.msignature.arity[ do
+ var variable = self.n_signature.n_params[i].variable.as(not null)
+ v.assign(v.variable(variable), arguments[i+1])
+ end
+ v.stmt(n_block)
+ else if mpropdef.is_intern then
+ compile_intern_to_c(v, mpropdef, arguments)
+ else if mpropdef.is_extern then
+ if mpropdef.mproperty.is_init then
+ compile_externinit_to_c(v, mpropdef, arguments)
+ else
+ compile_externmeth_to_c(v, mpropdef, arguments)
end
end
- v.stmt(self.n_block)
end
redef fun can_inline
if nblock isa ABlockExpr and nblock.n_expr.length == 0 then return true
return false
end
-end
-redef class AInternMethPropdef
- redef fun compile_to_c(v, mpropdef, arguments)
+ fun compile_intern_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
do
var pname = mpropdef.mproperty.name
var cname = mpropdef.mclassdef.mclass.name
var ret = mpropdef.msignature.return_mtype
if ret != null then
ret = v.resolve_for(ret, arguments.first)
+ else if mpropdef.mproperty.is_new then
+ ret = arguments.first.mcasttype
end
if pname != "==" and pname != "!=" then
v.adapt_signature(mpropdef, arguments)
else if pname == "unary -" then
v.ret(v.new_expr("-{arguments[0]}", ret.as(not null)))
return
- else if pname == "succ" then
- v.ret(v.new_expr("{arguments[0]}+1", ret.as(not null)))
- return
- else if pname == "prec" then
- v.ret(v.new_expr("{arguments[0]}-1", ret.as(not null)))
- return
else if pname == "*" then
v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null)))
return
v.add("printf(\"%c\", {arguments.first});")
return
else if pname == "object_id" then
- v.ret(arguments.first)
+ v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
return
- else if pname == "+" then
+ else if pname == "successor" then
v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
return
- else if pname == "-" then
+ else if pname == "predecessor" then
v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
return
else if pname == "==" then
var res = v.equal_test(arguments[0], arguments[1])
v.ret(v.new_expr("!{res}", ret.as(not null)))
return
- else if pname == "succ" then
- v.ret(v.new_expr("{arguments[0]}+1", ret.as(not null)))
- return
- else if pname == "prec" then
- v.ret(v.new_expr("{arguments[0]}-1", ret.as(not null)))
- return
else if pname == "<" then
v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
return
v.add("printf({arguments.first}?\"true\\n\":\"false\\n\");")
return
else if pname == "object_id" then
- v.ret(arguments.first)
+ v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
return
else if pname == "==" then
v.ret(v.equal_test(arguments[0], arguments[1]))
v.ret(v.new_expr("(long){arguments[0]}", ret.as(not null)))
return
end
- else if cname == "Char" then
- if pname == "output" then
- v.add("printf(\"%c\", {arguments.first});")
- return
- else if pname == "object_id" then
- v.ret(arguments.first)
- return
- else if pname == "==" then
- v.ret(v.equal_test(arguments[0], arguments[1]))
- return
- else if pname == "!=" then
- var res = v.equal_test(arguments[0], arguments[1])
- v.ret(v.new_expr("!{res}", ret.as(not null)))
- return
- else if pname == "ascii" then
- v.ret(v.new_expr("{arguments[0]}", ret.as(not null)))
- return
- end
else if cname == "NativeString" then
if pname == "[]" then
v.ret(v.new_expr("{arguments[0]}[{arguments[1]}]", ret.as(not null)))
else if pname == "atoi" then
v.ret(v.new_expr("atoi({arguments[0]});", ret.as(not null)))
return
+ else if pname == "init" then
+ v.ret(v.new_expr("(char*)nit_alloc({arguments[1]})", ret.as(not null)))
+ return
end
else if cname == "NativeArray" then
v.native_array_def(pname, ret, arguments)
v.ret(v.new_expr("glob_sys", ret.as(not null)))
return
else if pname == "calloc_string" then
- v.ret(v.new_expr("(char*)GC_MALLOC_ATOMIC({arguments[1]})", ret.as(not null)))
+ v.ret(v.new_expr("(char*)nit_alloc({arguments[1]})", ret.as(not null)))
return
else if pname == "calloc_array" then
v.calloc_array(ret.as(not null), arguments)
else if pname == "is_same_type" then
v.ret(v.is_same_type_test(arguments[0], arguments[1]))
return
+ else if pname == "is_same_instance" then
+ v.ret(v.equal_test(arguments[0], arguments[1]))
+ return
else if pname == "output_class_name" then
var nat = v.class_name_string(arguments.first)
v.add("printf(\"%s\\n\", {nat});")
v.ret(v.new_expr("(char*){nat}", ret.as(not null)))
return
else if pname == "force_garbage_collection" then
- v.add("GC_gcollect();")
+ v.add("nit_gcollect();")
+ return
+ else if pname == "native_argc" then
+ v.ret(v.new_expr("glob_argc", ret.as(not null)))
+ return
+ else if pname == "native_argv" then
+ v.ret(v.new_expr("glob_argv[{arguments[1]}]", ret.as(not null)))
return
end
- v.add("printf(\"NOT YET IMPLEMENTED {class_name}:{mpropdef} at {location.to_s}\\n\");")
+ v.add("PRINT_ERROR(\"NOT YET IMPLEMENTED {class_name}:{mpropdef} at {location.to_s}\\n\");")
debug("Not implemented {mpropdef}")
end
-end
-redef class AExternMethPropdef
- redef fun compile_to_c(v, mpropdef, arguments)
+ fun compile_externmeth_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
do
var externname
var nextern = self.n_extern
if nextern == null then
- v.add("fprintf(stderr, \"NOT YET IMPLEMENTED nitni for {mpropdef} at {location.to_s}\\n\");")
- v.add("exit(1);")
+ v.add("PRINT_ERROR(\"NOT YET IMPLEMENTED nitni for {mpropdef} at {location.to_s}\\n\");")
+ v.add("show_backtrace(1);")
return
end
externname = nextern.text.substring(1, nextern.text.length-2)
if location.file != null then
var file = location.file.filename
- v.compiler.add_extern(file)
+ v.add_extern(file)
end
var res: nullable RuntimeVariable = null
var ret = mpropdef.msignature.return_mtype
v.ret(res)
end
end
-end
-redef class AExternInitPropdef
- redef fun compile_to_c(v, mpropdef, arguments)
+ fun compile_externinit_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
do
var externname
var nextern = self.n_extern
if nextern == null then
- debug("{mpropdef} need extern name")
+ v.add("PRINT_ERROR(\"NOT YET IMPLEMENTED nitni for {mpropdef} at {location.to_s}\\n\");")
+ v.add("show_backtrace(1);")
return
end
externname = nextern.text.substring(1, nextern.text.length-2)
if location.file != null then
var file = location.file.filename
- v.compiler.add_extern(file)
+ v.add_extern(file)
end
v.adapt_signature(mpropdef, arguments)
var ret = arguments.first.mtype
if mpropdef == self.mfree_init then
var super_inits = self.super_inits
if super_inits != null then
- assert arguments.length == 1
+ var args_of_super = arguments
+ if arguments.length > 1 then args_of_super = [arguments.first]
for su in super_inits do
- v.send(su, arguments)
+ v.send(su, args_of_super)
end
- return
end
var recv = arguments.first
var i = 1
end
end
-redef class ADeferredMethPropdef
- redef fun compile_to_c(v, mpropdef, arguments) do v.add_abort("Deferred method called")
- redef fun can_inline do return true
-end
-
redef class AExpr
# Try to compile self as an expression
- # Do not call this method directly, use `v.expr' instead
+ # Do not call this method directly, use `v.expr` instead
private fun expr(v: AbstractCompilerVisitor): nullable RuntimeVariable
do
- v.add("printf(\"NOT YET IMPLEMENTED {class_name}:{location.to_s}\\n\");")
+ v.add("PRINT_ERROR(\"NOT YET IMPLEMENTED {class_name}:{location.to_s}\\n\");")
var mtype = self.mtype
if mtype == null then
return null
end
# Try to compile self as a statement
- # Do not call this method directly, use `v.stmt' instead
+ # Do not call this method directly, use `v.stmt` instead
private fun stmt(v: AbstractCompilerVisitor)
do
var res = expr(v)
do
for e in self.n_expr do v.stmt(e)
end
+ redef fun expr(v)
+ do
+ var last = self.n_expr.last
+ for e in self.n_expr do
+ if e == last then break
+ v.stmt(e)
+ end
+ return v.expr(last, null)
+ end
end
redef class AVardeclExpr
var i = v.expr(self.n_value, variable.declared_type)
v.assign(v.variable(variable), i)
end
+ redef fun expr(v)
+ do
+ var variable = self.variable.as(not null)
+ var i = v.expr(self.n_value, variable.declared_type)
+ v.assign(v.variable(variable), i)
+ return i
+ end
end
redef class AVarReassignExpr
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 AIfexprExpr
var cl = v.expr(self.n_expr, null)
var it_meth = self.method_iterator
assert it_meth != null
- var it = v.send(it_meth, [cl])
+ var it = v.compile_callsite(it_meth, [cl])
assert it != null
v.add("for(;;) \{")
var isok_meth = self.method_is_ok
assert isok_meth != null
- var ok = v.send(isok_meth, [it])
+ var ok = v.compile_callsite(isok_meth, [it])
assert ok != null
v.add("if(!{ok}) break;")
if self.variables.length == 1 then
var item_meth = self.method_item
assert item_meth != null
- var i = v.send(item_meth, [it])
+ var i = v.compile_callsite(item_meth, [it])
assert i != null
v.assign(v.variable(variables.first), i)
else if self.variables.length == 2 then
var key_meth = self.method_key
assert key_meth != null
- var i = v.send(key_meth, [it])
+ var i = v.compile_callsite(key_meth, [it])
assert i != null
v.assign(v.variable(variables[0]), i)
var item_meth = self.method_item
assert item_meth != null
- i = v.send(item_meth, [it])
+ i = v.compile_callsite(item_meth, [it])
assert i != null
v.assign(v.variable(variables[1]), i)
else
v.add("CONTINUE_{v.escapemark_name(escapemark)}: (void)0;")
var next_meth = self.method_next
assert next_meth != null
- v.send(next_meth, [it])
+ v.compile_callsite(next_meth, [it])
v.add("\}")
v.add("BREAK_{v.escapemark_name(escapemark)}: (void)0;")
end
if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return
var cond = v.expr_bool(self.n_expr)
- v.add("if (!{cond}) \{")
+ v.add("if (unlikely(!{cond})) \{")
v.stmt(self.n_else)
var nid = self.n_id
if nid != null then
end
end
+redef class AImpliesExpr
+ 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} = 1;")
+ 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
end
end
-redef class AEeExpr
- redef fun expr(v)
- do
- var value1 = v.expr(self.n_expr, null)
- var value2 = v.expr(self.n_expr2, null)
- return v.equal_test(value1, value2)
- end
-end
-
redef class AIntExpr
- redef fun expr(v) do return v.new_expr("{self.n_number.text}", self.mtype.as(not null))
+ redef fun expr(v) do return v.new_expr("{self.value.to_s}", self.mtype.as(not null))
end
redef class AFloatExpr
- redef fun expr(v) do return v.new_expr("{self.n_float.text}", self.mtype.as(not null))
+ redef fun expr(v) do return v.new_expr("{self.n_float.text}", self.mtype.as(not null)) # FIXME use value, not n_float
end
redef class ACharExpr
- redef fun expr(v) do return v.new_expr("{self.n_char.text}", self.mtype.as(not null))
+ redef fun expr(v) do return v.new_expr("'{self.value.to_s.escape_to_c}'", self.mtype.as(not null))
end
redef class AArrayExpr
var i2 = v.expr(self.n_expr2, null)
var mtype = self.mtype.as(MClassType)
var res = v.init_instance(mtype)
- var it = v.send(v.get_property("init", res.mtype), [res, i1, i2])
- v.check_init_instance(res, mtype)
+ var it = v.compile_callsite(init_callsite.as(not null), [res, i1, i2])
return res
end
end
var i2 = v.expr(self.n_expr2, null)
var mtype = self.mtype.as(MClassType)
var res = v.init_instance(mtype)
- var it = v.send(v.get_property("without_last", res.mtype), [res, i1, i2])
- v.check_init_instance(res, mtype)
+ var it = v.compile_callsite(init_callsite.as(not null), [res, i1, i2])
return res
end
end
var i = v.expr(self.n_expr, null)
if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i
- var cond = v.type_test(i, self.mtype.as(not null), "as")
- v.add("if (!{cond}) \{")
- v.add_abort("Cast failed")
- v.add("\}")
+ v.add_cast(i, self.mtype.as(not null), "as")
return i
end
end
var i = v.expr(self.n_expr, null)
if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i
- v.add("if ({i} == NULL) \{")
+ v.add("if (unlikely({i} == NULL)) \{")
v.add_abort("Cast failed")
v.add("\}")
return i
for a in self.n_args.n_exprs do
args.add(v.expr(a, null))
end
- if args.length == 1 then
- args = v.frame.arguments
- end
- var mproperty = self.mproperty
- if mproperty != null then
- if mproperty.intro.msignature.arity == 0 then
- args = [recv]
+ var callsite = self.callsite
+ if callsite != null then
+ # Add additionnals arguments for the super init call
+ if args.length == 1 then
+ for i in [0..callsite.msignature.arity[ do
+ args.add(v.frame.arguments[i+1])
+ end
end
# Super init call
- var res = v.send(mproperty, args)
+ var res = v.compile_callsite(callsite, args)
return res
end
+ if args.length == 1 then
+ args = v.frame.arguments
+ end
+
# stantard call-next-method
- return v.supercall(v.frame.mpropdef.as(MMethodDef), recv.mtype.as(MClassType), args)
+ return v.supercall(mpropdef.as(not null), recv.mtype.as(MClassType), args)
end
end
var mtype = self.mtype.as(MClassType)
var recv
var ctype = mtype.ctype
- if ctype == "val*" then
+ if mtype.mclass.name == "NativeArray" then
+ assert self.n_args.n_exprs.length == 1
+ var l = v.expr(self.n_args.n_exprs.first, null)
+ assert mtype isa MGenericType
+ var elttype = mtype.arguments.first
+ return v.native_array_instance(elttype, l)
+ else if ctype == "val*" then
recv = v.init_instance(mtype)
else if ctype == "void*" then
recv = v.new_expr("NULL/*special!*/", mtype)
else
- debug("cannot new {mtype}")
- abort
+ recv = v.new_expr("({ctype})0/*special!*/", mtype)
end
var args = [recv]
for a in self.n_args.n_exprs do
#self.debug("got {res2} from {mproperty}. drop {recv}")
return res2
end
- v.check_init_instance(recv, mtype)
return recv
end
end
# Utils
-redef class HashSet[E]
- init from(elements: Collection[E]) do
- init
- self.add_all(elements)
- end
-end
-
redef class Array[E]
- init from(elements: Collection[E]) do
- init
- self.add_all(elements)
- end
-
- # Return a new Array with the elements only contened in 'self' and not in 'o'
+ # Return a new `Array` with the elements only contened in self and not in `o`
fun -(o: Array[E]): Array[E] do
var res = new Array[E]
for e in self do if not o.has(e) then res.add(e)
end
redef class MModule
-
- # Return a linearization of a set of mtypes
- fun linearize_mtypes(mtypes: Set[MType]): Array[MType] do
- var lin = new Array[MType].from(mtypes)
- var sorter = new TypeSorter(self)
- sorter.sort(lin)
- return lin
- end
-
- # Return a reverse linearization of a set of mtypes
- fun reverse_linearize_mtypes(mtypes: Set[MType]): Array[MType] do
- var lin = new Array[MType].from(mtypes)
- var sorter = new ReverseTypeSorter(self)
- sorter.sort(lin)
- return lin
- end
-
- # Return super types of a `mtype` in `self`
- fun super_mtypes(mtype: MType, mtypes: Set[MType]): Set[MType] do
- if not self.super_mtypes_cache.has_key(mtype) then
- var supers = new HashSet[MType]
- for otype in mtypes do
- if otype == mtype then continue
- if mtype.is_subtype(self, null, otype) then
- supers.add(otype)
- end
- end
- self.super_mtypes_cache[mtype] = supers
- end
- return self.super_mtypes_cache[mtype]
- end
-
- private var super_mtypes_cache: Map[MType, Set[MType]] = new HashMap[MType, Set[MType]]
-
- # Return all sub mtypes (directs and indirects) of a `mtype` in `self`
- fun sub_mtypes(mtype: MType, mtypes: Set[MType]): Set[MType] do
- if not self.sub_mtypes_cache.has_key(mtype) then
- var subs = new HashSet[MType]
- for otype in mtypes do
- if otype == mtype then continue
- if otype.is_subtype(self, null, mtype) then
- subs.add(otype)
- end
- end
- self.sub_mtypes_cache[mtype] = subs
- end
- return self.sub_mtypes_cache[mtype]
- end
-
- private var sub_mtypes_cache: Map[MType, Set[MType]] = new HashMap[MType, Set[MType]]
-
- # Return a linearization of a set of mclasses
- fun linearize_mclasses_2(mclasses: Set[MClass]): Array[MClass] do
- var lin = new Array[MClass].from(mclasses)
- var sorter = new ClassSorter(self)
- sorter.sort(lin)
- return lin
- end
-
- # Return a reverse linearization of a set of mtypes
- fun reverse_linearize_mclasses(mclasses: Set[MClass]): Array[MClass] do
- var lin = new Array[MClass].from(mclasses)
- var sorter = new ReverseClassSorter(self)
- sorter.sort(lin)
- return lin
- end
-
- # Return all super mclasses (directs and indirects) of a `mclass` in `self`
- fun super_mclasses(mclass: MClass): Set[MClass] do
- if not self.super_mclasses_cache.has_key(mclass) then
- var supers = new HashSet[MClass]
- if self.flatten_mclass_hierarchy.has(mclass) then
- for sup in self.flatten_mclass_hierarchy[mclass].greaters do
- if sup == mclass then continue
- supers.add(sup)
- end
- end
- self.super_mclasses_cache[mclass] = supers
- end
- return self.super_mclasses_cache[mclass]
- end
-
- private var super_mclasses_cache: Map[MClass, Set[MClass]] = new HashMap[MClass, Set[MClass]]
-
- # Return all parents of a `mclass` in `self`
- fun parent_mclasses(mclass: MClass): Set[MClass] do
- if not self.parent_mclasses_cache.has_key(mclass) then
- var parents = new HashSet[MClass]
- if self.flatten_mclass_hierarchy.has(mclass) then
- for sup in self.flatten_mclass_hierarchy[mclass].direct_greaters do
- if sup == mclass then continue
- parents.add(sup)
- end
- end
- self.parent_mclasses_cache[mclass] = parents
- end
- return self.parent_mclasses_cache[mclass]
- end
-
- private var parent_mclasses_cache: Map[MClass, Set[MClass]] = new HashMap[MClass, Set[MClass]]
-
- # Return all sub mclasses (directs and indirects) of a `mclass` in `self`
- fun sub_mclasses(mclass: MClass): Set[MClass] do
- if not self.sub_mclasses_cache.has_key(mclass) then
- var subs = new HashSet[MClass]
- if self.flatten_mclass_hierarchy.has(mclass) then
- for sub in self.flatten_mclass_hierarchy[mclass].smallers do
- if sub == mclass then continue
- subs.add(sub)
- end
- end
- self.sub_mclasses_cache[mclass] = subs
- end
- return self.sub_mclasses_cache[mclass]
- end
-
- private var sub_mclasses_cache: Map[MClass, Set[MClass]] = new HashMap[MClass, Set[MClass]]
-
- # All 'mproperties' associated to all 'mclassdefs' of `mclass`
+ # All `MProperty` associated to all `MClassDef` of `mclass`
fun properties(mclass: MClass): Set[MProperty] do
if not self.properties_cache.has_key(mclass) then
var properties = new HashSet[MProperty]
- var parents = self.super_mclasses(mclass)
+ var parents = new Array[MClass]
+ if self.flatten_mclass_hierarchy.has(mclass) then
+ parents.add_all(mclass.in_hierarchy(self).direct_greaters)
+ end
for parent in parents do
properties.add_all(self.properties(parent))
end
-
for mclassdef in mclass.mclassdefs do
- for mpropdef in mclassdef.mpropdefs do
- properties.add(mpropdef.mproperty)
+ for mprop in mclassdef.intro_mproperties do
+ properties.add(mprop)
end
end
self.properties_cache[mclass] = properties
end
return properties_cache[mclass]
end
-
private var properties_cache: Map[MClass, Set[MProperty]] = new HashMap[MClass, Set[MProperty]]
-end
-# A sorter for linearize list of types
-private class TypeSorter
- super AbstractSorter[MType]
+ # Write FFI and nitni results to file
+ fun finalize_ffi(c: AbstractCompiler) do end
- private var mmodule: MModule
-
- init(mmodule: MModule) do self.mmodule = mmodule
-
- redef fun compare(a, b) do
- if a == b then
- return 0
- else if a.is_subtype(self.mmodule, null, b) then
- return -1
- end
- return 1
- end
+ # Give requided addinional system libraries (as given to LD_LIBS)
+ # Note: can return null instead of an empty set
+ fun collect_linker_libs: nullable Set[String] do return null
end
-# A sorter for reverse linearization
-private class ReverseTypeSorter
- super TypeSorter
+# Create a tool context to handle options and paths
+var toolcontext = new ToolContext
- init(mmodule: MModule) do end
+var opt_mixins = new OptionArray("Additionals module to min-in", "-m")
+toolcontext.option_context.add_option(opt_mixins)
- redef fun compare(a, b) do
- if a == b then
- return 0
- else if a.is_subtype(self.mmodule, null, b) then
- return 1
- end
- return -1
- end
-end
+toolcontext.tooldescription = "Usage: nitg [OPTION]... file.nit\nCompiles Nit programs."
-# A sorter for linearize list of classes
-private class ClassSorter
- super AbstractSorter[MClass]
+# We do not add other options, so process them now!
+toolcontext.process_options(args)
- var mmodule: MModule
+# We need a model to collect stufs
+var model = new Model
+# An a model builder to parse files
+var modelbuilder = new ModelBuilder(model, toolcontext)
- redef fun compare(a, b) do
- if a == b then
- return 0
- else if self.mmodule.flatten_mclass_hierarchy.has(a) and self.mmodule.flatten_mclass_hierarchy[a].greaters.has(b) then
- return -1
- end
- return 1
- end
+var arguments = toolcontext.option_context.rest
+if arguments.length > 1 then
+ print "Too much arguments: {arguments.join(" ")}"
+ print toolcontext.tooldescription
+ exit 1
end
+var progname = arguments.first
-# A sorter for reverse linearization
-private class ReverseClassSorter
- super AbstractSorter[MClass]
+# Here we load an process all modules passed on the command line
+var mmodules = modelbuilder.parse([progname])
+mmodules.add_all modelbuilder.parse(opt_mixins.value)
- var mmodule: MModule
+if mmodules.is_empty then return
+modelbuilder.run_phases
- redef fun compare(a, b) do
- if a == b then
- return 0
- else if self.mmodule.flatten_mclass_hierarchy.has(a) and self.mmodule.flatten_mclass_hierarchy[a].greaters.has(b) then
- return 1
- end
- return -1
- end
+var mainmodule
+if mmodules.length == 1 then
+ mainmodule = mmodules.first
+else
+ mainmodule = new MModule(model, null, mmodules.first.name, mmodules.first.location)
+ mainmodule.set_imported_mmodules(mmodules)
end
+
+toolcontext.run_global_phases(mmodules)