lib/standard/stream: Renamed streams for more explicit denomination
[nit.git] / src / compiler / abstract_compiler.nit
1 # This file is part of NIT ( http://www.nitlanguage.org ).
2 #
3 # Copyright 2012 Jean Privat <jean@pryen.org>
4 #
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
8 #
9 # http://www.apache.org/licenses/LICENSE-2.0
10 #
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
16
17 # Abstract compiler
18 module abstract_compiler
19
20 import literal
21 import semantize
22 import platform
23 import c_tools
24 private import annotation
25 import mixin
26
27 # Add compiling options
28 redef class ToolContext
29 # --output
30 var opt_output = new OptionString("Output file", "-o", "--output")
31 # --dir
32 var opt_dir = new OptionString("Output directory", "--dir")
33 # --no-cc
34 var opt_no_cc = new OptionBool("Do not invoke C compiler", "--no-cc")
35 # --no-main
36 var opt_no_main = new OptionBool("Do not generate main entry point", "--no-main")
37 # --make-flags
38 var opt_make_flags = new OptionString("Additional options to make", "--make-flags")
39 # --max-c-lines
40 var opt_max_c_lines = new OptionInt("Maximum number of lines in generated C files. Use 0 for unlimited", 10000, "--max-c-lines")
41 # --group-c-files
42 var opt_group_c_files = new OptionBool("Group all generated code in the same series of files", "--group-c-files")
43 # --compile-dir
44 var opt_compile_dir = new OptionString("Directory used to generate temporary files", "--compile-dir")
45 # --hardening
46 var opt_hardening = new OptionBool("Generate contracts in the C code against bugs in the compiler", "--hardening")
47 # --no-check-covariance
48 var opt_no_check_covariance = new OptionBool("Disable type tests of covariant parameters (dangerous)", "--no-check-covariance")
49 # --no-check-attr-isset
50 var opt_no_check_attr_isset = new OptionBool("Disable isset tests before each attribute access (dangerous)", "--no-check-attr-isset")
51 # --no-check-assert
52 var opt_no_check_assert = new OptionBool("Disable the evaluation of explicit 'assert' and 'as' (dangerous)", "--no-check-assert")
53 # --no-check-autocast
54 var opt_no_check_autocast = new OptionBool("Disable implicit casts on unsafe expression usage (dangerous)", "--no-check-autocast")
55 # --no-check-null
56 var opt_no_check_null = new OptionBool("Disable tests of null receiver (dangerous)", "--no-check-null")
57 # --no-check-all
58 var opt_no_check_all = new OptionBool("Disable all tests (dangerous)", "--no-check-all")
59 # --typing-test-metrics
60 var opt_typing_test_metrics = new OptionBool("Enable static and dynamic count of all type tests", "--typing-test-metrics")
61 # --invocation-metrics
62 var opt_invocation_metrics = new OptionBool("Enable static and dynamic count of all method invocations", "--invocation-metrics")
63 # --isset-checks-metrics
64 var opt_isset_checks_metrics = new OptionBool("Enable static and dynamic count of isset checks before attributes access", "--isset-checks-metrics")
65 # --stacktrace
66 var opt_stacktrace = new OptionString("Control the generation of stack traces", "--stacktrace")
67 # --no-gcc-directives
68 var opt_no_gcc_directive = new OptionArray("Disable a advanced gcc directives for optimization", "--no-gcc-directive")
69 # --release
70 var opt_release = new OptionBool("Compile in release mode and finalize application", "--release")
71
72 redef init
73 do
74 super
75 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)
76 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_null, self.opt_no_check_all)
77 self.option_context.add_option(self.opt_typing_test_metrics, self.opt_invocation_metrics, self.opt_isset_checks_metrics)
78 self.option_context.add_option(self.opt_stacktrace)
79 self.option_context.add_option(self.opt_no_gcc_directive)
80 self.option_context.add_option(self.opt_release)
81 self.option_context.add_option(self.opt_max_c_lines, self.opt_group_c_files)
82
83 opt_no_main.hidden = true
84 end
85
86 redef fun process_options(args)
87 do
88 super
89
90 var st = opt_stacktrace.value
91 if st == "none" or st == "libunwind" or st == "nitstack" then
92 # Fine, do nothing
93 else if st == "auto" or st == null then
94 # Default is nitstack
95 opt_stacktrace.value = "nitstack"
96 else
97 print "Error: unknown value `{st}` for --stacktrace. Use `none`, `libunwind`, `nitstack` or `auto`."
98 exit(1)
99 end
100
101 if opt_output.value != null and opt_dir.value != null then
102 print "Error: cannot use both --dir and --output"
103 exit(1)
104 end
105
106 if opt_no_check_all.value then
107 opt_no_check_covariance.value = true
108 opt_no_check_attr_isset.value = true
109 opt_no_check_assert.value = true
110 opt_no_check_autocast.value = true
111 opt_no_check_null.value = true
112 end
113 end
114 end
115
116 redef class ModelBuilder
117 # The compilation directory
118 var compile_dir: String
119
120 # Simple indirection to `Toolchain::write_and_make`
121 protected fun write_and_make(compiler: AbstractCompiler)
122 do
123 var platform = compiler.target_platform
124 var toolchain = platform.toolchain(toolcontext)
125 compile_dir = toolchain.compile_dir
126 toolchain.write_and_make compiler
127 end
128 end
129
130 redef class Platform
131 # The specific tool-chain associated to the platform
132 fun toolchain(toolcontext: ToolContext): Toolchain do return new MakefileToolchain(toolcontext)
133 end
134
135 class Toolchain
136 var toolcontext: ToolContext
137
138 fun compile_dir: String
139 do
140 var compile_dir = toolcontext.opt_compile_dir.value
141 if compile_dir == null then compile_dir = ".nit_compile"
142 return compile_dir
143 end
144
145 fun write_and_make(compiler: AbstractCompiler) is abstract
146 end
147
148 class MakefileToolchain
149 super Toolchain
150
151 redef fun write_and_make(compiler)
152 do
153 var compile_dir = compile_dir
154
155 # Generate the .h and .c files
156 # A single C file regroups many compiled rumtime functions
157 # Note that we do not try to be clever an a small change in a Nit source file may change the content of all the generated .c files
158 var time0 = get_time
159 self.toolcontext.info("*** WRITING C ***", 1)
160
161 compile_dir.mkdir
162
163 var cfiles = new Array[String]
164 write_files(compiler, compile_dir, cfiles)
165
166 # Generate the Makefile
167
168 write_makefile(compiler, compile_dir, cfiles)
169
170 var time1 = get_time
171 self.toolcontext.info("*** END WRITING C: {time1-time0} ***", 2)
172
173 # Execute the Makefile
174
175 if self.toolcontext.opt_no_cc.value then return
176
177 time0 = time1
178 self.toolcontext.info("*** COMPILING C ***", 1)
179
180 compile_c_code(compiler, compile_dir)
181
182 time1 = get_time
183 self.toolcontext.info("*** END COMPILING C: {time1-time0} ***", 2)
184 end
185
186 fun write_files(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String])
187 do
188 var platform = compiler.target_platform
189 if self.toolcontext.opt_stacktrace.value == "nitstack" and platform.supports_libunwind then compiler.build_c_to_nit_bindings
190 var cc_opt_with_libgc = "-DWITH_LIBGC"
191 if not platform.supports_libgc then cc_opt_with_libgc = ""
192
193 # Add gc_choser.h to aditionnal bodies
194 var gc_chooser = new ExternCFile("gc_chooser.c", cc_opt_with_libgc)
195 if cc_opt_with_libgc != "" then gc_chooser.pkgconfigs.add "bdw-gc"
196 compiler.extern_bodies.add(gc_chooser)
197 var clib = toolcontext.nit_dir / "clib"
198 compiler.files_to_copy.add "{clib}/gc_chooser.c"
199 compiler.files_to_copy.add "{clib}/gc_chooser.h"
200
201 # FFI
202 for m in compiler.mainmodule.in_importation.greaters do
203 compiler.finalize_ffi_for_module(m)
204 end
205
206 # Copy original .[ch] files to compile_dir
207 for src in compiler.files_to_copy do
208 var basename = src.basename("")
209 var dst = "{compile_dir}/{basename}"
210 src.file_copy_to dst
211 end
212
213 var hfilename = compiler.header.file.name + ".h"
214 var hfilepath = "{compile_dir}/{hfilename}"
215 var h = new FileWriter.open(hfilepath)
216 for l in compiler.header.decl_lines do
217 h.write l
218 h.write "\n"
219 end
220 for l in compiler.header.lines do
221 h.write l
222 h.write "\n"
223 end
224 h.close
225
226 var max_c_lines = toolcontext.opt_max_c_lines.value
227 for f in compiler.files do
228 var i = 0
229 var count = 0
230 var file: nullable FileWriter = null
231 for vis in f.writers do
232 if vis == compiler.header then continue
233 var total_lines = vis.lines.length + vis.decl_lines.length
234 if total_lines == 0 then continue
235 count += total_lines
236 if file == null or (count > max_c_lines and max_c_lines > 0) then
237 i += 1
238 if file != null then file.close
239 var cfilename = "{f.name}.{i}.c"
240 var cfilepath = "{compile_dir}/{cfilename}"
241 self.toolcontext.info("new C source files to compile: {cfilepath}", 3)
242 cfiles.add(cfilename)
243 file = new FileWriter.open(cfilepath)
244 file.write "#include \"{f.name}.0.h\"\n"
245 count = total_lines
246 end
247 for l in vis.decl_lines do
248 file.write l
249 file.write "\n"
250 end
251 for l in vis.lines do
252 file.write l
253 file.write "\n"
254 end
255 end
256 if file == null then continue
257 file.close
258
259 var cfilename = "{f.name}.0.h"
260 var cfilepath = "{compile_dir}/{cfilename}"
261 var hfile: nullable FileWriter = null
262 hfile = new FileWriter.open(cfilepath)
263 hfile.write "#include \"{hfilename}\"\n"
264 for key in f.required_declarations do
265 if not compiler.provided_declarations.has_key(key) then
266 var node = compiler.requirers_of_declarations.get_or_null(key)
267 if node != null then
268 node.debug "No provided declaration for {key}"
269 else
270 print "No provided declaration for {key}"
271 end
272 abort
273 end
274 hfile.write compiler.provided_declarations[key]
275 hfile.write "\n"
276 end
277 hfile.close
278 end
279
280 self.toolcontext.info("Total C source files to compile: {cfiles.length}", 2)
281 end
282
283 fun makefile_name(mainmodule: MModule): String do return "{mainmodule.c_name}.mk"
284
285 fun default_outname(mainmodule: MModule): String
286 do
287 # Search a non fictive module
288 var res = mainmodule.name
289 while mainmodule.is_fictive do
290 mainmodule = mainmodule.in_importation.direct_greaters.first
291 res = mainmodule.name
292 end
293 return res
294 end
295
296 # Combine options and platform informations to get the final path of the outfile
297 fun outfile(mainmodule: MModule): String
298 do
299 var res = self.toolcontext.opt_output.value
300 if res != null then return res
301 res = default_outname(mainmodule)
302 var dir = self.toolcontext.opt_dir.value
303 if dir != null then return dir.join_path(res)
304 return res
305 end
306
307 fun write_makefile(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String])
308 do
309 var mainmodule = compiler.mainmodule
310 var platform = compiler.target_platform
311
312 var outname = outfile(mainmodule)
313
314 var real_outpath = compile_dir.relpath(outname)
315 var outpath = real_outpath.escape_to_mk
316 if outpath != real_outpath then
317 # If the name is crazy and need escaping, we will do an indirection
318 # 1. generate the binary in the .nit_compile dir under an escaped name
319 # 2. copy the binary at the right place in the `all` goal.
320 outpath = mainmodule.c_name
321 end
322 var makename = makefile_name(mainmodule)
323 var makepath = "{compile_dir}/{makename}"
324 var makefile = new FileWriter.open(makepath)
325
326 var linker_options = new HashSet[String]
327 for m in mainmodule.in_importation.greaters do
328 var libs = m.collect_linker_libs
329 if libs != null then linker_options.add_all(libs)
330 end
331
332 makefile.write("CC = ccache cc\nCXX = ccache c++\nCFLAGS = -g -O2 -Wno-unused-value -Wno-switch -Wno-attributes\nCINCL =\nLDFLAGS ?= \nLDLIBS ?= -lm {linker_options.join(" ")}\n\n")
333
334 var ost = toolcontext.opt_stacktrace.value
335 if (ost == "libunwind" or ost == "nitstack") and platform.supports_libunwind then makefile.write("NEED_LIBUNWIND := YesPlease\n")
336
337 # Dynamic adaptations
338 # While `platform` enable complex toolchains, they are statically applied
339 # For a dynamic adaptsation of the compilation, the generated Makefile should check and adapt things itself
340
341 # Check and adapt the targeted system
342 makefile.write("uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')\n")
343 makefile.write("ifeq ($(uname_S),Darwin)\n")
344 # remove -lunwind since it is already included on macosx
345 makefile.write("\tNEED_LIBUNWIND :=\n")
346 makefile.write("endif\n\n")
347
348 # Check and adapt for the compiler used
349 # clang need an additionnal `-Qunused-arguments`
350 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")
351
352 makefile.write("ifdef NEED_LIBUNWIND\n\tLDLIBS += -lunwind\nendif\n")
353
354 makefile.write("all: {outpath}\n")
355 if outpath != real_outpath then
356 makefile.write("\tcp -- {outpath.escape_to_sh} {real_outpath.escape_to_sh.replace("$","$$")}")
357 end
358 makefile.write("\n")
359
360 var ofiles = new Array[String]
361 var dep_rules = new Array[String]
362 # Compile each generated file
363 for f in cfiles do
364 var o = f.strip_extension(".c") + ".o"
365 makefile.write("{o}: {f}\n\t$(CC) $(CFLAGS) $(CINCL) -c -o {o} {f}\n\n")
366 ofiles.add(o)
367 dep_rules.add(o)
368 end
369
370 # Generate linker script, if any
371 if not compiler.linker_script.is_empty then
372 var linker_script_path = "{compile_dir}/linker_script"
373 ofiles.add "linker_script"
374 var f = new FileWriter.open(linker_script_path)
375 for l in compiler.linker_script do
376 f.write l
377 f.write "\n"
378 end
379 f.close
380 end
381
382 var java_files = new Array[ExternFile]
383
384 var pkgconfigs = new Array[String]
385 for f in compiler.extern_bodies do
386 pkgconfigs.add_all f.pkgconfigs
387 end
388 # Protect pkg-config
389 if not pkgconfigs.is_empty then
390 makefile.write """
391 # does pkg-config exists?
392 ifneq ($(shell which pkg-config >/dev/null; echo $$?), 0)
393 $(error "Command `pkg-config` not found. Please install it")
394 endif
395 """
396 for p in pkgconfigs do
397 makefile.write """
398 # Check for library {{{p}}}
399 ifneq ($(shell pkg-config --exists '{{{p}}}'; echo $$?), 0)
400 $(error "pkg-config: package {{{p}}} is not found.")
401 endif
402 """
403 end
404 end
405
406 # Compile each required extern body into a specific .o
407 for f in compiler.extern_bodies do
408 var o = f.makefile_rule_name
409 var ff = f.filename.basename("")
410 makefile.write("{o}: {ff}\n")
411 makefile.write("\t{f.makefile_rule_content}\n\n")
412 dep_rules.add(f.makefile_rule_name)
413
414 if f.compiles_to_o_file then ofiles.add(o)
415 if f.add_to_jar then java_files.add(f)
416 end
417
418 if not java_files.is_empty then
419 var jar_file = "{outpath}.jar"
420
421 var class_files_array = new Array[String]
422 for f in java_files do class_files_array.add(f.makefile_rule_name)
423 var class_files = class_files_array.join(" ")
424
425 makefile.write("{jar_file}: {class_files}\n")
426 makefile.write("\tjar cf {jar_file} {class_files}\n\n")
427 dep_rules.add jar_file
428 end
429
430 # Link edition
431 var pkg = ""
432 if not pkgconfigs.is_empty then
433 pkg = "`pkg-config --libs {pkgconfigs.join(" ")}`"
434 end
435 makefile.write("{outpath}: {dep_rules.join(" ")}\n\t$(CC) $(LDFLAGS) -o {outpath.escape_to_sh} {ofiles.join(" ")} $(LDLIBS) {pkg}\n\n")
436 # Clean
437 makefile.write("clean:\n\trm {ofiles.join(" ")} 2>/dev/null\n")
438 if outpath != real_outpath then
439 makefile.write("\trm -- {outpath.escape_to_sh} 2>/dev/null\n")
440 end
441 makefile.close
442 self.toolcontext.info("Generated makefile: {makepath}", 2)
443
444 makepath.file_copy_to "{compile_dir}/Makefile"
445 end
446
447 fun compile_c_code(compiler: AbstractCompiler, compile_dir: String)
448 do
449 var makename = makefile_name(compiler.mainmodule)
450
451 var makeflags = self.toolcontext.opt_make_flags.value
452 if makeflags == null then makeflags = ""
453 self.toolcontext.info("make -B -C {compile_dir} -f {makename} -j 4 {makeflags}", 2)
454
455 var res
456 if self.toolcontext.verbose_level >= 3 then
457 res = sys.system("make -B -C {compile_dir} -f {makename} -j 4 {makeflags} 2>&1")
458 else
459 res = sys.system("make -B -C {compile_dir} -f {makename} -j 4 {makeflags} 2>&1 >/dev/null")
460 end
461 if res != 0 then
462 toolcontext.error(null, "make failed! Error code: {res}.")
463 end
464 end
465 end
466
467 # Singleton that store the knowledge about the compilation process
468 abstract class AbstractCompiler
469 type VISITOR: AbstractCompilerVisitor
470
471 # Table corresponding c_names to nit names (methods)
472 var names = new HashMap[String, String]
473
474 # The main module of the program currently compiled
475 # Is assigned during the separate compilation
476 var mainmodule: MModule is writable
477
478 # The real main module of the program
479 var realmainmodule: MModule is noinit
480
481 # The modelbuilder used to know the model and the AST
482 var modelbuilder: ModelBuilder is protected writable
483
484 # Is hardening asked? (see --hardening)
485 fun hardening: Bool do return self.modelbuilder.toolcontext.opt_hardening.value
486
487 # The targeted specific platform
488 var target_platform: Platform is noinit
489
490 init
491 do
492 self.realmainmodule = mainmodule
493 target_platform = mainmodule.target_platform or else new Platform
494 end
495
496 # Do the full code generation of the program `mainmodule`
497 # It is the main method usually called after the instantiation
498 fun do_compilation is abstract
499
500 # Force the creation of a new file
501 # The point is to avoid contamination between must-be-compiled-separately files
502 fun new_file(name: String): CodeFile
503 do
504 if modelbuilder.toolcontext.opt_group_c_files.value then
505 if self.files.is_empty then
506 var f = new CodeFile(mainmodule.c_name)
507 self.files.add(f)
508 end
509 return self.files.first
510 end
511 var f = new CodeFile(name)
512 self.files.add(f)
513 return f
514 end
515
516 # The list of all associated files
517 # Used to generate .c files
518 var files = new List[CodeFile]
519
520 # Initialize a visitor specific for a compiler engine
521 fun new_visitor: VISITOR is abstract
522
523 # Where global declaration are stored (the main .h)
524 var header: CodeWriter is writable, noinit
525
526 # Additionnal linker script for `ld`.
527 # Mainly used to do specific link-time symbol resolution
528 var linker_script = new Array[String]
529
530 # Provide a declaration that can be requested (before or latter) by a visitor
531 fun provide_declaration(key: String, s: String)
532 do
533 if self.provided_declarations.has_key(key) then
534 assert self.provided_declarations[key] == s
535 end
536 self.provided_declarations[key] = s
537 end
538
539 private var provided_declarations = new HashMap[String, String]
540
541 private var requirers_of_declarations = new HashMap[String, ANode]
542
543 # Builds the .c and .h files to be used when generating a Stack Trace
544 # Binds the generated C function names to Nit function names
545 fun build_c_to_nit_bindings
546 do
547 var compile_dir = modelbuilder.compile_dir
548
549 var stream = new FileWriter.open("{compile_dir}/c_functions_hash.c")
550 stream.write("#include <string.h>\n")
551 stream.write("#include <stdlib.h>\n")
552 stream.write("#include \"c_functions_hash.h\"\n")
553 stream.write("typedef struct C_Nit_Names\{char* name; char* nit_name;\}C_Nit_Names;\n")
554 stream.write("const char* get_nit_name(register const char* procproc, register unsigned int len)\{\n")
555 stream.write("char* procname = malloc(len+1);")
556 stream.write("memcpy(procname, procproc, len);")
557 stream.write("procname[len] = '\\0';")
558 stream.write("static const C_Nit_Names map[{names.length}] = \{\n")
559 for i in names.keys do
560 stream.write("\{\"")
561 stream.write(i.escape_to_c)
562 stream.write("\",\"")
563 stream.write(names[i].escape_to_c)
564 stream.write("\"\},\n")
565 end
566 stream.write("\};\n")
567 stream.write("int i;")
568 stream.write("for(i = 0; i < {names.length}; i++)\{")
569 stream.write("if(strcmp(procname,map[i].name) == 0)\{")
570 stream.write("free(procname);")
571 stream.write("return map[i].nit_name;")
572 stream.write("\}")
573 stream.write("\}")
574 stream.write("free(procname);")
575 stream.write("return NULL;")
576 stream.write("\}\n")
577 stream.close
578
579 stream = new FileWriter.open("{compile_dir}/c_functions_hash.h")
580 stream.write("const char* get_nit_name(register const char* procname, register unsigned int len);\n")
581 stream.close
582
583 extern_bodies.add(new ExternCFile("{compile_dir}/c_functions_hash.c", ""))
584 end
585
586 # Compile C headers
587 # This method call compile_header_strucs method that has to be refined
588 fun compile_header do
589 self.header.add_decl("#include <stdlib.h>")
590 self.header.add_decl("#include <stdio.h>")
591 self.header.add_decl("#include <string.h>")
592 self.header.add_decl("#include \"gc_chooser.h\"")
593 self.header.add_decl("#ifdef ANDROID")
594 self.header.add_decl(" #include <android/log.h>")
595 self.header.add_decl(" #define PRINT_ERROR(...) (void)__android_log_print(ANDROID_LOG_WARN, \"Nit\", __VA_ARGS__)")
596 self.header.add_decl("#else")
597 self.header.add_decl(" #define PRINT_ERROR(...) fprintf(stderr, __VA_ARGS__)")
598 self.header.add_decl("#endif")
599
600 compile_header_structs
601 compile_nitni_structs
602
603 var gccd_disable = modelbuilder.toolcontext.opt_no_gcc_directive.value
604 if gccd_disable.has("noreturn") or gccd_disable.has("all") then
605 # Signal handler function prototype
606 self.header.add_decl("void show_backtrace(int);")
607 else
608 self.header.add_decl("void show_backtrace(int) __attribute__ ((noreturn));")
609 end
610
611 if gccd_disable.has("likely") or gccd_disable.has("all") then
612 self.header.add_decl("#define likely(x) (x)")
613 self.header.add_decl("#define unlikely(x) (x)")
614 else if gccd_disable.has("correct-likely") then
615 # invert the `likely` definition
616 # Used by masochists to bench the worst case
617 self.header.add_decl("#define likely(x) __builtin_expect((x),0)")
618 self.header.add_decl("#define unlikely(x) __builtin_expect((x),1)")
619 else
620 self.header.add_decl("#define likely(x) __builtin_expect((x),1)")
621 self.header.add_decl("#define unlikely(x) __builtin_expect((x),0)")
622 end
623
624 # Global variable used by intern methods
625 self.header.add_decl("extern int glob_argc;")
626 self.header.add_decl("extern char **glob_argv;")
627 self.header.add_decl("extern val *glob_sys;")
628 end
629
630 # Declaration of structures for live Nit types
631 protected fun compile_header_structs is abstract
632
633 # Declaration of structures for nitni undelying the FFI
634 protected fun compile_nitni_structs
635 do
636 self.header.add_decl """
637 /* Native reference to Nit objects */
638 /* This structure is used to represent every Nit type in extern methods and custom C code. */
639 struct nitni_ref {
640 struct nitni_ref *next,
641 *prev; /* adjacent global references in global list */
642 int count; /* number of time this global reference has been marked */
643 };
644
645 /* List of global references from C code to Nit objects */
646 /* Instanciated empty at init of Nit system and filled explicitly by user in C code */
647 struct nitni_global_ref_list_t {
648 struct nitni_ref *head, *tail;
649 };
650 extern struct nitni_global_ref_list_t *nitni_global_ref_list;
651
652 /* Initializer of global reference list */
653 extern void nitni_global_ref_list_init();
654
655 /* Intern function to add a global reference to the list */
656 extern void nitni_global_ref_add( struct nitni_ref *ref );
657
658 /* Intern function to remove a global reference from the list */
659 extern void nitni_global_ref_remove( struct nitni_ref *ref );
660
661 /* Increase count on an existing global reference */
662 extern void nitni_global_ref_incr( struct nitni_ref *ref );
663
664 /* Decrease count on an existing global reference */
665 extern void nitni_global_ref_decr( struct nitni_ref *ref );
666 """
667 end
668
669 fun compile_finalizer_function
670 do
671 var finalizable_type = mainmodule.finalizable_type
672 if finalizable_type == null then return
673
674 var finalize_meth = mainmodule.try_get_primitive_method("finalize", finalizable_type.mclass)
675
676 if finalize_meth == null then
677 modelbuilder.toolcontext.error(null, "The `Finalizable` class doesn't declare the `finalize` method.")
678 return
679 end
680
681 var v = self.new_visitor
682 v.add_decl "void gc_finalize (void *obj, void *client_data) \{"
683 var recv = v.new_expr("obj", finalizable_type)
684 v.send(finalize_meth, [recv])
685 v.add "\}"
686 end
687
688 # Generate the main C function.
689 #
690 # This function:
691 #
692 # * allocate the Sys object if it exists
693 # * call init if is exists
694 # * call main if it exists
695 fun compile_main_function
696 do
697 var v = self.new_visitor
698 v.add_decl("#include <signal.h>")
699 var ost = modelbuilder.toolcontext.opt_stacktrace.value
700 var platform = target_platform
701
702 if not platform.supports_libunwind then ost = "none"
703
704 var no_main = platform.no_main or modelbuilder.toolcontext.opt_no_main.value
705
706 if ost == "nitstack" or ost == "libunwind" then
707 v.add_decl("#define UNW_LOCAL_ONLY")
708 v.add_decl("#include <libunwind.h>")
709 if ost == "nitstack" then
710 v.add_decl("#include \"c_functions_hash.h\"")
711 end
712 end
713 v.add_decl("int glob_argc;")
714 v.add_decl("char **glob_argv;")
715 v.add_decl("val *glob_sys;")
716
717 if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then
718 for tag in count_type_test_tags do
719 v.add_decl("long count_type_test_resolved_{tag};")
720 v.add_decl("long count_type_test_unresolved_{tag};")
721 v.add_decl("long count_type_test_skipped_{tag};")
722 v.compiler.header.add_decl("extern long count_type_test_resolved_{tag};")
723 v.compiler.header.add_decl("extern long count_type_test_unresolved_{tag};")
724 v.compiler.header.add_decl("extern long count_type_test_skipped_{tag};")
725 end
726 end
727
728 if self.modelbuilder.toolcontext.opt_invocation_metrics.value then
729 v.add_decl("long count_invoke_by_tables;")
730 v.add_decl("long count_invoke_by_direct;")
731 v.add_decl("long count_invoke_by_inline;")
732 v.compiler.header.add_decl("extern long count_invoke_by_tables;")
733 v.compiler.header.add_decl("extern long count_invoke_by_direct;")
734 v.compiler.header.add_decl("extern long count_invoke_by_inline;")
735 end
736
737 if self.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
738 v.add_decl("long count_attr_reads = 0;")
739 v.add_decl("long count_isset_checks = 0;")
740 v.compiler.header.add_decl("extern long count_attr_reads;")
741 v.compiler.header.add_decl("extern long count_isset_checks;")
742 end
743
744 v.add_decl("void sig_handler(int signo)\{")
745 v.add_decl("PRINT_ERROR(\"Caught signal : %s\\n\", strsignal(signo));")
746 v.add_decl("show_backtrace(signo);")
747 v.add_decl("\}")
748
749 v.add_decl("void show_backtrace (int signo) \{")
750 if ost == "nitstack" or ost == "libunwind" then
751 v.add_decl("char* opt = getenv(\"NIT_NO_STACK\");")
752 v.add_decl("unw_cursor_t cursor;")
753 v.add_decl("if(opt==NULL)\{")
754 v.add_decl("unw_context_t uc;")
755 v.add_decl("unw_word_t ip;")
756 v.add_decl("char* procname = malloc(sizeof(char) * 100);")
757 v.add_decl("unw_getcontext(&uc);")
758 v.add_decl("unw_init_local(&cursor, &uc);")
759 v.add_decl("PRINT_ERROR(\"-------------------------------------------------\\n\");")
760 v.add_decl("PRINT_ERROR(\"-- Stack Trace ------------------------------\\n\");")
761 v.add_decl("PRINT_ERROR(\"-------------------------------------------------\\n\");")
762 v.add_decl("while (unw_step(&cursor) > 0) \{")
763 v.add_decl(" unw_get_proc_name(&cursor, procname, 100, &ip);")
764 if ost == "nitstack" then
765 v.add_decl(" const char* recv = get_nit_name(procname, strlen(procname));")
766 v.add_decl(" if (recv != NULL)\{")
767 v.add_decl(" PRINT_ERROR(\"` %s\\n\", recv);")
768 v.add_decl(" \}else\{")
769 v.add_decl(" PRINT_ERROR(\"` %s\\n\", procname);")
770 v.add_decl(" \}")
771 else
772 v.add_decl(" PRINT_ERROR(\"` %s \\n\",procname);")
773 end
774 v.add_decl("\}")
775 v.add_decl("PRINT_ERROR(\"-------------------------------------------------\\n\");")
776 v.add_decl("free(procname);")
777 v.add_decl("\}")
778 end
779 v.add_decl("exit(signo);")
780 v.add_decl("\}")
781
782 if no_main then
783 v.add_decl("int nit_main(int argc, char** argv) \{")
784 else
785 v.add_decl("int main(int argc, char** argv) \{")
786 end
787
788 v.add("signal(SIGABRT, sig_handler);")
789 v.add("signal(SIGFPE, sig_handler);")
790 v.add("signal(SIGILL, sig_handler);")
791 v.add("signal(SIGINT, sig_handler);")
792 v.add("signal(SIGTERM, sig_handler);")
793 v.add("signal(SIGSEGV, sig_handler);")
794 v.add("signal(SIGPIPE, sig_handler);")
795
796 v.add("glob_argc = argc; glob_argv = argv;")
797 v.add("initialize_gc_option();")
798
799 v.add "initialize_nitni_global_refs();"
800
801 var main_type = mainmodule.sys_type
802 if main_type != null then
803 var mainmodule = v.compiler.mainmodule
804 var glob_sys = v.init_instance(main_type)
805 v.add("glob_sys = {glob_sys};")
806 var main_init = mainmodule.try_get_primitive_method("init", main_type.mclass)
807 if main_init != null then
808 v.send(main_init, [glob_sys])
809 end
810 var main_method = mainmodule.try_get_primitive_method("run", main_type.mclass) or else
811 mainmodule.try_get_primitive_method("main", main_type.mclass)
812 if main_method != null then
813 v.send(main_method, [glob_sys])
814 end
815 end
816
817 if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then
818 v.add_decl("long count_type_test_resolved_total = 0;")
819 v.add_decl("long count_type_test_unresolved_total = 0;")
820 v.add_decl("long count_type_test_skipped_total = 0;")
821 v.add_decl("long count_type_test_total_total = 0;")
822 for tag in count_type_test_tags do
823 v.add_decl("long count_type_test_total_{tag};")
824 v.add("count_type_test_total_{tag} = count_type_test_resolved_{tag} + count_type_test_unresolved_{tag} + count_type_test_skipped_{tag};")
825 v.add("count_type_test_resolved_total += count_type_test_resolved_{tag};")
826 v.add("count_type_test_unresolved_total += count_type_test_unresolved_{tag};")
827 v.add("count_type_test_skipped_total += count_type_test_skipped_{tag};")
828 v.add("count_type_test_total_total += count_type_test_total_{tag};")
829 end
830 v.add("printf(\"# dynamic count_type_test: total %l\\n\");")
831 v.add("printf(\"\\tresolved\\tunresolved\\tskipped\\ttotal\\n\");")
832 var tags = count_type_test_tags.to_a
833 tags.add("total")
834 for tag in tags do
835 v.add("printf(\"{tag}\");")
836 v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_resolved_{tag}, 100.0*count_type_test_resolved_{tag}/count_type_test_total_total);")
837 v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_unresolved_{tag}, 100.0*count_type_test_unresolved_{tag}/count_type_test_total_total);")
838 v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_skipped_{tag}, 100.0*count_type_test_skipped_{tag}/count_type_test_total_total);")
839 v.add("printf(\"\\t%ld (%.2f%%)\\n\", count_type_test_total_{tag}, 100.0*count_type_test_total_{tag}/count_type_test_total_total);")
840 end
841 end
842
843 if self.modelbuilder.toolcontext.opt_invocation_metrics.value then
844 v.add_decl("long count_invoke_total;")
845 v.add("count_invoke_total = count_invoke_by_tables + count_invoke_by_direct + count_invoke_by_inline;")
846 v.add("printf(\"# dynamic count_invocation: total %ld\\n\", count_invoke_total);")
847 v.add("printf(\"by table: %ld (%.2f%%)\\n\", count_invoke_by_tables, 100.0*count_invoke_by_tables/count_invoke_total);")
848 v.add("printf(\"direct: %ld (%.2f%%)\\n\", count_invoke_by_direct, 100.0*count_invoke_by_direct/count_invoke_total);")
849 v.add("printf(\"inlined: %ld (%.2f%%)\\n\", count_invoke_by_inline, 100.0*count_invoke_by_inline/count_invoke_total);")
850 end
851
852 if self.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
853 v.add("printf(\"# dynamic attribute reads: %ld\\n\", count_attr_reads);")
854 v.add("printf(\"# dynamic isset checks: %ld\\n\", count_isset_checks);")
855 end
856
857 v.add("return 0;")
858 v.add("\}")
859
860 for m in mainmodule.in_importation.greaters do
861 var f = "FILE_"+m.c_name
862 v.add "const char {f}[] = \"{m.location.file.filename.escape_to_c}\";"
863 provide_declaration(f, "extern const char {f}[];")
864 end
865 end
866
867 # Copile all C functions related to the [incr|decr]_ref features of the FFI
868 fun compile_nitni_global_ref_functions
869 do
870 var v = self.new_visitor
871 v.add """
872 struct nitni_global_ref_list_t *nitni_global_ref_list;
873 void initialize_nitni_global_refs() {
874 nitni_global_ref_list = (struct nitni_global_ref_list_t*)nit_alloc(sizeof(struct nitni_global_ref_list_t));
875 nitni_global_ref_list->head = NULL;
876 nitni_global_ref_list->tail = NULL;
877 }
878
879 void nitni_global_ref_add( struct nitni_ref *ref ) {
880 if ( nitni_global_ref_list->head == NULL ) {
881 nitni_global_ref_list->head = ref;
882 ref->prev = NULL;
883 } else {
884 nitni_global_ref_list->tail->next = ref;
885 ref->prev = nitni_global_ref_list->tail;
886 }
887 nitni_global_ref_list->tail = ref;
888
889 ref->next = NULL;
890 }
891
892 void nitni_global_ref_remove( struct nitni_ref *ref ) {
893 if ( ref->prev == NULL ) {
894 nitni_global_ref_list->head = ref->next;
895 } else {
896 ref->prev->next = ref->next;
897 }
898
899 if ( ref->next == NULL ) {
900 nitni_global_ref_list->tail = ref->prev;
901 } else {
902 ref->next->prev = ref->prev;
903 }
904 }
905
906 extern void nitni_global_ref_incr( struct nitni_ref *ref ) {
907 if ( ref->count == 0 ) /* not registered */
908 {
909 /* add to list */
910 nitni_global_ref_add( ref );
911 }
912
913 ref->count ++;
914 }
915
916 extern void nitni_global_ref_decr( struct nitni_ref *ref ) {
917 if ( ref->count == 1 ) /* was last reference */
918 {
919 /* remove from list */
920 nitni_global_ref_remove( ref );
921 }
922
923 ref->count --;
924 }
925 """
926 end
927
928 # List of additional files required to compile (FFI)
929 var extern_bodies = new Array[ExternFile]
930
931 # List of source files to copy over to the compile dir
932 var files_to_copy = new Array[String]
933
934 # This is used to avoid adding an extern file more than once
935 private var seen_extern = new ArraySet[String]
936
937 # Generate code that initialize the attributes on a new instance
938 fun generate_init_attr(v: VISITOR, recv: RuntimeVariable, mtype: MClassType)
939 do
940 var cds = mtype.collect_mclassdefs(self.mainmodule).to_a
941 self.mainmodule.linearize_mclassdefs(cds)
942 for cd in cds do
943 for npropdef in modelbuilder.collect_attr_propdef(cd) do
944 npropdef.init_expr(v, recv)
945 end
946 end
947 end
948
949 # Generate code that check if an attribute is correctly initialized
950 fun generate_check_attr(v: VISITOR, recv: RuntimeVariable, mtype: MClassType)
951 do
952 var cds = mtype.collect_mclassdefs(self.mainmodule).to_a
953 self.mainmodule.linearize_mclassdefs(cds)
954 for cd in cds do
955 for npropdef in modelbuilder.collect_attr_propdef(cd) do
956 npropdef.check_expr(v, recv)
957 end
958 end
959 end
960
961 # stats
962
963 var count_type_test_tags: Array[String] = ["isa", "as", "auto", "covariance", "erasure"]
964 var count_type_test_resolved: HashMap[String, Int] = init_count_type_test_tags
965 var count_type_test_unresolved: HashMap[String, Int] = init_count_type_test_tags
966 var count_type_test_skipped: HashMap[String, Int] = init_count_type_test_tags
967
968 protected fun init_count_type_test_tags: HashMap[String, Int]
969 do
970 var res = new HashMap[String, Int]
971 for tag in count_type_test_tags do
972 res[tag] = 0
973 end
974 return res
975 end
976
977 # Display stats about compilation process
978 #
979 # Metrics used:
980 #
981 # * type tests against resolved types (`x isa Collection[Animal]`)
982 # * type tests against unresolved types (`x isa Collection[E]`)
983 # * type tests skipped
984 # * type tests total
985 fun display_stats
986 do
987 if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then
988 print "# static count_type_test"
989 print "\tresolved:\tunresolved\tskipped\ttotal"
990 var count_type_test_total = init_count_type_test_tags
991 count_type_test_resolved["total"] = 0
992 count_type_test_unresolved["total"] = 0
993 count_type_test_skipped["total"] = 0
994 count_type_test_total["total"] = 0
995 for tag in count_type_test_tags do
996 count_type_test_total[tag] = count_type_test_resolved[tag] + count_type_test_unresolved[tag] + count_type_test_skipped[tag]
997 count_type_test_resolved["total"] += count_type_test_resolved[tag]
998 count_type_test_unresolved["total"] += count_type_test_unresolved[tag]
999 count_type_test_skipped["total"] += count_type_test_skipped[tag]
1000 count_type_test_total["total"] += count_type_test_total[tag]
1001 end
1002 var count_type_test = count_type_test_total["total"]
1003 var tags = count_type_test_tags.to_a
1004 tags.add("total")
1005 for tag in tags do
1006 printn tag
1007 printn "\t{count_type_test_resolved[tag]} ({div(count_type_test_resolved[tag],count_type_test)}%)"
1008 printn "\t{count_type_test_unresolved[tag]} ({div(count_type_test_unresolved[tag],count_type_test)}%)"
1009 printn "\t{count_type_test_skipped[tag]} ({div(count_type_test_skipped[tag],count_type_test)}%)"
1010 printn "\t{count_type_test_total[tag]} ({div(count_type_test_total[tag],count_type_test)}%)"
1011 print ""
1012 end
1013 end
1014 end
1015
1016 fun finalize_ffi_for_module(mmodule: MModule) do mmodule.finalize_ffi(self)
1017
1018 # Division facility
1019 # Avoid division by zero by returning the string "n/a"
1020 fun div(a,b:Int):String
1021 do
1022 if b == 0 then return "n/a"
1023 return ((a*10000/b).to_f / 100.0).to_precision(2)
1024 end
1025 end
1026
1027 # A file unit (may be more than one file if
1028 # A file unit aim to be autonomous and is made or one or more `CodeWriter`s
1029 class CodeFile
1030 var name: String
1031 var writers = new Array[CodeWriter]
1032 var required_declarations = new HashSet[String]
1033 end
1034
1035 # Where to store generated lines
1036 class CodeWriter
1037 var file: CodeFile
1038 var lines: List[String] = new List[String]
1039 var decl_lines: List[String] = new List[String]
1040
1041 # Add a line in the main part of the generated C
1042 fun add(s: String) do self.lines.add(s)
1043
1044 # Add a line in the
1045 # (used for local or global declaration)
1046 fun add_decl(s: String) do self.decl_lines.add(s)
1047
1048 init
1049 do
1050 file.writers.add(self)
1051 end
1052 end
1053
1054 # A visitor on the AST of property definition that generate the C code.
1055 abstract class AbstractCompilerVisitor
1056
1057 type COMPILER: AbstractCompiler
1058
1059 # The associated compiler
1060 var compiler: COMPILER
1061
1062 # The current visited AST node
1063 var current_node: nullable ANode = null is writable
1064
1065 # The current `StaticFrame`
1066 var frame: nullable StaticFrame = null is writable
1067
1068 # Alias for self.compiler.mainmodule.object_type
1069 fun object_type: MClassType do return self.compiler.mainmodule.object_type
1070
1071 # Alias for self.compiler.mainmodule.bool_type
1072 fun bool_type: MClassType do return self.compiler.mainmodule.bool_type
1073
1074 var writer: CodeWriter is noinit
1075
1076 init
1077 do
1078 self.writer = new CodeWriter(compiler.files.last)
1079 end
1080
1081 # Force to get the primitive class named `name` or abort
1082 fun get_class(name: String): MClass do return self.compiler.mainmodule.get_primitive_class(name)
1083
1084 # Force to get the primitive property named `name` in the instance `recv` or abort
1085 fun get_property(name: String, recv: MType): MMethod
1086 do
1087 assert recv isa MClassType
1088 return self.compiler.modelbuilder.force_get_primitive_method(self.current_node, name, recv.mclass, self.compiler.mainmodule)
1089 end
1090
1091 fun compile_callsite(callsite: CallSite, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
1092 do
1093 var initializers = callsite.mpropdef.initializers
1094 if not initializers.is_empty then
1095 var recv = arguments.first
1096
1097 var i = 1
1098 for p in initializers do
1099 if p isa MMethod then
1100 var args = [recv]
1101 for x in p.intro.msignature.mparameters do
1102 args.add arguments[i]
1103 i += 1
1104 end
1105 self.send(p, args)
1106 else if p isa MAttribute then
1107 self.write_attribute(p, recv, arguments[i])
1108 i += 1
1109 else abort
1110 end
1111 assert i == arguments.length
1112
1113 return self.send(callsite.mproperty, [recv])
1114 end
1115
1116 return self.send(callsite.mproperty, arguments)
1117 end
1118
1119 fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable is abstract
1120
1121 fun calloc_array(ret_type: MType, arguments: Array[RuntimeVariable]) is abstract
1122
1123 fun native_array_def(pname: String, ret_type: nullable MType, arguments: Array[RuntimeVariable]) is abstract
1124
1125 # Evaluate `args` as expressions in the call of `mpropdef` on `recv`.
1126 # This method is used to manage varargs in signatures and returns the real array
1127 # of runtime variables to use in the call.
1128 fun varargize(mpropdef: MMethodDef, recv: RuntimeVariable, args: SequenceRead[AExpr]): Array[RuntimeVariable]
1129 do
1130 var msignature = mpropdef.new_msignature or else mpropdef.msignature.as(not null)
1131 var res = new Array[RuntimeVariable]
1132 res.add(recv)
1133
1134 if args.is_empty then return res
1135
1136 var vararg_rank = msignature.vararg_rank
1137 var vararg_len = args.length - msignature.arity
1138 if vararg_len < 0 then vararg_len = 0
1139
1140 for i in [0..msignature.arity[ do
1141 if i == vararg_rank then
1142 var ne = args[i]
1143 if ne isa AVarargExpr then
1144 var e = self.expr(ne.n_expr, null)
1145 res.add(e)
1146 continue
1147 end
1148 var vararg = new Array[RuntimeVariable]
1149 for j in [vararg_rank..vararg_rank+vararg_len] do
1150 var e = self.expr(args[j], null)
1151 vararg.add(e)
1152 end
1153 var elttype = msignature.mparameters[vararg_rank].mtype
1154 var arg = self.vararg_instance(mpropdef, recv, vararg, elttype)
1155 res.add(arg)
1156 else
1157 var j = i
1158 if i > vararg_rank then j += vararg_len
1159 var e = self.expr(args[j], null)
1160 res.add(e)
1161 end
1162 end
1163 return res
1164 end
1165
1166 # Type handling
1167
1168 # Anchor a type to the main module and the current receiver
1169 fun anchor(mtype: MType): MType
1170 do
1171 if not mtype.need_anchor then return mtype
1172 return mtype.anchor_to(self.compiler.mainmodule, self.frame.receiver)
1173 end
1174
1175 fun resolve_for(mtype: MType, recv: RuntimeVariable): MType
1176 do
1177 if not mtype.need_anchor then return mtype
1178 return mtype.resolve_for(recv.mcasttype, self.frame.receiver, self.compiler.mainmodule, true)
1179 end
1180
1181 # Unsafely cast a value to a new type
1182 # ie the result share the same C variable but my have a different mcasttype
1183 # NOTE: if the adaptation is useless then `value` is returned as it.
1184 # ENSURE: `result.name == value.name`
1185 fun autoadapt(value: RuntimeVariable, mtype: MType): RuntimeVariable
1186 do
1187 mtype = self.anchor(mtype)
1188 var valmtype = value.mcasttype
1189 if valmtype.is_subtype(self.compiler.mainmodule, null, mtype) then
1190 return value
1191 end
1192
1193 if valmtype isa MNullableType and valmtype.mtype.is_subtype(self.compiler.mainmodule, null, mtype) then
1194 var res = new RuntimeVariable(value.name, valmtype, valmtype.mtype)
1195 return res
1196 else
1197 var res = new RuntimeVariable(value.name, valmtype, mtype)
1198 return res
1199 end
1200 end
1201
1202 # Generate a super call from a method definition
1203 fun supercall(m: MMethodDef, recvtype: MClassType, args: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
1204
1205 # Adapt the arguments of a method according to targetted `MMethodDef`
1206 fun adapt_signature(m: MMethodDef, args: Array[RuntimeVariable]) is abstract
1207
1208 # Unbox all the arguments of a method when implemented `extern` or `intern`
1209 fun unbox_signature_extern(m: MMethodDef, args: Array[RuntimeVariable]) is abstract
1210
1211 # Box or unbox a value to another type iff a C type conversion is needed
1212 # ENSURE: `result.mtype.ctype == mtype.ctype`
1213 fun autobox(value: RuntimeVariable, mtype: MType): RuntimeVariable is abstract
1214
1215 # Box extern classes to be used in the generated code
1216 fun box_extern(value: RuntimeVariable, mtype: MType): RuntimeVariable is abstract
1217
1218 # Unbox extern classes to be used in extern code (legacy NI and FFI)
1219 fun unbox_extern(value: RuntimeVariable, mtype: MType): RuntimeVariable is abstract
1220
1221 # Generate a polymorphic subtype test
1222 fun type_test(value: RuntimeVariable, mtype: MType, tag: String): RuntimeVariable is abstract
1223
1224 # Generate the code required to dynamically check if 2 objects share the same runtime type
1225 fun is_same_type_test(value1, value2: RuntimeVariable): RuntimeVariable is abstract
1226
1227 # Generate a Nit "is" for two runtime_variables
1228 fun equal_test(value1, value2: RuntimeVariable): RuntimeVariable is abstract
1229
1230 # Sends
1231
1232 # Generate a static call on a method definition
1233 fun call(m: MMethodDef, recvtype: MClassType, args: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
1234
1235 # Generate a polymorphic send for the method `m` and the arguments `args`
1236 fun send(m: MMethod, args: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
1237
1238 # Generate a monomorphic send for the method `m`, the type `t` and the arguments `args`
1239 fun monomorphic_send(m: MMethod, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable
1240 do
1241 assert t isa MClassType
1242 var propdef = m.lookup_first_definition(self.compiler.mainmodule, t)
1243 return self.call(propdef, t, args)
1244 end
1245
1246 # Generate a monomorphic super send from the method `m`, the type `t` and the arguments `args`
1247 fun monomorphic_super_send(m: MMethodDef, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable
1248 do
1249 assert t isa MClassType
1250 m = m.lookup_next_definition(self.compiler.mainmodule, t)
1251 return self.call(m, t, args)
1252 end
1253
1254 # Attributes handling
1255
1256 # Generate a polymorphic attribute is_set test
1257 fun isset_attribute(a: MAttribute, recv: RuntimeVariable): RuntimeVariable is abstract
1258
1259 # Generate a polymorphic attribute read
1260 fun read_attribute(a: MAttribute, recv: RuntimeVariable): RuntimeVariable is abstract
1261
1262 # Generate a polymorphic attribute write
1263 fun write_attribute(a: MAttribute, recv: RuntimeVariable, value: RuntimeVariable) is abstract
1264
1265 # Checks
1266
1267 # Add a check and an abort for a null receiver if needed
1268 fun check_recv_notnull(recv: RuntimeVariable)
1269 do
1270 if self.compiler.modelbuilder.toolcontext.opt_no_check_null.value then return
1271
1272 var maybenull = recv.mcasttype isa MNullableType or recv.mcasttype isa MNullType
1273 if maybenull then
1274 self.add("if (unlikely({recv} == NULL)) \{")
1275 self.add_abort("Receiver is null")
1276 self.add("\}")
1277 end
1278 end
1279
1280 # Names handling
1281
1282 private var names = new HashSet[String]
1283 private var last: Int = 0
1284
1285 # Return a new name based on `s` and unique in the visitor
1286 fun get_name(s: String): String
1287 do
1288 if not self.names.has(s) then
1289 self.names.add(s)
1290 return s
1291 end
1292 var i = self.last + 1
1293 loop
1294 var s2 = s + i.to_s
1295 if not self.names.has(s2) then
1296 self.last = i
1297 self.names.add(s2)
1298 return s2
1299 end
1300 i = i + 1
1301 end
1302 end
1303
1304 # Return an unique and stable identifier associated with an escapemark
1305 fun escapemark_name(e: nullable EscapeMark): String
1306 do
1307 assert e != null
1308 if frame.escapemark_names.has_key(e) then return frame.escapemark_names[e]
1309 var name = e.name
1310 if name == null then name = "label"
1311 name = get_name(name)
1312 frame.escapemark_names[e] = name
1313 return name
1314 end
1315
1316 # Insert a C label for associated with an escapemark
1317 fun add_escape_label(e: nullable EscapeMark)
1318 do
1319 if e == null then return
1320 if e.escapes.is_empty then return
1321 add("BREAK_{escapemark_name(e)}: (void)0;")
1322 end
1323
1324 # Return a "const char*" variable associated to the classname of the dynamic type of an object
1325 # NOTE: we do not return a `RuntimeVariable` "NativeString" as the class may not exist in the module/program
1326 fun class_name_string(value: RuntimeVariable): String is abstract
1327
1328 # Variables handling
1329
1330 protected var variables = new HashMap[Variable, RuntimeVariable]
1331
1332 # Return the local runtime_variable associated to a Nit local variable
1333 fun variable(variable: Variable): RuntimeVariable
1334 do
1335 if self.variables.has_key(variable) then
1336 return self.variables[variable]
1337 else
1338 var name = self.get_name("var_{variable.name}")
1339 var mtype = variable.declared_type.as(not null)
1340 mtype = self.anchor(mtype)
1341 var res = new RuntimeVariable(name, mtype, mtype)
1342 self.add_decl("{mtype.ctype} {name} /* var {variable}: {mtype} */;")
1343 self.variables[variable] = res
1344 return res
1345 end
1346 end
1347
1348 # Return a new uninitialized local runtime_variable
1349 fun new_var(mtype: MType): RuntimeVariable
1350 do
1351 mtype = self.anchor(mtype)
1352 var name = self.get_name("var")
1353 var res = new RuntimeVariable(name, mtype, mtype)
1354 self.add_decl("{mtype.ctype} {name} /* : {mtype} */;")
1355 return res
1356 end
1357
1358 # The difference with `new_var` is the C static type of the local variable
1359 fun new_var_extern(mtype: MType): RuntimeVariable
1360 do
1361 mtype = self.anchor(mtype)
1362 var name = self.get_name("var")
1363 var res = new RuntimeVariable(name, mtype, mtype)
1364 self.add_decl("{mtype.ctype_extern} {name} /* : {mtype} for extern */;")
1365 return res
1366 end
1367
1368 # Return a new uninitialized named runtime_variable
1369 fun new_named_var(mtype: MType, name: String): RuntimeVariable
1370 do
1371 mtype = self.anchor(mtype)
1372 var res = new RuntimeVariable(name, mtype, mtype)
1373 self.add_decl("{mtype.ctype} {name} /* : {mtype} */;")
1374 return res
1375 end
1376
1377 # Correctly assign a left and a right value
1378 # Boxing and unboxing is performed if required
1379 fun assign(left, right: RuntimeVariable)
1380 do
1381 right = self.autobox(right, left.mtype)
1382 self.add("{left} = {right};")
1383 end
1384
1385 # Generate instances
1386
1387 # Generate a alloc-instance + init-attributes
1388 fun init_instance(mtype: MClassType): RuntimeVariable is abstract
1389
1390 # Allocate and init attributes of an instance of a standard or extern class
1391 #
1392 # Does not support universals and the pseudo-internal `NativeArray` class.
1393 fun init_instance_or_extern(mtype: MClassType): RuntimeVariable
1394 do
1395 var recv
1396 var ctype = mtype.ctype
1397 assert mtype.mclass.name != "NativeArray"
1398 if ctype == "val*" then
1399 recv = init_instance(mtype)
1400 else if ctype == "char*" then
1401 recv = new_expr("NULL/*special!*/", mtype)
1402 else
1403 recv = new_expr("({ctype})0/*special!*/", mtype)
1404 end
1405 return recv
1406 end
1407
1408 # Set a GC finalizer on `recv`, only if `recv` isa Finalizable
1409 fun set_finalizer(recv: RuntimeVariable)
1410 do
1411 var mtype = recv.mtype
1412 var finalizable_type = compiler.mainmodule.finalizable_type
1413 if finalizable_type != null and not mtype.need_anchor and
1414 mtype.is_subtype(compiler.mainmodule, null, finalizable_type) then
1415 add "gc_register_finalizer({recv});"
1416 end
1417 end
1418
1419 # Generate an integer value
1420 fun int_instance(value: Int): RuntimeVariable
1421 do
1422 var res = self.new_var(self.get_class("Int").mclass_type)
1423 self.add("{res} = {value};")
1424 return res
1425 end
1426
1427 # Generate an integer value
1428 fun bool_instance(value: Bool): RuntimeVariable
1429 do
1430 var res = self.new_var(self.get_class("Bool").mclass_type)
1431 if value then
1432 self.add("{res} = 1;")
1433 else
1434 self.add("{res} = 0;")
1435 end
1436 return res
1437 end
1438
1439 # Generate a string value
1440 fun string_instance(string: String): RuntimeVariable
1441 do
1442 var mtype = self.get_class("String").mclass_type
1443 var name = self.get_name("varonce")
1444 self.add_decl("static {mtype.ctype} {name};")
1445 var res = self.new_var(mtype)
1446 self.add("if ({name}) \{")
1447 self.add("{res} = {name};")
1448 self.add("\} else \{")
1449 var native_mtype = self.get_class("NativeString").mclass_type
1450 var nat = self.new_var(native_mtype)
1451 self.add("{nat} = \"{string.escape_to_c}\";")
1452 var length = self.int_instance(string.length)
1453 self.add("{res} = {self.send(self.get_property("to_s_with_length", native_mtype), [nat, length]).as(not null)};")
1454 self.add("{name} = {res};")
1455 self.add("\}")
1456 return res
1457 end
1458
1459 fun value_instance(object: Object): RuntimeVariable
1460 do
1461 if object isa Int then
1462 return int_instance(object)
1463 else if object isa Bool then
1464 return bool_instance(object)
1465 else if object isa String then
1466 return string_instance(object)
1467 else
1468 abort
1469 end
1470 end
1471
1472 # Generate an array value
1473 fun array_instance(array: Array[RuntimeVariable], elttype: MType): RuntimeVariable is abstract
1474
1475 # Get an instance of a array for a vararg
1476 fun vararg_instance(mpropdef: MPropDef, recv: RuntimeVariable, varargs: Array[RuntimeVariable], elttype: MType): RuntimeVariable is abstract
1477
1478 # Code generation
1479
1480 # Add a line in the main part of the generated C
1481 fun add(s: String) do self.writer.lines.add(s)
1482
1483 # Add a line in the
1484 # (used for local or global declaration)
1485 fun add_decl(s: String) do self.writer.decl_lines.add(s)
1486
1487 # Request the presence of a global declaration
1488 fun require_declaration(key: String)
1489 do
1490 var reqs = self.writer.file.required_declarations
1491 if reqs.has(key) then return
1492 reqs.add(key)
1493 var node = current_node
1494 if node != null then compiler.requirers_of_declarations[key] = node
1495 end
1496
1497 # Add a declaration in the local-header
1498 # The declaration is ensured to be present once
1499 fun declare_once(s: String)
1500 do
1501 self.compiler.provide_declaration(s, s)
1502 self.require_declaration(s)
1503 end
1504
1505 # Look for a needed .h and .c file for a given module
1506 # This is used for the legacy FFI
1507 fun add_extern(mmodule: MModule)
1508 do
1509 var file = mmodule.location.file.filename
1510 file = file.strip_extension(".nit")
1511 var tryfile = file + ".nit.h"
1512 if tryfile.file_exists then
1513 self.declare_once("#include \"{tryfile.basename("")}\"")
1514 self.compiler.files_to_copy.add(tryfile)
1515 end
1516 tryfile = file + "_nit.h"
1517 if tryfile.file_exists then
1518 self.declare_once("#include \"{tryfile.basename("")}\"")
1519 self.compiler.files_to_copy.add(tryfile)
1520 end
1521
1522 if self.compiler.seen_extern.has(file) then return
1523 self.compiler.seen_extern.add(file)
1524 tryfile = file + ".nit.c"
1525 if not tryfile.file_exists then
1526 tryfile = file + "_nit.c"
1527 if not tryfile.file_exists then return
1528 end
1529 var f = new ExternCFile(tryfile.basename(""), "")
1530 self.compiler.extern_bodies.add(f)
1531 self.compiler.files_to_copy.add(tryfile)
1532 end
1533
1534 # Return a new local runtime_variable initialized with the C expression `cexpr`.
1535 fun new_expr(cexpr: String, mtype: MType): RuntimeVariable
1536 do
1537 var res = new_var(mtype)
1538 self.add("{res} = {cexpr};")
1539 return res
1540 end
1541
1542 # Generate generic abort
1543 # used by aborts, asserts, casts, etc.
1544 fun add_abort(message: String)
1545 do
1546 self.add("PRINT_ERROR(\"Runtime error: %s\", \"{message.escape_to_c}\");")
1547 add_raw_abort
1548 end
1549
1550 fun add_raw_abort
1551 do
1552 if self.current_node != null and self.current_node.location.file != null and
1553 self.current_node.location.file.mmodule != null then
1554 var f = "FILE_{self.current_node.location.file.mmodule.c_name}"
1555 self.require_declaration(f)
1556 self.add("PRINT_ERROR(\" (%s:%d)\\n\", {f}, {current_node.location.line_start});")
1557 else
1558 self.add("PRINT_ERROR(\"\\n\");")
1559 end
1560 self.add("show_backtrace(1);")
1561 end
1562
1563 # Add a dynamic cast
1564 fun add_cast(value: RuntimeVariable, mtype: MType, tag: String)
1565 do
1566 var res = self.type_test(value, mtype, tag)
1567 self.add("if (unlikely(!{res})) \{")
1568 var cn = self.class_name_string(value)
1569 self.add("PRINT_ERROR(\"Runtime error: Cast failed. Expected `%s`, got `%s`\", \"{mtype.to_s.escape_to_c}\", {cn});")
1570 self.add_raw_abort
1571 self.add("\}")
1572 end
1573
1574 # Generate a return with the value `s`
1575 fun ret(s: RuntimeVariable)
1576 do
1577 self.assign(self.frame.returnvar.as(not null), s)
1578 self.add("goto {self.frame.returnlabel.as(not null)};")
1579 end
1580
1581 # Compile a statement (if any)
1582 fun stmt(nexpr: nullable AExpr)
1583 do
1584 if nexpr == null then return
1585
1586 var narray = nexpr.comprehension
1587 if narray != null then
1588 var recv = frame.comprehension.as(not null)
1589 var val = expr(nexpr, narray.element_mtype)
1590 compile_callsite(narray.push_callsite.as(not null), [recv, val])
1591 return
1592 end
1593
1594 var old = self.current_node
1595 self.current_node = nexpr
1596 nexpr.stmt(self)
1597 self.current_node = old
1598 end
1599
1600 # Compile an expression an return its result
1601 # `mtype` is the expected return type, pass null if no specific type is expected.
1602 fun expr(nexpr: AExpr, mtype: nullable MType): RuntimeVariable
1603 do
1604 var old = self.current_node
1605 self.current_node = nexpr
1606 var res = nexpr.expr(self).as(not null)
1607 if mtype != null then
1608 mtype = self.anchor(mtype)
1609 res = self.autobox(res, mtype)
1610 end
1611 res = autoadapt(res, nexpr.mtype.as(not null))
1612 var implicit_cast_to = nexpr.implicit_cast_to
1613 if implicit_cast_to != null and not self.compiler.modelbuilder.toolcontext.opt_no_check_autocast.value then
1614 add_cast(res, implicit_cast_to, "auto")
1615 res = autoadapt(res, implicit_cast_to)
1616 end
1617 self.current_node = old
1618 return res
1619 end
1620
1621 # Alias for `self.expr(nexpr, self.bool_type)`
1622 fun expr_bool(nexpr: AExpr): RuntimeVariable do return expr(nexpr, bool_type)
1623
1624 # Safely show a debug message on the current node and repeat the message in the C code as a comment
1625 fun debug(message: String)
1626 do
1627 var node = self.current_node
1628 if node == null then
1629 print "?: {message}"
1630 else
1631 node.debug(message)
1632 end
1633 self.add("/* DEBUG: {message} */")
1634 end
1635 end
1636
1637 # A C function associated to a Nit method
1638 # Because of customization, a given Nit method can be compiler more that once
1639 abstract class AbstractRuntimeFunction
1640
1641 type COMPILER: AbstractCompiler
1642 type VISITOR: AbstractCompilerVisitor
1643
1644 # The associated Nit method
1645 var mmethoddef: MMethodDef
1646
1647 # The mangled c name of the runtime_function
1648 # Subclasses should redefine `build_c_name` instead
1649 fun c_name: String
1650 do
1651 var res = self.c_name_cache
1652 if res != null then return res
1653 res = self.build_c_name
1654 self.c_name_cache = res
1655 return res
1656 end
1657
1658 # Non cached version of `c_name`
1659 protected fun build_c_name: String is abstract
1660
1661 protected var c_name_cache: nullable String = null is writable
1662
1663 # Implements a call of the runtime_function
1664 # May inline the body or generate a C function call
1665 fun call(v: VISITOR, arguments: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
1666
1667 # Generate the code for the `AbstractRuntimeFunction`
1668 # Warning: compile more than once compilation makes CC unhappy
1669 fun compile_to_c(compiler: COMPILER) is abstract
1670 end
1671
1672 # A runtime variable hold a runtime value in C.
1673 # Runtime variables are associated to Nit local variables and intermediate results in Nit expressions.
1674 #
1675 # 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.
1676 class RuntimeVariable
1677 # The name of the variable in the C code
1678 var name: String
1679
1680 # The static type of the variable (as declard in C)
1681 var mtype: MType
1682
1683 # The current casted type of the variable (as known in Nit)
1684 var mcasttype: MType is writable
1685
1686 # If the variable exaclty a mcasttype?
1687 # false (usual value) means that the variable is a mcasttype or a subtype.
1688 var is_exact: Bool = false is writable
1689
1690 init
1691 do
1692 assert not mtype.need_anchor
1693 assert not mcasttype.need_anchor
1694 end
1695
1696 redef fun to_s do return name
1697
1698 redef fun inspect
1699 do
1700 var exact_str
1701 if self.is_exact then
1702 exact_str = " exact"
1703 else
1704 exact_str = ""
1705 end
1706 var type_str
1707 if self.mtype == self.mcasttype then
1708 type_str = "{mtype}{exact_str}"
1709 else
1710 type_str = "{mtype}({mcasttype}{exact_str})"
1711 end
1712 return "<{name}:{type_str}>"
1713 end
1714 end
1715
1716 # The static context of a visited property in a `AbstractCompilerVisitor`
1717 class StaticFrame
1718
1719 type VISITOR: AbstractCompilerVisitor
1720
1721 # The associated visitor
1722 var visitor: VISITOR
1723
1724 # The executed property.
1725 # A Method in case of a call, an attribute in case of a default initialization.
1726 var mpropdef: MPropDef
1727
1728 # The static type of the receiver
1729 var receiver: MClassType
1730
1731 # Arguments of the method (the first is the receiver)
1732 var arguments: Array[RuntimeVariable]
1733
1734 # The runtime_variable associated to the return (in a function)
1735 var returnvar: nullable RuntimeVariable = null is writable
1736
1737 # The label at the end of the property
1738 var returnlabel: nullable String = null is writable
1739
1740 # Labels associated to a each escapemarks.
1741 # Because of inlinings, escape-marks must be associated to their context (the frame)
1742 private var escapemark_names = new HashMap[EscapeMark, String]
1743
1744 # The array comprehension currently filled, if any
1745 private var comprehension: nullable RuntimeVariable = null
1746 end
1747
1748 redef class MType
1749 # Return the C type associated to a given Nit static type
1750 fun ctype: String do return "val*"
1751
1752 # C type outside of the compiler code and in boxes
1753 fun ctype_extern: String do return "val*"
1754
1755 # Short name of the `ctype` to use in unions
1756 fun ctypename: String do return "val"
1757 end
1758
1759 redef class MClassType
1760
1761 redef fun ctype: String
1762 do
1763 if mclass.name == "Int" then
1764 return "long"
1765 else if mclass.name == "Bool" then
1766 return "short int"
1767 else if mclass.name == "Char" then
1768 return "char"
1769 else if mclass.name == "Float" then
1770 return "double"
1771 else if mclass.name == "NativeString" then
1772 return "char*"
1773 else if mclass.name == "NativeArray" then
1774 return "val*"
1775 else
1776 return "val*"
1777 end
1778 end
1779
1780 redef fun ctype_extern: String
1781 do
1782 if mclass.kind == extern_kind then
1783 return "void*"
1784 else
1785 return ctype
1786 end
1787 end
1788
1789 redef fun ctypename: String
1790 do
1791 if mclass.name == "Int" then
1792 return "l"
1793 else if mclass.name == "Bool" then
1794 return "s"
1795 else if mclass.name == "Char" then
1796 return "c"
1797 else if mclass.name == "Float" then
1798 return "d"
1799 else if mclass.name == "NativeString" then
1800 return "str"
1801 else if mclass.name == "NativeArray" then
1802 #return "{self.arguments.first.ctype}*"
1803 return "val"
1804 else
1805 return "val"
1806 end
1807 end
1808 end
1809
1810 redef class MPropDef
1811 type VISITOR: AbstractCompilerVisitor
1812 end
1813
1814 redef class MMethodDef
1815 # Can the body be inlined?
1816 fun can_inline(v: VISITOR): Bool
1817 do
1818 if is_abstract then return true
1819 var modelbuilder = v.compiler.modelbuilder
1820 var node = modelbuilder.mpropdef2node(self)
1821 if node isa APropdef then
1822 return node.can_inline
1823 else if node isa AClassdef then
1824 # Automatic free init is always inlined since it is empty or contains only attribtes assigments
1825 return true
1826 else
1827 abort
1828 end
1829 end
1830
1831 # Inline the body in another visitor
1832 fun compile_inside_to_c(v: VISITOR, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
1833 do
1834 var modelbuilder = v.compiler.modelbuilder
1835 var val = constant_value
1836 var node = modelbuilder.mpropdef2node(self)
1837 if node isa APropdef then
1838 var oldnode = v.current_node
1839 v.current_node = node
1840 self.compile_parameter_check(v, arguments)
1841 node.compile_to_c(v, self, arguments)
1842 v.current_node = oldnode
1843 else if node isa AClassdef then
1844 var oldnode = v.current_node
1845 v.current_node = node
1846 self.compile_parameter_check(v, arguments)
1847 node.compile_to_c(v, self, arguments)
1848 v.current_node = oldnode
1849 else if val != null then
1850 v.ret(v.value_instance(val))
1851 else
1852 abort
1853 end
1854 return null
1855 end
1856
1857 # Generate type checks in the C code to check covariant parameters
1858 fun compile_parameter_check(v: VISITOR, arguments: Array[RuntimeVariable])
1859 do
1860 if v.compiler.modelbuilder.toolcontext.opt_no_check_covariance.value then return
1861
1862 for i in [0..msignature.arity[ do
1863 # skip test for vararg since the array is instantiated with the correct polymorphic type
1864 if msignature.vararg_rank == i then continue
1865
1866 # skip if the cast is not required
1867 var origmtype = self.mproperty.intro.msignature.mparameters[i].mtype
1868 if not origmtype.need_anchor then continue
1869
1870 # get the parameter type
1871 var mtype = self.msignature.mparameters[i].mtype
1872
1873 # generate the cast
1874 # note that v decides if and how to implements the cast
1875 v.add("/* Covariant cast for argument {i} ({self.msignature.mparameters[i].name}) {arguments[i+1].inspect} isa {mtype} */")
1876 v.add_cast(arguments[i+1], mtype, "covariance")
1877 end
1878 end
1879 end
1880
1881 # Node visit
1882
1883 redef class APropdef
1884 fun compile_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
1885 do
1886 v.add("PRINT_ERROR(\"NOT YET IMPLEMENTED {class_name} {mpropdef} at {location.to_s}\\n\");")
1887 debug("Not yet implemented")
1888 end
1889
1890 fun can_inline: Bool do return true
1891 end
1892
1893 redef class AMethPropdef
1894 redef fun compile_to_c(v, mpropdef, arguments)
1895 do
1896 if mpropdef.is_abstract then
1897 var cn = v.class_name_string(arguments.first)
1898 v.add("PRINT_ERROR(\"Runtime error: Abstract method `%s` called on `%s`\", \"{mpropdef.mproperty.name.escape_to_c}\", {cn});")
1899 v.add_raw_abort
1900 return
1901 end
1902
1903 # Call the implicit super-init
1904 var auto_super_inits = self.auto_super_inits
1905 if auto_super_inits != null then
1906 var args = [arguments.first]
1907 for auto_super_init in auto_super_inits do
1908 assert auto_super_init.mproperty != mpropdef.mproperty
1909 args.clear
1910 for i in [0..auto_super_init.msignature.arity+1[ do
1911 args.add(arguments[i])
1912 end
1913 assert auto_super_init.mproperty != mpropdef.mproperty
1914 v.compile_callsite(auto_super_init, args)
1915 end
1916 end
1917 if auto_super_call then
1918 v.supercall(mpropdef, arguments.first.mtype.as(MClassType), arguments)
1919 end
1920
1921 # Try special compilation
1922 if mpropdef.is_intern then
1923 if compile_intern_to_c(v, mpropdef, arguments) then return
1924 else if mpropdef.is_extern then
1925 if mpropdef.mproperty.is_init then
1926 if compile_externinit_to_c(v, mpropdef, arguments) then return
1927 else
1928 if compile_externmeth_to_c(v, mpropdef, arguments) then return
1929 end
1930 end
1931
1932 # Compile block if any
1933 var n_block = n_block
1934 if n_block != null then
1935 for i in [0..mpropdef.msignature.arity[ do
1936 var variable = self.n_signature.n_params[i].variable.as(not null)
1937 v.assign(v.variable(variable), arguments[i+1])
1938 end
1939 v.stmt(n_block)
1940 return
1941 end
1942
1943 # We have a problem
1944 var cn = v.class_name_string(arguments.first)
1945 v.add("PRINT_ERROR(\"Runtime error: uncompiled method `%s` called on `%s`. NOT YET IMPLEMENTED\", \"{mpropdef.mproperty.name.escape_to_c}\", {cn});")
1946 v.add_raw_abort
1947 end
1948
1949 redef fun can_inline
1950 do
1951 if self.auto_super_inits != null then return false
1952 var nblock = self.n_block
1953 if nblock == null then return true
1954 if (mpropdef.mproperty.name == "==" or mpropdef.mproperty.name == "!=") and mpropdef.mclassdef.mclass.name == "Object" then return true
1955 if nblock isa ABlockExpr and nblock.n_expr.length == 0 then return true
1956 return false
1957 end
1958
1959 fun compile_intern_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable]): Bool
1960 do
1961 var pname = mpropdef.mproperty.name
1962 var cname = mpropdef.mclassdef.mclass.name
1963 var ret = mpropdef.msignature.return_mtype
1964 if ret != null then
1965 ret = v.resolve_for(ret, arguments.first)
1966 end
1967 if pname != "==" and pname != "!=" then
1968 v.adapt_signature(mpropdef, arguments)
1969 v.unbox_signature_extern(mpropdef, arguments)
1970 end
1971 if cname == "Int" then
1972 if pname == "output" then
1973 v.add("printf(\"%ld\\n\", {arguments.first});")
1974 return true
1975 else if pname == "object_id" then
1976 v.ret(arguments.first)
1977 return true
1978 else if pname == "+" then
1979 v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
1980 return true
1981 else if pname == "-" then
1982 v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
1983 return true
1984 else if pname == "unary -" then
1985 v.ret(v.new_expr("-{arguments[0]}", ret.as(not null)))
1986 return true
1987 else if pname == "*" then
1988 v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null)))
1989 return true
1990 else if pname == "/" then
1991 v.ret(v.new_expr("{arguments[0]} / {arguments[1]}", ret.as(not null)))
1992 return true
1993 else if pname == "%" then
1994 v.ret(v.new_expr("{arguments[0]} % {arguments[1]}", ret.as(not null)))
1995 return true
1996 else if pname == "lshift" then
1997 v.ret(v.new_expr("{arguments[0]} << {arguments[1]}", ret.as(not null)))
1998 return true
1999 else if pname == "rshift" then
2000 v.ret(v.new_expr("{arguments[0]} >> {arguments[1]}", ret.as(not null)))
2001 return true
2002 else if pname == "==" then
2003 v.ret(v.equal_test(arguments[0], arguments[1]))
2004 return true
2005 else if pname == "!=" then
2006 var res = v.equal_test(arguments[0], arguments[1])
2007 v.ret(v.new_expr("!{res}", ret.as(not null)))
2008 return true
2009 else if pname == "<" then
2010 v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
2011 return true
2012 else if pname == ">" then
2013 v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null)))
2014 return true
2015 else if pname == "<=" then
2016 v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null)))
2017 return true
2018 else if pname == ">=" then
2019 v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null)))
2020 return true
2021 else if pname == "to_f" then
2022 v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null)))
2023 return true
2024 else if pname == "ascii" then
2025 v.ret(v.new_expr("{arguments[0]}", ret.as(not null)))
2026 return true
2027 end
2028 else if cname == "Char" then
2029 if pname == "output" then
2030 v.add("printf(\"%c\", {arguments.first});")
2031 return true
2032 else if pname == "object_id" then
2033 v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
2034 return true
2035 else if pname == "successor" then
2036 v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
2037 return true
2038 else if pname == "predecessor" then
2039 v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
2040 return true
2041 else if pname == "==" then
2042 v.ret(v.equal_test(arguments[0], arguments[1]))
2043 return true
2044 else if pname == "!=" then
2045 var res = v.equal_test(arguments[0], arguments[1])
2046 v.ret(v.new_expr("!{res}", ret.as(not null)))
2047 return true
2048 else if pname == "<" then
2049 v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
2050 return true
2051 else if pname == ">" then
2052 v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null)))
2053 return true
2054 else if pname == "<=" then
2055 v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null)))
2056 return true
2057 else if pname == ">=" then
2058 v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null)))
2059 return true
2060 else if pname == "to_i" then
2061 v.ret(v.new_expr("{arguments[0]}-'0'", ret.as(not null)))
2062 return true
2063 else if pname == "ascii" then
2064 v.ret(v.new_expr("(unsigned char){arguments[0]}", ret.as(not null)))
2065 return true
2066 end
2067 else if cname == "Bool" then
2068 if pname == "output" then
2069 v.add("printf({arguments.first}?\"true\\n\":\"false\\n\");")
2070 return true
2071 else if pname == "object_id" then
2072 v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
2073 return true
2074 else if pname == "==" then
2075 v.ret(v.equal_test(arguments[0], arguments[1]))
2076 return true
2077 else if pname == "!=" then
2078 var res = v.equal_test(arguments[0], arguments[1])
2079 v.ret(v.new_expr("!{res}", ret.as(not null)))
2080 return true
2081 end
2082 else if cname == "Float" then
2083 if pname == "output" then
2084 v.add("printf(\"%f\\n\", {arguments.first});")
2085 return true
2086 else if pname == "object_id" then
2087 v.ret(v.new_expr("(double){arguments.first}", ret.as(not null)))
2088 return true
2089 else if pname == "+" then
2090 v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
2091 return true
2092 else if pname == "-" then
2093 v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
2094 return true
2095 else if pname == "unary -" then
2096 v.ret(v.new_expr("-{arguments[0]}", ret.as(not null)))
2097 return true
2098 else if pname == "succ" then
2099 v.ret(v.new_expr("{arguments[0]}+1", ret.as(not null)))
2100 return true
2101 else if pname == "prec" then
2102 v.ret(v.new_expr("{arguments[0]}-1", ret.as(not null)))
2103 return true
2104 else if pname == "*" then
2105 v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null)))
2106 return true
2107 else if pname == "/" then
2108 v.ret(v.new_expr("{arguments[0]} / {arguments[1]}", ret.as(not null)))
2109 return true
2110 else if pname == "==" then
2111 v.ret(v.equal_test(arguments[0], arguments[1]))
2112 return true
2113 else if pname == "!=" then
2114 var res = v.equal_test(arguments[0], arguments[1])
2115 v.ret(v.new_expr("!{res}", ret.as(not null)))
2116 return true
2117 else if pname == "<" then
2118 v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
2119 return true
2120 else if pname == ">" then
2121 v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null)))
2122 return true
2123 else if pname == "<=" then
2124 v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null)))
2125 return true
2126 else if pname == ">=" then
2127 v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null)))
2128 return true
2129 else if pname == "to_i" then
2130 v.ret(v.new_expr("(long){arguments[0]}", ret.as(not null)))
2131 return true
2132 end
2133 else if cname == "NativeString" then
2134 if pname == "[]" then
2135 v.ret(v.new_expr("{arguments[0]}[{arguments[1]}]", ret.as(not null)))
2136 return true
2137 else if pname == "[]=" then
2138 v.add("{arguments[0]}[{arguments[1]}]={arguments[2]};")
2139 return true
2140 else if pname == "copy_to" then
2141 v.add("memmove({arguments[1]}+{arguments[4]},{arguments[0]}+{arguments[3]},{arguments[2]});")
2142 return true
2143 else if pname == "atoi" then
2144 v.ret(v.new_expr("atoi({arguments[0]});", ret.as(not null)))
2145 return true
2146 else if pname == "new" then
2147 v.ret(v.new_expr("(char*)nit_alloc({arguments[1]})", ret.as(not null)))
2148 return true
2149 end
2150 else if cname == "NativeArray" then
2151 v.native_array_def(pname, ret, arguments)
2152 return true
2153 end
2154 if pname == "exit" then
2155 v.add("exit({arguments[1]});")
2156 return true
2157 else if pname == "sys" then
2158 v.ret(v.new_expr("glob_sys", ret.as(not null)))
2159 return true
2160 else if pname == "calloc_string" then
2161 v.ret(v.new_expr("(char*)nit_alloc({arguments[1]})", ret.as(not null)))
2162 return true
2163 else if pname == "calloc_array" then
2164 v.calloc_array(ret.as(not null), arguments)
2165 return true
2166 else if pname == "object_id" then
2167 v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
2168 return true
2169 else if pname == "is_same_type" then
2170 v.ret(v.is_same_type_test(arguments[0], arguments[1]))
2171 return true
2172 else if pname == "is_same_instance" then
2173 v.ret(v.equal_test(arguments[0], arguments[1]))
2174 return true
2175 else if pname == "output_class_name" then
2176 var nat = v.class_name_string(arguments.first)
2177 v.add("printf(\"%s\\n\", {nat});")
2178 return true
2179 else if pname == "native_class_name" then
2180 var nat = v.class_name_string(arguments.first)
2181 v.ret(v.new_expr("(char*){nat}", ret.as(not null)))
2182 return true
2183 else if pname == "force_garbage_collection" then
2184 v.add("nit_gcollect();")
2185 return true
2186 else if pname == "native_argc" then
2187 v.ret(v.new_expr("glob_argc", ret.as(not null)))
2188 return true
2189 else if pname == "native_argv" then
2190 v.ret(v.new_expr("glob_argv[{arguments[1]}]", ret.as(not null)))
2191 return true
2192 end
2193 return false
2194 end
2195
2196 # Compile an extern method
2197 # Return `true` if the compilation was successful, `false` if a fall-back is needed
2198 fun compile_externmeth_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable]): Bool
2199 do
2200 var externname
2201 var at = self.get_single_annotation("extern", v.compiler.modelbuilder)
2202 if at != null and at.n_args.length == 1 then
2203 externname = at.arg_as_string(v.compiler.modelbuilder)
2204 if externname == null then return false
2205 else
2206 return false
2207 end
2208 v.add_extern(mpropdef.mclassdef.mmodule)
2209 var res: nullable RuntimeVariable = null
2210 var ret = mpropdef.msignature.return_mtype
2211 if ret != null then
2212 ret = v.resolve_for(ret, arguments.first)
2213 res = v.new_var_extern(ret)
2214 end
2215 v.adapt_signature(mpropdef, arguments)
2216 v.unbox_signature_extern(mpropdef, arguments)
2217
2218 if res == null then
2219 v.add("{externname}({arguments.join(", ")});")
2220 else
2221 v.add("{res} = {externname}({arguments.join(", ")});")
2222 res = v.box_extern(res, ret.as(not null))
2223 v.ret(res)
2224 end
2225 return true
2226 end
2227
2228 # Compile an extern factory
2229 # Return `true` if the compilation was successful, `false` if a fall-back is needed
2230 fun compile_externinit_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable]): Bool
2231 do
2232 var externname
2233 var at = self.get_single_annotation("extern", v.compiler.modelbuilder)
2234 if at != null then
2235 externname = at.arg_as_string(v.compiler.modelbuilder)
2236 if externname == null then return false
2237 else
2238 return false
2239 end
2240 v.add_extern(mpropdef.mclassdef.mmodule)
2241 v.adapt_signature(mpropdef, arguments)
2242 v.unbox_signature_extern(mpropdef, arguments)
2243 var ret = arguments.first.mtype
2244 var res = v.new_var_extern(ret)
2245
2246 arguments.shift
2247
2248 v.add("{res} = {externname}({arguments.join(", ")});")
2249 res = v.box_extern(res, ret)
2250 v.ret(res)
2251 return true
2252 end
2253 end
2254
2255 redef class AAttrPropdef
2256 redef fun can_inline: Bool do return not is_lazy
2257
2258 redef fun compile_to_c(v, mpropdef, arguments)
2259 do
2260 if mpropdef == mreadpropdef then
2261 assert arguments.length == 1
2262 var recv = arguments.first
2263 var res
2264 if is_lazy then
2265 var set
2266 var ret = self.mpropdef.static_mtype
2267 var useiset = ret.ctype == "val*" and not ret isa MNullableType
2268 var guard = self.mlazypropdef.mproperty
2269 if useiset then
2270 set = v.isset_attribute(self.mpropdef.mproperty, recv)
2271 else
2272 set = v.read_attribute(guard, recv)
2273 end
2274 v.add("if(likely({set})) \{")
2275 res = v.read_attribute(self.mpropdef.mproperty, recv)
2276 v.add("\} else \{")
2277
2278 var value = evaluate_expr(v, recv)
2279
2280 v.assign(res, value)
2281 if not useiset then
2282 var true_v = v.new_expr("1", v.bool_type)
2283 v.write_attribute(guard, arguments.first, true_v)
2284 end
2285 v.add("\}")
2286 else
2287 res = v.read_attribute(self.mpropdef.mproperty, arguments.first)
2288 end
2289 v.assign(v.frame.returnvar.as(not null), res)
2290 else if mpropdef == mwritepropdef then
2291 assert arguments.length == 2
2292 v.write_attribute(self.mpropdef.mproperty, arguments.first, arguments[1])
2293 if is_lazy then
2294 var ret = self.mpropdef.static_mtype
2295 var useiset = ret.ctype == "val*" and not ret isa MNullableType
2296 if not useiset then
2297 v.write_attribute(self.mlazypropdef.mproperty, arguments.first, v.new_expr("1", v.bool_type))
2298 end
2299 end
2300 else
2301 abort
2302 end
2303 end
2304
2305 fun init_expr(v: AbstractCompilerVisitor, recv: RuntimeVariable)
2306 do
2307 if has_value and not is_lazy then evaluate_expr(v, recv)
2308 end
2309
2310 # Evaluate, store and return the default value of the attribute
2311 private fun evaluate_expr(v: AbstractCompilerVisitor, recv: RuntimeVariable): RuntimeVariable
2312 do
2313 var oldnode = v.current_node
2314 v.current_node = self
2315 var old_frame = v.frame
2316 var frame = new StaticFrame(v, self.mpropdef.as(not null), recv.mcasttype.as_notnullable.as(MClassType), [recv])
2317 v.frame = frame
2318
2319 var value
2320 var mtype = self.mpropdef.static_mtype
2321 assert mtype != null
2322
2323 var nexpr = self.n_expr
2324 var nblock = self.n_block
2325 if nexpr != null then
2326 value = v.expr(nexpr, mtype)
2327 else if nblock != null then
2328 value = v.new_var(mtype)
2329 frame.returnvar = value
2330 frame.returnlabel = v.get_name("RET_LABEL")
2331 v.add("\{")
2332 v.stmt(nblock)
2333 v.add("{frame.returnlabel.as(not null)}:(void)0;")
2334 v.add("\}")
2335 else
2336 abort
2337 end
2338
2339 v.write_attribute(self.mpropdef.mproperty, recv, value)
2340
2341 v.frame = old_frame
2342 v.current_node = oldnode
2343
2344 return value
2345 end
2346
2347 fun check_expr(v: AbstractCompilerVisitor, recv: RuntimeVariable)
2348 do
2349 var nexpr = self.n_expr
2350 if nexpr != null then return
2351
2352 var oldnode = v.current_node
2353 v.current_node = self
2354 var old_frame = v.frame
2355 var frame = new StaticFrame(v, self.mpropdef.as(not null), recv.mtype.as(MClassType), [recv])
2356 v.frame = frame
2357 # Force read to check the initialization
2358 v.read_attribute(self.mpropdef.mproperty, recv)
2359 v.frame = old_frame
2360 v.current_node = oldnode
2361 end
2362 end
2363
2364 redef class AClassdef
2365 private fun compile_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
2366 do
2367 if mpropdef == self.mfree_init then
2368 assert mpropdef.mproperty.is_root_init
2369 assert arguments.length == 1
2370 if not mpropdef.is_intro then
2371 v.supercall(mpropdef, arguments.first.mtype.as(MClassType), arguments)
2372 end
2373 return
2374 else
2375 abort
2376 end
2377 end
2378 end
2379
2380 redef class AExpr
2381 # Try to compile self as an expression
2382 # Do not call this method directly, use `v.expr` instead
2383 private fun expr(v: AbstractCompilerVisitor): nullable RuntimeVariable
2384 do
2385 v.add("PRINT_ERROR(\"NOT YET IMPLEMENTED {class_name}:{location.to_s}\\n\");")
2386 var mtype = self.mtype
2387 if mtype == null then
2388 return null
2389 else
2390 var res = v.new_var(mtype)
2391 v.add("/* {res} = NOT YET {class_name} */")
2392 return res
2393 end
2394 end
2395
2396 # Try to compile self as a statement
2397 # Do not call this method directly, use `v.stmt` instead
2398 private fun stmt(v: AbstractCompilerVisitor)
2399 do
2400 expr(v)
2401 end
2402 end
2403
2404 redef class ABlockExpr
2405 redef fun stmt(v)
2406 do
2407 for e in self.n_expr do v.stmt(e)
2408 end
2409 redef fun expr(v)
2410 do
2411 var last = self.n_expr.last
2412 for e in self.n_expr do
2413 if e == last then break
2414 v.stmt(e)
2415 end
2416 return v.expr(last, null)
2417 end
2418 end
2419
2420 redef class AVardeclExpr
2421 redef fun stmt(v)
2422 do
2423 var variable = self.variable.as(not null)
2424 var ne = self.n_expr
2425 if ne != null then
2426 var i = v.expr(ne, variable.declared_type)
2427 v.assign(v.variable(variable), i)
2428 end
2429 end
2430 end
2431
2432 redef class AVarExpr
2433 redef fun expr(v)
2434 do
2435 var res = v.variable(self.variable.as(not null))
2436 var mtype = self.mtype.as(not null)
2437 return v.autoadapt(res, mtype)
2438 end
2439 end
2440
2441 redef class AVarAssignExpr
2442 redef fun expr(v)
2443 do
2444 var variable = self.variable.as(not null)
2445 var i = v.expr(self.n_value, variable.declared_type)
2446 v.assign(v.variable(variable), i)
2447 return i
2448 end
2449 end
2450
2451 redef class AVarReassignExpr
2452 redef fun stmt(v)
2453 do
2454 var variable = self.variable.as(not null)
2455 var vari = v.variable(variable)
2456 var value = v.expr(self.n_value, variable.declared_type)
2457 var res = v.compile_callsite(self.reassign_callsite.as(not null), [vari, value])
2458 assert res != null
2459 v.assign(v.variable(variable), res)
2460 end
2461 end
2462
2463 redef class ASelfExpr
2464 redef fun expr(v) do return v.frame.arguments.first
2465 end
2466
2467 redef class AEscapeExpr
2468 redef fun stmt(v) do v.add("goto BREAK_{v.escapemark_name(self.escapemark)};")
2469 end
2470
2471 redef class AReturnExpr
2472 redef fun stmt(v)
2473 do
2474 var nexpr = self.n_expr
2475 if nexpr != null then
2476 var returnvar = v.frame.returnvar.as(not null)
2477 var i = v.expr(nexpr, returnvar.mtype)
2478 v.assign(returnvar, i)
2479 end
2480 v.add("goto {v.frame.returnlabel.as(not null)};")
2481 end
2482 end
2483
2484 redef class AAbortExpr
2485 redef fun stmt(v) do v.add_abort("Aborted")
2486 end
2487
2488 redef class AIfExpr
2489 redef fun stmt(v)
2490 do
2491 var cond = v.expr_bool(self.n_expr)
2492 v.add("if ({cond})\{")
2493 v.stmt(self.n_then)
2494 v.add("\} else \{")
2495 v.stmt(self.n_else)
2496 v.add("\}")
2497 end
2498
2499 redef fun expr(v)
2500 do
2501 var res = v.new_var(self.mtype.as(not null))
2502 var cond = v.expr_bool(self.n_expr)
2503 v.add("if ({cond})\{")
2504 v.assign(res, v.expr(self.n_then.as(not null), null))
2505 v.add("\} else \{")
2506 v.assign(res, v.expr(self.n_else.as(not null), null))
2507 v.add("\}")
2508 return res
2509 end
2510 end
2511
2512 redef class AIfexprExpr
2513 redef fun expr(v)
2514 do
2515 var res = v.new_var(self.mtype.as(not null))
2516 var cond = v.expr_bool(self.n_expr)
2517 v.add("if ({cond})\{")
2518 v.assign(res, v.expr(self.n_then, null))
2519 v.add("\} else \{")
2520 v.assign(res, v.expr(self.n_else, null))
2521 v.add("\}")
2522 return res
2523 end
2524 end
2525
2526 redef class ADoExpr
2527 redef fun stmt(v)
2528 do
2529 v.stmt(self.n_block)
2530 v.add_escape_label(break_mark)
2531 end
2532 end
2533
2534 redef class AWhileExpr
2535 redef fun stmt(v)
2536 do
2537 v.add("for(;;) \{")
2538 var cond = v.expr_bool(self.n_expr)
2539 v.add("if (!{cond}) break;")
2540 v.stmt(self.n_block)
2541 v.add_escape_label(continue_mark)
2542 v.add("\}")
2543 v.add_escape_label(break_mark)
2544 end
2545 end
2546
2547 redef class ALoopExpr
2548 redef fun stmt(v)
2549 do
2550 v.add("for(;;) \{")
2551 v.stmt(self.n_block)
2552 v.add_escape_label(continue_mark)
2553 v.add("\}")
2554 v.add_escape_label(break_mark)
2555 end
2556 end
2557
2558 redef class AForExpr
2559 redef fun stmt(v)
2560 do
2561 var cl = v.expr(self.n_expr, null)
2562 var it_meth = self.method_iterator
2563 assert it_meth != null
2564 var it = v.compile_callsite(it_meth, [cl])
2565 assert it != null
2566 v.add("for(;;) \{")
2567 var isok_meth = self.method_is_ok
2568 assert isok_meth != null
2569 var ok = v.compile_callsite(isok_meth, [it])
2570 assert ok != null
2571 v.add("if(!{ok}) break;")
2572 if self.variables.length == 1 then
2573 var item_meth = self.method_item
2574 assert item_meth != null
2575 var i = v.compile_callsite(item_meth, [it])
2576 assert i != null
2577 v.assign(v.variable(variables.first), i)
2578 else if self.variables.length == 2 then
2579 var key_meth = self.method_key
2580 assert key_meth != null
2581 var i = v.compile_callsite(key_meth, [it])
2582 assert i != null
2583 v.assign(v.variable(variables[0]), i)
2584 var item_meth = self.method_item
2585 assert item_meth != null
2586 i = v.compile_callsite(item_meth, [it])
2587 assert i != null
2588 v.assign(v.variable(variables[1]), i)
2589 else
2590 abort
2591 end
2592 v.stmt(self.n_block)
2593 v.add_escape_label(continue_mark)
2594 var next_meth = self.method_next
2595 assert next_meth != null
2596 v.compile_callsite(next_meth, [it])
2597 v.add("\}")
2598 v.add_escape_label(break_mark)
2599
2600 var method_finish = self.method_finish
2601 if method_finish != null then
2602 # TODO: Find a way to call this also in long escape (e.g. return)
2603 v.compile_callsite(method_finish, [it])
2604 end
2605 end
2606 end
2607
2608 redef class AAssertExpr
2609 redef fun stmt(v)
2610 do
2611 if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return
2612
2613 var cond = v.expr_bool(self.n_expr)
2614 v.add("if (unlikely(!{cond})) \{")
2615 v.stmt(self.n_else)
2616 var nid = self.n_id
2617 if nid != null then
2618 v.add_abort("Assert '{nid.text}' failed")
2619 else
2620 v.add_abort("Assert failed")
2621 end
2622 v.add("\}")
2623 end
2624 end
2625
2626 redef class AOrExpr
2627 redef fun expr(v)
2628 do
2629 var res = v.new_var(self.mtype.as(not null))
2630 var i1 = v.expr_bool(self.n_expr)
2631 v.add("if ({i1}) \{")
2632 v.add("{res} = 1;")
2633 v.add("\} else \{")
2634 var i2 = v.expr_bool(self.n_expr2)
2635 v.add("{res} = {i2};")
2636 v.add("\}")
2637 return res
2638 end
2639 end
2640
2641 redef class AImpliesExpr
2642 redef fun expr(v)
2643 do
2644 var res = v.new_var(self.mtype.as(not null))
2645 var i1 = v.expr_bool(self.n_expr)
2646 v.add("if (!{i1}) \{")
2647 v.add("{res} = 1;")
2648 v.add("\} else \{")
2649 var i2 = v.expr_bool(self.n_expr2)
2650 v.add("{res} = {i2};")
2651 v.add("\}")
2652 return res
2653 end
2654 end
2655
2656 redef class AAndExpr
2657 redef fun expr(v)
2658 do
2659 var res = v.new_var(self.mtype.as(not null))
2660 var i1 = v.expr_bool(self.n_expr)
2661 v.add("if (!{i1}) \{")
2662 v.add("{res} = 0;")
2663 v.add("\} else \{")
2664 var i2 = v.expr_bool(self.n_expr2)
2665 v.add("{res} = {i2};")
2666 v.add("\}")
2667 return res
2668 end
2669 end
2670
2671 redef class ANotExpr
2672 redef fun expr(v)
2673 do
2674 var cond = v.expr_bool(self.n_expr)
2675 return v.new_expr("!{cond}", self.mtype.as(not null))
2676 end
2677 end
2678
2679 redef class AOrElseExpr
2680 redef fun expr(v)
2681 do
2682 var res = v.new_var(self.mtype.as(not null))
2683 var i1 = v.expr(self.n_expr, null)
2684 v.add("if ({i1}!=NULL) \{")
2685 v.assign(res, i1)
2686 v.add("\} else \{")
2687 var i2 = v.expr(self.n_expr2, null)
2688 v.assign(res, i2)
2689 v.add("\}")
2690 return res
2691 end
2692 end
2693
2694 redef class AIntExpr
2695 redef fun expr(v) do return v.new_expr("{self.value.to_s}", self.mtype.as(not null))
2696 end
2697
2698 redef class AFloatExpr
2699 redef fun expr(v) do return v.new_expr("{self.n_float.text}", self.mtype.as(not null)) # FIXME use value, not n_float
2700 end
2701
2702 redef class ACharExpr
2703 redef fun expr(v) do return v.new_expr("'{self.value.to_s.escape_to_c}'", self.mtype.as(not null))
2704 end
2705
2706 redef class AArrayExpr
2707 redef fun expr(v)
2708 do
2709 var mtype = self.element_mtype.as(not null)
2710 var array = new Array[RuntimeVariable]
2711 var res = v.array_instance(array, mtype)
2712
2713 var old_comprehension = v.frame.comprehension
2714 v.frame.comprehension = res
2715 for nexpr in self.n_exprs do
2716 v.stmt(nexpr)
2717 end
2718 v.frame.comprehension = old_comprehension
2719
2720 return res
2721 end
2722 end
2723
2724 redef class AStringFormExpr
2725 redef fun expr(v) do return v.string_instance(self.value.as(not null))
2726 end
2727
2728 redef class ASuperstringExpr
2729 redef fun expr(v)
2730 do
2731 var array = new Array[RuntimeVariable]
2732 for ne in self.n_exprs do
2733 if ne isa AStringFormExpr and ne.value == "" then continue # skip empty sub-strings
2734 var i = v.expr(ne, null)
2735 array.add(i)
2736 end
2737 var a = v.array_instance(array, v.object_type)
2738 var res = v.send(v.get_property("to_s", a.mtype), [a])
2739 return res
2740 end
2741 end
2742
2743 redef class ACrangeExpr
2744 redef fun expr(v)
2745 do
2746 var i1 = v.expr(self.n_expr, null)
2747 var i2 = v.expr(self.n_expr2, null)
2748 var mtype = self.mtype.as(MClassType)
2749 var res = v.init_instance(mtype)
2750 v.compile_callsite(init_callsite.as(not null), [res, i1, i2])
2751 return res
2752 end
2753 end
2754
2755 redef class AOrangeExpr
2756 redef fun expr(v)
2757 do
2758 var i1 = v.expr(self.n_expr, null)
2759 var i2 = v.expr(self.n_expr2, null)
2760 var mtype = self.mtype.as(MClassType)
2761 var res = v.init_instance(mtype)
2762 v.compile_callsite(init_callsite.as(not null), [res, i1, i2])
2763 return res
2764 end
2765 end
2766
2767 redef class ATrueExpr
2768 redef fun expr(v) do return v.new_expr("1", self.mtype.as(not null))
2769 end
2770
2771 redef class AFalseExpr
2772 redef fun expr(v) do return v.new_expr("0", self.mtype.as(not null))
2773 end
2774
2775 redef class ANullExpr
2776 redef fun expr(v) do return v.new_expr("NULL", self.mtype.as(not null))
2777 end
2778
2779 redef class AIsaExpr
2780 redef fun expr(v)
2781 do
2782 var i = v.expr(self.n_expr, null)
2783 return v.type_test(i, self.cast_type.as(not null), "isa")
2784 end
2785 end
2786
2787 redef class AAsCastExpr
2788 redef fun expr(v)
2789 do
2790 var i = v.expr(self.n_expr, null)
2791 if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i
2792
2793 v.add_cast(i, self.mtype.as(not null), "as")
2794 return i
2795 end
2796 end
2797
2798 redef class AAsNotnullExpr
2799 redef fun expr(v)
2800 do
2801 var i = v.expr(self.n_expr, null)
2802 if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i
2803
2804 if i.mtype.ctype != "val*" then return i
2805
2806 v.add("if (unlikely({i} == NULL)) \{")
2807 v.add_abort("Cast failed")
2808 v.add("\}")
2809 return i
2810 end
2811 end
2812
2813 redef class AParExpr
2814 redef fun expr(v) do return v.expr(self.n_expr, null)
2815 end
2816
2817 redef class AOnceExpr
2818 redef fun expr(v)
2819 do
2820 var mtype = self.mtype.as(not null)
2821 var name = v.get_name("varonce")
2822 var guard = v.get_name(name + "_guard")
2823 v.add_decl("static {mtype.ctype} {name};")
2824 v.add_decl("static int {guard};")
2825 var res = v.new_var(mtype)
2826 v.add("if ({guard}) \{")
2827 v.add("{res} = {name};")
2828 v.add("\} else \{")
2829 var i = v.expr(self.n_expr, mtype)
2830 v.add("{res} = {i};")
2831 v.add("{name} = {res};")
2832 v.add("{guard} = 1;")
2833 v.add("\}")
2834 return res
2835 end
2836 end
2837
2838 redef class ASendExpr
2839 redef fun expr(v)
2840 do
2841 var recv = v.expr(self.n_expr, null)
2842 var callsite = self.callsite.as(not null)
2843 var args = v.varargize(callsite.mpropdef, recv, self.raw_arguments)
2844 return v.compile_callsite(callsite, args)
2845 end
2846 end
2847
2848 redef class ASendReassignFormExpr
2849 redef fun stmt(v)
2850 do
2851 var recv = v.expr(self.n_expr, null)
2852 var callsite = self.callsite.as(not null)
2853 var args = v.varargize(callsite.mpropdef, recv, self.raw_arguments)
2854
2855 var value = v.expr(self.n_value, null)
2856
2857 var left = v.compile_callsite(callsite, args)
2858 assert left != null
2859
2860 var res = v.compile_callsite(self.reassign_callsite.as(not null), [left, value])
2861 assert res != null
2862
2863 args.add(res)
2864 v.compile_callsite(self.write_callsite.as(not null), args)
2865 end
2866 end
2867
2868 redef class ASuperExpr
2869 redef fun expr(v)
2870 do
2871 var recv = v.frame.arguments.first
2872
2873 var callsite = self.callsite
2874 if callsite != null then
2875 var args = v.varargize(callsite.mpropdef, recv, self.n_args.n_exprs)
2876
2877 # Add additional arguments for the super init call
2878 if args.length == 1 then
2879 for i in [0..callsite.msignature.arity[ do
2880 args.add(v.frame.arguments[i+1])
2881 end
2882 end
2883 # Super init call
2884 var res = v.compile_callsite(callsite, args)
2885 return res
2886 end
2887
2888 var mpropdef = self.mpropdef.as(not null)
2889 var args = v.varargize(mpropdef, recv, self.n_args.n_exprs)
2890 if args.length == 1 then
2891 args = v.frame.arguments
2892 end
2893
2894 # stantard call-next-method
2895 return v.supercall(mpropdef, recv.mtype.as(MClassType), args)
2896 end
2897 end
2898
2899 redef class ANewExpr
2900 redef fun expr(v)
2901 do
2902 var mtype = self.recvtype
2903 assert mtype != null
2904
2905 if mtype.mclass.name == "NativeArray" then
2906 assert self.n_args.n_exprs.length == 1
2907 var l = v.expr(self.n_args.n_exprs.first, null)
2908 assert mtype isa MGenericType
2909 var elttype = mtype.arguments.first
2910 return v.native_array_instance(elttype, l)
2911 end
2912
2913 var recv = v.init_instance_or_extern(mtype)
2914
2915 var callsite = self.callsite.as(not null)
2916 var args = v.varargize(callsite.mpropdef, recv, self.n_args.n_exprs)
2917 var res2 = v.compile_callsite(callsite, args)
2918 if res2 != null then
2919 #self.debug("got {res2} from {mproperty}. drop {recv}")
2920 return res2
2921 end
2922 return recv
2923 end
2924 end
2925
2926 redef class AAttrExpr
2927 redef fun expr(v)
2928 do
2929 var recv = v.expr(self.n_expr, null)
2930 var mproperty = self.mproperty.as(not null)
2931 return v.read_attribute(mproperty, recv)
2932 end
2933 end
2934
2935 redef class AAttrAssignExpr
2936 redef fun expr(v)
2937 do
2938 var recv = v.expr(self.n_expr, null)
2939 var i = v.expr(self.n_value, null)
2940 var mproperty = self.mproperty.as(not null)
2941 v.write_attribute(mproperty, recv, i)
2942 return i
2943 end
2944 end
2945
2946 redef class AAttrReassignExpr
2947 redef fun stmt(v)
2948 do
2949 var recv = v.expr(self.n_expr, null)
2950 var value = v.expr(self.n_value, null)
2951 var mproperty = self.mproperty.as(not null)
2952 var attr = v.read_attribute(mproperty, recv)
2953 var res = v.compile_callsite(self.reassign_callsite.as(not null), [attr, value])
2954 assert res != null
2955 v.write_attribute(mproperty, recv, res)
2956 end
2957 end
2958
2959 redef class AIssetAttrExpr
2960 redef fun expr(v)
2961 do
2962 var recv = v.expr(self.n_expr, null)
2963 var mproperty = self.mproperty.as(not null)
2964 return v.isset_attribute(mproperty, recv)
2965 end
2966 end
2967
2968 redef class ADebugTypeExpr
2969 redef fun stmt(v)
2970 do
2971 # do nothing
2972 end
2973 end
2974
2975 # Utils
2976
2977 redef class Array[E]
2978 # Return a new `Array` with the elements only contened in self and not in `o`
2979 fun -(o: Array[E]): Array[E] do
2980 var res = new Array[E]
2981 for e in self do if not o.has(e) then res.add(e)
2982 return res
2983 end
2984 end
2985
2986 redef class MModule
2987 # All `MProperty` associated to all `MClassDef` of `mclass`
2988 fun properties(mclass: MClass): Set[MProperty] do
2989 if not self.properties_cache.has_key(mclass) then
2990 var properties = new HashSet[MProperty]
2991 var parents = new Array[MClass]
2992 if self.flatten_mclass_hierarchy.has(mclass) then
2993 parents.add_all(mclass.in_hierarchy(self).direct_greaters)
2994 end
2995 for parent in parents do
2996 properties.add_all(self.properties(parent))
2997 end
2998 for mclassdef in mclass.mclassdefs do
2999 if not self.in_importation <= mclassdef.mmodule then continue
3000 for mprop in mclassdef.intro_mproperties do
3001 properties.add(mprop)
3002 end
3003 end
3004 self.properties_cache[mclass] = properties
3005 end
3006 return properties_cache[mclass]
3007 end
3008 private var properties_cache: Map[MClass, Set[MProperty]] = new HashMap[MClass, Set[MProperty]]
3009
3010 # Write FFI and nitni results to file
3011 fun finalize_ffi(c: AbstractCompiler) do end
3012
3013 # Give requided addinional system libraries (as given to LD_LIBS)
3014 # Note: can return null instead of an empty set
3015 fun collect_linker_libs: nullable Array[String] do return null
3016 end
3017
3018 # Create a tool context to handle options and paths
3019 var toolcontext = new ToolContext
3020
3021 toolcontext.tooldescription = "Usage: nitc [OPTION]... file.nit...\nCompiles Nit programs."
3022
3023 # We do not add other options, so process them now!
3024 toolcontext.process_options(args)
3025
3026 # We need a model to collect stufs
3027 var model = new Model
3028 # An a model builder to parse files
3029 var modelbuilder = new ModelBuilder(model, toolcontext)
3030
3031 var arguments = toolcontext.option_context.rest
3032 if arguments.length > 1 and toolcontext.opt_output.value != null then
3033 print "Error: --output needs a single source file. Do you prefer --dir?"
3034 exit 1
3035 end
3036
3037 # Here we load an process all modules passed on the command line
3038 var mmodules = modelbuilder.parse(arguments)
3039
3040 if mmodules.is_empty then return
3041 modelbuilder.run_phases
3042
3043 for mmodule in mmodules do
3044 toolcontext.info("*** PROCESS {mmodule} ***", 1)
3045 var ms = [mmodule]
3046 toolcontext.run_global_phases(ms)
3047 end