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
4afc9decd5
mal/basic/reader.in.bas

261 lines
7.2 KiB
QBasic
Raw Normal View History

Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
REM READ_TOKEN(RF=0, A$, RI) -> T$
REM READ_TOKEN(RF=1) -> T$
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
READ_TOKEN:
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
IF RF=1 THEN RF=2:T$="(":RETURN
IF RF=2 THEN RF=3:T$="do":RETURN
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 SKIP_SPACES
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
REM PRINT "READ_TOKEN: "+STR$(RI)+", "+MID$(A$,RI,1)
GOSUB READ_CHAR
IF C$=";" THEN GOSUB SKIP_TO_EOL:GOTO READ_TOKEN
T$=C$
Basic: various memory savings. - simplify DO_CONCAT. - inline MAL_READ/PRINT. - comment out memory debug/sanity checks. - more aggressive space removal. Saves over 900 bytes. Increase Z% value memory by 374 to 9216 (8192+1024).
2016-12-10 19:50:40 +03:00
IF T$="(" OR T$=")" OR T$="[" OR T$="]" OR T$="{" OR T$="}" OR T$="'" OR T$="`" OR T$="@" THEN RETURN
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
GOSUB PEEK_CHAR: REM peek at next character
IF T$="~" AND C$<>"@" THEN RETURN
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
S1=0:S2=0: REM S1: INSTRING?, S2: ESCAPED?
Basic: reduce memory usage by 614 bytes. - combine some lines - remove some unnecessary spaces and parens - add string allocations to single routine in types Also: - remove blank lines in qb2cbm.sh output (does not save memory)
2016-09-21 05:11:46 +03:00
IF T$=CHR$(34) THEN S1=1
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
READ_TOKEN_LOOP:
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
GOSUB PEEK_CHAR: REM peek at next character
IF C$="" THEN RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
IF S1 THEN GOTO READ_TOKEN_CONT
Basic: more memory savings - Do the pop of CALL return value at the end of the subroutine (callee) rather than at the call point (caller) - shorten some character variables (CH$->C$, CH->C) - remove spaces after OPEN, GET - print REPL header directly in BASIC code Together saves 404 bytes of memory.
2016-11-03 07:36:44 +03:00
IF C$=" " OR C$="," OR C$=CHR$(13) OR C$=CHR$(10) THEN RETURN
IF C$="(" OR C$=")" OR C$="[" OR C$="]" OR C$="{" OR C$="}" THEN RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
READ_TOKEN_CONT:
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
GOSUB READ_CHAR
Basic: more memory savings - Do the pop of CALL return value at the end of the subroutine (callee) rather than at the call point (caller) - shorten some character variables (CH$->C$, CH->C) - remove spaces after OPEN, GET - print REPL header directly in BASIC code Together saves 404 bytes of memory.
2016-11-03 07:36:44 +03:00
T$=T$+C$
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
IF T$="~@" THEN RETURN
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
IF S1=0 OR S2=1 THEN S2=0:GOTO READ_TOKEN_LOOP
REM S1=1 (INSTRING?) and S2=0 (not ESCAPED?)
IF C$=CHR$(92) THEN S2=1
IF C$=CHR$(34) THEN RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
GOTO READ_TOKEN_LOOP
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
REM READ_CHAR(A$, RI) -> C$
READ_CHAR:
RJ=1:GOSUB DO_READ_CHAR
RETURN
REM PEEK_CHAR(A$, RI) -> C$
PEEK_CHAR:
RJ=0:GOSUB DO_READ_CHAR
RETURN
REM DO_READ_CHAR(RJ, A$, RI):
REM - RI is position in A$
REM - RJ=1 is read, RJ=0 is peek
DO_READ_CHAR:
C$=""
IF RF>0 THEN GOTO READ_FILE_CHAR
IF RI<=LEN(A$) THEN C$=MID$(A$,RI,1):RI=RI+RJ
RETURN
REM READ_FILE_CHAR(RJ) -> C$
REM - RJ=1 is read, RJ=0 is peek
REM - D$ is global used for already read pending character
REM - EZ is global used for end of file state
READ_FILE_CHAR:
IF D$<>"" THEN C$=D$:IF RJ=0 THEN RETURN
IF D$<>"" AND RJ=1 THEN D$="":RETURN
D$=""
IF EZ>2 THEN C$=""
IF EZ=2 THEN C$=")"
IF EZ=1 THEN C$=CHR$(10)
IF EZ>0 THEN EZ=EZ+RJ:RETURN
#cbm GET#2,C$
#qbasic C$=INPUT$(1,2)
#qbasic IF EOF(2) THEN EZ=1:RETURN
IF RJ=0 THEN D$=C$
#cbm IF (ST AND 64) THEN EZ=1:RETURN
#cbm IF (ST AND 255) THEN EZ=1:ER=-1:E$="File read error"+STR$(ST)
RETURN
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
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
SKIP_SPACES:
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
GOSUB PEEK_CHAR: REM peek at next character
IF C$=" " OR C$="," OR C$=CHR$(13) OR C$=CHR$(10) THEN GOSUB READ_CHAR:GOTO SKIP_SPACES
RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +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
SKIP_TO_EOL:
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
GOSUB READ_CHAR
Basic: more memory savings - Do the pop of CALL return value at the end of the subroutine (callee) rather than at the call point (caller) - shorten some character variables (CH$->C$, CH->C) - remove spaces after OPEN, GET - print REPL header directly in BASIC code Together saves 404 bytes of memory.
2016-11-03 07:36:44 +03:00
IF C$="" OR C$=CHR$(13) OR C$=CHR$(10) THEN RETURN
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
GOTO SKIP_TO_EOL
Basic: step1 basics.
2016-09-05 04:42:50 +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
REM READ_FORM(A$, RI, RF) -> R
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
SUB READ_FORM
Q=T:GOSUB PUSH_Q: REM save current value of T
READ_FORM_RECUR:
IF ER<>-2 THEN GOTO READ_FORM_RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
GOSUB READ_TOKEN
Basic: reduce memory usage by 614 bytes. - combine some lines - remove some unnecessary spaces and parens - add string allocations to single routine in types Also: - remove blank lines in qb2cbm.sh output (does not save memory)
2016-09-21 05:11:46 +03:00
REM PRINT "READ_FORM T$: ["+T$+"]"
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 T$="" THEN R=0:GOSUB INC_REF_R:GOTO READ_FORM_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
IF T$="nil" THEN T=0:GOTO READ_NIL_BOOL
IF T$="false" THEN T=1:GOTO READ_NIL_BOOL
IF T$="true" THEN T=2:GOTO READ_NIL_BOOL
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
IF T$="'" THEN B$="quote":GOTO READ_MACRO
IF T$="`" THEN B$="quasiquote":GOTO READ_MACRO
IF T$="~" THEN B$="unquote":GOTO READ_MACRO
IF T$="~@" THEN B$="splice-unquote":GOTO READ_MACRO
IF T$="^" THEN B$="with-meta":GOTO READ_MACRO
IF T$="@" THEN B$="deref":GOTO READ_MACRO
Basic: more memory savings - Do the pop of CALL return value at the end of the subroutine (callee) rather than at the call point (caller) - shorten some character variables (CH$->C$, CH->C) - remove spaces after OPEN, GET - print REPL header directly in BASIC code Together saves 404 bytes of memory.
2016-11-03 07:36:44 +03:00
C$=MID$(T$,1,1)
REM PRINT "C$: ["+C$+"]("+STR$(ASC(C$))+")"
IF C$>="0" AND C$<="9" THEN GOTO READ_NUMBER
IF C$="-" THEN GOTO READ_SYMBOL_MAYBE
IF C$=CHR$(34) THEN GOTO READ_STRING
IF C$=":" THEN GOTO READ_KEYWORD
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 set end character in Q and read the sequence
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
IF C$="(" THEN T=6:Q=41:GOTO READ_SEQ_START: REM ")"
IF C$="[" THEN T=7:Q=93:GOTO READ_SEQ_START: REM "]"
IF C$="{" THEN T=8:Q=125:GOTO READ_SEQ_START: REM "}"
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 C$=")" OR C$="]" OR C$="}" THEN R=-1:ER=-1:E$="unexpected "+C$:GOTO READ_FORM_RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
GOTO READ_SYMBOL
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
READ_NIL_BOOL:
REM PRINT "READ_NIL_BOOL"
Basic: refactor memory layout. Use a one dimensional array for the Z% value array. This enables lists, vectors, environments and metadata pointers to all save off 1 word (2 bytes) of space. Split the memory init and functions into mem.in.bas. In addition, change type 14 to be metdata rather than any type 16-31. This change saves about 560 bytes (no second array dimension subscripts) and reduces Z% value usage by 10%-15%. Bump the number of Z% words by 200 (to 8591). This enables self-hosting up to step7 (without step8-stepA functions in core.mal).
2016-11-18 09:54:04 +03:00
R=T*2
Basic: miscellaneous memory savings. - Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively. - Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R - Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31) respectively. - Inline NATIVE_FUNCTION and MAL_FUNCTION. All together saves over 500 bytes so increase Z% value memory by 250 entries.
2016-11-19 08:51:33 +03:00
GOSUB INC_REF_R
Basic: 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
GOTO READ_FORM_RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
READ_NUMBER:
REM PRINT "READ_NUMBER"
Basic: smarter ALLOC. Keywords. Vector fixes. - Modify ALLOC to take a type (rather than size) and take default values to set for the 1-3 values/pointers. Let alloc do the ownership taking of the referred values when appropriate. - Add FORCE_SEQ_TYPE function to coerce sequence to given type. Fixes apply and rest on vector. Simplifies concat. - Use a double ON GOTO structure for calling the native functions in DO_FUNCTION. - Add some stub core functions. - Move CHECK_FREE_LIST to debug.in.bas - All changes together save over 1K
2016-10-15 07:48:03 +03:00
T=2:L=VAL(T$):GOSUB ALLOC
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
GOTO READ_FORM_RETURN
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
READ_MACRO:
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 push macro type
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=-1*(T$="^"):GOSUB PUSH_Q
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: 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 B$ is set above
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
T=5:GOSUB STRING
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 push string
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: 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: 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
CALL READ_FORM
REM push first form
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: 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 ER>-2 THEN GOTO READ_MACRO_DONE
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: 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 PEEK_Q_2
Basic: move logic/release stack to $C000 Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y% access. Seems to be about the same performance (maybe a 5% performance hit at most). This gives us a larger stack (1920 2-byte words of $C000 rather than 200 words as before). The release stack at $CF00 stays the same size (64 4-byte addr/level entries). Also saves over 1K or program and array space. So take the opportunity to expand Z% entry space from 3712 to 3950.
2016-11-05 05:46:45 +03:00
IF Q THEN GOTO READ_MACRO_3
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
READ_MACRO_2:
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:B=Q
GOSUB PEEK_Q:A=Q
GOSUB LIST2
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
GOTO READ_MACRO_DONE
READ_MACRO_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
CALL READ_FORM
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:C=Q
B=R
GOSUB PEEK_Q:A=Q
GOSUB LIST3
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
AY=C: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
READ_MACRO_DONE:
REM release values, list has ownership
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
AY=B:GOSUB RELEASE
AY=A: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
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 pop the stack
GOSUB POP_Q: REM pop first form
GOSUB POP_Q: REM pop string
GOSUB POP_Q: REM pop macro type
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
T$="": REM necessary to prevent unexpected EOF errors
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
GOTO READ_FORM_RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
READ_STRING:
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 PRINT "READ_STRING"
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
C=ASC(MID$(T$,LEN(T$),1))
Error on unterminated strings. Add a step1 test to make sure that implementations are properly throwing an error on unclosed strings. Fix 47 implementations and update the guide to note the correct behavior.
2019-01-24 21:40:36 +03:00
IF C<>34 THEN R=-1:ER=-1:E$="expected '"+CHR$(34)+"', got EOF":GOTO READ_FORM_RETURN
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
R$=MID$(T$,2,LEN(T$)-2)
Fix unescaping in bash, basic, es6, js, ruby, rust.
2017-09-26 17:12:29 +03:00
S1$=CHR$(92)+CHR$(92):S2$=CHR$(127):GOSUB REPLACE: REM protect backslashes
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
S1$=CHR$(92)+CHR$(34):S2$=CHR$(34):GOSUB REPLACE: REM unescape quotes
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 S1$=CHR$(92)+"n":S2$=CHR$(13):GOSUB REPLACE: REM unescape newlines
#qbasic S1$=CHR$(92)+"n":S2$=CHR$(10):GOSUB REPLACE: REM unescape newlines
Fix unescaping in bash, basic, es6, js, ruby, rust.
2017-09-26 17:12:29 +03:00
S1$=CHR$(127):S2$=CHR$(92):GOSUB REPLACE: REM unescape backslashes
Basic: most of step4.
2016-09-12 05:36:15 +03:00
REM intern string value
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
B$=R$:T=4:GOSUB STRING
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
GOTO READ_FORM_RETURN
Basic: smarter ALLOC. Keywords. Vector fixes. - Modify ALLOC to take a type (rather than size) and take default values to set for the 1-3 values/pointers. Let alloc do the ownership taking of the referred values when appropriate. - Add FORCE_SEQ_TYPE function to coerce sequence to given type. Fixes apply and rest on vector. Simplifies concat. - Use a double ON GOTO structure for calling the native functions in DO_FUNCTION. - Add some stub core functions. - Move CHECK_FREE_LIST to debug.in.bas - All changes together save over 1K
2016-10-15 07:48:03 +03:00
READ_KEYWORD:
R$=CHR$(127)+MID$(T$,2,LEN(T$)-1)
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
B$=R$:T=4:GOSUB STRING
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
GOTO READ_FORM_RETURN
Basic: step2 basics. Vectors and hash-maps. Adjust step2 tests to keep values within 2 byte int range.
2016-09-11 06:13:27 +03:00
READ_SYMBOL_MAYBE:
Basic: more memory savings - Do the pop of CALL return value at the end of the subroutine (callee) rather than at the call point (caller) - shorten some character variables (CH$->C$, CH->C) - remove spaces after OPEN, GET - print REPL header directly in BASIC code Together saves 404 bytes of memory.
2016-11-03 07:36:44 +03:00
C$=MID$(T$,2,1)
IF C$>="0" AND C$<="9" THEN GOTO READ_NUMBER
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
READ_SYMBOL:
REM PRINT "READ_SYMBOL"
Basic: reduce variables. Fix func printing. - Save over 450 bytes. Bump up Z values by 128. - Fix function printing when function is embedded in something else by using strings storage as a stack while printing rather than using RR$ - Simplify some error messages and sanity checks in RELEASE.
2016-11-04 08:07:09 +03:00
B$=T$:T=5:GOSUB STRING
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
GOTO READ_FORM_RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +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
READ_SEQ_START:
SD=SD+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: 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 PUSH_Q: REM push return character
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: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
REM setup the stack for the loop, T has type
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 MAP_LOOP_START
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
READ_SEQ_LOOP:
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
REM TODO: reduce redundancy with READ_TOKEN
GOSUB SKIP_SPACES
GOSUB PEEK_CHAR: REM peek at next character
IF C$="" THEN ER=-1:E$="unexpected EOF":GOTO READ_SEQ_DONE
IF C$=";" THEN GOSUB SKIP_TO_EOL:GOTO READ_SEQ_LOOP
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=3:GOSUB PEEK_Q_Q
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
IF C$=CHR$(Q) THEN GOSUB READ_CHAR:GOTO READ_SEQ_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
CALL READ_FORM
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: REM value (or key for hash-maps)
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
IF ER<>-2 THEN AY=R:GOSUB RELEASE:GOTO READ_SEQ_DONE
REM if this is a hash-map, READ_FORM again
IF T=8 THEN GOSUB PUSH_R:CALL READ_FORM
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=R:GOSUB POP_Q:M=Q: REM set key and value
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 since list takes full ownership
C=1:GOSUB MAP_LOOP_UPDATE
GOTO READ_SEQ_LOOP
Basic: step1 basics.
2016-09-05 04:42:50 +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
READ_SEQ_DONE:
SD=SD-1
REM cleanup stack and get return value
GOSUB MAP_LOOP_DONE
Basic: step1 basics.
2016-09-05 04:42:50 +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
GOSUB POP_Q: REM pop end character ptr
GOTO READ_FORM_RETURN
Basic: step1 basics.
2016-09-05 04:42:50 +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
READ_FORM_RETURN:
GOSUB POP_Q:T=Q: REM restore current value of T
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
END SUB
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 READ_STR(A$) -> R
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
READ_STR:
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
RI=1: REM index into A$
RF=0: REM not reading from file
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
SD=0: REM sequence read depth
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
CALL READ_FORM
Basic: step1 basics.
2016-09-05 04:42:50 +03:00
RETURN
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
REM READ_FILE(A$) -> R
READ_FILE:
RF=1: REM reading from file
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
EZ=0: REM file read state (1: EOF)
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
SD=0: REM sequence read depth
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
D$="": REM pending read/peek character
Basic: add QBasic support. make MODE=qbasic stepA_mal.bas qb64 stepA_mal.bas
2016-10-31 03:15:24 +03:00
#cbm OPEN 2,8,0,A$
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
#qbasic IF NOT _FILEEXISTS(A$) THEN ER=-1:E$="File not found":RETURN
Basic: add QBasic support. make MODE=qbasic stepA_mal.bas qb64 stepA_mal.bas
2016-10-31 03:15:24 +03:00
#qbasic OPEN A$ FOR INPUT AS #2
Basic: more efficient/correct file reader. - read one character at a time from the file instead of chunking it into the A$ string. - fix an overflow that was happening during reads of long forms.
2016-12-10 17:53:10 +03:00
REM READ_TOKEN adds "(do ... )"
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
CALL READ_FORM
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
CLOSE 2
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
EZ=0
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
RETURN
Reference in New Issue Copy Permalink