Wrap all flisp global states

Author: yuyichao

src/ast.c

@@ -4,40 +4,40 @@
 // comparable tag
 #define cmptag(v) (isfixnum(v) ? TAG_NUM : tag(v))
 
-static value_t eq_class(htable_t *table, value_t key)
+static value_t eq_class(fl_context_t *fl_ctx, htable_t *table, value_t key)
 {
     value_t c = (value_t)ptrhash_get(table, (void*)key);
     if (c == (value_t)HT_NOTFOUND)
-        return NIL;
+        return fl_ctx->NIL;
     if (c == key)
         return c;
-    return eq_class(table, c);
+    return eq_class(fl_ctx, table, c);
 }
 
-static void eq_union(htable_t *table, value_t a, value_t b,
-                     value_t c, value_t cb)
+static void eq_union(fl_context_t *fl_ctx, htable_t *table, value_t a,
+                     value_t b, value_t c, value_t cb)
 {
-    value_t ca = (c==NIL ? a : c);
-    if (cb != NIL)
+    value_t ca = (c==fl_ctx->NIL ? a : c);
+    if (cb != fl_ctx->NIL)
         ptrhash_put(table, (void*)cb, (void*)ca);
     ptrhash_put(table, (void*)a, (void*)ca);
     ptrhash_put(table, (void*)b, (void*)ca);
 }
 
-static value_t bounded_compare(value_t a, value_t b, int bound, int eq);
-static value_t cyc_compare(value_t a, value_t b, htable_t *table, int eq);
+static value_t bounded_compare(fl_context_t *fl_ctx, value_t a, value_t b, int bound, int eq);
+static value_t cyc_compare(fl_context_t *fl_ctx, value_t a, value_t b, htable_t *table, int eq);
 
-static value_t bounded_vector_compare(value_t a, value_t b, int bound, int eq)
+static value_t bounded_vector_compare(fl_context_t *fl_ctx, value_t a, value_t b, int bound, int eq)
 {
     size_t la = vector_size(a);
     size_t lb = vector_size(b);
     size_t m, i;
     if (eq && (la!=lb)) return fixnum(1);
     m = la < lb ? la : lb;
     for (i = 0; i < m; i++) {
-        value_t d = bounded_compare(vector_elt(a,i), vector_elt(b,i),
+        value_t d = bounded_compare(fl_ctx, vector_elt(a,i), vector_elt(b,i),
                                     bound-1, eq);
-        if (d==NIL || numval(d)!=0) return d;
+        if (d==fl_ctx->NIL || numval(d)!=0) return d;
     }
     if (la < lb) return fixnum(-1);
     if (la > lb) return fixnum(1);
@@ -46,14 +46,14 @@ static value_t bounded_vector_compare(value_t a, value_t b, int bound, int eq)
 
 // strange comparisons are resolved arbitrarily but consistently.
 // ordering: number < cprim < function < vector < cvalue < symbol < cons
-static value_t bounded_compare(value_t a, value_t b, int bound, int eq)
+static value_t bounded_compare(fl_context_t *fl_ctx, value_t a, value_t b, int bound, int eq)
 {
     value_t d;
 
  compare_top:
     if (a == b) return fixnum(0);
     if (bound <= 0)
-        return NIL;
+        return fl_ctx->NIL;
     int taga = tag(a);
     int tagb = cmptag(b);
     int c;
@@ -64,29 +64,29 @@ static value_t bounded_compare(value_t a, value_t b, int bound, int eq)
             return (numval(a) < numval(b)) ? fixnum(-1) : fixnum(1);
         }
         if (iscprim(b)) {
-            if (cp_class((cprim_t*)ptr(b)) == wchartype)
+            if (cp_class((cprim_t*)ptr(b)) == fl_ctx->wchartype)
                 return fixnum(1);
-            return fixnum(numeric_compare(a, b, eq, 1, NULL));
+            return fixnum(numeric_compare(fl_ctx, a, b, eq, 1, NULL));
         }
         return fixnum(-1);
     case TAG_SYM:
         if (eq) return fixnum(1);
         if (tagb < TAG_SYM) return fixnum(1);
         if (tagb > TAG_SYM) return fixnum(-1);
-        return fixnum(strcmp(symbol_name(a), symbol_name(b)));
+        return fixnum(strcmp(symbol_name(fl_ctx, a), symbol_name(fl_ctx, b)));
     case TAG_VECTOR:
         if (isvector(b))
-            return bounded_vector_compare(a, b, bound, eq);
+            return bounded_vector_compare(fl_ctx, a, b, bound, eq);
         break;
     case TAG_CPRIM:
-        if (cp_class((cprim_t*)ptr(a)) == wchartype) {
-            if (!iscprim(b) || cp_class((cprim_t*)ptr(b)) != wchartype)
+        if (cp_class((cprim_t*)ptr(a)) == fl_ctx->wchartype) {
+            if (!iscprim(b) || cp_class((cprim_t*)ptr(b)) != fl_ctx->wchartype)
                 return fixnum(-1);
         }
-        else if (iscprim(b) && cp_class((cprim_t*)ptr(b)) == wchartype) {
+        else if (iscprim(b) && cp_class((cprim_t*)ptr(b)) == fl_ctx->wchartype) {
             return fixnum(1);
         }
-        c = numeric_compare(a, b, eq, 1, NULL);
+        c = numeric_compare(fl_ctx, a, b, eq, 1, NULL);
         if (c != 2)
             return fixnum(c);
         break;
@@ -102,30 +102,30 @@ static value_t bounded_compare(value_t a, value_t b, int bound, int eq)
             if (uintval(a) > N_BUILTINS && uintval(b) > N_BUILTINS) {
                 function_t *fa = (function_t*)ptr(a);
                 function_t *fb = (function_t*)ptr(b);
-                d = bounded_compare(fa->bcode, fb->bcode, bound-1, eq);
-                if (d==NIL || numval(d) != 0) return d;
-                d = bounded_compare(fa->vals, fb->vals, bound-1, eq);
-                if (d==NIL || numval(d) != 0) return d;
-                d = bounded_compare(fa->env, fb->env, bound-1, eq);
-                if (d==NIL || numval(d) != 0) return d;
+                d = bounded_compare(fl_ctx, fa->bcode, fb->bcode, bound-1, eq);
+                if (d==fl_ctx->NIL || numval(d) != 0) return d;
+                d = bounded_compare(fl_ctx, fa->vals, fb->vals, bound-1, eq);
+                if (d==fl_ctx->NIL || numval(d) != 0) return d;
+                d = bounded_compare(fl_ctx, fa->env, fb->env, bound-1, eq);
+                if (d==fl_ctx->NIL || numval(d) != 0) return d;
                 return fixnum(0);
             }
             return (uintval(a) < uintval(b)) ? fixnum(-1) : fixnum(1);
         }
         break;
     case TAG_CONS:
         if (tagb < TAG_CONS) return fixnum(1);
-        d = bounded_compare(car_(a), car_(b), bound-1, eq);
-        if (d==NIL || numval(d) != 0) return d;
+        d = bounded_compare(fl_ctx, car_(a), car_(b), bound-1, eq);
+        if (d==fl_ctx->NIL || numval(d) != 0) return d;
         a = cdr_(a); b = cdr_(b);
         bound--;
         goto compare_top;
     }
     return (taga < tagb) ? fixnum(-1) : fixnum(1);
 }
 
-static value_t cyc_vector_compare(value_t a, value_t b, htable_t *table,
-                                  int eq)
+static value_t cyc_vector_compare(fl_context_t *fl_ctx, value_t a,
+                                  value_t b, htable_t *table, int eq)
 {
     size_t la = vector_size(a);
     size_t lb = vector_size(b);
@@ -139,8 +139,8 @@ static value_t cyc_vector_compare(value_t a, value_t b, htable_t *table,
         xa = vector_elt(a,i);
         xb = vector_elt(b,i);
         if (leafp(xa) || leafp(xb)) {
-            d = bounded_compare(xa, xb, 1, eq);
-            if (d!=NIL && numval(d)!=0) return d;
+            d = bounded_compare(fl_ctx, xa, xb, 1, eq);
+            if (d!=fl_ctx->NIL && numval(d)!=0) return d;
         }
         else if (tag(xa) < tag(xb)) {
             return fixnum(-1);
@@ -150,18 +150,18 @@ static value_t cyc_vector_compare(value_t a, value_t b, htable_t *table,
         }
     }
 
-    ca = eq_class(table, a);
-    cb = eq_class(table, b);
-    if (ca!=NIL && ca==cb)
+    ca = eq_class(fl_ctx, table, a);
+    cb = eq_class(fl_ctx, table, b);
+    if (ca!=fl_ctx->NIL && ca==cb)
         return fixnum(0);
 
-    eq_union(table, a, b, ca, cb);
+    eq_union(fl_ctx, table, a, b, ca, cb);
 
     for (i = 0; i < m; i++) {
         xa = vector_elt(a,i);
         xb = vector_elt(b,i);
         if (!leafp(xa) || tag(xa)==TAG_FUNCTION) {
-            d = cyc_compare(xa, xb, table, eq);
+            d = cyc_compare(fl_ctx, xa, xb, table, eq);
             if (numval(d)!=0)
                 return d;
         }
@@ -172,7 +172,7 @@ static value_t cyc_vector_compare(value_t a, value_t b, htable_t *table,
     return fixnum(0);
 }
 
-static value_t cyc_compare(value_t a, value_t b, htable_t *table, int eq)
+static value_t cyc_compare(fl_context_t *fl_ctx, value_t a, value_t b, htable_t *table, int eq)
 {
     value_t d, ca, cb;
  cyc_compare_top:
@@ -185,29 +185,29 @@ static value_t cyc_compare(value_t a, value_t b, htable_t *table, int eq)
             int tagaa = tag(aa); int tagda = tag(da);
             int tagab = tag(ab); int tagdb = tag(db);
             if (leafp(aa) || leafp(ab)) {
-                d = bounded_compare(aa, ab, 1, eq);
-                if (d!=NIL && numval(d)!=0) return d;
+                d = bounded_compare(fl_ctx, aa, ab, 1, eq);
+                if (d!=fl_ctx->NIL && numval(d)!=0) return d;
             }
             else if (tagaa < tagab)
                 return fixnum(-1);
             else if (tagaa > tagab)
                 return fixnum(1);
             if (leafp(da) || leafp(db)) {
-                d = bounded_compare(da, db, 1, eq);
-                if (d!=NIL && numval(d)!=0) return d;
+                d = bounded_compare(fl_ctx, da, db, 1, eq);
+                if (d!=fl_ctx->NIL && numval(d)!=0) return d;
             }
             else if (tagda < tagdb)
                 return fixnum(-1);
             else if (tagda > tagdb)
                 return fixnum(1);
 
-            ca = eq_class(table, a);
-            cb = eq_class(table, b);
-            if (ca!=NIL && ca==cb)
+            ca = eq_class(fl_ctx, table, a);
+            cb = eq_class(fl_ctx, table, b);
+            if (ca!=fl_ctx->NIL && ca==cb)
                 return fixnum(0);
 
-            eq_union(table, a, b, ca, cb);
-            d = cyc_compare(aa, ab, table, eq);
+            eq_union(fl_ctx, table, a, b, ca, cb);
+            d = cyc_compare(fl_ctx, aa, ab, table, eq);
             if (numval(d)!=0) return d;
             a = da;
             b = db;
@@ -218,56 +218,55 @@ static value_t cyc_compare(value_t a, value_t b, htable_t *table, int eq)
         }
     }
     else if (isvector(a) && isvector(b)) {
-        return cyc_vector_compare(a, b, table, eq);
+        return cyc_vector_compare(fl_ctx, a, b, table, eq);
     }
     else if (isclosure(a) && isclosure(b)) {
         function_t *fa = (function_t*)ptr(a);
         function_t *fb = (function_t*)ptr(b);
-        d = bounded_compare(fa->bcode, fb->bcode, 1, eq);
+        d = bounded_compare(fl_ctx, fa->bcode, fb->bcode, 1, eq);
         if (numval(d) != 0) return d;
 
-        ca = eq_class(table, a);
-        cb = eq_class(table, b);
-        if (ca!=NIL && ca==cb)
+        ca = eq_class(fl_ctx, table, a);
+        cb = eq_class(fl_ctx, table, b);
+        if (ca!=fl_ctx->NIL && ca==cb)
             return fixnum(0);
 
-        eq_union(table, a, b, ca, cb);
-        d = cyc_compare(fa->vals, fb->vals, table, eq);
+        eq_union(fl_ctx, table, a, b, ca, cb);
+        d = cyc_compare(fl_ctx, fa->vals, fb->vals, table, eq);
         if (numval(d) != 0) return d;
         a = fa->env;
         b = fb->env;
         goto cyc_compare_top;
     }
-    return bounded_compare(a, b, 1, eq);
+    return bounded_compare(fl_ctx, a, b, 1, eq);
 }
 
-static htable_t equal_eq_hashtable;
-void comparehash_init(void)
+void comparehash_init(fl_context_t *fl_ctx)
 {
-    htable_new(&equal_eq_hashtable, 512);
+    htable_new(&fl_ctx->equal_eq_hashtable, 512);
 }
 
 // 'eq' means unordered comparison is sufficient
-static value_t compare_(value_t a, value_t b, int eq)
+static value_t compare_(fl_context_t *fl_ctx, value_t a, value_t b, int eq)
 {
-    value_t guess = bounded_compare(a, b, BOUNDED_COMPARE_BOUND, eq);
-    if (guess == NIL) {
-        guess = cyc_compare(a, b, &equal_eq_hashtable, eq);
-        htable_reset(&equal_eq_hashtable, 512);
+    value_t guess = bounded_compare(fl_ctx, a, b, BOUNDED_COMPARE_BOUND, eq);
+    if (guess == fl_ctx->NIL) {
+        guess = cyc_compare(fl_ctx, a, b, &fl_ctx->equal_eq_hashtable, eq);
+        htable_reset(&fl_ctx->equal_eq_hashtable, 512);
     }
     return guess;
 }
 
-value_t fl_compare(value_t a, value_t b)
+value_t fl_compare(fl_context_t *fl_ctx, value_t a, value_t b)
 {
-    return compare_(a, b, 0);
+    return compare_(fl_ctx, a, b, 0);
 }
 
-value_t fl_equal(value_t a, value_t b)
+value_t fl_equal(fl_context_t *fl_ctx, value_t a, value_t b)
 {
     if (eq_comparable(a, b))
-        return (a == b) ? FL_T : FL_F;
-    return (numval(compare_(a,b,1))==0 ? FL_T : FL_F);
+        return (a == b) ? fl_ctx->T : fl_ctx->F;
+    return (numval(compare_(fl_ctx, a,b,1))==0 ? fl_ctx->T : fl_ctx->F);
 }
 
 /*
@@ -287,7 +286,7 @@ value_t fl_equal(value_t a, value_t b)
 #endif
 
 // *oob: output argument, means we hit the limit specified by 'bound'
-static uptrint_t bounded_hash(value_t a, int bound, int *oob)
+static uptrint_t bounded_hash(fl_context_t *fl_ctx, value_t a, int bound, int *oob)
 {
     *oob = 0;
     union {
@@ -308,14 +307,14 @@ static uptrint_t bounded_hash(value_t a, int bound, int *oob)
         return doublehash(u.i64);
     case TAG_FUNCTION:
         if (uintval(a) > N_BUILTINS)
-            return bounded_hash(((function_t*)ptr(a))->bcode, bound, oob);
+            return bounded_hash(fl_ctx, ((function_t*)ptr(a))->bcode, bound, oob);
         return inthash(a);
     case TAG_SYM:
         return ((symbol_t*)ptr(a))->hash;
     case TAG_CPRIM:
         cp = (cprim_t*)ptr(a);
         data = cp_data(cp);
-        if (cp_class(cp) == wchartype)
+        if (cp_class(cp) == fl_ctx->wchartype)
             return inthash(*(int32_t*)data);
         nt = cp_numtype(cp);
         u.d = conv_to_double(data, nt);
@@ -332,7 +331,7 @@ static uptrint_t bounded_hash(value_t a, int bound, int *oob)
         }
         len = vector_size(a);
         for(i=0; i < len; i++) {
-            h = MIX(h, bounded_hash(vector_elt(a,i), bound/2, &oob2)^1);
+            h = MIX(h, bounded_hash(fl_ctx, vector_elt(a,i), bound/2, &oob2)^1);
             if (oob2)
                 bound/=2;
             *oob = *oob || oob2;
@@ -345,7 +344,7 @@ static uptrint_t bounded_hash(value_t a, int bound, int *oob)
                 *oob = 1;
                 return h;
             }
-            h = MIX(h, bounded_hash(car_(a), bound/2, &oob2));
+            h = MIX(h, bounded_hash(fl_ctx, car_(a), bound/2, &oob2));
             // bounds balancing: try to share the bounds efficiently
             // so we can hash better when a list is cdr-deep (a common case)
             if (oob2)
@@ -357,29 +356,29 @@ static uptrint_t bounded_hash(value_t a, int bound, int *oob)
             *oob = *oob || oob2;
             a = cdr_(a);
         } while (iscons(a));
-        h = MIX(h, bounded_hash(a, bound-1, &oob2)^2);
+        h = MIX(h, bounded_hash(fl_ctx, a, bound-1, &oob2)^2);
         *oob = *oob || oob2;
         return h;
     }
     return 0;
 }
 
-int equal_lispvalue(value_t a, value_t b)
+int equal_lispvalue(fl_context_t *fl_ctx, value_t a, value_t b)
 {
     if (eq_comparable(a, b))
         return (a==b);
-    return (numval(compare_(a,b,1))==0);
+    return (numval(compare_(fl_ctx, a, b, 1))==0);
 }
 
-uptrint_t hash_lispvalue(value_t a)
+uptrint_t hash_lispvalue(fl_context_t *fl_ctx, value_t a)
 {
-    int oob=0;
-    uptrint_t n = bounded_hash(a, BOUNDED_HASH_BOUND, &oob);
+    int oob = 0;
+    uptrint_t n = bounded_hash(fl_ctx, a, BOUNDED_HASH_BOUND, &oob);
     return n;
 }
 
-value_t fl_hash(value_t *args, u_int32_t nargs)
+value_t fl_hash(fl_context_t *fl_ctx, value_t *args, u_int32_t nargs)
 {
-    argcount("hash", nargs, 1);
-    return fixnum(hash_lispvalue(args[0]));
+    argcount(fl_ctx, "hash", nargs, 1);
+    return fixnum(hash_lispvalue(fl_ctx, args[0]));
 }