redef class ToolContext
# --output
var opt_output: OptionString = new OptionString("Output file", "-o", "--output")
+ # --dir
+ var opt_dir: OptionString = new OptionString("Output directory", "--dir")
# --no-cc
var opt_no_cc: OptionBool = new OptionBool("Do not invoke C compiler", "--no-cc")
# --no-main
redef init
do
super
- 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_output, self.opt_dir, 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)
super
var st = opt_stacktrace.value
- if st == null or st == "none" or st == "libunwind" or st == "nitstack" then
+ if 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 if st == "auto" or st == null then
+ # Default is nitstack
+ opt_stacktrace.value = "nitstack"
else
print "Error: unknown value `{st}` for --stacktrace. Use `none`, `libunwind`, `nitstack` or `auto`."
exit(1)
end
+
+ if opt_output.value != null and opt_dir.value != null then
+ print "Error: cannot use both --dir and --output"
+ exit(1)
+ end
end
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
+ if self.toolcontext.opt_stacktrace.value == "nitstack" and (platform == null or platform.supports_libunwind) then compiler.build_c_to_nit_bindings
+ 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", "-DWITH_LIBGC")
+ 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"
self.toolcontext.info("Total C source files to compile: {cfiles.length}", 2)
end
+ fun makefile_name(mainmodule: MModule): String do return "{mainmodule.name}.mk"
+
+ fun default_outname(mainmodule: MModule): String do return mainmodule.name
+
+ # Combine options and platform informations to get the final path of the outfile
+ fun outfile(mainmodule: MModule): String
+ do
+ var res = self.toolcontext.opt_output.value
+ if res != null then return res
+ res = default_outname(mainmodule)
+ var dir = self.toolcontext.opt_dir.value
+ if dir != null then return dir.join_path(res)
+ return res
+ end
+
fun write_makefile(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String])
do
var mainmodule = compiler.mainmodule
+ var platform = compiler.mainmodule.target_platform
- var outname = self.toolcontext.opt_output.value
- if outname == null then
- outname = "{mainmodule.name}"
- end
+ var outname = outfile(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 = "{mainmodule.name}.mk"
+ var makename = makefile_name(mainmodule)
var makepath = "{compile_dir}/{makename}"
var makefile = new OFStream.open(makepath)
if libs != null then linker_options.add_all(libs)
end
+ makefile.write("CC = ccache cc\nCXX = ccache c++\nCFLAGS = -g -O2 -Wno-unused-value -Wno-switch\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lm -lgc {linker_options.join(" ")}\n\n")
+
var ost = toolcontext.opt_stacktrace.value
- if ost == "libunwind" or ost == "nitstack" then linker_options.add("-lunwind")
+ if (ost == "libunwind" or ost == "nitstack") and (platform == null or platform.supports_libunwind) then makefile.write("NEED_LIBUNWIND := YesPlease\n")
+
+ # Dynamic adaptations
+ # While `platform` enable complex toolchains, they are statically applied
+ # For a dynamic adaptsation of the compilation, the generated Makefile should check and adapt things itself
+
+ # Check and adapt the targeted system
+ makefile.write("uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')\n")
+ makefile.write("ifeq ($(uname_S),Darwin)\n")
+ # remove -lunwind since it is already included on macosx
+ makefile.write("\tNEED_LIBUNWIND :=\n")
+ makefile.write("endif\n\n")
+
+ # Check and adapt for the compiler used
+ # clang need an additionnal `-Qunused-arguments`
+ makefile.write("clang_check := $(shell sh -c '$(CC) -v 2>&1 | grep -q clang; echo $$?')\nifeq ($(clang_check), 0)\n\tCFLAGS += -Qunused-arguments\nendif\n")
+
+ makefile.write("ifdef NEED_LIBUNWIND\n\tLDLIBS += -lunwind\nendif\n")
- 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]
fun compile_c_code(compiler: AbstractCompiler, compile_dir: String)
do
- var makename = "{compiler.mainmodule.name}.mk" # FIXME duplicated from write_makefile
+ var makename = makefile_name(compiler.mainmodule)
var makeflags = self.toolcontext.opt_make_flags.value
if makeflags == null then makeflags = ""
protected fun compile_header_structs is abstract
# Declaration of structures for nitni undelying the FFI
- protected fun compile_nitni_structs is abstract
+ protected fun compile_nitni_structs
+ do
+ self.header.add_decl """
+/* Native reference to Nit objects */
+/* This structure is used to represent every Nit type in extern methods and custom C code. */
+struct nitni_ref {
+ struct nitni_ref *next,
+ *prev; /* adjacent global references in global list */
+ int count; /* number of time this global reference has been marked */
+};
+
+/* List of global references from C code to Nit objects */
+/* Instanciated empty at init of Nit system and filled explicitly by user in C code */
+struct nitni_global_ref_list_t {
+ struct nitni_ref *head, *tail;
+};
+extern struct nitni_global_ref_list_t *nitni_global_ref_list;
+
+/* Initializer of global reference list */
+extern void nitni_global_ref_list_init();
+
+/* Intern function to add a global reference to the list */
+extern void nitni_global_ref_add( struct nitni_ref *ref );
+
+/* Intern function to remove a global reference from the list */
+extern void nitni_global_ref_remove( struct nitni_ref *ref );
+
+/* Increase count on an existing global reference */
+extern void nitni_global_ref_incr( struct nitni_ref *ref );
+
+/* Decrease count on an existing global reference */
+extern void nitni_global_ref_decr( struct nitni_ref *ref );
+"""
+ end
+
+ fun compile_finalizer_function
+ do
+ var finalizable_type = mainmodule.finalizable_type
+ if finalizable_type == null then return
+
+ var finalize_meth = mainmodule.try_get_primitive_method("finalize", finalizable_type.mclass)
+
+ if finalize_meth == null then
+ modelbuilder.toolcontext.error(null, "The `Finalizable` class doesn't declare the `finalize` method.")
+ return
+ end
+
+ var v = self.new_visitor
+ v.add_decl "void gc_finalize (void *obj, void *client_data) \{"
+ var recv = v.new_expr("obj", finalizable_type)
+ v.send(finalize_meth, [recv])
+ v.add "\}"
+ end
# Generate the main C function.
# This function:
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 not platform.supports_libunwind then ost = "none"
- if platform != null and platform.no_main then modelbuilder.toolcontext.opt_no_main.value = true
+ var no_main = (platform != null and platform.no_main) or modelbuilder.toolcontext.opt_no_main.value
if ost == "nitstack" or ost == "libunwind" then
v.add_decl("#define UNW_LOCAL_ONLY")
v.add_decl("exit(signo);")
v.add_decl("\}")
- if modelbuilder.toolcontext.opt_no_main.value then
+ if no_main then
v.add_decl("int nit_main(int argc, char** argv) \{")
else
v.add_decl("int main(int argc, char** argv) \{")
v.add("glob_argc = argc; glob_argv = argv;")
v.add("initialize_gc_option();")
+
+ v.add "initialize_nitni_global_refs();"
+
var main_type = mainmodule.sys_type
if main_type != null then
var mainmodule = v.compiler.mainmodule
if main_init != null then
v.send(main_init, [glob_sys])
end
- var main_method = mainmodule.try_get_primitive_method("main", main_type.mclass)
+ 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
v.add("\}")
end
+ # Copile all C functions related to the [incr|decr]_ref features of the FFI
+ fun compile_nitni_global_ref_functions
+ do
+ var v = self.new_visitor
+ v.add """
+struct nitni_global_ref_list_t *nitni_global_ref_list;
+void initialize_nitni_global_refs() {
+ nitni_global_ref_list = (struct nitni_global_ref_list_t*)nit_alloc(sizeof(struct nitni_global_ref_list_t));
+ nitni_global_ref_list->head = NULL;
+ nitni_global_ref_list->tail = NULL;
+}
+
+void nitni_global_ref_add( struct nitni_ref *ref ) {
+ if ( nitni_global_ref_list->head == NULL ) {
+ nitni_global_ref_list->head = ref;
+ ref->prev = NULL;
+ } else {
+ nitni_global_ref_list->tail->next = ref;
+ ref->prev = nitni_global_ref_list->tail;
+ }
+ nitni_global_ref_list->tail = ref;
+
+ ref->next = NULL;
+}
+
+void nitni_global_ref_remove( struct nitni_ref *ref ) {
+ if ( ref->prev == NULL ) {
+ nitni_global_ref_list->head = ref->next;
+ } else {
+ ref->prev->next = ref->next;
+ }
+
+ if ( ref->next == NULL ) {
+ nitni_global_ref_list->tail = ref->prev;
+ } else {
+ ref->next->prev = ref->prev;
+ }
+}
+
+extern void nitni_global_ref_incr( struct nitni_ref *ref ) {
+ if ( ref->count == 0 ) /* not registered */
+ {
+ /* add to list */
+ nitni_global_ref_add( ref );
+ }
+
+ ref->count ++;
+}
+
+extern void nitni_global_ref_decr( struct nitni_ref *ref ) {
+ if ( ref->count == 1 ) /* was last reference */
+ {
+ /* remove from list */
+ nitni_global_ref_remove( ref );
+ }
+
+ ref->count --;
+}
+"""
+ end
+
# List of additional files required to compile (FFI)
var extern_bodies = new Array[ExternFile]
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
# Generate a alloc-instance + init-attributes
fun init_instance(mtype: MClassType): RuntimeVariable is abstract
+ # Set a GC finalizer on `recv`, only if `recv` isa Finalizable
+ fun set_finalizer(recv: RuntimeVariable)
+ do
+ var mtype = recv.mtype
+ var finalizable_type = compiler.mainmodule.finalizable_type
+ if finalizable_type != null and not mtype.need_anchor and
+ mtype.is_subtype(compiler.mainmodule, null, finalizable_type) then
+ add "gc_register_finalizer({recv});"
+ end
+ end
+
# Generate an integer value
fun int_instance(value: Int): RuntimeVariable
do
do
if mpropdef.is_abstract then
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("PRINT_ERROR(\"Runtime error: Abstract method `%s` called on `%s`\", \"{mpropdef.mproperty.name.escape_to_c}\", {cn});")
v.add_raw_abort
return
end
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 == "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)
redef class AAttrPropdef
redef fun compile_to_c(v, mpropdef, arguments)
do
- if arguments.length == 1 then
- var res = v.read_attribute(self.mpropdef.mproperty, arguments.first)
+ if mpropdef == mreadpropdef then
+ assert arguments.length == 1
+ var res
+ if is_lazy then
+ var nexpr = n_expr
+ assert nexpr != null
+ var set
+ var ret = self.mpropdef.static_mtype
+ var useiset = ret.ctype == "val*" and not ret isa MNullableType
+ var guard = self.mlazypropdef.mproperty
+ if useiset then
+ set = v.isset_attribute(self.mpropdef.mproperty, arguments.first)
+ else
+ set = v.read_attribute(guard, arguments.first)
+ end
+ v.add("if(likely({set})) \{")
+ res = v.read_attribute(self.mpropdef.mproperty, arguments.first)
+ v.add("\} else \{")
+ var value = v.expr(nexpr, self.mpropdef.static_mtype)
+ v.write_attribute(self.mpropdef.mproperty, arguments.first, value)
+ v.assign(res, value)
+ if not useiset then
+ var true_v = v.new_expr("1", v.bool_type)
+ v.write_attribute(guard, arguments.first, true_v)
+ end
+ v.add("\}")
+ else
+ res = v.read_attribute(self.mpropdef.mproperty, arguments.first)
+ end
v.assign(v.frame.returnvar.as(not null), res)
- else
+ else if mpropdef == mwritepropdef then
+ assert arguments.length == 2
v.write_attribute(self.mpropdef.mproperty, arguments.first, arguments[1])
+ if is_lazy then
+ var ret = self.mpropdef.static_mtype
+ var useiset = ret.ctype == "val*" and not ret isa MNullableType
+ if not useiset then
+ v.write_attribute(self.mlazypropdef.mproperty, arguments.first, v.new_expr("1", v.bool_type))
+ end
+ end
+ else
+ abort
end
end
fun init_expr(v: AbstractCompilerVisitor, recv: RuntimeVariable)
do
var nexpr = self.n_expr
- if nexpr != null then
+ if nexpr != null and not is_lazy then
var oldnode = v.current_node
v.current_node = self
var old_frame = v.frame
var i = 1
# Collect undefined attributes
for npropdef in self.n_propdefs do
- if npropdef isa AAttrPropdef and npropdef.n_expr == null then
+ if npropdef isa AAttrPropdef and npropdef.n_expr == null and not npropdef.noinit then
v.write_attribute(npropdef.mpropdef.mproperty, recv, arguments[i])
i += 1
end
var i = v.expr(self.n_expr, null)
if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i
+ if i.mtype.ctype != "val*" then return i
+
v.add("if (unlikely({i} == NULL)) \{")
v.add_abort("Cast failed")
v.add("\}")
do
var recv = v.expr(self.n_expr, null)
var args = [recv]
- for a in self.raw_arguments.as(not null) do
+ for a in self.raw_arguments do
args.add(v.expr(a, null))
end
return v.compile_callsite(self.callsite.as(not null), args)
do
var recv = v.expr(self.n_expr, null)
var args = [recv]
- for a in self.raw_arguments.as(not null) do
+ for a in self.raw_arguments do
args.add(v.expr(a, null))
end
var value = v.expr(self.n_value, null)
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
properties.add_all(self.properties(parent))
end
for mclassdef in mclass.mclassdefs do
+ if not self.in_importation <= mclassdef.mmodule then continue
for mprop in mclassdef.intro_mproperties do
properties.add(mprop)
end
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."
+toolcontext.tooldescription = "Usage: nitg [OPTION]... file.nit...\nCompiles Nit programs."
# We do not add other options, so process them now!
toolcontext.process_options(args)
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
+if arguments.length > 1 and toolcontext.opt_output.value != null then
+ print "Error: --output needs a single source file. Do you prefer --dir?"
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)
+var mmodules = modelbuilder.parse(arguments)
+var mixins = 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)
+for mmodule in mmodules do
+ toolcontext.info("*** PROCESS {mmodule} ***", 1)
+ var ms = [mmodule]
+ if not mixins.is_empty then
+ ms.add_all mixins
+ end
+ toolcontext.run_global_phases(ms)
end
-toolcontext.run_global_phases(mmodules)
nitlanguage / nit.git / blobdiff