include term-colours.4th
include defer-is.4th
+include goto.4th
include catch-throw.4th
include integer.4th
include float.4th
defer read
defer expand
+defer analyze
defer eval
defer print
make-exception recoverable-exception
make-exception unrecoverable-exception
-: throw reset-term throw ;
+: throw reset-term cr throw ;
\ }}}
create cdr-cells scheme-memsize allot
create cdr-type-cells scheme-memsize allot
+variable gc-enabled
+false gc-enabled !
+
+: gc-enabled?
+ gc-enabled @ ;
+
create nextfrees scheme-memsize allot
:noname
scheme-memsize 0 do
nextfree !
nextfree @ scheme-memsize >= if
- collect-garbage
+ gc-enabled? if
+ collect-garbage
+ then
then
nextfree @ scheme-memsize >= if
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 ---- {{{
exit
then
+ nextchar [char] ) = if
+ inc-parse-idx
+ except-message: ." unmatched closing parenthesis." recoverable-exception throw
+ then
+
\ Anything else is parsed as a symbol
readsymbol charlist>symbol
\ }}}
-\ ---- Eval ---- {{{
+\ ---- Syntax ---- {{{
: self-evaluating? ( obj -- obj bool )
boolean-type istype? if true exit then
: definition-val ( obj -- val )
cdr cdr car ;
-: eval-definition ( obj env -- res )
- 2swap
- 2over 2over
- definition-val 2swap
- eval
-
- 2swap definition-var 2swap
-
- 2rot
- define-var
-
- ok-symbol
-;
-
: assignment? ( obj -- obj bool )
set!-symbol tagged-list? ;
: assignment-val ( obj -- val )
cdr cdr car ;
-: eval-assignment ( obj env -- res )
- 2swap
- 2over 2over ( env obj env obj )
- assignment-val 2swap ( env obj valexp env )
- eval ( env obj val )
-
- 2swap assignment-var 2swap ( env var val )
-
- 2rot ( var val env )
- set-var
-
- ok-symbol
-;
-
: macro-definition? ( obj -- obj bool )
define-macro-symbol tagged-list? ;
: macro-definition-body ( exp -- body )
cdr cdr ;
-objvar env
-: eval-define-macro ( obj env -- res )
- env obj!
-
- 2dup macro-definition-name 2swap ( name obj )
- 2dup macro-definition-params 2swap ( name params obj )
- macro-definition-body ( name params body )
-
- env obj@ ( name params body env )
-
- make-macro
-
- ok-symbol
-;
-hide env
-
: if? ( obj -- obj bool )
if-symbol tagged-list? ;
: lambda-body ( obj -- body )
cdr cdr ;
-: eval-sequence ( explist env -- finalexp env )
- ( Evaluates all bar the final expressions in
- an an expression list. The final expression
- is returned to allow for tail optimization. )
-
- 2swap ( env explist )
-
- \ Abort on empty list
- nil? if
- 2drop none
- 2swap exit
- then
-
- begin
- 2dup cdr ( env explist nextexplist )
- nil? false =
- while
- -2rot car 2over ( nextexplist env exp env )
- eval
- 2drop \ discard result
- 2swap ( env nextexplist )
- repeat
-
- 2drop car 2swap ( finalexp env )
-;
-
: application? ( obj -- obj bool )
pair-type istype? ;
: rest-operands ( operands -- other-operands )
cdr ;
-: list-of-vals ( args env -- vals )
- 2swap
-
- 2dup nooperands? if
- 2swap 2drop
- else
- 2over 2over first-operand 2swap eval
- -2rot rest-operands 2swap recurse
- cons
- then
-;
-
: procedure-params ( proc -- params )
drop pair-type car ;
2swap
;
-: apply ( proc argvals -- result )
- 2swap dup case
- primitive-proc-type of
- drop execute
- endof
+\ }}}
- compound-proc-type of
- 2dup procedure-body ( argvals proc body )
- -2rot 2dup procedure-params ( body argvals proc argnames )
- -2rot procedure-env ( body argnames argvals procenv )
+\ ---- Analyze ---- {{{
- -2rot 2swap
- flatten-proc-args
- 2swap 2rot
+: evaluate-eproc ( eproc env --- res )
- extend-env ( body env )
+ >R >R
- eval-sequence
+ begin
+ nil? invert
+ while
+ 2dup car
+ 2swap cdr
+ repeat
+
+ 2drop \ get rid of null
- R> drop ['] eval goto-deferred \ Tail call optimization
- endof
+ R> R> 2swap
- except-message: ." object '" drop print ." ' not applicable." recoverable-exception throw
- endcase
+ \ Final element of eproc list is primitive procedure
+ drop \ dump type signifier
+
+ goto \ jump straight to primitive procedure (executor)
;
-:noname ( obj env -- result )
+: 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
+;
+
+: sequence-executor ( eproc-list env -- res )
2swap
- \ --- DEBUG ---
- (
- fg yellow ." Evaluating: " bold 2dup print reset-term
- space fg green ." PS: " bold depth . reset-term
- space fg blue ." RS: " bold RSP@ RSP0 - . reset-term cr
- )
+ 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
- self-evaluating? if
- 2swap 2drop
- exit
- then
+ 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
+;
- quote? if
- quote-body
+
+: macro-definition-executor ( name params bproc env -- ok )
+ make-macro ok-symbol
+;
+
+: analyze-macro-definition ( exp -- eproc )
+ 2dup macro-definition-name
+ 2swap 2dup macro-definition-params
+ 2swap macro-definition-body analyze-sequence
+
+ ['] macro-definition-executor primitive-proc-type
+ nil cons cons cons cons
+;
+
+: if-executor ( cproc aproc pproc env -- res )
+ 2swap 2over ( cproc aproc env pproc env -- res )
+ evaluate-eproc
+
+ true? if
2swap 2drop
- exit
+ else
+ 2rot 2drop
then
- variable? if
- 2swap lookup-var
- exit
- then
+ ['] evaluate-eproc goto
+;
- definition? if
- 2swap eval-definition
- exit
- then
+: analyze-if ( exp -- eproc )
+ 2dup if-consequent analyze
+ 2swap 2dup if-alternative analyze
+ 2swap if-predicate analyze
- assignment? if
- 2swap eval-assignment
- exit
- then
+ ['] if-executor primitive-proc-type
+ nil cons cons cons cons
+;
- macro-definition? if
- 2swap eval-define-macro
- exit
+: 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
- if? if
- 2over 2over
- if-predicate
- 2swap eval
+ analyze-sequence
- true? if
- if-consequent
- else
- if-alternative
- then
+ ['] lambda-executor primitive-proc-type
+ nil cons cons cons
+;
- 2swap
- ['] eval goto-deferred
+: operand-eproc-list ( operands -- eprocs )
+ nil? invert if
+ 2dup car analyze
+ 2swap cdr recurse
+ cons
then
+;
- lambda? if
- 2dup lambda-parameters
- 2swap lambda-body
- 2rot make-procedure
- exit
+: 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? if
+: apply ( vals proc )
+ dup case
+ primitive-proc-type of
+ drop execute
+ endof
- 2over 2over ( env exp env exp )
- operator ( env exp env opname )
+ compound-proc-type of
+ 2dup procedure-body ( argvals proc bproc )
+ -2rot 2dup procedure-params ( bproc argvals proc argnames )
+ -2rot procedure-env ( bproc argnames argvals procenv )
- 2swap eval ( env exp proc )
+ -2rot 2swap
+ flatten-proc-args
+ 2swap 2rot
- -2rot ( proc env exp )
- operands 2swap ( proc operands env )
- list-of-vals ( proc argvals )
+ extend-env ( bproc env )
- apply
- exit
- then
+ ['] evaluate-eproc goto
+ endof
- except-message: ." tried to evaluate object with unknown type." recoverable-exception throw
-; is eval
+ except-message: ." object '" drop print ." ' not applicable." recoverable-exception throw
+ endcase
+;
+
+: 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 )
+
+ ['] apply goto
+;
+
+: 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
+
+ macro-definition? if analyze-macro-definition 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
\ }}}
( Simply evaluates the given procedure with expbody as its argument. )
: macro-eval ( proc expbody -- result )
2swap
- 2dup procedure-body ( expbody proc procbody )
- -2rot 2dup procedure-params ( procbody expbody proc argnames )
- -2rot procedure-env ( procbody argnames expbody procenv )
+ 2dup procedure-body ( expbody proc bproc )
+ -2rot 2dup procedure-params ( bproc expbody proc argnames )
+ -2rot procedure-env ( bproc argnames expbody procenv )
-2rot 2swap
flatten-proc-args
2swap 2rot
- extend-env eval-sequence eval
+ extend-env ( bproc env )
+
+ ['] evaluate-eproc goto
;
: expand-macro ( exp -- result )
pair-type istype? invert if exit then
+
2dup car symbol-type istype? invert if 2drop exit then
-
- lookup-macro nil? if
- 2drop exit then
+
+ lookup-macro nil? if 2drop exit then
2over cdr macro-eval
\ }}}
+:noname ( exp env -- res )
+ 2swap expand analyze 2swap evaluate-eproc
+; is eval
+
\ ---- Print ---- {{{
: printfixnum ( fixnum -- ) drop 0 .R ;
\ ---- Garbage Collection ---- {{{
-variable gc-enabled
-false gc-enabled !
-
variable gc-stack-depth
: enable-gc
: disable-gc
false gc-enabled ! ;
-: gc-enabled?
- gc-enabled @ ;
-
: pairlike? ( obj -- obj bool )
pair-type istype? if true exit then
string-type istype? if true exit then
ok-symbol ( port res )
begin
+ \ DEBUG
+ \ bold fg blue ." READ from " 2over drop . ." ==> " reset-term
+
2over read-port ( port res obj )
+ \ DEBUG
+ \ 2dup print cr
+
2dup EOF character-type objeq? if
2drop 2swap close-port
exit
2swap 2drop ( port obj )
- expand
-
global-env obj@ eval ( port res )
again
;
include scheme-primitives.4th
+ enable-gc
+
s" scheme-library.scm" load 2drop
+
+ disable-gc
\ }}}
true exit
then
- expand
-
global-env obj@ eval
fg cyan ." ; " print reset-term
throw false
endcase
until
+
+ disable-gc
;
forth definitions