import literal
import typing
import auto_super_init
-import frontend
import platform
import c_tools
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_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_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")
- # --no-stacktrace
- var opt_no_stacktrace: OptionBool = new OptionBool("Disables libunwind and generation of C stack traces (can be problematic when compiling to targets such as Android or NaCl)", "--no-stacktrace")
- # --stack-trace-C-to-Nit-name-binding
- var opt_stacktrace: OptionBool = new OptionBool("Enables the use of gperf to bind C to Nit function names when encountering a Stack trace at runtime", "--nit-stacktrace")
+ # --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_compile_dir, 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.opt_invocation_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_stacktrace)
self.option_context.add_option(self.opt_no_gcc_directive)
+ self.option_context.add_option(self.opt_release)
end
-end
-redef class ModelBuilder
- redef init(model, toolcontext)
+ redef fun process_options(args)
do
- if toolcontext.opt_no_stacktrace.value and toolcontext.opt_stacktrace.value then
- print "Cannot use --nit-stacktrace when --no-stacktrace is activated"
+ 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
-
- super
end
+end
+redef class ModelBuilder
# The compilation directory
var compile_dir: String
# The list is initially set with :
# * the toolcontext --cc-path option
# * the NIT_CC_PATH environment variable
- # * some heuristics including the NIT_DIR environment variable and the progname of the process
+ # * `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 = "NIT_DIR".environ
- if not path_env.is_empty then
+ 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
- var libname = "{sys.program_name.dirname}/../clib"
- if libname.file_exists then cc_paths.add(libname.simplify_path)
-
if cc_paths.is_empty then
toolcontext.error(null, "Cannot determine the nit clib path. define envvar NIT_DIR.")
end
fun write_files(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String])
do
- if self.toolcontext.opt_stacktrace.value then compiler.build_c_to_nit_bindings
+ if self.toolcontext.opt_stacktrace.value == "nitstack" then compiler.build_c_to_nit_bindings
# Add gc_choser.h to aditionnal bodies
var gc_chooser = new ExternCFile("gc_chooser.c", "-DWITH_LIBGC")
if libs != null then linker_options.add_all(libs)
end
- if not toolcontext.opt_no_stacktrace.value then linker_options.add("-lunwind")
+ 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")
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
var o = f.makefile_rule_name
makefile.write("{o}: {ff}\n")
makefile.write("\t{f.makefile_rule_content}\n\n")
dep_rules.add(f.makefile_rule_name)
- ofiles.add(o)
+
+ 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
do
var compile_dir = modelbuilder.compile_dir
- var stream = new OFStream.open("{compile_dir}/C_fun_names")
- stream.write("%\{\n#include \"c_functions_hash.h\"\n%\}\n")
- stream.write("%define lookup-function-name get_nit_name\n")
- stream.write("struct C_Nit_Names;\n")
- stream.write("%%\n")
- stream.write("####\n")
+ 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(",\t\"")
+ stream.write("\",\"")
stream.write(names[i])
- stream.write("\"\n")
- end
- if names.is_empty then
- stream.write("DEAD,\t\"DEAD\"\n") # Force at least one entry
- end
- stream.write("####\n")
- stream.write("%%\n")
+ 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("typedef struct C_Nit_Names\{char* name; char* nit_name;\}C_Nit_Names;\n")
- stream.write("const struct C_Nit_Names* get_nit_name(register const char *str, register unsigned int len);\n")
+ stream.write("const char* get_nit_name(register const char* procname, register unsigned int len);\n")
stream.close
- var x = new Process("gperf","{compile_dir}/C_fun_names","-t","-7","--output-file={compile_dir}/c_functions_hash.c","-C")
- x.wait
-
extern_bodies.add(new ExternCFile("{compile_dir}/c_functions_hash.c", ""))
end
self.header.add_decl("#include <stdio.h>")
self.header.add_decl("#include <string.h>")
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
fun compile_main_function
do
var v = self.new_visitor
- if modelbuilder.toolcontext.opt_stacktrace.value then
- v.add_decl("#include \"c_functions_hash.h\"")
- end
v.add_decl("#include <signal.h>")
- if not modelbuilder.toolcontext.opt_no_stacktrace.value then
+ 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.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("printf(\"Caught signal : %s\\n\", strsignal(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 not modelbuilder.toolcontext.opt_no_stacktrace.value then
+ 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("char* procname = malloc(sizeof(char) * 100);")
v.add_decl("unw_getcontext(&uc);")
v.add_decl("unw_init_local(&cursor, &uc);")
- v.add_decl("printf(\"-------------------------------------------------\\n\");")
- v.add_decl("printf(\"-- Stack Trace ------------------------------\\n\");")
- v.add_decl("printf(\"-------------------------------------------------\\n\");")
+ 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 modelbuilder.toolcontext.opt_stacktrace.value then
- v.add_decl(" const C_Nit_Names* recv = get_nit_name(procname, strlen(procname));")
- v.add_decl(" if (recv != 0)\{")
- v.add_decl(" printf(\"` %s\\n\", recv->nit_name);")
+ 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(" printf(\"` %s\\n\", procname);")
+ v.add_decl(" PRINT_ERROR(\"` %s\\n\", procname);")
v.add_decl(" \}")
else
- v.add_decl(" printf(\"` %s \\n\",procname);")
+ v.add_decl(" PRINT_ERROR(\"` %s \\n\",procname);")
end
v.add_decl("\}")
- v.add_decl("printf(\"-------------------------------------------------\\n\");")
+ v.add_decl("PRINT_ERROR(\"-------------------------------------------------\\n\");")
v.add_decl("free(procname);")
v.add_decl("\}")
end
v.add_decl("exit(signo);")
v.add_decl("\}")
- v.add_decl("int main(int argc, char** argv) \{")
+ 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("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
+
+ 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
# used by aborts, asserts, casts, etc.
fun add_abort(message: String)
do
- self.add("fprintf(stderr, \"Runtime error: %s\", \"{message.escape_to_c}\");")
+ 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, \" (%s:%d)\\n\", \"{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, \"\\n\");")
+ self.add("PRINT_ERROR(\"\\n\");")
end
self.add("show_backtrace(1);")
end
var res = self.type_test(value, mtype, tag)
self.add("if (unlikely(!{res})) \{")
var cn = self.class_name_string(value)
- self.add("fprintf(stderr, \"Runtime error: Cast failed. Expected `%s`, got `%s`\", \"{mtype.to_s.escape_to_c}\", {cn});")
+ 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
# 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]
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
v.compile_callsite(auto_super_init, args)
end
end
- v.stmt(self.n_block)
+
+ 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
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
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
else if pname == "object_id" then
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.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("PRINT_ERROR(\"NOT YET IMPLEMENTED nitni for {mpropdef} at {location.to_s}\\n\");")
v.add("show_backtrace(1);")
return
end
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
- v.add("printf(\"NOT YET IMPLEMENTED nitni for {mpropdef} at {location.to_s}\\n\");")
+ v.add("PRINT_ERROR(\"NOT YET IMPLEMENTED nitni for {mpropdef} at {location.to_s}\\n\");")
v.add("show_backtrace(1);")
return
end
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
- var cn = v.class_name_string(arguments.first)
- v.add("fprintf(stderr, \"Runtime error: Abstract method `%s` called on `%s`\", \"{mpropdef.mproperty.name.escape_to_c}\", {cn});")
- v.add_raw_abort
- end
- 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
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
if callsite != null then
# Add additionnals arguments for the super init call
if args.length == 1 then
- for i in [0..callsite.mproperty.intro.msignature.arity[ do
+ for i in [0..callsite.msignature.arity[ do
args.add(v.frame.arguments[i+1])
end
end
# Note: can return null instead of an empty set
fun collect_linker_libs: nullable Set[String] do return null
end
+
+# Create a tool context to handle options and paths
+var toolcontext = new ToolContext
+
+var opt_mixins = new OptionArray("Additionals module to min-in", "-m")
+toolcontext.option_context.add_option(opt_mixins)
+
+toolcontext.tooldescription = "Usage: nitg [OPTION]... file.nit\nCompiles Nit programs."
+
+# We do not add other options, so process them now!
+toolcontext.process_options(args)
+
+# We need a model to collect stufs
+var model = new Model
+# An a model builder to parse files
+var modelbuilder = new ModelBuilder(model, toolcontext)
+
+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
+
+# 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)
+
+if mmodules.is_empty then return
+modelbuilder.run_phases
+
+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)
nitlanguage / nit.git / blobdiff