kanaka/mal
1
1
Fork 0
mirror of https://github.com/kanaka/mal.git synced 2024-09-21 10:37:58 +03:00
Code Issues Projects Releases Wiki Activity
bbd62dc97c
mal/basic/step4_if_fn_do.in.bas

372 lines
8.7 KiB
QBasic
Raw Normal View History

Basic: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +03:00
REM $INCLUDE: 'reader.in.bas'
REM $INCLUDE: 'printer.in.bas'
REM $INCLUDE: 'env.in.bas'
REM $INCLUDE: 'core.in.bas'
Basic: step7 basics, reader macros. step1,3 tests. Also: - Add some step1 and step3 tests that were discovered during Basic development. - Move PR_MEMORY* to debug.in.bas - Simplify Makefile deps - Fix freeing in steps4-7 when error at deeper level i.e. (prn (abc)) - add SLICE function to support concat implementation.
2016-09-22 07:27:12 +03:00
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: most of step4.
2016-09-12 05:36:15 +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 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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +03:00
GOTO EVAL_AST_RETURN
Basic: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
Basic: most of step4.
2016-09-12 05:36:15 +03:00
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: most of step4.
2016-09-12 05:36:15 +03:00
EVAL_AST_SEQ_LOOP:
Basic: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +03:00
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: most of step4.
2016-09-12 05:36:15 +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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: most of step4.
2016-09-12 05:36:15 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
Basic: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +03:00
Basic: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +03:00
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: most of step4.
2016-09-12 05:36:15 +03:00
GOTO EVAL_RETURN
APPLY_LIST:
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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +03:00
IF A$="def!" THEN GOTO EVAL_DEF
IF A$="let*" THEN GOTO EVAL_LET
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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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
Basic: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +03:00
GOTO EVAL_RETURN
Basic: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
Basic: most of step4.
2016-09-12 05:36:15 +03:00
EVAL_LET:
Basic: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +03:00
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
Basic: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: most of step4.
2016-09-12 05:36:15 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: most of step4.
2016-09-12 05:36:15 +03:00
GOTO EVAL_LET_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: most of step4.
2016-09-12 05:36:15 +03:00
EVAL_LET_LOOP_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:A2=Q: REM pop A2
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 using let_env
Basic: most of step4.
2016-09-12 05:36:15 +03:00
GOTO EVAL_RETURN
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: most of step4.
2016-09-12 05:36:15 +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
CALL EVAL_AST
Basic: most of step4.
2016-09-12 05:36:15 +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 PUSH_R: REM push eval'd list
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 LAST: REM return the last element
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: REM pop eval'd list
Basic: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
GOSUB RELEASE: REM release the eval'd list
Basic: most of step4.
2016-09-12 05:36:15 +03:00
GOTO EVAL_RETURN
Basic: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
Basic: most of step4.
2016-09-12 05:36:15 +03:00
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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
Basic: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +03:00
GOTO EVAL_RETURN
Basic: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
Basic: most of step4.
2016-09-12 05:36:15 +03:00
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: most of step4.
2016-09-12 05:36:15 +03:00
Basic: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: most of step4.
2016-09-12 05:36:15 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
Basic: most of step4.
2016-09-12 05:36:15 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: most of step4.
2016-09-12 05:36:15 +03:00
GOTO EVAL_RETURN
Basic: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
Basic: most of step4.
2016-09-12 05:36:15 +03:00
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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: step7 basics, reader macros. step1,3 tests. Also: - Add some step1 and step3 tests that were discovered during Basic development. - Move PR_MEMORY* to debug.in.bas - Simplify Makefile deps - Fix freeing in steps4-7 when error at deeper level i.e. (prn (abc)) - add SLICE function to support concat implementation.
2016-09-22 07:27:12 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: most of step4.
2016-09-12 05:36:15 +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: step7 basics, reader macros. step1,3 tests. Also: - Add some step1 and step3 tests that were discovered during Basic development. - Move PR_MEMORY* to debug.in.bas - Simplify Makefile deps - Fix freeing in steps4-7 when error at deeper level i.e. (prn (abc)) - add SLICE function to support concat implementation.
2016-09-22 07:27:12 +03:00
Basic: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +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: step7 basics, reader macros. step1,3 tests. Also: - Add some step1 and step3 tests that were discovered during Basic development. - Move PR_MEMORY* to debug.in.bas - Simplify Makefile deps - Fix freeing in steps4-7 when error at deeper level i.e. (prn (abc)) - add SLICE function to support concat implementation.
2016-09-22 07:27:12 +03:00
Basic: add step5, fix recursive/error memory issues. - Add TCO recur to let* - Release of all memory from recursive function and let* calls. - Fix a number of cases of trying to release already freed memory. - Print function in memory as 2 byte unit rather than two separate memory locations.
2016-09-18 07:03:30 +03:00
REM release everything we couldn't release earlier
GOSUB RELEASE_PEND
Basic: most of step4.
2016-09-12 05:36:15 +03:00
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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +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: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +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: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +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: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +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: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +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: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +03:00
RETURN: REM caller must release result of EVAL
Basic: most of step4.
2016-09-12 05:36:15 +03:00
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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +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: most of step4.
2016-09-12 05:36:15 +03:00
Basic: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +03:00
REM core.mal: defined using the language itself
Basic: basicpp adds, other misc. Shaves 3031 bytes. - basicpp.py: - Fix "ON GOTO/GOSUB" label replacment - Add combine line capability - Change "THEN GOTO" to "THEN" - Remove some spaces and unnecessary parens - Restructure several places with multiple "GOTO/GOSUBs" statements into fewer "ON GOTO/GOSUB" statements
2016-09-24 06:36:17 +03:00
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: most of step4.
2016-09-12 05:36:15 +03:00
Basic: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +03:00
REPL_LOOP:
Basic: basicpp adds, other misc. Shaves 3031 bytes. - basicpp.py: - Fix "ON GOTO/GOSUB" label replacment - Add combine line capability - Change "THEN GOTO" to "THEN" - Remove some spaces and unnecessary parens - Restructure several places with multiple "GOTO/GOSUBs" statements into fewer "ON GOTO/GOSUB" statements
2016-09-24 06:36:17 +03:00
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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: Add memory management. More step4. Also: - More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY - Fix *.prg image build (for running under Vice). Have to lower-case everything since what C64/Vice shows as capitals are actually lowercase.
2016-09-16 09:00:58 +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: most of step4.
2016-09-12 05:36:15 +03:00
PRINT R$
Basic: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +03:00
GOTO REPL_LOOP
Basic: most of step4.
2016-09-12 05:36:15 +03:00
Basic: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +03:00
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: most of step4.
2016-09-12 05:36:15 +03:00
Basic: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +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: step6 basics and atoms. Fix strings. Also: - command lines arguments are implemented by creating a file ".args.mal" that contains a list of arguments and that is loaded by the run script (load-file) into -*ARGS*-. The rest is put in *ARGV* and the first element is pulled out and used as the script name. - fix string reading/printing using new REPLACE function - add RE function to skip printing and to get back evaluated value (result must be freed by caller). Needed for step6 to get first argument pointer for scripting. - Sync earlier steps - add cons, first, rest to support parsing the command line. - eval is implemented as standard function in core.in.mal - fix println bug (using PR_STR rather than PR_STR_SEQ) - change sequence printing to save the initial sequence type on the stack and use that for the ending sequence delimeter. This way sequences of one type can still use the tail of sequences of a different type but still be considered the initial type.
2016-09-20 05:23:21 +03:00
RETURN
Reference in New Issue Copy Permalink