ported to clang

Makefile

@@ -28,8 +28,12 @@ endif
 endif
 endif
 
-CC:=cc -Wall -Wextra -Werror $(CCMODE) $(EXTRA_DEFINES)
-LAXCC:=cc -Werror $(CCMODE) $(EXTRA_DEFINES)
+ifndef CCC
+CCC:=clang
+endif
+
+CC:=$(CCC) -Wall -Wextra -Werror $(CCMODE) $(EXTRA_DEFINES)
+LAXCC:=$(CCC) -Werror $(CCMODE) $(EXTRA_DEFINES)
 
 PYTHON=python3
 MAKE_AST=$(PYTHON) ./tools/makeAST.py

docs/TODO.md

@@ -2,6 +2,8 @@
 
 More of a wish-list than a hard and fast plan.
 
+* Target LLVM
+* Proper namespace import support including user-defined operators.
 * Over-application i.e. `fn (a) { fn (b) { a + b } }(2, 3)`.
 * Unpacking function return values (tuples only).
 * More numbers:

src/annotate.c

@@ -226,11 +226,12 @@ static CTEnv *annotateCexpCondCases(CexpCondCases *x, CTEnv *env) {
 
 static CTEnv *annotateLetRecLam(Aexp *x, CTEnv *env, int letRecOffset) {
     switch (x->type) {
-        case AEXP_TYPE_LAM:
+        case AEXP_TYPE_LAM: {
             AexpLam *lam = x->val.lam;
             annotateAexpLam(lam, env);
             lam->letRecOffset = letRecOffset;
-            break;
+        }
+        break;
         default:
             cant_happen("letrec bindings can only contain lambdas, got %s", aexpTypeName(x->type));
     }

src/builtins_helper.h

@@ -1,5 +1,5 @@
 #ifndef cekf_builtins_helper_h
-#  define cekf_builtin_helper_h
+#  define cekf_builtins_helper_h
 /*
  * CEKF - VM supporting amb
  * Copyright (C) 2022-2023  Bill Hails

src/hash.c

@@ -260,7 +260,6 @@ void printHashSymbol(HashSymbol *symbol) {
 }
 
 void printHashTable(HashTable *table, int depth) {
-    int count = 0;
     eprintf("%*s", depth * PAD_WIDTH, "");
     if (table == NULL) {
         eprintf("HashTable: (NULL)");
@@ -289,7 +288,6 @@ void printHashTable(HashTable *table, int depth) {
             } else {
                 eprintf("\n");
             }
-            count++;
         }
     }
     if (first)

src/lambda_simplfication.c

@@ -16,7 +16,6 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-
 #include <stdio.h>
 #include <stdlib.h>
 #include "common.h"
@@ -37,8 +36,10 @@ static LamExp *performLamSimplifications(LamLam *lam) {
     lam->exp = lamPerformSimplifications(lam->exp);
     if (   lam->args == NULL
         && lam->exp->type == LAMEXP_TYPE_APPLY
-        && lam->exp->val.apply->args == NULL) {
+        && lam->exp->val.apply->args == NULL
+        && lam->exp->val.apply->function->type != LAMEXP_TYPE_CONSTRUCTOR) {
         LEAVE(performLamSimplifications);
+        printLamLam(lam, 0);
         return lam->exp->val.apply->function;
     }
     LEAVE(performLamSimplifications);
@@ -64,19 +65,34 @@ static LamUnaryApp *performUnarySimplifications(LamUnaryApp *unary) {
     return unary;
 }
 
-static LamSequence *performSequenceSimplifications(LamSequence *sequence) {
-    ENTER(performSequenceSimplifications);
+static LamSequence *_performSequenceSimplifications(LamSequence *sequence) {
+    ENTER(_performSequenceSimplifications);
     if (sequence == NULL) {
-        LEAVE(performSequenceSimplifications);
+        LEAVE(_performSequenceSimplifications);
         return NULL;
     }
     sequence->next =
-        performSequenceSimplifications(sequence->next);
+        _performSequenceSimplifications(sequence->next);
     sequence->exp = lamPerformSimplifications(sequence->exp);
-    LEAVE(performSequenceSimplifications);
+    LEAVE(_performSequenceSimplifications);
     return sequence;
 }
 
+#define SIMPLIFY_SINGLE_SEQUENCE
+
+static LamExp *performSequenceSimplifications(ParserInfo I, LamSequence *sequence) {
+    sequence = _performSequenceSimplifications(sequence);
+#ifdef SIMPLIFY_SINGLE_SEQUENCE
+    if (countLamSequence(sequence) == 1) {
+        return sequence->exp;
+    }
+#endif
+    int save = PROTECT(sequence);
+    LamExp *res = newLamExp_List(I, sequence);
+    UNPROTECT(save);
+    return res;
+}
+
 static LamList *performListSimplifications(LamList *list) {
     ENTER(performListSimplifications);
     if (list == NULL) {
@@ -294,7 +310,7 @@ LamExp *lamPerformSimplifications(LamExp *exp) {
                 exp->val.unary = performUnarySimplifications(exp->val.unary);
                 break;
             case LAMEXP_TYPE_LIST:
-                exp->val.list = performSequenceSimplifications(exp->val.list);
+                exp = performSequenceSimplifications(CPI(exp), exp->val.list);
                 break;
             case LAMEXP_TYPE_MAKEVEC:
                 exp->val.makeVec = performMakeVecSimplifications(exp->val.makeVec);

src/pratt_scanner.c

@@ -589,11 +589,12 @@ static MaybeBigInt *makeIrrational(char *str, int length) {
             case '.':
                 frac = true;
                 continue;
-            default:
+            default: {
                 int n = convert_char(*p);
                 f *= 10.0;
                 f += n;
                 if (frac) div *= 10.0;
+            }
         }
     }
     return irrationalBigInt(f/div, imag);

src/print_generator.h

@@ -26,8 +26,8 @@ LamLetRecBindings *makePrintFunctions(LamTypeDefList *typeDefs,
                                       LamLetRecBindings *rest,
                                       LamContext *env, bool inPreamble);
 LamExp *makeSymbolExpr(ParserInfo I, char *name);
-LamExp *makePrintInt();
-LamExp *makePrintChar();
+LamExp *makePrintInt(ParserInfo);
+LamExp *makePrintChar(ParserInfo);
 HashSymbol *makePrintName(char *prefix, char *name);
 LamExp *stringToLamList(ParserInfo I, char *name);
 

src/step.c

@@ -92,10 +92,6 @@ static inline Value peek(int index) {
     return peeknStack(state.S, index);
 }
 
-static inline Value tos(void) {
-    return peekStack(state.S);
-}
-
 static inline void copyToVec(Vec *vec) {
     copyTosToVec(vec, state.S);
 }
@@ -502,7 +498,7 @@ static void applyProc(int naargs) {
         }
         break;
         default:
-            cant_happen("unexpected type %d in APPLY", callable.type);
+            cant_happen("unexpected type %s in APPLY", valueTypeName(callable.type));
     }
     UNPROTECT(save);
 }

src/tpmc_translate.c

@@ -251,7 +251,7 @@ static LamExp *translateArcToCode(TpmcArc *arc, LamExpTable *lambdaCache) {
         }
         break;
         default:
-            // no-op
+            break;
     }
     LEAVE(translateArcToCode);
     return res;
@@ -715,12 +715,13 @@ static LamExp *translateState(TpmcState *dfa, LamExpTable *lambdaCache) {
 static void resetStateRefCountsToZero(TpmcState *dfa) {
     dfa->refcount = 0;
     switch (dfa->state->type) {
-        case TPMCSTATEVALUE_TYPE_TEST:
+        case TPMCSTATEVALUE_TYPE_TEST:{
             TpmcArcArray *arcs = dfa->state->val.test->arcs;
             for (Index i = 0; i < arcs->size; ++i) {
                 resetStateRefCountsToZero(arcs->entries[i]->state);
             }
-            break;
+        }
+        break;
         case TPMCSTATEVALUE_TYPE_FINAL:
         case TPMCSTATEVALUE_TYPE_ERROR:
             break;
@@ -734,12 +735,13 @@ static void incrementStateRefCounts(TpmcState *dfa) {
     dfa->refcount++;
     if (dfa->refcount == 1) {
         switch (dfa->state->type) {
-            case TPMCSTATEVALUE_TYPE_TEST:
+            case TPMCSTATEVALUE_TYPE_TEST:{
                 TpmcArcArray *arcs = dfa->state->val.test->arcs;
                 for (Index i = 0; i < arcs->size; ++i) {
                     incrementStateRefCounts(arcs->entries[i]->state);
                 }
-                break;
+            }
+            break;
             case TPMCSTATEVALUE_TYPE_FINAL:
             case TPMCSTATEVALUE_TYPE_ERROR:
                 break;

tests/fn/test_if.fn

@@ -0,0 +1,2 @@
+let a = if (true) { 3 } else { 4 };
+in assert(a == 3);

tests/src/test_pratt.c

@@ -44,7 +44,7 @@ static void test(char *expr, char *expected, bool expectError) {
     PrattUTF8 *dest = newPrattUTF8();
     PROTECT(dest);
     ppAstNest(dest, result);
-    if (strcmp(dest->entries, expected) != 0) {
+    if (strcmp((char *)dest->entries, expected) != 0) {
         printf("%s - expected %s got %s\n", expr, expected, dest->entries);
         failed = true;
     }

tests/src/test_unicode.c

@@ -22,9 +22,9 @@
 #define TEST(c, s) do { \
     character = c; \
     assert(byteSize(character) == s); \
-    char *ptr = writeChar(bytes, character); \
+    unsigned char *ptr = writeChar(bytes, character); \
     *ptr = 0; \
-    assert(strlen(bytes) == s); \
+    assert(strlen((char *)bytes) == s); \
     assert(decodedLength(bytes) == 1); \
     character = 0; \
     utf8_to_unicode_char(&character, bytes); \