kanaka/mal
1
1
Fork 0
mirror of https://github.com/kanaka/mal.git synced 2024-11-11 00:52:44 +03:00
Code Issues Projects Releases Wiki Activity
93708da80e
mal/basic/step8_macros.in.bas

593 lines
14 KiB
QBasic
Raw Normal View History

Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO MAIN
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
REM $INCLUDE: 'mem.in.bas'
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM $INCLUDE: 'types.in.bas'
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
REM $INCLUDE: 'readline.in.bas'
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM $INCLUDE: 'reader.in.bas'
REM $INCLUDE: 'printer.in.bas'
REM $INCLUDE: 'env.in.bas'
REM $INCLUDE: 'core.in.bas'
REM $INCLUDE: 'debug.in.bas'
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM READ(A$) -> R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
MAL_READ:
GOSUB READ_STR
RETURN
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM QUASIQUOTE(A) -> R
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
SUB QUASIQUOTE
REM pair?
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB TYPE_A
IF T<6 OR T>7 THEN GOTO QQ_QUOTE
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF (Z%(A+1)=0) THEN GOTO QQ_QUOTE
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
GOTO QQ_UNQUOTE
QQ_QUOTE:
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM ['quote, ast]
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
B$="quote":T=5:GOSUB STRING
B=R:A=A:GOSUB LIST2
AY=B:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
GOTO QQ_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
QQ_UNQUOTE:
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
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
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM [ast[1]]
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
R=Z%(Z%(A+1)+2)
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB INC_REF_R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
GOTO QQ_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
QQ_SPLICE_UNQUOTE:
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PUSH_A
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM rest of cases call quasiquote on ast[1..]
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A=Z%(A+1):CALL QUASIQUOTE
Basic: more reductions. RELEASE refactor. Save about 400 bytes. Increase value Z% array by 100 to 4195. Reduce string array by 1 (to 199) since in BASIC the value is the last index not the size.
2016-11-10 10:51:02 +03:00
W=R
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_A
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM set A to ast[0] for last two cases
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A=Z%(A+2)
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
REM pair?
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB TYPE_A
IF T<6 OR T>7 THEN GOTO QQ_DEFAULT
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF (Z%(A+1)=0) THEN GOTO QQ_DEFAULT
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
B=Z%(A+2)
IF (Z%(B)AND 31)<>5 THEN GOTO QQ_DEFAULT
IF S$(Z%(B+1))<>"splice-unquote" THEN QQ_DEFAULT
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM ['concat, ast[0][1], quasiquote(ast[1..])]
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
B=Z%(Z%(A+1)+2)
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
B$="concat":T=5:GOSUB STRING:C=R
Basic: more reductions. RELEASE refactor. Save about 400 bytes. Increase value Z% array by 100 to 4195. Reduce string array by 1 (to 199) since in BASIC the value is the last index not the size.
2016-11-10 10:51:02 +03:00
A=W:GOSUB LIST3
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM release inner quasiquoted since outer list takes ownership
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
AY=A:GOSUB RELEASE
AY=C:GOSUB RELEASE
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
GOTO QQ_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
QQ_DEFAULT:
REM ['cons, quasiquote(ast[0]), quasiquote(ast[1..])]
Basic: more reductions. RELEASE refactor. Save about 400 bytes. Increase value Z% array by 100 to 4195. Reduce string array by 1 (to 199) since in BASIC the value is the last index not the size.
2016-11-10 10:51:02 +03:00
Q=W:GOSUB PUSH_Q
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM A set above to ast[0]
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
CALL QUASIQUOTE
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
B=R
Basic: more reductions. RELEASE refactor. Save about 400 bytes. Increase value Z% array by 100 to 4195. Reduce string array by 1 (to 199) since in BASIC the value is the last index not the size.
2016-11-10 10:51:02 +03:00
GOSUB POP_Q:W=Q
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
B$="cons":T=5:GOSUB STRING:C=R
Basic: more reductions. RELEASE refactor. Save about 400 bytes. Increase value Z% array by 100 to 4195. Reduce string array by 1 (to 199) since in BASIC the value is the last index not the size.
2016-11-10 10:51:02 +03:00
A=W:GOSUB LIST3
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM release inner quasiquoted since outer list takes ownership
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
AY=A:GOSUB RELEASE
AY=B:GOSUB RELEASE
AY=C:GOSUB RELEASE
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
QQ_DONE:
END SUB
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM MACROEXPAND(A, E) -> A:
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
SUB MACROEXPAND
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PUSH_A
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
MACROEXPAND_LOOP:
REM list?
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB TYPE_A
IF T<>6 THEN GOTO MACROEXPAND_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM non-empty?
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF Z%(A+1)=0 THEN GOTO MACROEXPAND_DONE
B=Z%(A+2)
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM symbol? in first position
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF (Z%(B)AND 31)<>5 THEN GOTO MACROEXPAND_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM defined in environment?
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
K=B:CALL ENV_FIND
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF R=-1 THEN GOTO MACROEXPAND_DONE
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
B=R4
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM macro?
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF (Z%(B)AND 31)<>11 THEN GOTO MACROEXPAND_DONE
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
F=B:AR=Z%(A+1):CALL APPLY
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
A=R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PEEK_Q:AY=Q
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM if previous A was not the first A into macroexpand (i.e. an
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM intermediate form) then free it
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
IF A<>AY THEN GOSUB PEND_A_LV
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF ER<>-2 THEN GOTO MACROEXPAND_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO MACROEXPAND_LOOP
MACROEXPAND_DONE:
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_Q: REM pop original A
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
END SUB
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM EVAL_AST(A, E) -> R
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
SUB EVAL_AST
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM push A and E on the stack
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
Q=E:GOSUB PUSH_Q
GOSUB PUSH_A
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF ER<>-2 THEN GOTO EVAL_AST_RETURN
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB TYPE_A
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF T=5 THEN GOTO EVAL_AST_SYMBOL
IF T>=6 AND T<=8 THEN GOTO EVAL_AST_SEQ
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM scalar: deref to actual value and inc ref cnt
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
R=A
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB INC_REF_R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_AST_RETURN
EVAL_AST_SYMBOL:
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
K=A:GOTO ENV_GET
ENV_GET_RETURN:
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_AST_RETURN
EVAL_AST_SEQ:
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
REM setup the stack for the loop
GOSUB MAP_LOOP_START
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_AST_SEQ_LOOP:
REM check if we are done evaluating the source sequence
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF Z%(A+1)=0 THEN GOTO EVAL_AST_SEQ_LOOP_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: Reduce GOSUB use. Partial self-host to step3 step4 runs out of space attempting to load the program. Step2 and step3 run out of memory (stack exhaustion) for more complicated forms. - Use GOTO with return label on our stack instead of GOSUB for: - APPLY function in types.in.bas - "apply", "map" and "swap!" core functions - Implement DO TCO. Change EVAL_AST to detect if we are called from DO and exit one element early. - Remove GOSUB recursion from EQUAL_Q - Inline PAIR_Q. Reduce REPLACE stack use. - Remove one level of GOSUB/stack by calling REP with GOTO - Simplify mal/step2_eval.mal to remove use of (or ) macro in eval_ast. - Fix ON GOTO/GOSUB line detection in basicpp
2016-10-25 07:29:27 +03:00
REM if we are returning to DO, then skip last element
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
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
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF Q=2 AND Z%(Z%(A+1)+1)=0 THEN GOTO EVAL_AST_SEQ_LOOP_DONE
Basic: Reduce GOSUB use. Partial self-host to step3 step4 runs out of space attempting to load the program. Step2 and step3 run out of memory (stack exhaustion) for more complicated forms. - Use GOTO with return label on our stack instead of GOSUB for: - APPLY function in types.in.bas - "apply", "map" and "swap!" core functions - Implement DO TCO. Change EVAL_AST to detect if we are called from DO and exit one element early. - Remove GOSUB recursion from EQUAL_Q - Inline PAIR_Q. Reduce REPLACE stack use. - Remove one level of GOSUB/stack by calling REP with GOTO - Simplify mal/step2_eval.mal to remove use of (or ) macro in eval_ast. - Fix ON GOTO/GOSUB line detection in basicpp
2016-10-25 07:29:27 +03:00
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
REM call EVAL for each entry
GOSUB PUSH_A
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF T<>8 THEN A=Z%(A+2)
IF T=8 THEN A=Z%(A+3)
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
Q=T:GOSUB PUSH_Q: REM push/save type
CALL EVAL
GOSUB POP_Q:T=Q: REM pop/restore type
GOSUB POP_A
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
M=R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
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
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
REM for hash-maps, copy the key (inc ref since we are going to
REM release it below)
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF T=8 THEN N=M:M=Z%(A+2):Z%(M)=Z%(M)+32
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
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
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM process the next sequence entry from source list
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A=Z%(A+1)
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_AST_SEQ_LOOP
EVAL_AST_SEQ_LOOP_DONE:
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
REM cleanup stack and get return value
GOSUB MAP_LOOP_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_AST_RETURN
EVAL_AST_RETURN:
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM pop A and E off the stack
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_A
GOSUB POP_Q:E=Q
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
END SUB
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
REM EVAL(A, E) -> R
SUB EVAL
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
LV=LV+1: REM track basic return stack level
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM push A and E on the stack
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
Q=E:GOSUB PUSH_Q
GOSUB PUSH_A
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: Reduce GOSUB use. Partial self-host to step3 step4 runs out of space attempting to load the program. Step2 and step3 run out of memory (stack exhaustion) for more complicated forms. - Use GOTO with return label on our stack instead of GOSUB for: - APPLY function in types.in.bas - "apply", "map" and "swap!" core functions - Implement DO TCO. Change EVAL_AST to detect if we are called from DO and exit one element early. - Remove GOSUB recursion from EQUAL_Q - Inline PAIR_Q. Reduce REPLACE stack use. - Remove one level of GOSUB/stack by calling REP with GOTO - Simplify mal/step2_eval.mal to remove use of (or ) macro in eval_ast. - Fix ON GOTO/GOSUB line detection in basicpp
2016-10-25 07:29:27 +03:00
REM PRINT "EVAL A:"+STR$(A)+",X:"+STR$(X)+",LV:"+STR$(LV)+",FRE:"+STR$(FRE(0))
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_TCO_RECUR:
Basic: fix errors, reader, if form. Self-host 0-3 - Stop let binding eval on error. Also don't continue into EVAL if error. - if without a false position was freeing up too much when it finished. - fix reader so that it doesn't keep incrementing ref cnt of static empty sequences.
2016-10-27 06:29:09 +03:00
IF ER<>-2 THEN GOTO EVAL_RETURN
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
REM AZ=A:B=1:GOSUB PR_STR
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM PRINT "EVAL: "+R$+" [A:"+STR$(A)+", LV:"+STR$(LV)+"]"
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOSUB LIST_Q
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF R THEN GOTO APPLY_LIST
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_NOT_LIST:
REM ELSE
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
CALL EVAL_AST
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_RETURN
APPLY_LIST:
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
CALL MACROEXPAND
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOSUB LIST_Q
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF R<>1 THEN GOTO EVAL_NOT_LIST
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOSUB EMPTY_Q
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
IF R THEN R=A:GOSUB INC_REF_R:GOTO EVAL_RETURN
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A0=Z%(A+2)
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM get symbol in A$
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF (Z%(A0)AND 31)<>5 THEN A$=""
IF (Z%(A0)AND 31)=5 THEN A$=S$(Z%(A0+1))
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
IF A$="def!" THEN GOTO EVAL_DEF
IF A$="let*" THEN GOTO EVAL_LET
IF A$="quote" THEN GOTO EVAL_QUOTE
IF A$="quasiquote" THEN GOTO EVAL_QUASIQUOTE
IF A$="defmacro!" THEN GOTO EVAL_DEFMACRO
IF A$="macroexpand" THEN GOTO EVAL_MACROEXPAND
IF A$="do" THEN GOTO EVAL_DO
IF A$="if" THEN GOTO EVAL_IF
IF A$="fn*" THEN GOTO EVAL_FN
GOTO EVAL_INVOKE
EVAL_GET_A3:
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A3=Z%(Z%(Z%(Z%(A+1)+1)+1)+2)
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_GET_A2:
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A2=Z%(Z%(Z%(A+1)+1)+2)
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_GET_A1:
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A1=Z%(Z%(A+1)+2)
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
RETURN
EVAL_DEF:
REM PRINT "def!"
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
GOSUB EVAL_GET_A2: REM set A1 and A2
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
Q=A1:GOSUB PUSH_Q
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
A=A2:CALL EVAL: REM eval a2
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_Q:A1=Q
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF ER<>-2 THEN GOTO EVAL_RETURN
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM set a1 in env to a2
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
K=A1:C=R:GOSUB ENV_SET
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_RETURN
EVAL_LET:
REM PRINT "let*"
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
GOSUB EVAL_GET_A2: REM set A1 and A2
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
Q=A2:GOSUB PUSH_Q: REM push/save A2
Q=E:GOSUB PUSH_Q: REM push env for for later release
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM create new environment with outer as current environment
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
C=E:GOSUB ENV_NEW
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
E=R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_LET_LOOP:
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF Z%(A1+1)=0 THEN GOTO EVAL_LET_LOOP_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
Q=A1:GOSUB PUSH_Q: REM push A1
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM eval current A1 odd element
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A=Z%(Z%(A1+1)+2):CALL EVAL
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_Q:A1=Q: REM pop A1
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: fix errors, reader, if form. Self-host 0-3 - Stop let binding eval on error. Also don't continue into EVAL if error. - if without a false position was freeing up too much when it finished. - fix reader so that it doesn't keep incrementing ref cnt of static empty sequences.
2016-10-27 06:29:09 +03:00
IF ER<>-2 THEN GOTO EVAL_LET_LOOP_DONE
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
REM set key/value in the environment
K=Z%(A1+2):C=R:GOSUB ENV_SET
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
AY=R:GOSUB RELEASE: REM release our use, ENV_SET took ownership
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
REM skip to the next pair of A1 elements
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A1=Z%(Z%(A1+1)+1)
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_LET_LOOP
EVAL_LET_LOOP_DONE:
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
GOSUB POP_Q:AY=Q: REM pop previous env
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM release previous environment if not the current EVAL env
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PEEK_Q_2
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
IF AY<>Q THEN GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_Q:A2=Q: REM pop A2
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
A=A2:GOTO EVAL_TCO_RECUR: REM TCO loop
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_DO:
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A=Z%(A+1): REM rest
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PUSH_A: REM push/save A
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
REM this must be EVAL_AST call #2 for EVAL_AST to return early
REM and for TCO to work
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
CALL EVAL_AST
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: Reduce GOSUB use. Partial self-host to step3 step4 runs out of space attempting to load the program. Step2 and step3 run out of memory (stack exhaustion) for more complicated forms. - Use GOTO with return label on our stack instead of GOSUB for: - APPLY function in types.in.bas - "apply", "map" and "swap!" core functions - Implement DO TCO. Change EVAL_AST to detect if we are called from DO and exit one element early. - Remove GOSUB recursion from EQUAL_Q - Inline PAIR_Q. Reduce REPLACE stack use. - Remove one level of GOSUB/stack by calling REP with GOTO - Simplify mal/step2_eval.mal to remove use of (or ) macro in eval_ast. - Fix ON GOTO/GOSUB line detection in basicpp
2016-10-25 07:29:27 +03:00
REM cleanup
AY=R: REM get eval'd list for release
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_A: REM pop/restore original A for LAST
Basic: Reduce GOSUB use. Partial self-host to step3 step4 runs out of space attempting to load the program. Step2 and step3 run out of memory (stack exhaustion) for more complicated forms. - Use GOTO with return label on our stack instead of GOSUB for: - APPLY function in types.in.bas - "apply", "map" and "swap!" core functions - Implement DO TCO. Change EVAL_AST to detect if we are called from DO and exit one element early. - Remove GOSUB recursion from EQUAL_Q - Inline PAIR_Q. Reduce REPLACE stack use. - Remove one level of GOSUB/stack by calling REP with GOTO - Simplify mal/step2_eval.mal to remove use of (or ) macro in eval_ast. - Fix ON GOTO/GOSUB line detection in basicpp
2016-10-25 07:29:27 +03:00
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
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_QUOTE:
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
R=Z%(Z%(A+1)+2)
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB INC_REF_R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_RETURN
EVAL_QUASIQUOTE:
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
R=Z%(Z%(A+1)+2)
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
A=R:CALL QUASIQUOTE
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
A=R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM add quasiquote result to pending release queue to free when
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM next lower EVAL level returns (LV)
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PEND_A_LV
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOTO EVAL_TCO_RECUR: REM TCO loop
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_DEFMACRO:
REM PRINT "defmacro!"
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
GOSUB EVAL_GET_A2: REM set A1 and A2
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
Q=A1:GOSUB PUSH_Q: REM push A1
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
A=A2:CALL EVAL: REM eval A2
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_Q:A1=Q: REM pop A1
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM change function to macro
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
Z%(R)=Z%(R)+1
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
REM set A1 in env to A2
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
K=A1:C=R:GOSUB ENV_SET
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_RETURN
EVAL_MACROEXPAND:
REM PRINT "macroexpand"
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
R=Z%(Z%(A+1)+2)
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
A=R:CALL MACROEXPAND
R=A
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM since we are returning it unevaluated, inc the ref cnt
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB INC_REF_R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_RETURN
EVAL_IF:
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
GOSUB EVAL_GET_A1: REM set A1
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PUSH_A: REM push/save A
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
A=A1:CALL EVAL
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_A: REM pop/restore A
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF (R=0) OR (R=2) THEN GOTO EVAL_IF_FALSE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_IF_TRUE:
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
AY=R:GOSUB RELEASE
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
GOSUB EVAL_GET_A2: REM set A1 and A2 after EVAL
A=A2:GOTO EVAL_TCO_RECUR: REM TCO loop
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_IF_FALSE:
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
AY=R:GOSUB RELEASE
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
REM if no false case (A3), return nil
Basic: more reductions. RELEASE refactor. Save about 400 bytes. Increase value Z% array by 100 to 4195. Reduce string array by 1 (to 199) since in BASIC the value is the last index not the size.
2016-11-10 10:51:02 +03:00
GOSUB COUNT
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
IF R<4 THEN R=0:GOSUB INC_REF_R:GOTO EVAL_RETURN
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
GOSUB EVAL_GET_A3: REM set A1 - A3 after EVAL
A=A3:GOTO EVAL_TCO_RECUR: REM TCO loop
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_FN:
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
GOSUB EVAL_GET_A2: REM set A1 and A2
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
T=10:L=A2:M=A1:N=E:GOSUB ALLOC: REM mal function
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_RETURN
EVAL_INVOKE:
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
CALL EVAL_AST
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM if error, return f/args for release by caller
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF ER<>-2 THEN GOTO EVAL_RETURN
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM push f/args for release after call
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PUSH_R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
AR=Z%(R+1): REM rest
F=Z%(R+2)
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
REM if metadata, get the actual object
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB TYPE_F
IF T=14 THEN F=Z%(F+1):GOSUB TYPE_F
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
ON T-8 GOTO EVAL_DO_FUNCTION,EVAL_DO_MAL_FUNCTION,EVAL_DO_MAL_FUNCTION
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM if error, pop and return f/args for release by caller
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_R
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
ER=-1:E$="apply of non-function":GOTO EVAL_RETURN
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_DO_FUNCTION:
Basic: Reduce GOSUB use. Partial self-host to step3 step4 runs out of space attempting to load the program. Step2 and step3 run out of memory (stack exhaustion) for more complicated forms. - Use GOTO with return label on our stack instead of GOSUB for: - APPLY function in types.in.bas - "apply", "map" and "swap!" core functions - Implement DO TCO. Change EVAL_AST to detect if we are called from DO and exit one element early. - Remove GOSUB recursion from EQUAL_Q - Inline PAIR_Q. Reduce REPLACE stack use. - Remove one level of GOSUB/stack by calling REP with GOTO - Simplify mal/step2_eval.mal to remove use of (or ) macro in eval_ast. - Fix ON GOTO/GOSUB line detection in basicpp
2016-10-25 07:29:27 +03:00
REM regular function
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF Z%(F+1)<60 THEN GOSUB DO_FUNCTION:GOTO EVAL_DO_FUNCTION_SKIP
Basic: Reduce GOSUB use. Partial self-host to step3 step4 runs out of space attempting to load the program. Step2 and step3 run out of memory (stack exhaustion) for more complicated forms. - Use GOTO with return label on our stack instead of GOSUB for: - APPLY function in types.in.bas - "apply", "map" and "swap!" core functions - Implement DO TCO. Change EVAL_AST to detect if we are called from DO and exit one element early. - Remove GOSUB recursion from EQUAL_Q - Inline PAIR_Q. Reduce REPLACE stack use. - Remove one level of GOSUB/stack by calling REP with GOTO - Simplify mal/step2_eval.mal to remove use of (or ) macro in eval_ast. - Fix ON GOTO/GOSUB line detection in basicpp
2016-10-25 07:29:27 +03:00
REM for recur functions (apply, map, swap!), use GOTO
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
IF Z%(F+1)>60 THEN CALL DO_TCO_FUNCTION
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
EVAL_DO_FUNCTION_SKIP:
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM pop and release f/args
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_Q:AY=Q
GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOTO EVAL_RETURN
EVAL_DO_MAL_FUNCTION:
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
Q=E:GOSUB PUSH_Q: REM save the current environment for release
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
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
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM release previous env if it is not the top one on the
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
REM stack (X%(X-2)) because our new env refers to it and
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM we no longer need to track it (since we are TCO recurring)
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
GOSUB POP_Q:AY=Q
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PEEK_Q_2
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
IF AY<>Q THEN GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM claim the AST before releasing the list containing it
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
A=Z%(F+1):Z%(A)=Z%(A)+32
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM add AST to pending release queue to free as soon as EVAL
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM actually returns (LV+1)
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
LV=LV+1:GOSUB PEND_A_LV:LV=LV-1
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM pop and release f/args
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_Q:AY=Q
GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM A set above
E=R:GOTO EVAL_TCO_RECUR: REM TCO loop
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
EVAL_RETURN:
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
REM AZ=R: B=1: GOSUB PR_STR
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM PRINT "EVAL_RETURN R: ["+R$+"] ("+STR$(R)+"), LV:"+STR$(LV)+",ER:"+STR$(ER)
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM release environment if not the top one on the stack
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB PEEK_Q_1
IF E<>Q THEN AY=E:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
LV=LV-1: REM track basic return stack level
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM release everything we couldn't release earlier
GOSUB RELEASE_PEND
REM trigger GC
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
#cbm T=FRE(0)
#qbasic T=0
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM pop A and E off the stack
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
GOSUB POP_A
GOSUB POP_Q:E=Q
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
END SUB
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM PRINT(A) -> R$
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
MAL_PRINT:
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
AZ=A:B=1:GOSUB PR_STR
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
RETURN
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
REM RE(A$) -> R
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
REM Assume D has repl_env
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM caller must release result
RE:
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
R1=-1
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
GOSUB MAL_READ
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
R1=R
Basic: add read-file. Misc basicpp space savings. - Add read-file which is similar to read-string but from a file name rather than a string. This allows steps 0-2 to load although each one eventuall crashes with out of memory after evaluating "123" a few times. - basicpp: - Renumber the line numbers so they are ordinally increasing. This saves 150 or so bytes because GOTO/GOSUB calls have smaller line numbers. - Shrink 'IF 123' -> 'IF123' for almost 300 byte savings.[:w - Simplify PR_MEMORY_SUMMARY output. Save 75 bytes - Add missing runtest.py change that allows basic tests to pass.
2016-10-24 06:18:08 +03:00
IF ER<>-2 THEN GOTO RE_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
A=R:E=D:CALL EVAL
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: add read-file. Misc basicpp space savings. - Add read-file which is similar to read-string but from a file name rather than a string. This allows steps 0-2 to load although each one eventuall crashes with out of memory after evaluating "123" a few times. - basicpp: - Renumber the line numbers so they are ordinally increasing. This saves 150 or so bytes because GOTO/GOSUB calls have smaller line numbers. - Shrink 'IF 123' -> 'IF123' for almost 300 byte savings.[:w - Simplify PR_MEMORY_SUMMARY output. Save 75 bytes - Add missing runtest.py change that allows basic tests to pass.
2016-10-24 06:18:08 +03:00
RE_DONE:
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM Release memory from MAL_READ
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
AY=R1:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
RETURN: REM caller must release result of EVAL
REM REP(A$) -> R$
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
REM Assume D has repl_env
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
SUB REP
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
R2=-1
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB RE
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
R2=R
IF ER<>-2 THEN GOTO REP_DONE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
A=R:GOSUB MAL_PRINT
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REP_DONE:
REM Release memory from MAL_READ and EVAL
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
AY=R2:GOSUB RELEASE
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
END SUB
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM MAIN program
MAIN:
GOSUB INIT_MEMORY
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
LV=0
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM create repl_env
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
C=0:GOSUB ENV_NEW:D=R
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM core.EXT: defined in Basic
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
E=D:GOSUB INIT_CORE_NS: REM set core functions in repl_env
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: hashmap functions. Basic metadata (on funcs) - Metadata support required expanding the type size (to 5 bits). This also implies that ref cnt now only has 11 bits (2048). - Added ^ reader macro (with-meta) which required some refactoring of READ_MACRO to share code. - Rename some more variables: ZJ -> S S% -> X% ZR% -> Y% ZM% -> Y RE% -> D This removes remaining % variables apart from the pre-allocated arrays Z%, S% and X%.
2016-10-23 00:11:46 +03:00
ZT=ZI: REM top of memory after base repl_env
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM core.mal: defined using the language itself
A$="(def! not (fn* (a) (if a false true)))"
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
GOSUB RE:AY=R:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: add read-file. Misc basicpp space savings. - Add read-file which is similar to read-string but from a file name rather than a string. This allows steps 0-2 to load although each one eventuall crashes with out of memory after evaluating "123" a few times. - basicpp: - Renumber the line numbers so they are ordinally increasing. This saves 150 or so bytes because GOTO/GOSUB calls have smaller line numbers. - Shrink 'IF 123' -> 'IF123' for almost 300 byte savings.[:w - Simplify PR_MEMORY_SUMMARY output. Save 75 bytes - Add missing runtest.py change that allows basic tests to pass.
2016-10-24 06:18:08 +03:00
A$="(def! load-file (fn* (f) (eval (read-file f))))"
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
GOSUB RE:AY=R:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
A$="(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs)"
A$=A$+" (if (> (count xs) 1) (nth xs 1) (throw "+CHR$(34)+"odd number of"
A$=A$+" forms to cond"+CHR$(34)+")) (cons 'cond (rest (rest xs)))))))"
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
GOSUB RE:AY=R:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
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))))))))"
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
GOSUB RE:AY=R:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM load the args file
A$="(def! -*ARGS*- (load-file "+CHR$(34)+".args.mal"+CHR$(34)+"))"
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
GOSUB RE:AY=R:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
IF ER>-2 THEN GOSUB PRINT_ERROR:END
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM set the argument list
A$="(def! *ARGV* (rest -*ARGS*-))"
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
GOSUB RE:AY=R:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM get the first argument
A$="(first -*ARGS*-)"
GOSUB RE
REM no arguments, start REPL loop
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
IF R<16 THEN GOTO REPL_LOOP
REM if there is an argument, then run it as a program
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
RUN_PROG:
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
REM free up first arg because we get it again
AY=R:GOSUB RELEASE
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REM run a single mal program and exit
A$="(load-file (first -*ARGS*-))"
GOSUB RE
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF ER<>-2 THEN GOSUB PRINT_ERROR
Basic: Reduce GOSUB use. Partial self-host to step3 step4 runs out of space attempting to load the program. Step2 and step3 run out of memory (stack exhaustion) for more complicated forms. - Use GOTO with return label on our stack instead of GOSUB for: - APPLY function in types.in.bas - "apply", "map" and "swap!" core functions - Implement DO TCO. Change EVAL_AST to detect if we are called from DO and exit one element early. - Remove GOSUB recursion from EQUAL_Q - Inline PAIR_Q. Reduce REPLACE stack use. - Remove one level of GOSUB/stack by calling REP with GOTO - Simplify mal/step2_eval.mal to remove use of (or ) macro in eval_ast. - Fix ON GOTO/GOSUB line detection in basicpp
2016-10-25 07:29:27 +03:00
GOTO QUIT
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
REPL_LOOP:
A$="user> ":GOSUB READLINE: REM call input parser
Basic: add QBasic support. make MODE=qbasic stepA_mal.bas qb64 stepA_mal.bas
2016-10-31 03:15:24 +03:00
IF EZ=1 THEN GOTO QUIT
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
IF R$="" THEN GOTO REPL_LOOP
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: implement CALL in basicpp.py and use it. - Add clean rule to Makefile and restructure deps.
2016-10-26 09:26:05 +03:00
A$=R$:CALL REP: REM call REP
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
Basic: variable renaming. Save 2 kbytes. Also, add variables.txt file with start of documenting meanings of variables. List of renamings/savings: ZZ% -> S% : 131 bytes ZL% -> X : 550 bytes A% -> A : 192 bytes E% -> E : 32 bytes R% -> R : 381 bytes AR% -> AR : 30 bytes AY% -> AY : 71 bytes AZ% -> AZ : 33 bytes B% -> B : 47 bytes AA% -> AA : 64 bytes AB% -> AB : 25 bytes F% -> F : 21 bytes FF% -> FF : 14 bytes ER% -> ER : 41 bytes PR% -> PR : 7 bytes T% -> T : 46 bytes R0-9% -> R0-9 : 31 bytes T0-9% -> T0-9 : 42 bytes S1-4% -> S1-4 : 25 bytes U0-9% -> U0-9 : 44 bytes ZK% -> ZK : 10 bytes ZI% -> ZI : 10 bytes RC% -> RC : 16 bytes K%/V% -> K/V : 21 bytes SD% -> SD : 16 bytes ZS$ -> S$ : 40 bytes HM% -> H : 10 bytes SZ% -> SZ : 39 bytes LV% -> LV : 9 bytes EO% -> O : 18 bytes C% -> C : 4 bytes P% -> P : 4 bytes
2016-10-15 06:42:56 +03:00
IF ER<>-2 THEN GOSUB PRINT_ERROR:GOTO REPL_LOOP
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
PRINT R$
GOTO REPL_LOOP
QUIT:
Basic: refactor of hashmaps, map loops, remove derefs. - Alternate memory layout of hash-maps: Instead of hash-maps being an alternating sequence of keys and values, combine the key/values into a single entry. In other words, switch from this: 8 -> next Z% index (0 for last) 14 key/value (alternating) To this: 8 -> next Z% index (0 for last) key value This requires refactoring of the sequence reader, EVAL_AST and especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big refactoring: - Change mapping/lapping constructs to share code: Several pieces of mapping/looping code have a common structure, so this moves that common structure to types.in.bas: MAP_LOOP_START, MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in: - EVAL_AST - READ_SEQ_* - DO_MAP - DO_HASH_MAP - DO_KEYS_VALS This also fixes the issue that several of these looping constructs were creating new empty sequence entries instead of using the common ones at the beginning of memory. - Remove the use of DEREF_*. This isn't actually needed because we no longer create structure that refer to multiple levels of type 14 references. Replace DEREF_* with VAL_* which gets the value of a particular sequence element i.e. Z%(A+1,1). All together, the above changes save over 300 bytes. Also: - Fix empty nil/false/true entries so they are treated the same as other types of data with regards to reference counting and ALLOC/RELEASE. - Add a new memory summary function in debug.in.bas that just prints out free, value count, and references for the early scalar and empty list elements. Comment out the larger one. This saves about 90 bytes.
2016-11-16 07:38:09 +03:00
REM GOSUB PR_MEMORY_SUMMARY_SMALL
Basic: QBasic fixes/enabling. Recursive includes. Enable QBasic console mode usage and fix bugs in newline handling differences with C64 basic (cbm). To enable console mode for QBasic programs, have basicpp.py prefix the output with the QB64 specific console activation variables/functions. One change to basicpp.py to make this change more straightfowards is recursive includes so that includes can appear in more than just the top level step files. This allows us to conditionally include the right readline implementation. For QBasic in the special console mode (instead of the default full-screen UI mode) we need to use the LINE INPUT command in order to read input.
2017-09-15 07:50:15 +03:00
#cbm END
#qbasic SYSTEM
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
PRINT_ERROR:
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
PRINT "Error: "+E$
ER=-2:E$=""
Basic: step8 basics. Fix def!, let*, concat, scalars. - Move apply logic in swap! to APPLY function in types and use that for macroexpand - Abort def! if error before updating the environment - let* wasn't properly saving A2% for the final eval. Also, the environment release check should be against the top-level EVAL env, not the root repl env. - (concat (list) ...) was broken so fix it to ignore empty lists that aren't in the trailing position. - nil, false and true in the reader were always being returned as references (with an ref cnt) but we have the assumption that references (14) are not ref cnt'd and are always part of a compound type so fix the reader to just return the interned addresses.
2016-10-07 06:22:57 +03:00
RETURN
Reference in New Issue Copy Permalink