Merged macro quasiquote into analyze.

diff --git a/README.md b/README.md
index 0a861b9..8f7f12e 100644 (file)
--- a/README.md
+++ b/README.md
@@ -75,12 +75,12 @@ You'll then be greeted by the following prompt:
     ;; M-Eval input:
 
 At this point you can start entering Scheme commands... but be prepared to wait
-a while for the result.  After all, when evaluating commands in the MCE you are
+a while for each result.  After all, when evaluating commands in the MCE you are
 running a program in a Scheme interpreter running inside another Scheme
 interpreter which is itself running on a Forth system that is implemented atop
-the Julia numerical computing environment.  **That's three levels of
-abstraction more than a native Julia program experiences**, so some delay is to
-be expected!
+a virtual register machine running in the Julia numerical computing
+environment.  **That's four levels of abstraction more than a native Julia
+program experiences**, so some delay is to be expected!
 
 For instance, the following example from SICP defines and demonstrates a
 recursive list append procedure:

diff --git a/src/defer-is.4th b/src/defer-is.4th
index 89f07de..468a353 100644 (file)
--- a/src/defer-is.4th
+++ b/src/defer-is.4th
@@ -33,9 +33,3 @@ hide abort-defer
     0 ,
     here docol ,
     [compile] ] ;
-
-
-\ Need this for tail call optimization
-
-: goto-deferred ( cfa -- )
-    R> drop >body @ >body >R ;

diff --git a/src/goto.4th b/src/goto.4th
new file mode 100644 (file)
index 0000000..a2b5536
--- /dev/null
+++ b/src/goto.4th
@@ -0,0 +1,8 @@
+\ Words implementing GOTO
+\ These are required for tail call optimization.
+
+: goto ( cfa -- )
+    R> drop >body >R ;
+
+: goto-deferred ( cfa -- )
+    R> drop >body @ >body >R ;

diff --git a/src/scheme.4th b/src/scheme.4th
index abd214e..e5ac9cd 100644 (file)
--- a/src/scheme.4th
+++ b/src/scheme.4th
@@ -3,6 +3,7 @@ scheme definitions
 
 include term-colours.4th
 include defer-is.4th
+include goto.4th
 include catch-throw.4th
 include integer.4th
 include float.4th
@@ -11,6 +12,7 @@ include debugging.4th
 
 defer read
 defer expand
+defer analyze
 defer eval
 defer print
 
@@ -162,6 +164,10 @@ variable nextfree
     R> R>
 ;
 
+: 2pick ( an bn an-1 bn-1 ... a0 b0 n -- an bn an-1 bn-1 ... a0 b0 an bn )
+    2* 1+ dup
+    >R pick R> pick ;
+
 \ }}}
 
 \ ---- Pre-defined symbols ---- {{{
@@ -1632,6 +1638,270 @@ hide env
 
 \ }}}
 
+\ ---- Analyze ----
+
+: evaluate-eproc ( eproc env --- res )
+
+    >R >R
+
+    begin
+        nil? invert
+    while
+        2dup car
+        2swap cdr
+    repeat
+    
+    2drop \ get rid of null
+
+    R> R> 2swap
+
+    \ Final element of eproc list is primitive procedure
+    drop \ dump type signifier
+
+    .s cr \ DEBUG
+
+    goto \ jump straight to primitive procedure (executor)
+;
+
+: self-evaluating-executor ( exp env -- exp )
+    2drop ;
+
+: analyze-self-evaluating ( exp --- eproc )
+    ['] self-evaluating-executor primitive-proc-type
+    nil cons cons
+;
+
+: quote-executor ( exp env -- exp )
+    2drop ;
+
+: analyze-quoted ( exp -- eproc )
+    quote-body
+
+    ['] quote-executor primitive-proc-type
+    nil cons cons
+;
+
+: variable-executor ( var env -- val )
+    lookup-var ;
+
+: analyze-variable ( exp -- eproc )
+    ['] variable-executor primitive-proc-type
+    nil cons cons
+;
+
+: definition-executor ( var val-eproc env -- ok )
+    2swap 2over ( var env val-eproc env )
+    evaluate-eproc 2swap ( var val env )
+    define-var
+    ok-symbol
+;
+
+: analyze-definition ( exp -- eproc )
+    2dup definition-var
+    2swap definition-val analyze
+
+    ['] definition-executor primitive-proc-type
+    nil cons cons cons
+;
+
+: assignment-executor ( var val-eproc env -- ok )
+    2swap 2over ( var env val-eproc env )
+    evaluate-eproc 2swap ( var val env )
+    set-var
+    ok-symbol
+;
+
+: analyze-assignment ( exp -- eproc )
+    2dup assignment-var
+    2swap assignment-val analyze ( var val-eproc )
+
+    ['] assignment-executor primitive-proc-type
+    nil cons cons cons
+;
+
+: if-executor ( cproc aproc pproc env -- res )
+    2swap 2over ( cproc aproc env pproc env -- res )
+    evaluate-eproc
+
+    true? if
+        2swap 2drop
+    else
+        2rot 2drop
+    then
+
+    evaluate-eproc
+;
+
+: analyze-if ( exp -- eproc )
+    2dup if-predicate analyze
+    2swap 2dup if-consequent analyze
+    2swap if-alternative analyze
+
+    ['] if-executor primitive-proc-type
+    nil cons cons cons cons
+;
+
+: sequence-executor ( eproc-list env -- res )
+    2swap
+
+    begin
+        2dup cdr ( env elist elist-rest)
+        nil? invert
+    while
+
+        -2rot car 2over ( elist-rest env elist-head env )
+        evaluate-eproc  ( elist-rest env head-res )
+        2drop 2swap     ( env elist-rest )
+    repeat
+
+    2drop car 2swap
+    ['] evaluate-eproc goto
+;
+
+
+: (analyze-sequence) ( explist -- eproc-list )
+    nil? if exit then
+
+    2dup car analyze
+    2swap cdr recurse
+
+    cons
+;
+
+: analyze-sequence ( explist -- eproc )
+    (analyze-sequence)
+    ['] sequence-executor primitive-proc-type
+    nil cons cons
+;
+
+: lambda-executor ( params bproc env -- res )
+    make-procedure
+    ( Although this is packaged up as a regular compound procedure,
+      the "body" element contains an _eproc_ to be evaluated in an
+      environment resulting from extending env with the parameter
+      bindings. )
+;
+
+: analyze-lambda ( exp -- eproc )
+    2dup lambda-parameters
+    2swap lambda-body
+
+    nil? if
+        except-message: ." encountered lambda with an empty body." recoverable-exception throw
+    then
+
+    analyze-sequence
+
+    ['] lambda-executor primitive-proc-type
+    nil cons cons cons
+;
+
+: operand-eproc-list ( operands -- eprocs )
+    nil? invert if
+        2dup car analyze
+        2swap cdr recurse
+        cons
+    then
+;
+
+: evaluate-operand-eprocs ( env aprocs -- vals )
+    nil? if
+        2swap 2drop
+    else
+        2over 2over car 2swap evaluate-eproc ( env aprocs thisval )
+        -2rot cdr recurse ( thisval restvals )
+        cons
+    then
+;
+
+: application-executor ( operator-proc arg-procs env -- res )
+    2rot 2over ( aprocs env fproc env )
+    evaluate-eproc ( aprocs env proc )
+
+    -2rot 2swap ( proc env aprocs )
+    evaluate-operand-eprocs ( proc vals )
+
+    2swap ( vals proc )
+    
+    dup case
+        primitive-proc-type of
+            drop execute
+        endof
+
+        compound-proc-type of
+                2dup procedure-body ( argvals proc body )
+                -2rot 2dup procedure-params ( bproc argvals proc argnames )
+                -2rot procedure-env ( bproc argnames argvals procenv )
+
+                -2rot 2swap
+                flatten-proc-args
+                2swap 2rot
+
+                extend-env ( bproc env )
+
+               ['] evaluate-eproc goto
+        endof
+
+        except-message: ." object '" drop print ." ' not applicable." recoverable-exception throw
+    endcase
+;
+
+: analyze-application ( exp -- eproc )
+    2dup operator analyze
+    2swap operands operand-eproc-list
+
+    ['] application-executor primitive-proc-type
+    nil cons cons cons
+;
+
+:noname ( exp --- eproc )
+
+    self-evaluating? if
+        analyze-self-evaluating
+        exit
+    then
+
+    quote? if
+        analyze-quoted
+        exit
+    then
+    
+    variable? if
+        analyze-variable
+        exit
+    then
+
+    definition? if
+        analyze-definition
+        exit
+    then
+
+    assignment? if
+        analyze-assignment
+        exit
+    then
+
+    if? if
+        analyze-if
+        exit
+    then
+
+    lambda? if
+        analyze-lambda
+        exit
+    then
+
+    application? if
+        analyze-application
+        exit
+    then
+
+    
+    except-message: ." tried to analyze unknown expression type." recoverable-exception throw
+
+; is analyze
+
+
 \ ---- Macro Expansion ---- {{{
 
 ( Simply evaluates the given procedure with expbody as its argument. )
@@ -1987,7 +2257,7 @@ variable gc-stack-depth
 
     include scheme-primitives.4th
 
-    s" scheme-library.scm" load 2drop
+    \ s" scheme-library.scm" load 2drop
     
 \ }}}
 
@@ -2020,7 +2290,7 @@ variable gc-stack-depth
     enable-gc
 
     \ Display welcome message
-    welcome-symbol nil cons global-env obj@ eval 2drop
+    \ welcome-symbol nil cons global-env obj@ eval 2drop
 
     begin
         ['] repl-body catch