-REM POKE 1, PEEK(1)AND248: REM enable all ROM areas as RAM
-REM POKE 55,0: POKE 56,192: CLR: REM move BASIC end from $A000 to $C000
GOTO MAIN
-REM $INCLUDE: 'readline.in.bas'
+REM $INCLUDE: 'mem.in.bas'
REM $INCLUDE: 'types.in.bas'
+REM $INCLUDE: 'readline.in.bas'
REM $INCLUDE: 'reader.in.bas'
REM $INCLUDE: 'printer.in.bas'
REM $INCLUDE: 'env.in.bas'
GOSUB READ_STR
RETURN
-REM PAIR_Q(B) -> R
-PAIR_Q:
- R=0
- IF (Z%(B,0)AND15)<>6 AND (Z%(B,0)AND15)<>7 THEN RETURN
- IF (Z%(B,1)=0) THEN RETURN
- R=1
- RETURN
-
REM QUASIQUOTE(A) -> R
-QUASIQUOTE:
- B=A:GOSUB PAIR_Q
- IF R=1 THEN GOTO QQ_UNQUOTE
+SUB QUASIQUOTE
+ REM pair?
+ GOSUB TYPE_A
+ IF T<6 OR T>7 THEN GOTO QQ_QUOTE
+ IF (Z%(A+1)=0) THEN GOTO QQ_QUOTE
+ GOTO QQ_UNQUOTE
+
+ QQ_QUOTE:
REM ['quote, ast]
- AS$="quote":T=5:GOSUB STRING
- B2%=R:B1%=A:GOSUB LIST2
+ B$="quote":T=5:GOSUB STRING
+ B=R:A=A:GOSUB LIST2
+ AY=B:GOSUB RELEASE
- RETURN
+ GOTO QQ_DONE
QQ_UNQUOTE:
- R=A+1:GOSUB DEREF_R
- IF (Z%(R,0)AND15)<>5 THEN GOTO QQ_SPLICE_UNQUOTE
- IF S$(Z%(R,1))<>"unquote" THEN GOTO QQ_SPLICE_UNQUOTE
+ R=Z%(A+2)
+ IF (Z%(R)AND 31)<>5 THEN GOTO QQ_SPLICE_UNQUOTE
+ IF S$(Z%(R+1))<>"unquote" THEN GOTO QQ_SPLICE_UNQUOTE
REM [ast[1]]
- R=Z%(A,1)+1:GOSUB DEREF_R
- Z%(R,0)=Z%(R,0)+16
+ R=Z%(Z%(A+1)+2)
+ GOSUB INC_REF_R
- RETURN
+ GOTO QQ_DONE
QQ_SPLICE_UNQUOTE:
- REM push A on the stack
- X=X+1:S%(X)=A
+ GOSUB PUSH_A
REM rest of cases call quasiquote on ast[1..]
- A=Z%(A,1):GOSUB QUASIQUOTE:T6=R
- REM pop A off the stack
- A=S%(X):X=X-1
+ A=Z%(A+1):CALL QUASIQUOTE
+ W=R
+ GOSUB POP_A
REM set A to ast[0] for last two cases
- A=A+1:GOSUB DEREF_A
+ A=Z%(A+2)
- B=A:GOSUB PAIR_Q
- IF R=0 THEN GOTO QQ_DEFAULT
- B=A+1:GOSUB DEREF_B
- IF (Z%(B,0)AND15)<>5 THEN GOTO QQ_DEFAULT
- IF S$(Z%(B,1))<>"splice-unquote" THEN QQ_DEFAULT
+ REM pair?
+ GOSUB TYPE_A
+ IF T<6 OR T>7 THEN GOTO QQ_DEFAULT
+ IF (Z%(A+1)=0) THEN GOTO QQ_DEFAULT
+
+ B=Z%(A+2)
+ IF (Z%(B)AND 31)<>5 THEN GOTO QQ_DEFAULT
+ IF S$(Z%(B+1))<>"splice-unquote" THEN QQ_DEFAULT
REM ['concat, ast[0][1], quasiquote(ast[1..])]
- B=Z%(A,1)+1:GOSUB DEREF_B:B2%=B
- AS$="concat":T=5:GOSUB STRING:B3%=R
- B1%=T6:GOSUB LIST3
+ B=Z%(Z%(A+1)+2)
+ B$="concat":T=5:GOSUB STRING:C=R
+ A=W:GOSUB LIST3
REM release inner quasiquoted since outer list takes ownership
- AY=B1%:GOSUB RELEASE
- RETURN
+ AY=A:GOSUB RELEASE
+ AY=C:GOSUB RELEASE
+ GOTO QQ_DONE
QQ_DEFAULT:
REM ['cons, quasiquote(ast[0]), quasiquote(ast[1..])]
- REM push T6 on the stack
- X=X+1:S%(X)=T6
+ Q=W:GOSUB PUSH_Q
REM A set above to ast[0]
- GOSUB QUASIQUOTE:B2%=R
- REM pop T6 off the stack
- T6=S%(X):X=X-1
+ CALL QUASIQUOTE
+ B=R
+ GOSUB POP_Q:W=Q
- AS$="cons":T=5:GOSUB STRING:B3%=R
- B1%=T6:GOSUB LIST3
+ B$="cons":T=5:GOSUB STRING:C=R
+ A=W:GOSUB LIST3
REM release inner quasiquoted since outer list takes ownership
- AY=B1%:GOSUB RELEASE
- AY=B2%:GOSUB RELEASE
- RETURN
+ AY=A:GOSUB RELEASE
+ AY=B:GOSUB RELEASE
+ AY=C:GOSUB RELEASE
+ QQ_DONE:
+END SUB
REM MACROEXPAND(A, E) -> A:
-MACROEXPAND:
- REM push original A
- X=X+1:S%(X)=A
+SUB MACROEXPAND
+ GOSUB PUSH_A
MACROEXPAND_LOOP:
REM list?
- IF (Z%(A,0)AND15)<>6 THEN GOTO MACROEXPAND_DONE
+ GOSUB TYPE_A
+ IF T<>6 THEN GOTO MACROEXPAND_DONE
REM non-empty?
- IF Z%(A,1)=0 THEN GOTO MACROEXPAND_DONE
- B=A+1:GOSUB DEREF_B
+ IF Z%(A+1)=0 THEN GOTO MACROEXPAND_DONE
+ B=Z%(A+2)
REM symbol? in first position
- IF (Z%(B,0)AND15)<>5 THEN GOTO MACROEXPAND_DONE
+ IF (Z%(B)AND 31)<>5 THEN GOTO MACROEXPAND_DONE
REM defined in environment?
- K=B:GOSUB ENV_FIND
+ K=B:CALL ENV_FIND
IF R=-1 THEN GOTO MACROEXPAND_DONE
- B=T4:GOSUB DEREF_B
+ B=R4
REM macro?
- IF (Z%(B,0)AND15)<>11 THEN GOTO MACROEXPAND_DONE
-
- REM apply
- F=B:AR=Z%(A,1):GOSUB APPLY
+ IF (Z%(B)AND 31)<>11 THEN GOTO MACROEXPAND_DONE
+
+ F=B:AR=Z%(A+1):CALL APPLY
A=R
- AY=S%(X)
+ GOSUB PEEK_Q:AY=Q
REM if previous A was not the first A into macroexpand (i.e. an
REM intermediate form) then free it
- IF A<>AY THEN ZM%=ZM%+1:ZR%(ZM%,0)=A:ZR%(ZM%,1)=LV
-
+ IF A<>AY THEN GOSUB PEND_A_LV
+
IF ER<>-2 THEN GOTO MACROEXPAND_DONE
GOTO MACROEXPAND_LOOP
MACROEXPAND_DONE:
- X=X-1: REM pop original A
- RETURN
+ GOSUB POP_Q: REM pop original A
+END SUB
REM EVAL_AST(A, E) -> R
-REM called using GOTO to avoid basic return address stack usage
-REM top of stack should have return label index
-EVAL_AST:
+SUB EVAL_AST
REM push A and E on the stack
- X=X+2:S%(X-1)=E:S%(X)=A
+ Q=E:GOSUB PUSH_Q
+ GOSUB PUSH_A
IF ER<>-2 THEN GOTO EVAL_AST_RETURN
- GOSUB DEREF_A
-
- T=Z%(A,0)AND15
+ GOSUB TYPE_A
IF T=5 THEN GOTO EVAL_AST_SYMBOL
IF T>=6 AND T<=8 THEN GOTO EVAL_AST_SEQ
REM scalar: deref to actual value and inc ref cnt
- R=A:GOSUB DEREF_R
- Z%(R,0)=Z%(R,0)+16
+ R=A
+ GOSUB INC_REF_R
GOTO EVAL_AST_RETURN
EVAL_AST_SYMBOL:
- K=A:GOSUB ENV_GET
+ K=A:GOTO ENV_GET
+ ENV_GET_RETURN:
GOTO EVAL_AST_RETURN
EVAL_AST_SEQ:
- REM allocate the first entry
- SZ=2:GOSUB ALLOC
-
- REM make space on the stack
- X=X+4
- REM push type of sequence
- S%(X-3)=T
- REM push sequence index
- S%(X-2)=-1
- REM push future return value (new sequence)
- S%(X-1)=R
- REM push previous new sequence entry
- S%(X)=R
+ REM setup the stack for the loop
+ GOSUB MAP_LOOP_START
EVAL_AST_SEQ_LOOP:
- REM set new sequence entry type (with 1 ref cnt)
- Z%(R,0)=S%(X-3)+16
- Z%(R,1)=0
- REM create value ptr placeholder
- Z%(R+1,0)=14
- Z%(R+1,1)=0
-
- REM update index
- S%(X-2)=S%(X-2)+1
-
REM check if we are done evaluating the source sequence
- IF Z%(A,1)=0 THEN GOTO EVAL_AST_SEQ_LOOP_DONE
-
- REM if hashmap, skip eval of even entries (keys)
- IF (S%(X-3)=8) AND ((S%(X-2) AND 1)=0) THEN GOTO EVAL_AST_DO_REF
- GOTO EVAL_AST_DO_EVAL
-
- EVAL_AST_DO_REF:
- R=A+1:GOSUB DEREF_R: REM deref to target of referred entry
- Z%(R,0)=Z%(R,0)+16: REM inc ref cnt of referred value
- GOTO EVAL_AST_ADD_VALUE
+ IF Z%(A+1)=0 THEN GOTO EVAL_AST_SEQ_LOOP_DONE
- EVAL_AST_DO_EVAL:
- REM call EVAL for each entry
- A=A+1:GOSUB EVAL
- A=A-1
- GOSUB DEREF_R: REM deref to target of evaluated entry
+ REM if we are returning to DO, then skip last element
+ REM The EVAL_DO call to EVAL_AST must be call #2 for EVAL_AST to
+ REM return early and for TCO to work
+ Q=5:GOSUB PEEK_Q_Q
+ IF Q=2 AND Z%(Z%(A+1)+1)=0 THEN GOTO EVAL_AST_SEQ_LOOP_DONE
- EVAL_AST_ADD_VALUE:
+ REM call EVAL for each entry
+ GOSUB PUSH_A
+ IF T<>8 THEN A=Z%(A+2)
+ IF T=8 THEN A=Z%(A+3)
+ Q=T:GOSUB PUSH_Q: REM push/save type
+ CALL EVAL
+ GOSUB POP_Q:T=Q: REM pop/restore type
+ GOSUB POP_A
+ M=R
- REM update previous value pointer to evaluated entry
- Z%(S%(X)+1,1)=R
+ REM if error, release the unattached element
+ REM TODO: is R=0 correct?
+ IF ER<>-2 THEN AY=R:GOSUB RELEASE:R=0:GOTO EVAL_AST_SEQ_LOOP_DONE
- IF ER<>-2 THEN GOTO EVAL_AST_SEQ_LOOP_DONE
+ REM for hash-maps, copy the key (inc ref since we are going to
+ REM release it below)
+ IF T=8 THEN N=M:M=Z%(A+2):Z%(M)=Z%(M)+32
- REM allocate the next entry
- SZ=2:GOSUB ALLOC
- REM update previous sequence entry value to point to new entry
- Z%(S%(X),1)=R
- REM update previous ptr to current entry
- S%(X)=R
+ REM update the return sequence structure
+ REM release N (and M if T=8) since seq takes full ownership
+ C=1:GOSUB MAP_LOOP_UPDATE
REM process the next sequence entry from source list
- A=Z%(A,1)
+ A=Z%(A+1)
GOTO EVAL_AST_SEQ_LOOP
EVAL_AST_SEQ_LOOP_DONE:
- REM if no error, get return value (new seq)
- IF ER=-2 THEN R=S%(X-1)
- REM otherwise, free the return value and return nil
- IF ER<>-2 THEN R=0:AY=S%(X-1):GOSUB RELEASE
-
- REM pop previous, return, index and type
- X=X-4
+ REM cleanup stack and get return value
+ GOSUB MAP_LOOP_DONE
GOTO EVAL_AST_RETURN
EVAL_AST_RETURN:
REM pop A and E off the stack
- E=S%(X-1):A=S%(X):X=X-2
-
- REM pop EVAL AST return label/address
- RN%=S%(X):X=X-1
- ON RN% GOTO EVAL_AST_RETURN_1,EVAL_AST_RETURN_2,EVAL_AST_RETURN_3
- RETURN
+ GOSUB POP_A
+ GOSUB POP_Q:E=Q
+END SUB
-REM EVAL(A, E)) -> R
-EVAL:
+REM EVAL(A, E) -> R
+SUB EVAL
LV=LV+1: REM track basic return stack level
REM push A and E on the stack
- X=X+2:S%(X-1)=E:S%(X)=A
+ Q=E:GOSUB PUSH_Q
+ GOSUB PUSH_A
+
+ REM PRINT "EVAL A:"+STR$(A)+",X:"+STR$(X)+",LV:"+STR$(LV)+",FRE:"+STR$(FRE(0))
EVAL_TCO_RECUR:
- REM AZ=A:PR=1:GOSUB PR_STR
- REM PRINT "EVAL: "+R$+" [A:"+STR$(A)+", LV:"+STR$(LV)+"]"
+ IF ER<>-2 THEN GOTO EVAL_RETURN
- GOSUB DEREF_A
+ REM AZ=A:B=1:GOSUB PR_STR
+ REM PRINT "EVAL: "+R$+" [A:"+STR$(A)+", LV:"+STR$(LV)+"]"
GOSUB LIST_Q
IF R THEN GOTO APPLY_LIST
EVAL_NOT_LIST:
REM ELSE
- REM push EVAL_AST return label/address
- X=X+1:S%(X)=1
- GOTO EVAL_AST
- EVAL_AST_RETURN_1:
-
+ CALL EVAL_AST
GOTO EVAL_RETURN
APPLY_LIST:
- GOSUB MACROEXPAND
+ CALL MACROEXPAND
GOSUB LIST_Q
IF R<>1 THEN GOTO EVAL_NOT_LIST
GOSUB EMPTY_Q
- IF R THEN R=A:Z%(R,0)=Z%(R,0)+16:GOTO EVAL_RETURN
+ IF R THEN R=A:GOSUB INC_REF_R:GOTO EVAL_RETURN
- A0%=A+1
- R=A0%:GOSUB DEREF_R:A0%=R
+ A0=Z%(A+2)
REM get symbol in A$
- IF (Z%(A0%,0)AND15)<>5 THEN A$=""
- IF (Z%(A0%,0)AND15)=5 THEN A$=S$(Z%(A0%,1))
+ IF (Z%(A0)AND 31)<>5 THEN A$=""
+ IF (Z%(A0)AND 31)=5 THEN A$=S$(Z%(A0+1))
IF A$="def!" THEN GOTO EVAL_DEF
IF A$="let*" THEN GOTO EVAL_LET
GOTO EVAL_INVOKE
EVAL_GET_A3:
- A3%=Z%(Z%(Z%(A,1),1),1)+1
- R=A3%:GOSUB DEREF_R:A3%=R
+ A3=Z%(Z%(Z%(Z%(A+1)+1)+1)+2)
EVAL_GET_A2:
- A2%=Z%(Z%(A,1),1)+1
- R=A2%:GOSUB DEREF_R:A2%=R
+ A2=Z%(Z%(Z%(A+1)+1)+2)
EVAL_GET_A1:
- A1%=Z%(A,1)+1
- R=A1%:GOSUB DEREF_R:A1%=R
+ A1=Z%(Z%(A+1)+2)
RETURN
EVAL_DEF:
REM PRINT "def!"
- GOSUB EVAL_GET_A2: REM set a1% and a2%
+ GOSUB EVAL_GET_A2: REM set A1 and A2
- X=X+1:S%(X)=A1%: REM push A1%
- A=A2%:GOSUB EVAL: REM eval a2
- A1%=S%(X):X=X-1: REM pop A1%
+ Q=A1:GOSUB PUSH_Q
+ A=A2:CALL EVAL: REM eval a2
+ GOSUB POP_Q:A1=Q
IF ER<>-2 THEN GOTO EVAL_RETURN
REM set a1 in env to a2
- K=A1%:V=R:GOSUB ENV_SET
+ K=A1:C=R:GOSUB ENV_SET
GOTO EVAL_RETURN
EVAL_LET:
REM PRINT "let*"
- GOSUB EVAL_GET_A2: REM set a1% and a2%
+ GOSUB EVAL_GET_A2: REM set A1 and A2
- X=X+1:S%(X)=A2%: REM push/save A2%
- X=X+1:S%(X)=E: REM push env for for later release
+ Q=A2:GOSUB PUSH_Q: REM push/save A2
+ Q=E:GOSUB PUSH_Q: REM push env for for later release
REM create new environment with outer as current environment
- O=E:GOSUB ENV_NEW
+ C=E:GOSUB ENV_NEW
E=R
EVAL_LET_LOOP:
- IF Z%(A1%,1)=0 THEN GOTO EVAL_LET_LOOP_DONE
+ IF Z%(A1+1)=0 THEN GOTO EVAL_LET_LOOP_DONE
- X=X+1:S%(X)=A1%: REM push A1%
+ Q=A1:GOSUB PUSH_Q: REM push A1
REM eval current A1 odd element
- A=Z%(A1%,1)+1:GOSUB EVAL
- A1%=S%(X):X=X-1: REM pop A1%
+ A=Z%(Z%(A1+1)+2):CALL EVAL
+ GOSUB POP_Q:A1=Q: REM pop A1
+
+ IF ER<>-2 THEN GOTO EVAL_LET_LOOP_DONE
- REM set environment: even A1% key to odd A1% eval'd above
- K=A1%+1:V=R:GOSUB ENV_SET
+ REM set key/value in the environment
+ K=Z%(A1+2):C=R:GOSUB ENV_SET
AY=R:GOSUB RELEASE: REM release our use, ENV_SET took ownership
- REM skip to the next pair of A1% elements
- A1%=Z%(Z%(A1%,1),1)
+ REM skip to the next pair of A1 elements
+ A1=Z%(Z%(A1+1)+1)
GOTO EVAL_LET_LOOP
EVAL_LET_LOOP_DONE:
- E4%=S%(X):X=X-1: REM pop previous env
+ GOSUB POP_Q:AY=Q: REM pop previous env
REM release previous environment if not the current EVAL env
- IF E4%<>S%(X-2) THEN AY=E4%:GOSUB RELEASE
+ GOSUB PEEK_Q_2
+ IF AY<>Q THEN GOSUB RELEASE
- A2%=S%(X):X=X-1: REM pop A2%
- A=A2%:GOTO EVAL_TCO_RECUR: REM TCO loop
+ GOSUB POP_Q:A2=Q: REM pop A2
+ A=A2:GOTO EVAL_TCO_RECUR: REM TCO loop
EVAL_DO:
- A=Z%(A,1): REM rest
+ A=Z%(A+1): REM rest
+ GOSUB PUSH_A: REM push/save A
- REM TODO: TCO
+ REM this must be EVAL_AST call #2 for EVAL_AST to return early
+ REM and for TCO to work
+ CALL EVAL_AST
- REM push EVAL_AST return label/address
- X=X+1:S%(X)=2
- GOTO EVAL_AST
- EVAL_AST_RETURN_2:
+ REM cleanup
+ AY=R: REM get eval'd list for release
- X=X+1:S%(X)=R: REM push eval'd list
- A=R:GOSUB LAST: REM return the last element
- AY=S%(X):X=X-1: REM pop eval'd list
- GOSUB RELEASE: REM release the eval'd list
- GOTO EVAL_RETURN
+ GOSUB POP_A: REM pop/restore original A for LAST
+ GOSUB LAST: REM get last element for return
+ A=R: REM new recur AST
+
+ REM cleanup
+ GOSUB RELEASE: REM release eval'd list
+ AY=A:GOSUB RELEASE: REM release LAST value (not sure why)
+
+ GOTO EVAL_TCO_RECUR: REM TCO loop
EVAL_QUOTE:
- R=Z%(A,1)+1:GOSUB DEREF_R
- Z%(R,0)=Z%(R,0)+16
+ R=Z%(Z%(A+1)+2)
+ GOSUB INC_REF_R
GOTO EVAL_RETURN
EVAL_QUASIQUOTE:
- R=Z%(A,1)+1:GOSUB DEREF_R
- A=R:GOSUB QUASIQUOTE
+ R=Z%(Z%(A+1)+2)
+ A=R:CALL QUASIQUOTE
+ A=R
REM add quasiquote result to pending release queue to free when
REM next lower EVAL level returns (LV)
- ZM%=ZM%+1:ZR%(ZM%,0)=R:ZR%(ZM%,1)=LV
+ GOSUB PEND_A_LV
- A=R:GOTO EVAL_TCO_RECUR: REM TCO loop
+ GOTO EVAL_TCO_RECUR: REM TCO loop
EVAL_DEFMACRO:
REM PRINT "defmacro!"
- GOSUB EVAL_GET_A2: REM set a1% and a2%
+ GOSUB EVAL_GET_A2: REM set A1 and A2
- X=X+1:S%(X)=A1%: REM push A1%
- A=A2%:GOSUB EVAL: REM eval a2
- A1%=S%(X):X=X-1: REM pop A1%
+ Q=A1:GOSUB PUSH_Q: REM push A1
+ A=A2:CALL EVAL: REM eval A2
+ GOSUB POP_Q:A1=Q: REM pop A1
REM change function to macro
- Z%(R,0)=Z%(R,0)+1
+ Z%(R)=Z%(R)+1
- REM set a1 in env to a2
- K=A1%:V=R:GOSUB ENV_SET
+ REM set A1 in env to A2
+ K=A1:C=R:GOSUB ENV_SET
GOTO EVAL_RETURN
EVAL_MACROEXPAND:
REM PRINT "macroexpand"
- R=Z%(A,1)+1:GOSUB DEREF_R
- A=R:GOSUB MACROEXPAND:R=A
+ R=Z%(Z%(A+1)+2)
+ A=R:CALL MACROEXPAND
+ R=A
REM since we are returning it unevaluated, inc the ref cnt
- Z%(R,0)=Z%(R,0)+16
+ GOSUB INC_REF_R
GOTO EVAL_RETURN
EVAL_TRY:
REM PRINT "try*"
- GOSUB EVAL_GET_A1: REM set a1%, a2%, and a3%
+ GOSUB EVAL_GET_A1: REM set A1
+
+ GOSUB PUSH_A: REM push/save A
+ A=A1:CALL EVAL: REM eval A1
+ GOSUB POP_A: REM pop/restore A
- X=X+1:S%(X)=A: REM push/save A
- A=A1%:GOSUB EVAL: REM eval a1
- A=S%(X):X=X-1: REM pop/restore A
+ GOSUB EVAL_GET_A2: REM set A1 and A2
- REM if there is not error or catch block then return
- IF ER=-2 OR Z%(A,1)=0 THEN GOTO EVAL_RETURN
+ REM if there is no error or catch block then return
+ IF ER=-2 OR A2=0 THEN GOTO EVAL_RETURN
REM create environment for the catch block eval
- O=E:GOSUB ENV_NEW:E=R
+ C=E:GOSUB ENV_NEW:E=R
- GOSUB EVAL_GET_A2: REM set a1% and a2%
- A=A2%:GOSUB EVAL_GET_A2: REM set a1% and a2% from catch block
+ A=A2:GOSUB EVAL_GET_A2: REM set A1 and A2 from catch block
REM create object for ER=-1 type raw string errors
- IF ER=-1 THEN AS$=ER$:T=4:GOSUB STRING:ER=R:Z%(R,0)=Z%(R,0)+16
+ IF ER=-1 THEN B$=E$:T=4:GOSUB STRING:ER=R:GOSUB INC_REF_R
REM bind the catch symbol to the error object
- K=A1%:V=ER:GOSUB ENV_SET
- AY=R:GOSUB RELEASE: REM release out use, env took ownership
+ K=A1:C=ER:GOSUB ENV_SET
+ AY=R:GOSUB RELEASE: REM release our use, env took ownership
REM unset error for catch eval
- ER=-2:ER$=""
+ ER=-2:E$=""
- A=A2%:GOSUB EVAL
+ A=A2:CALL EVAL
GOTO EVAL_RETURN
EVAL_IF:
- GOSUB EVAL_GET_A1: REM set a1%
- REM push A
- X=X+1:S%(X)=A
- A=A1%:GOSUB EVAL
- REM pop A
- A=S%(X):X=X-1
- IF (R=0) OR (R=1) THEN GOTO EVAL_IF_FALSE
+ GOSUB EVAL_GET_A1: REM set A1
+ GOSUB PUSH_A: REM push/save A
+ A=A1:CALL EVAL
+ GOSUB POP_A: REM pop/restore A
+ IF (R=0) OR (R=2) THEN GOTO EVAL_IF_FALSE
EVAL_IF_TRUE:
AY=R:GOSUB RELEASE
- GOSUB EVAL_GET_A2: REM set a1% and a2% after EVAL
- A=A2%:GOTO EVAL_TCO_RECUR: REM TCO loop
+ GOSUB EVAL_GET_A2: REM set A1 and A2 after EVAL
+ A=A2:GOTO EVAL_TCO_RECUR: REM TCO loop
EVAL_IF_FALSE:
AY=R:GOSUB RELEASE
- REM if no false case (A3%), return nil
- IF Z%(Z%(Z%(A,1),1),1)=0 THEN R=0:GOTO EVAL_RETURN
- GOSUB EVAL_GET_A3: REM set a1% - a3% after EVAL
- A=A3%:GOTO EVAL_TCO_RECUR: REM TCO loop
+ REM if no false case (A3), return nil
+ GOSUB COUNT
+ IF R<4 THEN R=0:GOSUB INC_REF_R:GOTO EVAL_RETURN
+ GOSUB EVAL_GET_A3: REM set A1 - A3 after EVAL
+ A=A3:GOTO EVAL_TCO_RECUR: REM TCO loop
EVAL_FN:
- GOSUB EVAL_GET_A2: REM set a1% and a2%
- A=A2%:P=A1%:GOSUB MAL_FUNCTION
+ GOSUB EVAL_GET_A2: REM set A1 and A2
+ T=10:L=A2:M=A1:N=E:GOSUB ALLOC: REM mal function
GOTO EVAL_RETURN
EVAL_INVOKE:
- REM push EVAL_AST return label/address
- X=X+1:S%(X)=3
- GOTO EVAL_AST
- EVAL_AST_RETURN_3:
+ CALL EVAL_AST
REM if error, return f/args for release by caller
IF ER<>-2 THEN GOTO EVAL_RETURN
REM push f/args for release after call
- X=X+1:S%(X)=R
+ GOSUB PUSH_R
- F=R+1
+ AR=Z%(R+1): REM rest
+ F=Z%(R+2)
- AR=Z%(R,1): REM rest
- R=F:GOSUB DEREF_R:F=R
+ REM if metadata, get the actual object
+ GOSUB TYPE_F
+ IF T=14 THEN F=Z%(F+1):GOSUB TYPE_F
- IF (Z%(F,0)AND15)=9 THEN GOTO EVAL_DO_FUNCTION
- IF (Z%(F,0)AND15)=10 THEN GOTO EVAL_DO_MAL_FUNCTION
+ ON T-8 GOTO EVAL_DO_FUNCTION,EVAL_DO_MAL_FUNCTION,EVAL_DO_MAL_FUNCTION
REM if error, pop and return f/args for release by caller
- R=S%(X):X=X-1
- ER=-1:ER$="apply of non-function":GOTO EVAL_RETURN
+ GOSUB POP_R
+ ER=-1:E$="apply of non-function":GOTO EVAL_RETURN
EVAL_DO_FUNCTION:
- GOSUB DO_FUNCTION
+ REM regular function
+ IF Z%(F+1)<60 THEN GOSUB DO_FUNCTION:GOTO EVAL_DO_FUNCTION_SKIP
+ REM for recur functions (apply, map, swap!), use GOTO
+ IF Z%(F+1)>60 THEN CALL DO_TCO_FUNCTION
+ EVAL_DO_FUNCTION_SKIP:
REM pop and release f/args
- AY=S%(X):X=X-1:GOSUB RELEASE
+ GOSUB POP_Q:AY=Q
+ GOSUB RELEASE
GOTO EVAL_RETURN
EVAL_DO_MAL_FUNCTION:
- E4%=E: REM save the current environment for release
+ Q=E:GOSUB PUSH_Q: REM save the current environment for release
- REM create new environ using env stored with function
- O=Z%(F+1,1):BI%=Z%(F+1,0):EX%=AR:GOSUB ENV_NEW_BINDS
+ REM create new environ using env and params stored in function
+ C=Z%(F+3):A=Z%(F+2):B=AR:GOSUB ENV_NEW_BINDS
REM release previous env if it is not the top one on the
- REM stack (S%(X-2)) because our new env refers to it and
+ REM stack (X%(X-2)) because our new env refers to it and
REM we no longer need to track it (since we are TCO recurring)
- IF E4%<>S%(X-2) THEN AY=E4%:GOSUB RELEASE
+ GOSUB POP_Q:AY=Q
+ GOSUB PEEK_Q_2
+ IF AY<>Q THEN GOSUB RELEASE
REM claim the AST before releasing the list containing it
- A=Z%(F,1):Z%(A,0)=Z%(A,0)+16
+ A=Z%(F+1):Z%(A)=Z%(A)+32
REM add AST to pending release queue to free as soon as EVAL
REM actually returns (LV+1)
- ZM%=ZM%+1:ZR%(ZM%,0)=A:ZR%(ZM%,1)=LV+1
+ LV=LV+1:GOSUB PEND_A_LV:LV=LV-1
REM pop and release f/args
- AY=S%(X):X=X-1:GOSUB RELEASE
+ GOSUB POP_Q:AY=Q
+ GOSUB RELEASE
REM A set above
E=R:GOTO EVAL_TCO_RECUR: REM TCO loop
EVAL_RETURN:
- REM AZ=R: PR=1: GOSUB PR_STR
+ REM AZ=R: B=1: GOSUB PR_STR
REM PRINT "EVAL_RETURN R: ["+R$+"] ("+STR$(R)+"), LV:"+STR$(LV)+",ER:"+STR$(ER)
REM release environment if not the top one on the stack
- IF E<>S%(X-1) THEN AY=E:GOSUB RELEASE
+ GOSUB PEEK_Q_1
+ IF E<>Q THEN AY=E:GOSUB RELEASE
LV=LV-1: REM track basic return stack level
GOSUB RELEASE_PEND
REM trigger GC
- TA%=FRE(0)
+ #cbm T=FRE(0)
+ #qbasic T=0
REM pop A and E off the stack
- E=S%(X-1):A=S%(X):X=X-2
+ GOSUB POP_A
+ GOSUB POP_Q:E=Q
- RETURN
+END SUB
REM PRINT(A) -> R$
MAL_PRINT:
- AZ=A:PR=1:GOSUB PR_STR
+ AZ=A:B=1:GOSUB PR_STR
RETURN
REM RE(A$) -> R
-REM Assume RE% has repl_env
+REM Assume D has repl_env
REM caller must release result
RE:
- R1=0
+ R1=-1
GOSUB MAL_READ
R1=R
- IF ER<>-2 THEN GOTO REP_DONE
+ IF ER<>-2 THEN GOTO RE_DONE
- A=R:E=RE%:GOSUB EVAL
+ A=R:E=D:CALL EVAL
- REP_DONE:
+ RE_DONE:
REM Release memory from MAL_READ
- IF R1<>0 THEN AY=R1:GOSUB RELEASE
+ AY=R1:GOSUB RELEASE
RETURN: REM caller must release result of EVAL
REM REP(A$) -> R$
-REM Assume RE% has repl_env
-REP:
- R1=0:R2=0
- GOSUB MAL_READ
- R1=R
- IF ER<>-2 THEN GOTO REP_DONE
+REM Assume D has repl_env
+SUB REP
+ R2=-1
- A=R:E=RE%:GOSUB EVAL
+ GOSUB RE
R2=R
IF ER<>-2 THEN GOTO REP_DONE
A=R:GOSUB MAL_PRINT
- RT$=R$
REP_DONE:
REM Release memory from MAL_READ and EVAL
- IF R2<>0 THEN AY=R2:GOSUB RELEASE
- IF R1<>0 THEN AY=R1:GOSUB RELEASE
- R$=RT$
- RETURN
+ AY=R2:GOSUB RELEASE
+END SUB
REM MAIN program
MAIN:
LV=0
REM create repl_env
- O=-1:GOSUB ENV_NEW:RE%=R
+ C=0:GOSUB ENV_NEW:D=R
REM core.EXT: defined in Basic
- E=RE%:GOSUB INIT_CORE_NS: REM set core functions in repl_env
+ E=D:GOSUB INIT_CORE_NS: REM set core functions in repl_env
- ZT%=ZI: REM top of memory after base repl_env
+ ZT=ZI: REM top of memory after base repl_env
REM core.mal: defined using the language itself
A$="(def! not (fn* (a) (if a false true)))"
GOSUB RE:AY=R:GOSUB RELEASE
- A$="(def! load-file (fn* (f) (eval (read-string (str "
- A$=A$+CHR$(34)+"(do "+CHR$(34)+" (slurp f) "+CHR$(34)+")"+CHR$(34)+")))))"
+ A$="(def! load-file (fn* (f) (eval (read-file f))))"
GOSUB RE:AY=R:GOSUB RELEASE
A$="(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs)"
A$=A$+" forms to cond"+CHR$(34)+")) (cons 'cond (rest (rest xs)))))))"
GOSUB RE:AY=R:GOSUB RELEASE
- A$="(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs)"
- A$=A$+" `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"
- GOSUB RE:AY=R:GOSUB RELEASE
-
REM load the args file
- A$="(def! -*ARGS*- (load-file "+CHR$(34)+".args.mal"+CHR$(34)+"))"
+ A$="(load-file "+CHR$(34)+".args.mal"+CHR$(34)+")"
GOSUB RE:AY=R:GOSUB RELEASE
+ IF ER>-2 THEN GOSUB PRINT_ERROR:END
+
REM set the argument list
A$="(def! *ARGV* (rest -*ARGS*-))"
GOSUB RE:AY=R:GOSUB RELEASE
A$="(first -*ARGS*-)"
GOSUB RE
- REM if there is an argument, then run it as a program
- IF R<>0 THEN AY=R:GOSUB RELEASE:GOTO RUN_PROG
REM no arguments, start REPL loop
- IF R=0 THEN GOTO REPL_LOOP
+ IF R<16 THEN GOTO REPL_LOOP
+
+ REM if there is an argument, then run it as a program
RUN_PROG:
+ REM free up first arg because we get it again
+ AY=R:GOSUB RELEASE
REM run a single mal program and exit
A$="(load-file (first -*ARGS*-))"
GOSUB RE
IF ER<>-2 THEN GOSUB PRINT_ERROR
- END
+ GOTO QUIT
REPL_LOOP:
A$="user> ":GOSUB READLINE: REM call input parser
- IF EOF=1 THEN GOTO QUIT
+ IF EZ=1 THEN GOTO QUIT
+ IF R$="" THEN GOTO REPL_LOOP
- A$=R$:GOSUB REP: REM call REP
+ A$=R$:CALL REP: REM call REP
IF ER<>-2 THEN GOSUB PRINT_ERROR:GOTO REPL_LOOP
PRINT R$
GOTO REPL_LOOP
QUIT:
- REM P1%=ZT%: P2%=-1: GOSUB PR_MEMORY
- GOSUB PR_MEMORY_SUMMARY
- END
+ REM GOSUB PR_MEMORY_SUMMARY_SMALL
+ #cbm END
+ #qbasic SYSTEM
PRINT_ERROR:
REM if the error is an object, then print and free it
- IF ER>=0 THEN AZ=ER:PR=0:GOSUB PR_STR:ER$=R$:AY=ER:GOSUB RELEASE
- PRINT "Error: "+ER$
- ER=-2:ER$=""
+ IF ER>=0 THEN AZ=ER:B=0:GOSUB PR_STR:E$=R$:AY=ER:GOSUB RELEASE
+ PRINT "Error: "+E$
+ ER=-2:E$=""
RETURN
HCoop / jackhill / mal.git / blobdiff