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
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)
end
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
+ 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")
+ makefile.write("all: {outpath}\n\n")
var ofiles = new Array[String]
# Compile each generated file
# 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}.")
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
# 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);")
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 (!{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
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
# 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)))
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
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
nitlanguage / nit.git / blobdiff