Merge pull request #1511 from andrew-johnson-4/port-more-macros-fasee

Port more macros fasee

Author: andrew-johnson-4

BOOTSTRAP/cli.c

@@ -64,5 +64,9 @@ typed macro macro::for(item: lazy, iter: Vector<?>, loop: lazy): lazy = (
 );
 
 typed macro macro::while(cond: lazy, body: lazy): lazy = (
-   $"primitive::while"( body as Nil, into-branch-conditional(cond) )
+   primitive::while( body as Nil, into-branch-conditional(cond) )
+);
+
+typed macro macro::assert(cond: lazy): lazy = (
+   if not(cond) then fail("Assertion Failed", macro::location(cond))
 );

PLATFORM/C/LIB/common-macros.lsts

@@ -19,6 +19,11 @@ fail := λ(: msg SmartString). (: (
    (as (exit 1_u32) Never)
  ) Never);
 
+fail := λ(: msg SmartString)(: loc SmartString). (: (
+   (print msg)(print '\sat\s_s)(print loc)
+   (as (exit 1_u32) Never)
+) Never);
+
 fail := λ(: msg String). (: (
    (print msg)
    (as (exit 1_u32) Never)

PLATFORM/C/LIB/io.lm

@@ -525,13 +525,14 @@ let lsts-make-maybe-var(tokens: List<Token>): Tuple<AST,List<Token>> = (
       lsts-parse-lit(tokens)
    } else {
       if not(non-zero(tokens)) { lsts-parse-expect(c"Identifier", tokens); };
+      let loc = head(tokens).location;
       let base = ASTEOF;
       if lsts-is-lit(head(tokens).key) {
          base = lsts-make-lit(head(tokens));
          tokens = tail(tokens);
       } else {
          (let var-name, tokens) = lsts-parse-identifier(tokens);
-         base = mk-var(var-name);
+         base = with-location(mk-var(var-name), loc);
       };
       Tuple { base, tokens }
    }
@@ -1286,9 +1287,7 @@ let lsts-make-lit(t: Token): AST = (
       while non-zero(s) && s != c"_ss" {
          if s.has-prefix(c"\\{") {
             if non-zero(buffer) {
-               buffer = buffer + SAtom{c"_ss"};
-               let bs = clone-rope(buffer);
-               let be = Lit { bs, with-location(mk-token(bs),loc) };
+               let be = mk-lit(with-location(mk-token(clone-rope(buffer)),loc)).ascript(t1(c"SmartString"));
                if non-zero(base) {
                   base = mk-app(
                      Var{ c"+", with-location(mk-token("+"),loc) },
@@ -1330,9 +1329,7 @@ let lsts-make-lit(t: Token): AST = (
          }
       };
       if non-zero(buffer) {
-         buffer = buffer + SAtom{ c"_ss" };
-         let bs = clone-rope(buffer);
-         let be = Lit{ bs, with-location(mk-token(bs),loc) };
+         let be = mk-lit(with-location(mk-token(clone-rope(buffer)),loc)).ascript(t1(c"SmartString"));
          if non-zero(base) {
             base = mk-app(
                Var{ c"+", with-location(mk-token("+"),loc) },
@@ -1342,6 +1339,8 @@ let lsts-make-lit(t: Token): AST = (
             base = be;
          };
       };
+   } else if t.key.has-suffix(c"_ss") {
+      base = with-location(mk-lit(t.key.remove-suffix(c"_ss")),loc).ascript(t1(c"SmartString"));
    };
    base
 );
@@ -1493,6 +1492,8 @@ let lsts-parse-atom-without-tail(tokens: List<Token>): Tuple<AST,List<Token>> =
       tokens = term-rest.second;
       lsts-parse-expect(c")", tokens); tokens = tail(tokens);
       term = AType{ term-rest.first };
+   } else if lsts-parse-head(tokens).has-suffix(c"_ss") {
+      (term, tokens) = lsts-parse-lit(tokens);
    } else if lsts-parse-head(tokens)==c"sizeof" {
       let loc = head(tokens).location;
       tokens = tail(tokens);

PLUGINS/FRONTEND/LSTS/lsts-parse.lsts

@@ -1,6 +1,7 @@
 
 let index-macro-table = {} :: HashtableEq<CString,List<(Type,Type,AST)>>;
 index-macro-table = index-macro-table.bind(c"macro::concat", [] :: List<(Type,Type,AST)>);
+index-macro-table = index-macro-table.bind(c"macro::location", [] :: List<(Type,Type,AST)>);
 
 let bind-new-macro(mname: CString, mterm: AST): Nil = (
    let row = index-macro-table.lookup(mname, [] :: List<(Type,Type,AST)>);

SRC/macro-table.lsts

@@ -27,12 +27,26 @@ preprocess-apply := λ(: program AST). (: (
             (close(preprocess-apply( nt )))
          )))
       ))
+      ( (App( is-cons-1 (App( is-cons-2 (Lit( ':_s ctk )) (App( is-cons-3 (@( t (Lit( l ltk )) )) (AType tt) )) )) nt )) (
+         (if (not(.is-t( tt 'SmartString_s ))) (set t (preprocess-apply t)) ())
+         (set r (App( is-cons-1
+            (close(App( is-cons-2 (close(Lit( ':_s (unique ctk) ))) (close(App( is-cons-3 (close t) (close(AType tt)) ))) )))
+            (close(preprocess-apply( nt )))
+         )))
+      ) )
       ( (App( is-cons-1 (App( is-cons-2 (Lit( ':_s ctk )) (App( is-cons-3 t (AType tt) )) )) nt )) (
          (set r (App( is-cons-1
             (close(App( is-cons-2 (close(Lit( ':_s (unique ctk) ))) (close(App( is-cons-3 (close(preprocess-apply t)) (close(AType tt)) ))) )))
             (close(preprocess-apply( nt )))
          )))
       ))
+      ( (App( is-cons-2 (Lit( ':_s ctk )) (App( is-cons-3 (@( t (Lit _) )) (AType tt) )) )) (
+         (if (not(.is-t( tt 'SmartString_s ))) (set t (preprocess-apply t)) ())
+         (set r (App( is-cons-2
+            (close(Lit( ':_s (unique ctk) )))
+            (close(App( is-cons-3 (close t) (close(AType tt)) )))
+         )))
+      ) )
       ( (App( is-cons-1 (App( is-cons-2 (Lit( ':_s ctk )) mvar )) (Lit( mtype mtk )) )) (
          (if is-cons-1
             (set r (App( is-cons-1 (close(App( is-cons-2 (close(Lit( ':_s ctk ))) (close(preprocess-apply mvar))  ))) (close(Lit( mtype mtk ))) )))

SRC/preprocess-apply.lm

@@ -17,9 +17,14 @@ let std-apply-macro-concat(tctx: Maybe<TContext>, mname: CString, margs: AST): (
    }
 );
 
+let std-apply-macro-location(tctx: Maybe<TContext>, mname: CString, margs: AST): (TContext?, AST) = (
+   (tctx, mk-lit(to-smart-string(margs.location)).ascript(t1(c"SmartString")))
+);
+
 let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST, strong: Bool): (TContext?, AST) = (
    let result = ASTEOF;
    if mname==c"macro::concat" then (tctx, result) = std-apply-macro-concat(tctx, mname, margs)
+   else if mname==c"macro::location" then (tctx, result) = std-apply-macro-location(tctx, mname, margs)
    else {
       let row = index-macro-table.lookup(mname, [] :: List<(Type,Type,AST)>);
       let peep-holes = TAny;

SRC/std-apply-macro.lsts

@@ -25,5 +25,16 @@ type A = A{a:U64};
    print(a.a);
 );
 
+(
+   let wi = 0_u64;
+   macro::while( wi < 4, ( print(wi); wi = wi + 1; ) )
+);
+
+macro::assert(true);
+
+# match
+
+# for
 #$"macro::for"(x, [1, 2], print(x));
 #$"macro::for"(x, mk-vector(type(U64)).push(3).push(4), print(x));
+

tests/unit/ast-macros.lsts

@@ -1 +1 @@
-[3,4]2
+[3,4]20123