stabilized

Author: andrew-johnson-4

PRODUCTION/stack.lm

@@ -232,5 +232,12 @@ stack-define-destructure := λ ctx lhs offset . (match lhs (
       (set return (expr::set-offset( return (expr::get-offset more-e) )))
       return
    )))
+   ( Nil (tail(
+      (local return)
+      (set return (expr::new()))
+      (set return (expr::set-context( return ctx )))
+      (set return (expr::set-offset( return offset )))
+      return
+   )))
    ( u (fail (UnknownStackArg lhs)))
 ));

STRICT/ast.lm

@@ -0,0 +1,6 @@
+
+
+type AST ASTNil;
+
+ast-tokenized-program := (: EOF Tokens);
+ast-parsed-program := (: ASTNil AST);

STRICT/cli.lm

@@ -4,6 +4,7 @@ import STDLIB/default-primitives.lm;
 import STDLIB/default-rules.lm;
 import STDLIB/default-stdlib.lm;
 
+import STRICT/ast.lm;
 import STRICT/utility.lm;
 import STRICT/tokenize.lm;
 import STRICT/parse.lm;
@@ -60,61 +61,30 @@ main := λ(: argc U64)(: argv U8[][]).(tail(
       ()
       ( SNil (set continue Falseu8) )
       ( (SCons( rst SNil )) (set input rst) )
-      ( (SCons( rst (SAtom( fp )) )) (tail( (cli-intake fp) (set input rst) )))
-      ( (SAtom( fp )) (tail( (cli-intake fp) (set continue Falseu8) )))
+      ( (SCons( rst (SAtom( fp )) )) (tail( (tokenize fp) (set input rst) )))
+      ( (SAtom( fp )) (tail( (tokenize fp) (set continue Falseu8) )))
    )))
 
-
-#      (Compile (
-#         (parse-program (tokenize-file (head inputs)))
-#         (set inputs (tail inputs))
-#      ))
-#      (Parse (
-#         (parse-program (tokenize-file (head inputs)))
-#         (set inputs (tail inputs))
-#      ))
-#      (Typecheck (
-#         (parse-program (tokenize-file (head inputs)))
-#         (set inputs (tail inputs))
-#      ))
-#      (ParseExpression (
-#         (print-s (parse-expression (tokenize-file (head inputs))))
-#         (set inputs (tail inputs))
-#      ))
-#      (Tokenize (
-#         (print-s (tokenize-file (head inputs)))
-#         (set inputs (tail inputs))
-#      ))
-));
-
-cli-intake := λ(: fp U8[]) . (: (tail(
    (match config-mode (
       ()
-      (ModeTokenize (tail(
-         (print 'Tokenize:\s_s)
-         (print fp)
-         (print '\n_s)
-      )))
-      (ModeParse (tail(
-         (print 'Parse:\s_s)
-         (print fp)
-         (print '\n_s)
+      ( ModeTokenize () )
+      ( ModeParse (parse ast-tokenized-program) )
+      ( ModePreprocess (tail(
+         (parse ast-tokenized-program)
+         (preprocess ast-parsed-program)
       )))
-      (ModePreprocess (tail(
-         (print 'Preprocess:\s_s)
-         (print fp)
-         (print '\n_s)
+      ( ModeTypecheck (tail(
+         (parse ast-tokenized-program)
+         (preprocess ast-parsed-program)
+         (typecheck())
       )))
-      (ModeTypecheck (tail(
-         (print 'Typecheck:\s_s)
-         (print fp)
-         (print '\n_s)
-      )))
-      (ModeCompile (tail(
-         (print 'Compile:\s_s)
-         (print fp)
-         (print '\n_s)
+      ( ModeCompile (tail(
+         (parse ast-tokenized-program)
+         (preprocess ast-parsed-program)
+         (typecheck())
+         (compile())
       )))
    ))
-   ()
-)) Nil);
+
+));
+

STRICT/codegen.lm

@@ -0,0 +1,5 @@
+
+compile := λ. (: (tail(
+   ()
+   ()
+)) Nil);

STRICT/parse.lm

@@ -0,0 +1,5 @@
+
+parse := λ(: fp Tokens). (: (tail(
+   ()
+   ()
+)) Nil);

STRICT/preprocess.lm

@@ -0,0 +1,5 @@
+
+preprocess := λ(: program AST). (: (tail(
+   ()
+   ()
+)) Nil);

STRICT/tokenize.lm

@@ -0,0 +1,7 @@
+
+type Tokens EOF;
+
+tokenize := λ(: fp U8[]). (: (tail(
+   ()
+   ()
+)) Nil);

STRICT/typecheck.lm

@@ -0,0 +1,5 @@
+
+typecheck := λ. (: (tail(
+   ()
+   ()
+)) Nil);