Compiler: move c2_trace functions to libs/c2/c2_trace.c2

* add c2_trace.c2 source module in libs/c2 (will later incorporate all
  libs/c2 files in an internal embedded library
* generate call tracing tables in **c2_trace_tables.c** for fast builds

Fix external array definitions:
* accept array definitions without size in interface files
* reject `elemsof` and `sizesof` on arrays of unknown lengh
* fix external array definitions in C generator
* fix test/interface/incremental_array.c2t: fix external array definition
* fix test/interface/public_by_array_expr.c2t: fix external array definition
* fix test/interface/muti_dimensional_array.c2t: `Row` and `Columns` definitions
  were reversed, 2D external array definition in C was incorrect

Author: chqrlie

analyser/module_analyser.c2

@@ -563,7 +563,7 @@ fn void Analyser.analyseGlobalVarDecl(Analyser* ma, VarDecl* v) {
                 return;
             }
         } else {
-            if (!init_expr) {
+            if (!init_expr && !d.isExternal()) {
                 ma.error(d.getLoc(), "array-type variable '%s' needs an explicit size or an initializer", d.getFullName());
                 return;
             }

analyser/module_analyser_builtin.c2

@@ -59,6 +59,13 @@ fn QualType Analyser.analyseSizeof(Analyser* ma, BuiltinExpr* e) {
         if (qt.isInvalid()) return QualType_Invalid;
 
         // TODO extract to function
+        if (qt.isArray()) {
+            const ArrayType* at = qt.getArrayTypeOrNil();
+            if (at && !at.hasSize()) {
+                ma.error(inner.getLoc(), "sizeof cannot be used on arrays of unknown length");
+                return QualType_Invalid;
+            }
+        }
         if (qt.isStruct()) {
             StructType* st = qt.getStructType();
             const StructTypeDecl* std = st.getDecl();
@@ -95,6 +102,10 @@ fn QualType Analyser.analyseElemsof(Analyser* ma, BuiltinExpr* b) {
 
     const ArrayType* at = qt.getArrayTypeOrNil();
     if (at) {
+        if (!at.hasSize()) {
+            ma.error(inner.getLoc(), "elemsof cannot be used on arrays of unknown length");
+            return QualType_Invalid;
+        }
         b.setUValue(at.getSize());
         return builtins[BuiltinKind.UInt32];
     }

ast/expr.c2

@@ -548,7 +548,7 @@ public fn void Expr.printLiteral(const Expr* e, string_buffer.Buf* out) {
         IdentifierExpr.printLiteral((IdentifierExpr*)e, out);
         return;
     case Type:
-        TypeExpr.printLiteral((TypeExpr*)e, out, false);
+        TypeExpr.printLiteral((TypeExpr*)e, out);
         return;
     case Call:
         CallExpr.printLiteral((CallExpr*)e, out);

ast/module.c2

@@ -29,6 +29,7 @@ public type Module struct @(opaque) {
     bool is_external;
     bool is_internal; // currently only for c2 module
     bool is_direct; // otherwise indirectly loaded via library.
+    bool is_foreign; // module identifiers are not mangled
     bool is_exported;
     bool is_loaded; // the file(s) parsed. For external libs
     ModuleType* mt;
@@ -48,6 +49,7 @@ public fn Module* Module.create(ast_context.Context* c, u32 name_idx, bool is_ex
     m.mt = ModuleType.create(c, m);
     m.name_idx = name_idx;
     m.is_external = is_external;
+    m.is_foreign = is_external;    // default for external modules
     m.is_internal = false;
     m.is_direct = is_direct;
     m.is_loaded = false;
@@ -76,6 +78,9 @@ public fn bool Module.isInternal(const Module* m) { return m.is_internal; }
 
 public fn bool Module.isExternal(const Module* m) { return m.is_external; }
 
+public fn void Module.setForeign(Module* m, bool is_foreign) { m.is_foreign = is_foreign; }
+public fn bool Module.isForeign(const Module* m) { return m.is_foreign; }
+
 public fn void Module.setLoaded(Module* m) { m.is_loaded = true; }
 public fn bool Module.isLoaded(const Module* m) { return m.is_loaded; }
 

ast/type_expr.c2

@@ -74,6 +74,6 @@ fn void TypeExpr.print(const TypeExpr* e, string_buffer.Buf* out, u32 indent) {
     out.newline();
 }
 
-fn void TypeExpr.printLiteral(const TypeExpr* e, string_buffer.Buf* out, bool decay) {
-    e.typeRef.printLiteral(out, true, decay);
+fn void TypeExpr.printLiteral(const TypeExpr* e, string_buffer.Buf* out) {
+    e.typeRef.printLiteral(out, true);
 }

ast/type_ref.c2

@@ -332,7 +332,7 @@ public fn Expr** TypeRef.getArray2(TypeRef* r, u32 idx) {
     return &arrays[idx];
 }
 
-public fn void TypeRef.printLiteral(const TypeRef* r, string_buffer.Buf* out, bool print_prefix, bool decay) {
+public fn void TypeRef.printLiteral(const TypeRef* r, string_buffer.Buf* out, bool print_prefix) {
     if (r.isConst()) out.add("const ");
     if (r.isVolatile()) out.add("volatile ");
 
@@ -350,22 +350,16 @@ public fn void TypeRef.printLiteral(const TypeRef* r, string_buffer.Buf* out, bo
 
     for (u32 i=0; i<r.flags.num_ptrs; i++) out.add1('*');
 
-    // note: convert arrays into pointers
-    if (r.flags.incr_array) out.add("*");
+    // TODO need the actual array length
+    // should update the type with current array length or use VarDecl
+    if (r.flags.incr_array) out.add("[]");
 
-    if (decay) {
-        // TODO: this seems incorrect: char[10][10] does not decay as char**
-        for (u32 i = 0; i < r.flags.num_arrays; i++) {
-            out.add("*");
-        }
-    } else {
-        for (u32 i = 0; i < r.flags.num_arrays; i++) {
-            out.add1('[');
-            const Expr* a = r.getArray(i);
-            // note: a can be nil, when[]
-            if (a) a.printLiteral(out);
-            out.add1(']');
-        }
+    for (u32 i = 0; i < r.flags.num_arrays; i++) {
+        out.add1('[');
+        const Expr* a = r.getArray(i);
+        // note: a can be nil, when[]
+        if (a) a.printLiteral(out);
+        out.add1(']');
     }
 }
 
@@ -390,13 +384,20 @@ public fn void TypeRef.printLiteral2(const TypeRef* r, string_buffer.Buf* out, b
 
     for (u32 i=0; i<r.flags.num_ptrs; i++) out.add1('*');
 
-    if (r.flags.incr_array) out.add("*");
+    // TODO need the actual array length
+    // should update the type with current array length or use VarDecl
+    if (r.flags.incr_array) out.add("[]");
 
     for (u32 i=0; i<r.flags.num_arrays; i++) {
         out.add1('[');
         const Expr* a = r.getArray(i);
         // note: a can be nil, when[]
-        if (a) print_expr(arg, a, out);
+        if (a) {
+            if (print_expr)
+                print_expr(arg, a, out);
+            else
+                a.printLiteral(out);
+        }
         out.add1(']');
     }
 }

common/component.c2

@@ -63,6 +63,7 @@ public type Component struct @(opaque) {
     u32 linkname;   // into auxPool
     Kind kind;
     bool is_direct; // only for external, if used directly (otherwise sub-dep)
+    bool is_foreign;        // only for external
     bool available_static;  // only for external
     bool available_dynamic; // only for external
 
@@ -116,6 +117,14 @@ public fn const char* Component.getPath(const Component* c) {
     return c.auxPool.idx2str(c.dirname_idx);
 }
 
+public fn void Component.setForeign(Component* c, bool is_foreign) {
+    c.is_foreign = is_foreign;
+}
+
+public fn bool Component.getForeign(const Component* c) {
+    return c.is_foreign;
+}
+
 public fn void Component.setLinkName(Component* c, const char* name) {
     c.linkname = c.auxPool.addStr(name, false);
 }

compiler/compiler.c2

@@ -295,6 +295,13 @@ fn void Compiler.build(Compiler* c,
     if (opts.msan) c.addFeature("__MSAN__", "1");
     if (opts.ubsan) c.addFeature("__UBSAN__", "1");
 
+    target.addLib(c.auxPool.add("c2", 2, true), false);
+
+    if (c.opts.trace_calls) {
+        if (!c.addLibFile("c2", "c2_trace.c2"))
+            stdlib.exit(-1);
+    }
+
     c.parser = c2_parser.create(sm,
                                 diags,
                                 c.astPool,

compiler/compiler_libs.c2

@@ -113,7 +113,9 @@ fn void Compiler.open_lib(Compiler* c, Component* comp) {
     for (u32 i=0; i<mods.length(); i++) {
         u32 mod_name = mods.get_idx(i);
         ast.Module* m = comp.getOrAddModule(mod_name);
-        if (!m) {
+        if (m) {
+            m.setForeign(comp.getForeign());
+        } else {
             m = c.allmodules.find(mod_name);
             Component* other = c.find_component(m);
             assert(other);
@@ -148,6 +150,20 @@ fn bool Compiler.has_component(Compiler* c, u32 name) {
     return false;
 }
 
+fn bool Compiler.addLibFile(Compiler* c, const char* libname, const char* filename) {
+    char[512] dirname;
+    char[512] fullname;
+
+    if (c.find_lib(libname, dirname)) {
+        stdio.snprintf(fullname, elemsof(fullname), "%s/%s", dirname, filename);
+        c.target.addFile(c.auxPool.addStr(fullname, true), 0);
+        return true;
+    } else {
+        console.error("c2c: find library file %s/%s", libname, filename);
+        return false;
+    }
+}
+
 fn bool Compiler.find_lib(const Compiler* c, const char* libname, char* fullpath) {
     for (u32 i=0; i<c.libdirs.length(); i++) {
         const char* dirname = c.libdirs.get(i);

compiler/main.c2

@@ -589,8 +589,6 @@ fn bool Context.build_target(Context* c,
         }
     }
 
-    target.addLib(c.auxPool.add("c2", 2, true), false);
-
     compiler.build(c.auxPool, c.sm, c.diags, c.build_info, target, &c.comp_opts, &c.pluginHandler);
 
     // TODO unload target-specific plugins?