compiler: Support TCC

This requires making some constants actually constant (per the C
standard), not just the subtle variants allowed by Clang and GCC.

Author: tekknolagi

.github/workflows/ci.yml

@@ -42,10 +42,14 @@ jobs:
       run: sudo apt update
     - name: Install Python
       run: sudo apt install --yes ${{matrix.PYTHON}}
+    - name: Install TCC
+      run: sudo apt install --yes tcc
     - name: Run interpreter tests
       run: ${{matrix.PYTHON}} scrapscript.py test
     - name: Run compiler tests
       run: ${{matrix.PYTHON}} compiler_tests.py
+    - name: Run compiler tests with TCC
+      run: CC=tcc ${{matrix.PYTHON}} compiler_tests.py
   build_docker_image:
     runs-on: ubuntu-latest
     permissions:

compiler.py

@@ -219,9 +219,10 @@ def compile_match_function(self, env: Env, exp: MatchFunction, name: Optional[st
             case_result = self.compile({**funcenv, **env_updates}, case.body)
             self._emit(f"return {case_result};")
             self._emit(f"{fallthrough}:;")
-        # TODO(max): (non-fatal?) exceptions
         self._emit(r'fprintf(stderr, "no matching cases\n");')
         self._emit("abort();")
+        # Pacify the C compiler
+        self._emit("return NULL;")
         self.function = cur
         return self.make_closure(env, fn)
 
@@ -387,6 +388,9 @@ def compile_to_string(source: str, memory: int, debug: bool) -> str:
         for key, idx in compiler.variant_tags.items():
             print(f"Tag_{key} = {idx},", file=f)
         print("};", file=f)
+    else:
+        # Pacify the C compiler
+        print("const char* variant_names[] = { NULL };", file=f)
     for function in compiler.functions:
         print(function.decl() + ";", file=f)
     for builtin in builtins:

runtime.c

@@ -30,16 +30,19 @@ struct object {};
 // The three low bits make up a primary tag, used to differentiate gc_obj
 // from immediate objects. All even tags map to SmallInt, which is
 // optimized by checking only the lowest bit for parity.
-static const uword kSmallIntTagBits = 1;
-static const uword kPrimaryTagBits = 3;
-static const uword kImmediateTagBits = 5;
+enum {
+  kSmallIntTagBits = 1,
+  kPrimaryTagBits = 3,
+  kImmediateTagBits = 5,
+  kWordSize = sizeof(word),
+  kBitsPerByte = 8,
+  kBitsPerPointer = kBitsPerByte * kWordSize,
+};
 static const uword kSmallIntTagMask = (1 << kSmallIntTagBits) - 1;
 static const uword kPrimaryTagMask = (1 << kPrimaryTagBits) - 1;
 static const uword kImmediateTagMask = (1 << kImmediateTagBits) - 1;
 
-const int kWordSize = sizeof(word);
 static const word kMaxSmallStringLength = kWordSize - 1;
-const int kBitsPerByte = 8;
 
 static const uword kSmallIntTag = 0;      // 0b****0
 static const uword kHeapObjectTag = 1;    // 0b**001
@@ -309,6 +312,8 @@ size_t heap_object_size(struct gc_obj* obj) {
     default:
       fprintf(stderr, "unknown tag: %lu\n", obj->tag);
       abort();
+      // Pacify the C compiler
+      return (size_t)-1;
   }
 }
 
@@ -341,8 +346,9 @@ size_t trace_heap_object(struct gc_obj* obj, struct gc_heap* heap,
   return heap_object_size(obj);
 }
 
-const int kBitsPerPointer = kBitsPerByte * kWordSize;
-static const word kSmallIntBits = kBitsPerPointer - kSmallIntTagBits;
+enum {
+  kSmallIntBits = kBitsPerPointer - kSmallIntTagBits,
+};
 static const word kSmallIntMinValue = -(((word)1) << (kSmallIntBits - 1));
 static const word kSmallIntMaxValue = (((word)1) << (kSmallIntBits - 1)) - 1;