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 = ""
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 or else default_outname(mainmodule)
+ 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
if libs != null then linker_options.add_all(libs)
end
- var ost = toolcontext.opt_stacktrace.value
- if ost == "libunwind" or ost == "nitstack" then linker_options.add("-lunwind")
+ 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")
- makefile.write("CC = ccache cc\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") 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("all: {outpath}\n\n")
var ofiles = new Array[String]
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
# 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
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]
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)
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)