import literal
import typing
import auto_super_init
+import frontend
# Add compiling options
redef class ToolContext
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_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")
+ # --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")
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_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.option_context.add_option(self.opt_stacktrace)
+ self.option_context.add_option(self.opt_no_stacktrace)
end
end
toolcontext.error(null, "Cannot determine the nit clib path. define envvar NIT_DIR.")
end
+ if toolcontext.opt_no_stacktrace.value and toolcontext.opt_stacktrace.value then
+ print "Cannot use --nit-stacktrace when --no-stacktrace is activated"
+ exit(1)
+ end
+
# Add user defined cc_paths
cc_paths.append(toolcontext.opt_cc_path.value)
var time0 = get_time
self.toolcontext.info("*** WRITING C ***", 1)
- ".nit_compile".mkdir
+ var compile_dir = toolcontext.opt_compile_dir.value
+ if compile_dir == null then compile_dir = ".nit_compile"
+
+ compile_dir.mkdir
+
+ if self.toolcontext.opt_stacktrace.value then compiler.build_c_to_nit_bindings
+
+ # Add gc_choser.h to aditionnal bodies
+ var gc_chooser = new ExternCFile("{cc_paths.first}/gc_chooser.c", "-DWITH_LIBGC")
+ compiler.extern_bodies.add(gc_chooser)
+
+ # 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 orig_dir=".." # FIXME only works if `compile_dir` is a subdirectory of cwd
var outname = self.toolcontext.opt_output.value
if outname == null then
outname = "{mainmodule.name}"
end
+ var outpath = orig_dir.join_path(outname).simplify_path
var hfilename = compiler.header.file.name + ".h"
- var hfilepath = ".nit_compile/{hfilename}"
+ var hfilepath = "{compile_dir}/{hfilename}"
var h = new OFStream.open(hfilepath)
for l in compiler.header.decl_lines do
h.write l
var i = 0
var hfile: nullable OFStream = null
var count = 0
- var cfilename = ".nit_compile/{f.name}.0.h"
- hfile = new OFStream.open(cfilename)
+ 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
if file == null or count > 10000 then
i += 1
if file != null then file.close
- cfilename = ".nit_compile/{f.name}.{i}.c"
- self.toolcontext.info("new C source files to compile: {cfilename}", 3)
+ 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(cfilename)
+ file = new OFStream.open(cfilepath)
file.write "#include \"{f.name}.0.h\"\n"
count = total_lines
end
# Generate the Makefile
- var makename = ".nit_compile/{mainmodule.name}.mk"
- var makefile = new OFStream.open(makename)
+ var makename = "{mainmodule.name}.mk"
+ var makepath = "{compile_dir}/{makename}"
+ var makefile = new OFStream.open(makepath)
var cc_includes = ""
for p in cc_paths do
- #p = "..".join_path(p)
+ p = orig_dir.join_path(p).simplify_path
cc_includes += " -I \"" + p + "\""
end
- makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lm -lgc\n\n")
- makefile.write("all: {outname}\n\n")
+ if toolcontext.opt_no_stacktrace.value then
+ makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lm -lgc\n\n")
+ else
+ makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lunwind -lm -lgc\n\n")
+ end
+ makefile.write("all: {outpath}\n\n")
var ofiles = new Array[String]
# Compile each generated file
ofiles.add(o)
end
- # Add gc_choser.h to aditionnal bodies
- var gc_chooser = new ExternCFile("{cc_paths.first}/gc_chooser.c", "-DWITH_LIBGC")
- compiler.extern_bodies.add(gc_chooser)
-
# Compile each required extern body into a specific .o
for f in compiler.extern_bodies do
var basename = f.filename.basename(".c")
- var o = ".nit_compile/{basename}.extern.o"
- makefile.write("{o}: {f.filename}\n\t$(CC) $(CFLAGS) -D NONITCNI {f.cflags} -c -o {o} {f.filename}\n\n")
+ var o = "{basename}.extern.o"
+ var ff = orig_dir.join_path(f.filename).simplify_path
+ makefile.write("{o}: {ff}\n\t$(CC) $(CFLAGS) -D NONITCNI {f.cflags} -c -o {o} {ff}\n\n")
ofiles.add(o)
end
# Link edition
- makefile.write("{outname}: {ofiles.join(" ")}\n\t$(CC) $(LDFLAGS) -o {outname} {ofiles.join(" ")} $(LDLIBS)\n\n")
+ makefile.write("{outpath}: {ofiles.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)
+ self.toolcontext.info("Generated makefile: {makepath}", 2)
var time1 = get_time
self.toolcontext.info("*** END WRITING C: {time1-time0} ***", 2)
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}.")
abstract class AbstractCompiler
type VISITOR: AbstractCompilerVisitor
+ # 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
private var provided_declarations = new HashMap[String, String]
+ # 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.toolcontext.opt_compile_dir.value
+ if compile_dir == null then compile_dir = ".nit_compile"
+
+ 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")
+ for i in names.keys do
+ stream.write(i)
+ stream.write(",\t\"")
+ stream.write(names[i])
+ stream.write("\"\n")
+ end
+ stream.write("####\n")
+ 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.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
+
# 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>")
compile_header_structs
+ # Signal handler function prototype
+ self.header.add_decl("void show_backtrace(int);")
+
# Global variable used by the legacy native interface
self.header.add_decl("extern int glob_argc;")
self.header.add_decl("extern char **glob_argv;")
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
+ v.add_decl("#define UNW_LOCAL_ONLY")
+ v.add_decl("#include <libunwind.h>")
+ 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("void show_backtrace (int signo) \{")
+ if not modelbuilder.toolcontext.opt_no_stacktrace.value 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("printf(\"-------------------------------------------------\\n\");")
+ v.add_decl("printf(\"-- Stack Trace ------------------------------\\n\");")
+ v.add_decl("printf(\"-------------------------------------------------\\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);")
+ v.add_decl(" \}else\{")
+ v.add_decl(" printf(\"` %s\\n\", procname);")
+ v.add_decl(" \}")
+ else
+ v.add_decl(" printf(\"` %s \\n\",procname);")
+ end
+ v.add_decl("\}")
+ v.add_decl("printf(\"-------------------------------------------------\\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) \{")
+
+ v.add("signal(SIGABRT, show_backtrace);")
+ v.add("signal(SIGFPE, show_backtrace);")
+ v.add("signal(SIGILL, show_backtrace);")
+ v.add("signal(SIGINT, show_backtrace);")
+ v.add("signal(SIGTERM, show_backtrace);")
+ v.add("signal(SIGSEGV, show_backtrace);")
+
v.add("glob_argc = argc; glob_argv = argv;")
v.add("initialize_gc_option();")
var main_type = mainmodule.sys_type
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
# List of additional .c files required to compile (native interface)
var extern_bodies = new Array[ExternCFile]
+ # 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 check if an instance is correctly initialized
- fun generate_check_init_instance(mtype: MClassType) is abstract
-
# Generate code that initialize the attributes on a new instance
fun generate_init_attr(v: VISITOR, recv: RuntimeVariable, mtype: MClassType)
do
# 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
# *
# 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
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
assert recv isa MClassType
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
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
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
+ # 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 \"{"..".join_path(tryfile)}\"")
+ self.compiler.files_to_copy.add(tryfile)
end
tryfile = file + "_nit.h"
if tryfile.file_exists then
self.declare_once("#include \"{"..".join_path(tryfile)}\"")
+ self.compiler.files_to_copy.add(tryfile)
end
if self.compiler.seen_extern.has(file) then return
end
var f = new ExternCFile(tryfile, "")
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'.
+ # 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("fprintf(stderr, \"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("fprintf(stderr, \" (%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("fprintf(stderr, \"\\n\");")
end
- self.add("exit(1);")
+ self.add("show_backtrace(1);")
end
- # Generate a return with the value `s'
+ # 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 (!{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_raw_abort
+ self.add("\}")
+ end
+
+ # 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 cflags: String
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*"
# 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
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
v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
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 == "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});")
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("show_backtrace(1);")
return
end
externname = nextern.text.substring(1, nextern.text.length-2)
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("exit(1);")
+ v.add("show_backtrace(1);")
return
end
externname = nextern.text.substring(1, nextern.text.length-2)
end
redef class ADeferredMethPropdef
- redef fun compile_to_c(v, mpropdef, arguments) do v.add_abort("Deferred method called")
+ 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
+ # 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\");")
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)
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 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)
return res
end
end
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)
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
#self.debug("got {res2} from {mproperty}. drop {recv}")
return res2
end
- v.check_init_instance(recv, mtype)
return recv
end
end
# Utils
redef class Array[E]
- # 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
- # 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]
nitlanguage / nit.git / blobdiff