Merge pull request #1984 from andrew-johnson-4/lib1-zero-init-fdsiiii

Lib1 zero init fdsiiii

Author: andrew4328

BOOTSTRAP/cli.c

@@ -428,7 +428,7 @@ let std-infer-call-arg(tctx: TypeContext?, term: AST, function-name: CString, hi
    }} else if function-name==c"map::cons" { match term {
       App{k=left, m=right} => (
          (tctx, let new-k) = std-infer-expr(tctx, k, false, Call(function-name), ta);
-         let direct-hint = if config-v3
+         let direct-hint = if config-v3 or config-v23
          then t2(c"Hashtable",typeof-term(new-k).normalize.slot(c"Cons",2).l1,typeof-term(new-k).normalize.slot(c"Cons",2).l2) && t0(c"ReturnHint")
          else t2(c"HashtableEq",typeof-term(new-k).normalize.slot(c"Cons",2).l1,typeof-term(new-k).normalize.slot(c"Cons",2).l2);
          (tctx, let new-m) = std-infer-expr(tctx, m, false, Used(), direct-hint);

LM23COMMON/typecheck-infer-expr.lsts

@@ -25,9 +25,11 @@ let infer-global-terms(tctx: TypeContext?, term: AST): (TypeContext?, AST) = (
          let kto = typeof-term(rhs);
          let ktd = kto && t0(c"GlobalVariable");
          tctx = tctx.bind-global(k.key, kto, ktd, term);
-         mark-global-as-seen(k.key, ktd, ta);
-         tctx = tctx.ascript(term, ktd);
-         (tctx, _) = tctx.maybe-apply-callable(c"mov", t2(c"Cons",ktd.without-phi,ktd.without-phi), term);
+         if not(global-is-seen(k.key, ktd)) {
+            mark-global-as-seen(k.key, ktd, ta);
+            tctx = tctx.ascript(term, ktd);
+            (tctx, _) = tctx.maybe-apply-callable(c"mov", t2(c"Cons",ktd.without-phi,ktd.without-phi), term);
+         }
       );
       _ => (
          (tctx, term) = std-infer-expr(tctx, term, false, Unused, ta);
@@ -44,10 +46,12 @@ let infer-global-context-prim(term: AST): Nil = (
       Glb{ k=key, frhs=val:Abs{lhs=lhs, rhs:App{left:Lit{key:c":"}, right:App{rhs=left, right:AType{return-type=tt}}}, misc-tt=tt} } => (
          if k.key.has-prefix(c"primitive::") then {
             let ft = t2(c"Arrow", typeof-lhs(lhs), return-type.without-modifiers).without-phi-keep-state && misc-tt;
-            mark-global-as-seen(k.key, ft, misc-tt);
-            Some(mk-tctx()).ascript(term, ft);
-            Some(mk-tctx()).ascript(frhs, ft);
-            Some(mk-tctx()).bind-global(k.key, ft, ft, term);
+            if not(global-is-seen(k.key, ft)) {
+               mark-global-as-seen(k.key, ft, misc-tt);
+               Some(mk-tctx()).ascript(term, ft);
+               Some(mk-tctx()).ascript(frhs, ft);
+               Some(mk-tctx()).bind-global(k.key, ft, ft, term);
+            }
          };
       );
       _ => ();
@@ -75,10 +79,12 @@ let infer-global-context(term: AST): Nil = (
          else if misc-tt.is-t(c"TypedMacro",0) then bind-new-macro(k.key, frhs)
          else {
             let ft = t2(c"Arrow", typeof-lhs(lhs), return-type.rewrite-type-alias.expand-implied-phi.without-modifiers).without-phi-keep-state && misc-tt;
-            mark-global-as-seen(k.key, ft, misc-tt);
-            Some(mk-tctx()).ascript(term, ft);
-            Some(mk-tctx()).ascript(frhs, ft);
-            Some(mk-tctx()).bind-global(k.key, ft, denormalize-strong(ft), term);
+            if not(global-is-seen(k.key, ft)) {
+               mark-global-as-seen(k.key, ft, misc-tt);
+               Some(mk-tctx()).ascript(term, ft);
+               Some(mk-tctx()).ascript(frhs, ft);
+               Some(mk-tctx()).bind-global(k.key, ft, denormalize-strong(ft), term);
+            }
          };
       );
       _ => ();

LM23COMMON/typecheck-infer-global-terms.lsts

@@ -29,6 +29,7 @@ let print-toks-json(fp: CString): Nil = (
 let show-alloc-count = false;
 
 let main(argc: C_int, argv: CString[]): Nil = (
+   config-v23 = false;
    let argi = 1_sz;
    let input = [] : List<CString>;
    let highlight = false;
@@ -43,6 +44,7 @@ let main(argc: C_int, argv: CString[]): Nil = (
          c"--v0" => (config-v3 = false; config-v0 = true;);
          c"--v1" => (config-v3 = false; config-v1 = true;);
          c"--v2" => config-v3 = false;
+         c"--v23" => (config-v3 = false; config-v23 = true;);
          c"--v3" => config-v3 = true;
          c"--highlight" => (
             config-mode = ModeTokenize();

LM23COMMON/unit-main-core.lsts

@@ -53,7 +53,7 @@ let blob-render-simple(ctx: FContext, context-key: CString, term: AST): (FContex
          let ri = to-i64(clone-rope(rs));
          while li < ri {
             ri = ri - 1;
-            r = SCons( close(SAtom(to-string(ri))), close(r) );
+            r = SCons( close(SAtom(ri.into(type(CString)))), close(r) );
          }
       );
       App{ left:Var{key:c"uuid"} } => r = SAtom(uuid());
@@ -72,7 +72,7 @@ let blob-render-simple(ctx: FContext, context-key: CString, term: AST): (FContex
          if typeof-term(f).is-arrow { match f {
             Var{fname=key} => (
                if fname.has-prefix(c":")
-               then r = blob-render-simple(ctx, tail-string(fname), a).second
+               then r = blob-render-simple(ctx, tail(fname), a).second
                else r = std-c-compile-call(ctx, fname, a).get(context-key);
             );
             _ => (
@@ -97,14 +97,14 @@ let blob-render(ctx: FContext, term: AST, f: Fragment): Fragment = (
       App{ left:Lit{key:c":"}, right:App{ t=left, right:AType{} } } => blob-render(ctx, t, f);
       App{ left:Var{k=key}, a=right } => (
          if k.has-prefix(c":")
-         then f.set(tail-string(k), blob-render-simple(ctx, tail-string(k), a).second)
-         else f.set(c"expression", blob-render-simple(ctx, tail-string(k), a).second)
+         then f.set(tail(k), blob-render-simple(ctx, tail(k), a).second)
+         else f.set(c"expression", blob-render-simple(ctx, tail(k), a).second)
       );
       App{ rst=left, right:App{ left:Var{k=key}, a=right } } => (
          f = blob-render(ctx, rst, f);
          if k.has-prefix(c":")
-         then f.set(tail-string(k), blob-render-simple(ctx, tail-string(k), a).second)
-         else f.set(c"expression", blob-render-simple(ctx, tail-string(k), a).second)
+         then f.set(tail(k), blob-render-simple(ctx, tail(k), a).second)
+         else f.set(c"expression", blob-render-simple(ctx, tail(k), a).second)
       );
       _ => f.set(c"expression", blob-render-simple(ctx,c"expression",term).second);
    }

PLUGINS/BACKEND/C/blob-render.lsts

@@ -3,7 +3,7 @@ let compile-program-ordered(global-ctx: FContext, program: AST): Nil = (
    for vector g in program.unroll-seq { match g {
       Glb{ key=key, val=val } => (
          if not(typeof-term(def-to-sym(g)).is-open)
-         || not(typeof-term(val).is-open) then {
+         or not(typeof-term(val).is-open) then {
             std-c-compile-global(global-ctx, key.key, val);
          };
       );

PLUGINS/BACKEND/C/compile-program-ordered.lsts

@@ -13,10 +13,10 @@ let .escape-as-cstring(in: CString): S = (
       c"\\o"..  rest => (out = out + SAtom(c"#"); in = rest;);
       c"\\s"..  rest => (out = out + SAtom(c" "); in = rest;);
       c"\\t"..  rest => (out = out + SAtom(c"\\\\t"); in = rest;);
-      c"\\"..   rest => fail("Illegal Escape Character: \{head-string(rest)}");
+      c"\\"..   rest => fail("Illegal Escape Character: \{head(rest)}");
       rest => (
-         out = out + SAtom(clone-rope(head-string(rest)));
-         in = tail-string(rest);
+         out = out + SAtom(clone-rope(head(rest)));
+         in = tail(rest);
       );
    }};
    SAtom(c"\"") + out + SAtom(c"\"")

PLUGINS/BACKEND/C/escape-as-cstring.lsts

@@ -1,10 +1,10 @@
 
 let escape-string(s: CString): CString = (
    let e = SNil;
-   while head-string(s) {
-      if head-string(s) == 92 {
-         s = tail-string(s);
-         match head-string(s) {
+   while head(s) {
+      if head(s) == 92 {
+         s = tail(s);
+         match head(s) {
             58 => e = e + SAtom(c";");   # \: -> ;
             91 => e = e + SAtom(c"(");   # \[ -> (
             92 => e = e + SAtom(c"\\");  # \\ -> \
@@ -16,10 +16,10 @@ let escape-string(s: CString): CString = (
             115 => e = e + SAtom(c" ");  # \s -> [space]
             c => fail("Illegal Escape Sequence In String: \{c}\n");
          };
-         s = tail-string(s);
+         s = tail(s);
       } else {
-         e = e + SAtom(clone-rope(head-string(s)));
-         s = tail-string(s);
+         e = e + SAtom(clone-rope(head(s)));
+         s = tail(s);
       }
    };
    clone-rope(e)

PLUGINS/BACKEND/C/escape-string.lsts

@@ -1,7 +1,7 @@
 
 let mangle-identifier(k: CString): S = (
    let cs = SAtom(c"LM_");
-   while head-string(k) { match head-string(k) {
+   while head(k) != 0 { match head(k) {
       33 => cs = cs + SAtom(c"_EX_"); # !
       36 => cs = cs + SAtom(c"_DL_"); # $
       37 => cs = cs + SAtom(c"_MD_"); # %
@@ -28,7 +28,7 @@ let mangle-identifier(k: CString): S = (
       124 => cs = cs + SAtom(c"_BR_"); # |
       126 => cs = cs + SAtom(c"_TL_"); # ~
       c => cs = cs + SAtom(clone-rope(c));
-   }; k = tail-string(k); };
+   }; k = tail(k); };
    cs
 );
 

PLUGINS/BACKEND/C/mangle-identifier.lsts

@@ -29,7 +29,7 @@ let std-c-compile-call(ctx: FContext, fname: CString, return-hint-if-constructor
          exit-error("STD C compile call is open \{fname} (\{typeof-term(args)})\n\{typeof-term(fterm)}\nArgs \{args}\n", args);
       };
       let push-args = std-c-compile-push-args(ctx, args);
-      let function-id = if typeof-term(fterm).is-t(c"FFI",0) || typeof-term(fterm).is-t(c"C-FFI",0)
+      let function-id = if typeof-term(fterm).is-t(c"FFI",0) or typeof-term(fterm).is-t(c"C-FFI",0)
                         then fname else mangle-identifier-function(fname, typeof-term(fterm));
       let ictx = mk-fragment().set(c"function-id", SAtom(function-id));
       let inner-ctx = mk-fctx().bind(c"ictx", t0(c"ImplicitContext"), ictx)