MORPH
SIGN IN SIGN UP
kanaka / mal UNCLAIMED

mal - Make a Lisp

0 0 0 Assembly
Normal View History Raw
bbc-basic: Specify the file name at the top of each library file. This means that they can be saved using "SAVE" without a filename, which will make tokenising them a little less painful. I haven't done this to the step files because those have "." in their canonical names, which turns into "/" on RISC OS, so there's no good name to put in the comment.
2019-04-20 01:33:31 +01:00
REM > types library for mal in BBC BASIC
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
REM This library should be the only thing that understands the
REM implementation of mal data types in BBC BASIC. All other
REM code should use routines in this library to access them.
REM As far as other code is concerned, a mal object is just an
REM opaque 32-bit integer, which might be a pointer, or might not.
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
REM All mal objects live in an array, Z%(), with string values held
REM in a parallel array, Z$(). There's one row in Z%(), and one
REM entry in Z$(), for each mal object.
bbc-basic: Reference-count strings in S$(). If it's going to be possible to free them, we need a way to tell whether a given entry is in use. Or we need a free list, which will also need an integer per entry.
2019-04-13 00:10:36 +01:00
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
REM Z%(x,0) holds the type of an object and other small amounts of
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
REM information. The bottom bit indicates the semantics of Z%(x,1):
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
REM &01 : Z%(x,1) is a pointer into Z%()
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
REM Z%(x,2) and Z%(x,3) are always pointers into Z%(), to 'nil' if nothing
REM else.
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
REM The &40 bit is used to distinguish empty lists, vectors and hash-maps.
REM The &80 bit distinguishes vectors from lists and macros from functions.
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
REM sS%() is a shadow stack, used to keep track of which mal values might
REM be referenced from local variables at a given depth of the BASIC call
REM stack. It grows upwards. sSP% points to the first unused word. sFP%
REM points to the start of the current shadow stack frame. The first word
REM of each shadow stack frame is the saved value of sFP%. The rest are
REM mal values.
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
REM Types are:
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
REM &00 nil
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
REM &04 boolean
REM &08 integer
REM &0C core function
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
REM &01 atom
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
REM &05 free block
REM &09 list/vector (each object is a cons cell)
REM &0D environment
REM &11 hash-map internal node
REM &15 mal function (first part)
REM &19 mal function (second part)
REM &02 string/keyword
REM &06 symbol
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
REM &0A hash-map leaf node
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
REM Formats of individual objects are defined below.
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
DEF PROCtypes_init
bbc-basic: Add comment explaining sizing of mal heap.
2019-05-28 20:47:13 +01:00
REM Mal's heap has to be statically dimensioned, but we also
REM need to leave enough space for BASIC's stack and heap.
REM The BASIC heap is where all strings live.
REM
REM Each row of Z%() consumes 16 bytes. The size of each entry
REM in Z$() varies by platform: 5 bytes in ARM BBC BASIC V,
REM 8 bytes in Brandy on a 32-bit system, 16 bytes in Brandy on
REM a 64-bit system.
bbc-basic: Slight tweak to heap size. Making the mal heap very slightly smaller allows the self-hosting test to complete on a 64-bit host. This is really not the right approach, though. I should really just give in and specify "-size 1024k" to Brandy, or have the GC somehow detect that we're wasting a lot of memory on strings and it should run early. At the moment, there's a tiny range of heap sizes that actually work.
2019-05-30 22:31:12 +01:00
DIM Z%((HIMEM-LOMEM)/110,3), Z$((HIMEM-LOMEM)/110)
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
DIM sS%((HIMEM-LOMEM)/64)
bbc-basic: Add comment explaining sizing of mal heap.
2019-05-28 20:47:13 +01:00
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
Z%(1,0) = &04 : REM false
Z%(2,0) = &04 : Z%(2,1) = TRUE : REM true
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
Z%(3,0) = &49 : Z%(3,1) = 3 : REM empty list
Z%(4,0) = &C9 : Z%(4,1) = 4 : REM empty vector
Z%(5,0) = &51 : REM empty hashmap
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
next_Z% = 6
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
sSP% = 1
sFP% = 0
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
F% = 0
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
ENDPROC
DEF FNtype_of(val%)
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
=Z%(val%,0) AND &1F
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
DEF PROCgc_enter
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT ;sFP%;
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
sS%(sSP%) = sFP%
sFP% = sSP%
sSP% += 1
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT " >>> ";sFP%
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
ENDPROC
bbc-basic: Rough mechanism for checking whether heap is empty on exit. Not actually useful yet, because no garbage collection.
2019-04-14 16:52:59 +01:00
bbc-basic: Make FNgc_save/PROCgc_restore more useful and less confusing. FNgc_save now creates a new stack frame, so PROCgc_restore precisely reverses the effect of FNgc_save (along with freeing any stack frames pushed since FNgc_save). This means it doesn't surprisingly destroy the current stack frame. This requires changes to each step file to adjust the REPL to these new semantics.
2019-05-03 22:57:56 +01:00
REM FNgc_save is equivalent to PROCgc_enter except that it returns a
REM value that can be passed to PROCgc_restore to pop all the stack
REM frames back to (and including) the one pushed by FNgc_save.
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
DEF FNgc_save
bbc-basic: Make FNgc_save/PROCgc_restore more useful and less confusing. FNgc_save now creates a new stack frame, so PROCgc_restore precisely reverses the effect of FNgc_save (along with freeing any stack frames pushed since FNgc_save). This means it doesn't surprisingly destroy the current stack frame. This requires changes to each step file to adjust the REPL to these new semantics.
2019-05-03 22:57:56 +01:00
PROCgc_enter
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
=sFP%
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
DEF PROCgc_exit
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT ;sS%(sFP%);" <<< ";sFP%
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
sSP% = sFP%
sFP% = sS%(sFP%)
bbc-basic: Rough mechanism for checking whether heap is empty on exit. Not actually useful yet, because no garbage collection.
2019-04-14 16:52:59 +01:00
ENDPROC
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
DEF PROCgc_restore(oldFP%)
sFP% = oldFP%
bbc-basic: Make FNgc_save/PROCgc_restore more useful and less confusing. FNgc_save now creates a new stack frame, so PROCgc_restore precisely reverses the effect of FNgc_save (along with freeing any stack frames pushed since FNgc_save). This means it doesn't surprisingly destroy the current stack frame. This requires changes to each step file to adjust the REPL to these new semantics.
2019-05-03 22:57:56 +01:00
REM PRINT "!!! FP reset"
PROCgc_exit
ENDPROC
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
DEF FNref_local(val%)
sS%(sSP%) = val%
sSP% += 1
=val%
DEF FNgc_exit(val%)
PROCgc_exit
bbc-basic: Make FNgc_save/PROCgc_restore more useful and less confusing. FNgc_save now creates a new stack frame, so PROCgc_restore precisely reverses the effect of FNgc_save (along with freeing any stack frames pushed since FNgc_save). This means it doesn't surprisingly destroy the current stack frame. This requires changes to each step file to adjust the REPL to these new semantics.
2019-05-03 22:57:56 +01:00
=FNref_local(val%)
DEF FNgc_restore(oldFP%, val%)
PROCgc_restore(oldFP%)
=FNref_local(val%)
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
bbc-basic: Make step 5 mostly work. It now has minimal shadow-stack handling to interface with the garbage collector. This involved adding a procedure to the garbage collector to tell it that only two values (ast% and val%) in the current stack frame are live, so the rest can usefully be collected.
2019-04-19 15:42:39 +01:00
DEF PROCgc_keep_only2(val1%, val2%)
PROCgc_exit
PROCgc_enter
val1% = FNref_local(val1%)
val2% = FNref_local(val2%)
ENDPROC
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
DEF FNmalloc(type%)
bbc-basic: Abstract out memory allocation into its own function. It's trivial at the moment, but it will doubtless get more complicated.
2019-04-06 00:54:30 +01:00
LOCAL val%
bbc-basic: Automatically run the garbage-collector when the heap is full. This means that it runs as rarely as possible, which is probably good.
2019-04-19 15:41:17 +01:00
REM If the heap is full, collect garbage first.
bbc-basic: Detect running out of heap memory. This happens when the garbage collector runs but frees no memory. Raising a polite error explains what happens and offers a theoretical possiblity of an application's recovering.
2019-05-17 00:58:15 +01:00
IF F% = 0 AND next_Z% > DIM(Z%(),1) THEN
PROCgc
IF F% = 0 ERROR &40E80950, "Out of mal heap memory"
ENDIF
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
IF F% <> 0 THEN
val% = F%
F% = Z%(val%,1)
ELSE
val% = next_Z%
next_Z% += 1
ENDIF
bbc-basic: Always use the same interpretation of the GC mark bit. We now always set it when marking and clear it when sweeping, rather than inverting it on each GC pass. This is slightly less confusing, and also means the code matches the description of naïve mark-and-sweep in Wikipedia.
2019-05-06 18:45:20 +01:00
Z%(val%,0) = type%
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
=FNref_local(val%)
bbc-basic: Abstract out memory allocation into its own function. It's trivial at the moment, but it will doubtless get more complicated.
2019-04-06 00:54:30 +01:00
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
DEF PROCfree(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
Z%(val%,0) = &05
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
Z%(val%,1) = F%
Z%(val%,2) = 0
Z%(val%,3) = 0
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
Z$(val%) = ""
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
F% = val%
ENDPROC
DEF PROCgc
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT "** START GC **"
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
PROCgc_markall
PROCgc_sweep
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT "** FINISH GC **"
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
ENDPROC
DEF PROCgc_markall
LOCAL sp%, fp%
fp% = sFP%
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT ">>marking...";
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
FOR sp% = sSP% - 1 TO 0 STEP -1
IF sp% = fp% THEN
fp% = sS%(sp%)
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT " / ";
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
ELSE PROCgc_mark(sS%(sp%))
ENDIF
NEXT sp%
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
ENDPROC
DEF PROCgc_mark(val%)
bbc-basic: Always use the same interpretation of the GC mark bit. We now always set it when marking and clear it when sweeping, rather than inverting it on each GC pass. This is slightly less confusing, and also means the code matches the description of naïve mark-and-sweep in Wikipedia.
2019-05-06 18:45:20 +01:00
IF (Z%(val%,0) AND &100) = 0 THEN
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT " ";val%;
bbc-basic: Always use the same interpretation of the GC mark bit. We now always set it when marking and clear it when sweeping, rather than inverting it on each GC pass. This is slightly less confusing, and also means the code matches the description of naïve mark-and-sweep in Wikipedia.
2019-05-06 18:45:20 +01:00
Z%(val%,0) += &100
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
IF (Z%(val%,0) AND &01) THEN PROCgc_mark(Z%(val%,1))
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
PROCgc_mark(Z%(val%,2))
bbc-basic: Metadata support, including 'meta' and 'with-meta'.
2019-05-12 23:49:51 +01:00
PROCgc_mark(Z%(val%,3))
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
ENDIF
ENDPROC
DEF PROCgc_sweep
LOCAL val%
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT ">>sweeping ...";
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
FOR val% = 6 TO next_Z% - 1
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
IF FNtype_of(val%) <> &05 AND (Z%(val%,0) AND &100) = 0 THEN
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT " ";val%;
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
PROCfree(val%)
bbc-basic: Always use the same interpretation of the GC mark bit. We now always set it when marking and clear it when sweeping, rather than inverting it on each GC pass. This is slightly less confusing, and also means the code matches the description of naïve mark-and-sweep in Wikipedia.
2019-05-06 18:45:20 +01:00
ELSE
Z%(val%,0) -= &100
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
ENDIF
NEXT val%
bbc-basic: Suppress debugging PRINT statements in the garbage collector. It seems to work properly now, but I'll keep them commented out in case it stops.
2019-04-19 15:44:18 +01:00
REM PRINT
bbc-basic: Rough but apparently functional garbage-collector in step 4. It's a fairly simple mark-and-sweep job, with a slighly mad arrangement for tracking values that _might_ be in BASIC variables. It's full of debugging PRINTs and assorted other unpleasantness, but it does seem to be working correctly, not leaking heap or shadow stack even in the face of errors, so I want to get it committed before I break it.
2019-04-18 22:40:33 +01:00
ENDPROC
bbc-basic: Metadata support, including 'meta' and 'with-meta'.
2019-05-12 23:49:51 +01:00
DEF FNmeta(val%)
=Z%(val%,3)
DEF FNwith_meta(val%, meta%)
LOCAL newval%
newval% = FNmalloc(Z%(val%,0))
Z%(newval%,1) = Z%(val%,1)
Z%(newval%,2) = Z%(val%,2)
Z%(newval%,3) = meta%
bbc-basic: Make metadata on string-like types work. The new string handling makes this simpler than forbidding it.
2019-05-26 13:36:39 +01:00
Z$(newval%) = Z$(val%)
bbc-basic: Metadata support, including 'meta' and 'with-meta'.
2019-05-12 23:49:51 +01:00
=newval%
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
REM ** Nil **
bbc-basic: Add support for reading and printing nil (deferred step 1 task).
2019-04-07 10:30:56 +01:00
DEF FNis_nil(val%)
=FNtype_of(val%) = 0
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
DEF FNnil
=0
bbc-basic: Support for reading and printing booleans (deferred step 1 task).
2019-04-07 11:01:11 +01:00
REM ** Boolean **
bbc-basic: Simplify booleans. They now contain TRUE and FALSE so that FNunbox_boolean can just extract the value.
2019-04-12 23:38:30 +01:00
REM Z%(x,1) = TRUE or FALSE
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
bbc-basic: Support for reading and printing booleans (deferred step 1 task).
2019-04-07 11:01:11 +01:00
DEF FNis_boolean(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &04
bbc-basic: Support for reading and printing booleans (deferred step 1 task).
2019-04-07 11:01:11 +01:00
DEF FNalloc_boolean(bval%)
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
IF bval% THEN =2
=1
bbc-basic: Support for reading and printing booleans (deferred step 1 task).
2019-04-07 11:01:11 +01:00
DEF FNunbox_boolean(val%)
bbc-basic: Use distinct error numbers for all errors. This is an improvement on always using error 1 ("Out of range"). Mal's error numbers are taken from a random block in the range suggested by the RISC OS Programmer's Reference Manual for use by applications.
2019-04-07 11:02:20 +01:00
IF NOT FNis_boolean(val%) THEN ERROR &40E80911, "Not a boolean"
bbc-basic: Simplify booleans. They now contain TRUE and FALSE so that FNunbox_boolean can just extract the value.
2019-04-12 23:38:30 +01:00
=Z%(val%,1)
bbc-basic: Support for reading and printing booleans (deferred step 1 task).
2019-04-07 11:01:11 +01:00
bbc-basic: Add "do" and "if" special forms (first part of step 4).
2019-04-07 22:27:28 +01:00
DEF FNis_truish(val%)
IF FNis_nil(val%) THEN =FALSE
bbc-basic: Simplify booleans. They now contain TRUE and FALSE so that FNunbox_boolean can just extract the value.
2019-04-12 23:38:30 +01:00
IF FNis_boolean(val%) THEN =FNunbox_boolean(val%)
bbc-basic: Add "do" and "if" special forms (first part of step 4).
2019-04-07 22:27:28 +01:00
=TRUE
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
REM ** Integers **
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
REM Z%(x,1) = integer value
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
DEF FNis_int(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &08
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
DEF FNalloc_int(ival%)
LOCAL val%
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
val% = FNmalloc(&08)
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
Z%(val%,1) = ival%
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
=val%
DEF FNunbox_int(val%)
bbc-basic: Use distinct error numbers for all errors. This is an improvement on always using error 1 ("Out of range"). Mal's error numbers are taken from a random block in the range suggested by the RISC OS Programmer's Reference Manual for use by applications.
2019-04-07 11:02:20 +01:00
IF NOT FNis_int(val%) THEN ERROR &40E80912, "Not an integer"
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
=Z%(val%,1)
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
bbc-basic: Add minimal support for keywords (deferred from step 1). They're implemented as prefixed strings, as suggested by the guide.
2019-05-04 21:02:09 +01:00
REM ** Strings and keywords **
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
REM Z$(x) is the string value
REM Z%(x,2) points to the next part of the string
bbc-basic: Add minimal support for keywords (deferred from step 1). They're implemented as prefixed strings, as suggested by the guide.
2019-05-04 21:02:09 +01:00
REM A keyword is a string with first character CHR$(127).
bbc-basic: Add string support (deferred from step 1). Strings are internally like symbols, but with special reading and printing rules. This will serve until we need strings over 255 characters long (the longest that ARM BBC BASIC V can handle natively).
2019-04-20 13:44:12 +01:00
DEF FNis_string(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &02
bbc-basic: Add string support (deferred from step 1). Strings are internally like symbols, but with special reading and printing rules. This will serve until we need strings over 255 characters long (the longest that ARM BBC BASIC V can handle natively).
2019-04-20 13:44:12 +01:00
DEF FNalloc_string(sval$)
LOCAL val%
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
val% = FNmalloc(&02)
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
Z$(val%) = sval$
bbc-basic: Add string support (deferred from step 1). Strings are internally like symbols, but with special reading and printing rules. This will serve until we need strings over 255 characters long (the longest that ARM BBC BASIC V can handle natively).
2019-04-20 13:44:12 +01:00
=val%
DEF FNunbox_string(val%)
IF NOT FNis_string(val%) THEN ERROR &40E80914, "Not a string"
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
IF NOT FNis_nil(Z%(val%,2)) ERROR &40E80914, "Cannot unbox a long string"
=Z$(val%)
bbc-basic: Add string support (deferred from step 1). Strings are internally like symbols, but with special reading and printing rules. This will serve until we need strings over 255 characters long (the longest that ARM BBC BASIC V can handle natively).
2019-04-20 13:44:12 +01:00
bbc-basic: Clean up long-string support. When I first implemented support for strings over 255 characters long, I did so quite crudely, and the procedures to construct long strings modified the mal objects passed into them. This was unfortunate: no other routine (apart from PROCatom_reset, of course) modified an object in the mal heap after it had escaped from the "types" library. It also led to quite a few annoying bugs. This is now fixed: all routines that modify long strings now return a new object as necessary, and leave the arguments unchanged. This is probably rather slower than the old code, but it's also much cleaner.
2019-05-27 12:51:20 +01:00
DEF FNstring_append(val%, add$)
LOCAL newval%
bbc-basic: Support strings longer than the underlying interpreter allows. Brandy supports strings up to 65536 characters long, but ARM BBC BASIC V only allows strings up to 255 characters. Mal needs strings longer than 255 characters, so we implement them by chaining together several strings in S$() to make one logical string from mal's point of view. This has entailed far-reaching changes as lots of routines that used to take BASIC strings (especially in the reader/printer area) now have to take references to mal strings instead. There are still a lot of places that don't, though, so you can't use long strings as hash-map keys, for instance. This commit passes all the tests, but I wouldn't be surprised if there are still bugs lurking somewhere.
2019-05-18 22:28:13 +01:00
IF NOT FNis_string(val%) THEN ERROR &40E80914, "Not a string"
bbc-basic: Clean up long-string support. When I first implemented support for strings over 255 characters long, I did so quite crudely, and the procedures to construct long strings modified the mal objects passed into them. This was unfortunate: no other routine (apart from PROCatom_reset, of course) modified an object in the mal heap after it had escaped from the "types" library. It also led to quite a few annoying bugs. This is now fixed: all routines that modify long strings now return a new object as necessary, and leave the arguments unchanged. This is probably rather slower than the old code, but it's also much cleaner.
2019-05-27 12:51:20 +01:00
newval% = FNalloc_string(Z$(val%))
IF FNis_nil(Z%(val%,2)) THEN
IF LEN(Z$(newval%)) + LEN(add$) <= 255 THEN
Z$(newval%) += add$
ELSE
Z%(newval%,2) = FNalloc_string(add$)
ENDIF
bbc-basic: Support strings longer than the underlying interpreter allows. Brandy supports strings up to 65536 characters long, but ARM BBC BASIC V only allows strings up to 255 characters. Mal needs strings longer than 255 characters, so we implement them by chaining together several strings in S$() to make one logical string from mal's point of view. This has entailed far-reaching changes as lots of routines that used to take BASIC strings (especially in the reader/printer area) now have to take references to mal strings instead. There are still a lot of places that don't, though, so you can't use long strings as hash-map keys, for instance. This commit passes all the tests, but I wouldn't be surprised if there are still bugs lurking somewhere.
2019-05-18 22:28:13 +01:00
ELSE
bbc-basic: Clean up long-string support. When I first implemented support for strings over 255 characters long, I did so quite crudely, and the procedures to construct long strings modified the mal objects passed into them. This was unfortunate: no other routine (apart from PROCatom_reset, of course) modified an object in the mal heap after it had escaped from the "types" library. It also led to quite a few annoying bugs. This is now fixed: all routines that modify long strings now return a new object as necessary, and leave the arguments unchanged. This is probably rather slower than the old code, but it's also much cleaner.
2019-05-27 12:51:20 +01:00
Z%(newval%,2) = FNstring_append(Z%(val%,2), add$)
bbc-basic: Support strings longer than the underlying interpreter allows. Brandy supports strings up to 65536 characters long, but ARM BBC BASIC V only allows strings up to 255 characters. Mal needs strings longer than 255 characters, so we implement them by chaining together several strings in S$() to make one logical string from mal's point of view. This has entailed far-reaching changes as lots of routines that used to take BASIC strings (especially in the reader/printer area) now have to take references to mal strings instead. There are still a lot of places that don't, though, so you can't use long strings as hash-map keys, for instance. This commit passes all the tests, but I wouldn't be surprised if there are still bugs lurking somewhere.
2019-05-18 22:28:13 +01:00
ENDIF
bbc-basic: Clean up long-string support. When I first implemented support for strings over 255 characters long, I did so quite crudely, and the procedures to construct long strings modified the mal objects passed into them. This was unfortunate: no other routine (apart from PROCatom_reset, of course) modified an object in the mal heap after it had escaped from the "types" library. It also led to quite a few annoying bugs. This is now fixed: all routines that modify long strings now return a new object as necessary, and leave the arguments unchanged. This is probably rather slower than the old code, but it's also much cleaner.
2019-05-27 12:51:20 +01:00
=newval%
bbc-basic: Support strings longer than the underlying interpreter allows. Brandy supports strings up to 65536 characters long, but ARM BBC BASIC V only allows strings up to 255 characters. Mal needs strings longer than 255 characters, so we implement them by chaining together several strings in S$() to make one logical string from mal's point of view. This has entailed far-reaching changes as lots of routines that used to take BASIC strings (especially in the reader/printer area) now have to take references to mal strings instead. There are still a lot of places that don't, though, so you can't use long strings as hash-map keys, for instance. This commit passes all the tests, but I wouldn't be surprised if there are still bugs lurking somewhere.
2019-05-18 22:28:13 +01:00
bbc-basic: Clean up long-string support. When I first implemented support for strings over 255 characters long, I did so quite crudely, and the procedures to construct long strings modified the mal objects passed into them. This was unfortunate: no other routine (apart from PROCatom_reset, of course) modified an object in the mal heap after it had escaped from the "types" library. It also led to quite a few annoying bugs. This is now fixed: all routines that modify long strings now return a new object as necessary, and leave the arguments unchanged. This is probably rather slower than the old code, but it's also much cleaner.
2019-05-27 12:51:20 +01:00
DEF FNstring_concat(val%, add%)
bbc-basic: Fix accidental quadratic behaviour in string handling. The code for constructing long strings in FNstring_concat and 'slurp' was accidentally quadratic in the size of output. This meant that it consumed BASIC heap space in inordinate quantities for storing strings. Mal doesn't monitor the usage of the BASIC heap, so it didn't run the garbage collector and instead suffered a fatal error. Making these functions use sane amounts of memory avoids that problem.
2019-05-27 22:51:09 +01:00
LOCAL newval%
bbc-basic: Support strings longer than the underlying interpreter allows. Brandy supports strings up to 65536 characters long, but ARM BBC BASIC V only allows strings up to 255 characters. Mal needs strings longer than 255 characters, so we implement them by chaining together several strings in S$() to make one logical string from mal's point of view. This has entailed far-reaching changes as lots of routines that used to take BASIC strings (especially in the reader/printer area) now have to take references to mal strings instead. There are still a lot of places that don't, though, so you can't use long strings as hash-map keys, for instance. This commit passes all the tests, but I wouldn't be surprised if there are still bugs lurking somewhere.
2019-05-18 22:28:13 +01:00
IF NOT FNis_string(val%) THEN ERROR &40E80914, "Not a string"
IF NOT FNis_string(add%) THEN ERROR &40E80914, "Not a string"
bbc-basic: Fix accidental quadratic behaviour in string handling. The code for constructing long strings in FNstring_concat and 'slurp' was accidentally quadratic in the size of output. This meant that it consumed BASIC heap space in inordinate quantities for storing strings. Mal doesn't monitor the usage of the BASIC heap, so it didn't run the garbage collector and instead suffered a fatal error. Making these functions use sane amounts of memory avoids that problem.
2019-05-27 22:51:09 +01:00
newval% = FNalloc_string(Z$(val%))
IF FNis_nil(Z%(val%,2)) THEN
IF LEN(Z$(newval%)) + LEN(Z$(add%)) <= 255 THEN
Z$(newval%) += Z$(add%)
Z%(newval%,2) = Z%(add%,2)
ELSE
Z%(newval%,2) = add%
ENDIF
ELSE
Z%(newval%,2) = FNstring_concat(Z%(val%,2), add%)
ENDIF
=newval%
bbc-basic: Support strings longer than the underlying interpreter allows. Brandy supports strings up to 65536 characters long, but ARM BBC BASIC V only allows strings up to 255 characters. Mal needs strings longer than 255 characters, so we implement them by chaining together several strings in S$() to make one logical string from mal's point of view. This has entailed far-reaching changes as lots of routines that used to take BASIC strings (especially in the reader/printer area) now have to take references to mal strings instead. There are still a lot of places that don't, though, so you can't use long strings as hash-map keys, for instance. This commit passes all the tests, but I wouldn't be surprised if there are still bugs lurking somewhere.
2019-05-18 22:28:13 +01:00
DEF FNstring_len(val%)
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
LOCAL len%
WHILE NOT FNis_nil(val%)
len% += LEN(Z$(val%))
val% = Z%(val%,2)
bbc-basic: Support strings longer than the underlying interpreter allows. Brandy supports strings up to 65536 characters long, but ARM BBC BASIC V only allows strings up to 255 characters. Mal needs strings longer than 255 characters, so we implement them by chaining together several strings in S$() to make one logical string from mal's point of view. This has entailed far-reaching changes as lots of routines that used to take BASIC strings (especially in the reader/printer area) now have to take references to mal strings instead. There are still a lot of places that don't, though, so you can't use long strings as hash-map keys, for instance. This commit passes all the tests, but I wouldn't be surprised if there are still bugs lurking somewhere.
2019-05-18 22:28:13 +01:00
ENDWHILE
=len%
DEF FNstring_chr(val%, pos%)
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
WHILE pos% > LEN(Z$(val%))
pos% -= LEN(Z$(val%))
val% = Z%(val%,2)
IF FNis_nil(val%) THEN =""
bbc-basic: Support strings longer than the underlying interpreter allows. Brandy supports strings up to 65536 characters long, but ARM BBC BASIC V only allows strings up to 255 characters. Mal needs strings longer than 255 characters, so we implement them by chaining together several strings in S$() to make one logical string from mal's point of view. This has entailed far-reaching changes as lots of routines that used to take BASIC strings (especially in the reader/printer area) now have to take references to mal strings instead. There are still a lot of places that don't, though, so you can't use long strings as hash-map keys, for instance. This commit passes all the tests, but I wouldn't be surprised if there are still bugs lurking somewhere.
2019-05-18 22:28:13 +01:00
ENDWHILE
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
=MID$(Z$(val%), pos%, 1)
bbc-basic: Support strings longer than the underlying interpreter allows. Brandy supports strings up to 65536 characters long, but ARM BBC BASIC V only allows strings up to 255 characters. Mal needs strings longer than 255 characters, so we implement them by chaining together several strings in S$() to make one logical string from mal's point of view. This has entailed far-reaching changes as lots of routines that used to take BASIC strings (especially in the reader/printer area) now have to take references to mal strings instead. There are still a lot of places that don't, though, so you can't use long strings as hash-map keys, for instance. This commit passes all the tests, but I wouldn't be surprised if there are still bugs lurking somewhere.
2019-05-18 22:28:13 +01:00
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
REM ** Symbols **
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
REM Z$(x) = value of the symbol
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
DEF FNis_symbol(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &06
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
DEF FNalloc_symbol(sval$)
bbc-basic: Factor out string allocation into its own function.
2019-04-11 00:08:56 +01:00
LOCAL val%
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
val% = FNmalloc(&06)
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
Z$(val%) = sval$
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
=val%
DEF FNunbox_symbol(val%)
bbc-basic: Use distinct error numbers for all errors. This is an improvement on always using error 1 ("Out of range"). Mal's error numbers are taken from a random block in the range suggested by the RISC OS Programmer's Reference Manual for use by applications.
2019-04-07 11:02:20 +01:00
IF NOT FNis_symbol(val%) THEN ERROR &40E80915, "Not a symbol"
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
=Z$(val%)
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
REM ** Lists and vectors **
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
REM Lists and vectors are both represented as linked lists: the only
REM difference is in the state of the is_vector flag in the head cell
REM of the list. Note that this means that the tail of a list may be
REM a vector, and vice versa. FNas_list and FNas_vector can be used
REM to convert a sequence to a particular type as necessary.
REM Z%(x,0) AND &80 = is_vector flag
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
REM Z%(x,1) = index in Z%() of next pair
REM Z%(x,2) = index in Z%() of first element
bbc-basic: Simplify 'first' and 'rest'. Rather than special-casing the empty list/vector, arrange that the dedicated empty list/vector objects have the correct values in their first and rest pointers. Still dithering about whether to do that to 'nil' as well. This does mean that the internal FNfirst and FNrest don't error on an empty list any more. Nothing should have depended on that, but it might mask some bugs.
2019-05-13 23:06:12 +01:00
REM The empty list is a distinguished value, with elements that match
REM the spec of 'first' and 'rest'.
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
DEF FNempty
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
=3
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
DEF FNempty_vector
=4
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
DEF FNalloc_pair(car%, cdr%)
LOCAL val%
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
val% = FNmalloc(&09)
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
Z%(val%,2) = car%
Z%(val%,1) = cdr%
=val%
bbc-basic: Rough mechanism for checking whether heap is empty on exit. Not actually useful yet, because no garbage collection.
2019-04-14 16:52:59 +01:00
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
DEF FNalloc_vector_pair(car%, cdr%)
LOCAL val%
val% = FNalloc_pair(car%, cdr%)
bbc-basic: Extend vector support throughout steps 2 to 9.
2019-05-05 23:52:31 +01:00
Z%(val%,0) = Z%(val%,0) OR &80
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
=val%
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
DEF FNis_empty(val%)
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
=(Z%(val%,0) AND &40) = &40
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
bbc-basic: Extend vector support throughout steps 2 to 9.
2019-05-05 23:52:31 +01:00
DEF FNis_seq(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &09
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
bbc-basic: Extend vector support throughout steps 2 to 9.
2019-05-05 23:52:31 +01:00
DEF FNis_list(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &09 AND (Z%(val%, 0) AND &80) = &00
bbc-basic: Extend vector support throughout steps 2 to 9.
2019-05-05 23:52:31 +01:00
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
DEF FNis_vector(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &09 AND (Z%(val%, 0) AND &80) = &80
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
DEF FNas_list(val%)
bbc-basic: Extend vector support throughout steps 2 to 9.
2019-05-05 23:52:31 +01:00
IF FNis_list(val%) THEN =val%
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
IF FNis_empty(val%) THEN =FNempty
bbc-basic: Rename list-manipulating functions to match their mal counterparts. FNlist_car becomes FNfirst FNlist_cdr becomes FNrest FNlist_nth becomes FNnth FNlist_len becomes FNcount This makes out terminology more mal-ish, and also avoids mentioning lists in the names of functions that also work on vectors. Note that in edge cases (empty sequences, nil), these functions don't quite have their mal semantics, so the core library still does some remapping.
2019-05-06 12:00:25 +01:00
=FNalloc_pair(FNfirst(val%), FNrest(val%))
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
DEF FNas_vector(val%)
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
IF FNis_vector(val%) THEN =val%
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
IF FNis_empty(val%) THEN =FNempty_vector
bbc-basic: Rename list-manipulating functions to match their mal counterparts. FNlist_car becomes FNfirst FNlist_cdr becomes FNrest FNlist_nth becomes FNnth FNlist_len becomes FNcount This makes out terminology more mal-ish, and also avoids mentioning lists in the names of functions that also work on vectors. Note that in edge cases (empty sequences, nil), these functions don't quite have their mal semantics, so the core library still does some remapping.
2019-05-06 12:00:25 +01:00
=FNalloc_vector_pair(FNfirst(val%), FNrest(val%))
bbc-basic: Minimal support for vectors (read/print only, deferred from step 1). A vector is just a list in a silly hat, or more precisely a special flag in its head cell. This means that all the list functions work on vectors as well, but it may be necessary to rename them in order to avoid confusion, since at least FNis_list needs to be more specific in order for FNEVAL to work properly.
2019-05-05 13:36:21 +01:00
bbc-basic: Rename list-manipulating functions to match their mal counterparts. FNlist_car becomes FNfirst FNlist_cdr becomes FNrest FNlist_nth becomes FNnth FNlist_len becomes FNcount This makes out terminology more mal-ish, and also avoids mentioning lists in the names of functions that also work on vectors. Note that in edge cases (empty sequences, nil), these functions don't quite have their mal semantics, so the core library still does some remapping.
2019-05-06 12:00:25 +01:00
DEF FNfirst(val%)
bbc-basic: Extend vector support throughout steps 2 to 9.
2019-05-05 23:52:31 +01:00
IF NOT FNis_seq(val%) THEN ERROR &40E80916, "Can't get car of non-sequence"
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
=FNref_local(Z%(val%,2))
bbc-basic: Minimal step 1.
2019-03-31 22:44:13 +01:00
bbc-basic: Rename list-manipulating functions to match their mal counterparts. FNlist_car becomes FNfirst FNlist_cdr becomes FNrest FNlist_nth becomes FNnth FNlist_len becomes FNcount This makes out terminology more mal-ish, and also avoids mentioning lists in the names of functions that also work on vectors. Note that in edge cases (empty sequences, nil), these functions don't quite have their mal semantics, so the core library still does some remapping.
2019-05-06 12:00:25 +01:00
DEF FNrest(val%)
bbc-basic: Extend vector support throughout steps 2 to 9.
2019-05-05 23:52:31 +01:00
IF NOT FNis_seq(val%) THEN ERROR &40E80916, "Can't get cdr of non-sequence"
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
=FNref_local(Z%(val%,1))
bbc-basic: Add a hashmap type. Since I don't have mal strings yet, the keys are just native BASIC strings.
2019-04-06 11:25:40 +01:00
bbc-basic: Implement 'concat' and 'quasiquote'. Step 7 done.
2019-04-28 10:41:10 +01:00
DEF FNalloc_list2(val0%, val1%)
=FNalloc_pair(val0%, FNalloc_pair(val1%, FNempty))
DEF FNalloc_list3(val0%, val1%, val2%)
=FNalloc_pair(val0%, FNalloc_pair(val1%, FNalloc_pair(val2%, FNempty)))
bbc-basic: Rename list-manipulating functions to match their mal counterparts. FNlist_car becomes FNfirst FNlist_cdr becomes FNrest FNlist_nth becomes FNnth FNlist_len becomes FNcount This makes out terminology more mal-ish, and also avoids mentioning lists in the names of functions that also work on vectors. Note that in edge cases (empty sequences, nil), these functions don't quite have their mal semantics, so the core library still does some remapping.
2019-05-06 12:00:25 +01:00
DEF FNcount(val%)
bbc-basic: Mostly-functional step 2.
2019-04-06 12:43:16 +01:00
LOCAL i%
WHILE NOT FNis_empty(val%)
bbc-basic: Rename list-manipulating functions to match their mal counterparts. FNlist_car becomes FNfirst FNlist_cdr becomes FNrest FNlist_nth becomes FNnth FNlist_len becomes FNcount This makes out terminology more mal-ish, and also avoids mentioning lists in the names of functions that also work on vectors. Note that in edge cases (empty sequences, nil), these functions don't quite have their mal semantics, so the core library still does some remapping.
2019-05-06 12:00:25 +01:00
val% = FNrest(val%)
bbc-basic: Mostly-functional step 2.
2019-04-06 12:43:16 +01:00
i% += 1
ENDWHILE
= i%
bbc-basic: Rename list-manipulating functions to match their mal counterparts. FNlist_car becomes FNfirst FNlist_cdr becomes FNrest FNlist_nth becomes FNnth FNlist_len becomes FNcount This makes out terminology more mal-ish, and also avoids mentioning lists in the names of functions that also work on vectors. Note that in edge cases (empty sequences, nil), these functions don't quite have their mal semantics, so the core library still does some remapping.
2019-05-06 12:00:25 +01:00
DEF FNnth(val%, n%)
bbc-basic: Align the spec of FNlist_nth with 'nth'. It now counts from zero (like BBC BASIC arrays) rather than 1 (like BBC BASIC strings).
2019-04-22 19:15:08 +01:00
WHILE n% > 0
bbc-basic: Add FNlist_nth, which does the obvious thing.
2019-04-07 18:37:36 +01:00
IF FNis_empty(val%) THEN ERROR &40E80923, "Subscript out of range"
bbc-basic: Rename list-manipulating functions to match their mal counterparts. FNlist_car becomes FNfirst FNlist_cdr becomes FNrest FNlist_nth becomes FNnth FNlist_len becomes FNcount This makes out terminology more mal-ish, and also avoids mentioning lists in the names of functions that also work on vectors. Note that in edge cases (empty sequences, nil), these functions don't quite have their mal semantics, so the core library still does some remapping.
2019-05-06 12:00:25 +01:00
val% = FNrest(val%)
bbc-basic: Add FNlist_nth, which does the obvious thing.
2019-04-07 18:37:36 +01:00
n% -= 1
ENDWHILE
bbc-basic: Make FNlist_nth fail correctly when passed an empty list. It failed before, but not with the correct error, and the step 9 tests depend on the correct error.
2019-05-01 12:30:36 +01:00
IF FNis_empty(val%) THEN ERROR &40E80923, "Subscript out of range"
bbc-basic: Rename list-manipulating functions to match their mal counterparts. FNlist_car becomes FNfirst FNlist_cdr becomes FNrest FNlist_nth becomes FNnth FNlist_len becomes FNcount This makes out terminology more mal-ish, and also avoids mentioning lists in the names of functions that also work on vectors. Note that in edge cases (empty sequences, nil), these functions don't quite have their mal semantics, so the core library still does some remapping.
2019-05-06 12:00:25 +01:00
=FNfirst(val%)
bbc-basic: Add FNlist_nth, which does the obvious thing.
2019-04-07 18:37:36 +01:00
bbc-basic: Mostly-functional step 2.
2019-04-06 12:43:16 +01:00
REM ** Core functions **
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
REM Z%(x,1) = index of function in FNcore_call
bbc-basic: Mostly-functional step 2.
2019-04-06 12:43:16 +01:00
DEF FNis_corefn(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &0C
bbc-basic: Mostly-functional step 2.
2019-04-06 12:43:16 +01:00
DEF FNalloc_corefn(fn%)
LOCAL val%
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
val% = FNmalloc(&0C)
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
Z%(val%,1) = fn%
bbc-basic: Mostly-functional step 2.
2019-04-06 12:43:16 +01:00
=val%
DEF FNunbox_corefn(val%)
bbc-basic: Use distinct error numbers for all errors. This is an improvement on always using error 1 ("Out of range"). Mal's error numbers are taken from a random block in the range suggested by the RISC OS Programmer's Reference Manual for use by applications.
2019-04-07 11:02:20 +01:00
IF NOT FNis_corefn(val%) THEN ERROR &40E80919, "Not a core function"
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
=Z%(val%,1)
bbc-basic: Mostly-functional step 2.
2019-04-06 12:43:16 +01:00
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
REM ** Hash-maps **
bbc-basic: Refer to the trees we use for hash-maps as "crit-bit trees". That seems to be the generic term, with PATRICIA being a particular early implementaion.
2019-05-15 20:45:50 +01:00
REM Hash-maps are represented as a crit-bit tree.
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
REM An internal node has:
REM Z%(x,0) >> 16 = next bit of key to check
REM Z%(x,1) = index in Z%() of left child (if next bit of key is 0)
REM Z%(x,2) = index in Z%() of right child (if next bit of key is 1)
REM A leaf node has
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
REM Z$(x) = key
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
REM Z%(x,2) = index in Z%() of value
bbc-basic: Add a hashmap type. Since I don't have mal strings yet, the keys are just native BASIC strings.
2019-04-06 11:25:40 +01:00
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
REM The empty hash-map is a special value containing no data.
bbc-basic: Add a hashmap type. Since I don't have mal strings yet, the keys are just native BASIC strings.
2019-04-06 11:25:40 +01:00
DEF FNempty_hashmap
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
=5
bbc-basic: Add a hashmap type. Since I don't have mal strings yet, the keys are just native BASIC strings.
2019-04-06 11:25:40 +01:00
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
DEF FNhashmap_alloc_leaf(key$, val%)
bbc-basic: Add a hashmap type. Since I don't have mal strings yet, the keys are just native BASIC strings.
2019-04-06 11:25:40 +01:00
LOCAL entry%
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
entry% = FNmalloc(&0A)
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
Z$(entry%) = key$
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
Z%(entry%,2) = val%
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
=entry%
bbc-basic: Add a hashmap type. Since I don't have mal strings yet, the keys are just native BASIC strings.
2019-04-06 11:25:40 +01:00
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
DEF FNhashmap_alloc_node(bit%, left%, right%)
LOCAL entry%
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
entry% = FNmalloc(&11)
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
Z%(entry%,0) += (bit% << 16)
Z%(entry%,1) = left%
Z%(entry%,2) = right%
=entry%
bbc-basic: Add a hashmap type. Since I don't have mal strings yet, the keys are just native BASIC strings.
2019-04-06 11:25:40 +01:00
DEF FNis_hashmap(val%)
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
LOCAL t%
t% = FNtype_of(val%)
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
=t% = &11 OR t% = &0A
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
DEF FNkey_bit(key$, bit%)
LOCAL cnum%
cnum% = bit% >> 3
IF cnum% >= LEN(key$) THEN =FALSE
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
=ASC(MID$(key$, cnum% + 1, 1)) AND (&80 >> (bit% AND 7))
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
DEF FNkey_bitdiff(key1$, key2$)
LOCAL bit%
WHILE FNkey_bit(key1$, bit%) = FNkey_bit(key2$, bit%)
bit% += 1
ENDWHILE
=bit%
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
DEF FNhashmap_set(map%, key$, val%)
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
LOCAL bit%, nearest%
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
IF FNis_empty(map%) THEN =FNhashmap_alloc_leaf(key$, val%)
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
nearest% = FNhashmap_find(map%, key$)
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
IF Z$(nearest%) = key$ THEN =FNhashmap_replace(map%, key$, val%)
bit% = FNkey_bitdiff(key$, Z$(nearest%))
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
=FNhashmap_insert(map%, bit%, key$, val%)
DEF FNhashmap_insert(map%, bit%, key$, val%)
LOCAL left%, right%
IF FNtype_of(map%) = &11 AND (Z%(map%,0) >> 16) < bit% THEN
IF FNkey_bit(key$, Z%(map%,0) >> 16) THEN
left% = Z%(map%,1)
right% = FNhashmap_insert(Z%(map%,2), bit%, key$, val%)
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
ELSE
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
left% = FNhashmap_insert(Z%(map%,1), bit%, key$, val%)
right% = Z%(map%,2)
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
ENDIF
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
=FNhashmap_alloc_node(Z%(map%,0)>>16, left%, right%)
ENDIF
IF FNkey_bit(key$, bit%) THEN
left% = map%
right% = FNhashmap_alloc_leaf(key$, val%)
ELSE
left% = FNhashmap_alloc_leaf(key$, val%)
right% = map%
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
ENDIF
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
=FNhashmap_alloc_node(bit%, left%, right%)
REM Replace a known-present key in a non-empty hashmap.
DEF FNhashmap_replace(map%, key$, val%)
LOCAL left%, right%
IF FNtype_of(map%) = &0A THEN =FNhashmap_alloc_leaf(key$, val%)
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
IF FNkey_bit(key$, Z%(map%,0) >> 16) THEN
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
left% = Z%(map%,1)
right% = FNhashmap_replace(Z%(map%,2), key$, val%)
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
ELSE
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
left% = FNhashmap_replace(Z%(map%,1), key$, val%)
right% = Z%(map%,2)
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
ENDIF
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
=FNhashmap_alloc_node(Z%(map%,0)>>16, left%, right%)
bbc-basic: Add the ability to free strings.
2019-04-19 15:23:17 +01:00
bbc-basic: Add 'dissoc' and 'vals' core functions.
2019-05-12 21:52:15 +01:00
DEF FNhashmap_remove(map%, key$)
LOCAL child%
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
IF FNis_empty(map%) THEN =map%
bbc-basic: Add 'dissoc' and 'vals' core functions.
2019-05-12 21:52:15 +01:00
IF FNtype_of(map%) = &0A THEN
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
IF Z$(map%) = key$ THEN =FNempty_hashmap
bbc-basic: Add 'dissoc' and 'vals' core functions.
2019-05-12 21:52:15 +01:00
ENDIF
IF FNkey_bit(key$, Z%(map%,0) >> 16) THEN
child% = FNhashmap_remove(Z%(map%,2), key$)
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
IF FNis_empty(child%) THEN =Z%(map%,1)
bbc-basic: Add 'dissoc' and 'vals' core functions.
2019-05-12 21:52:15 +01:00
=FNhashmap_alloc_node(Z%(map%,0)>>16, Z%(map%,1), child%)
ELSE
child% = FNhashmap_remove(Z%(map%,1), key$)
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
IF FNis_empty(child%) THEN =Z%(map%,2)
bbc-basic: Add 'dissoc' and 'vals' core functions.
2019-05-12 21:52:15 +01:00
=FNhashmap_alloc_node(Z%(map%,0)>>16, child%, Z%(map%,2))
ENDIF
bbc-basic: Iterative implementation of 'get' and 'contains?'. There's no good reason for these to be recursive. Also they can easily share code.
2019-05-18 13:58:14 +01:00
REM FNhashmap_find finds the nearest entry in a non-empty hash-map to
REM the key requested, and returns the entire entry.
DEF FNhashmap_find(map%, key$)
WHILE FNtype_of(map%) = &11
IF FNkey_bit(key$, Z%(map%,0) >> 16) THEN map% = Z%(map%,2) ELSE map% = Z%(map%,1)
ENDWHILE
=map%
bbc-basic: Add 'dissoc' and 'vals' core functions.
2019-05-12 21:52:15 +01:00
bbc-basic: Add a hashmap type. Since I don't have mal strings yet, the keys are just native BASIC strings.
2019-04-06 11:25:40 +01:00
DEF FNhashmap_get(map%, key$)
bbc-basic: Use distinct error numbers for all errors. This is an improvement on always using error 1 ("Out of range"). Mal's error numbers are taken from a random block in the range suggested by the RISC OS Programmer's Reference Manual for use by applications.
2019-04-07 11:02:20 +01:00
IF NOT FNis_hashmap(map%) THEN ERROR &40E80918, "Can't get item from a non-hashmap"
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
IF FNis_empty(map%) THEN =FNnil
bbc-basic: Iterative implementation of 'get' and 'contains?'. There's no good reason for these to be recursive. Also they can easily share code.
2019-05-18 13:58:14 +01:00
map% = FNhashmap_find(map%, key$)
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
IF Z$(map%) = key$ THEN =FNref_local(Z%(map%,2)) ELSE =FNnil
bbc-basic: First part of step 3: repl_env% is now an environment.
2019-04-07 16:01:55 +01:00
bbc-basic: Add FNhashmap_contains, being the internal version of contains?.
2019-04-20 14:29:28 +01:00
DEF FNhashmap_contains(map%, key$)
IF NOT FNis_hashmap(map%) THEN ERROR &40E80918, "Can't get item from a non-hashmap"
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
IF FNis_empty(map%) THEN =FALSE
bbc-basic: Iterative implementation of 'get' and 'contains?'. There's no good reason for these to be recursive. Also they can easily share code.
2019-05-18 13:58:14 +01:00
map% = FNhashmap_find(map%, key$)
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
=Z$(map%) = key$
bbc-basic: Add FNhashmap_contains, being the internal version of contains?.
2019-04-20 14:29:28 +01:00
bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps. Not very useful, but enough to pass step 1.
2019-05-12 11:19:03 +01:00
DEF FNhashmap_keys(map%)
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
=FNhashmap_keys1(map%, FNempty)
DEF FNhashmap_keys1(map%, acc%)
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
IF FNis_empty(map%) THEN =acc%
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
IF FNtype_of(map%) = &0A THEN
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
=FNalloc_pair(FNalloc_string(Z$(map%)), acc%)
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
ENDIF
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
=FNhashmap_keys1(Z%(map%,1), FNhashmap_keys1(Z%(map%,2), acc%))
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
bbc-basic: Add 'dissoc' and 'vals' core functions.
2019-05-12 21:52:15 +01:00
DEF FNhashmap_vals(map%)
=FNhashmap_vals1(map%, FNempty)
DEF FNhashmap_vals1(map%, acc%)
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
IF FNis_empty(map%) THEN =acc%
bbc-basic: Add 'dissoc' and 'vals' core functions.
2019-05-12 21:52:15 +01:00
IF FNtype_of(map%) = &0A THEN
=FNalloc_pair(Z%(map%,2), acc%)
ENDIF
bbc-basic: Properly sort hash-map keys. This turned out to be quite twiddly, and the code isn't quite as obviously correct as it was. Still, it seems to work correctly.
2019-05-18 14:38:32 +01:00
=FNhashmap_vals1(Z%(map%,1), FNhashmap_vals1(Z%(map%,2), acc%))
bbc-basic: Add 'dissoc' and 'vals' core functions.
2019-05-12 21:52:15 +01:00
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
DEF PROChashmap_dump(map%)
bbc-basic: Change how empty collections work. Rather that recognising them by address, they now have a special bit set in their type words. That means that adding metadata to an empty collection doesn't cause it to cease being properly empty.
2019-05-15 20:26:36 +01:00
IF FNis_empty(map%) THEN
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
PRINT "[empty]"
ELSE
PRINT "[-----]"
PROChashmap_dump_internal(map%, "")
ENDIF
ENDPROC
DEF PROChashmap_dump_internal(map%, prefix$)
bbc-basic: Radically simplify string storage. Rather than having a separately indexed array of strings, S$(), with its own free-list in S%(), we now keep string values in an array, Z$(), whose indices parallel those in Z%(), so Z$(x) is the string value of the object at Z%(x,y). This saves a fair amount of complexity at the expense of slightly more memory usage.
2019-05-26 13:28:16 +01:00
IF FNtype_of(map%) = &0A PRINT prefix$;Z$(map%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
IF FNtype_of(map%) = &11 THEN
bbc-basic: PATRICIA hashmaps now working up to step 2.
2019-05-12 13:34:26 +01:00
PRINT prefix$;"<";Z%(map%,0) >> 16;">"
PROChashmap_dump_internal(Z%(map%,1), prefix$ + "L ")
PROChashmap_dump_internal(Z%(map%,2), prefix$ + "R ")
ENDIF
ENDPROC
bbc-basic: Reading and printing support for hash-maps (deferred from step 1).
2019-05-11 16:47:12 +01:00
bbc-basic: Implement fn*.
2019-04-07 23:45:29 +01:00
REM ** Functions **
bbc-basic: Redesign storage of functions to use two cells. Functions were the only type using all three columns of Z%(). By reducing that to two (at the expense of spreading a function over two cells), we make space for storing a metadata pointer in Z%(x,3) of all types.
2019-05-12 23:43:48 +01:00
REM A function is represented by two cells:
bbc-basic: Start of step 8: minimal support for 'defmacro!'. Nothing yet treats macros any differently from ordinary functions.
2019-04-30 21:24:40 +01:00
REM Z%(x,0) AND &80 = is_macro flag
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
REM Z%(x,1) = index in Z%() of ast
bbc-basic: Redesign storage of functions to use two cells. Functions were the only type using all three columns of Z%(). By reducing that to two (at the expense of spreading a function over two cells), we make space for storing a metadata pointer in Z%(x,3) of all types.
2019-05-12 23:43:48 +01:00
REM Z%(x,2) = y
REM Z%(y,1) = index in Z%() of params
REM Z%(y,2) = index in Z%() of env
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
bbc-basic: Implement fn*.
2019-04-07 23:45:29 +01:00
DEF FNis_fn(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &15
bbc-basic: Implement fn*.
2019-04-07 23:45:29 +01:00
bbc-basic: Start of step 8: minimal support for 'defmacro!'. Nothing yet treats macros any differently from ordinary functions.
2019-04-30 21:24:40 +01:00
DEF FNis_nonmacro_fn(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &15 AND (Z%(val%, 0) AND &80) = &00
bbc-basic: Start of step 8: minimal support for 'defmacro!'. Nothing yet treats macros any differently from ordinary functions.
2019-04-30 21:24:40 +01:00
DEF FNis_macro(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &15 AND (Z%(val%, 0) AND &80) = &80
bbc-basic: Start of step 8: minimal support for 'defmacro!'. Nothing yet treats macros any differently from ordinary functions.
2019-04-30 21:24:40 +01:00
bbc-basic: Rename parts of a mal function to match the guide.
2019-04-10 23:59:17 +01:00
DEF FNalloc_fn(ast%, params%, env%)
bbc-basic: Redesign storage of functions to use two cells. Functions were the only type using all three columns of Z%(). By reducing that to two (at the expense of spreading a function over two cells), we make space for storing a metadata pointer in Z%(x,3) of all types.
2019-05-12 23:43:48 +01:00
LOCAL val1%, val2%
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
val1% = FNmalloc(&15)
bbc-basic: Redesign storage of functions to use two cells. Functions were the only type using all three columns of Z%(). By reducing that to two (at the expense of spreading a function over two cells), we make space for storing a metadata pointer in Z%(x,3) of all types.
2019-05-12 23:43:48 +01:00
Z%(val1%,1) = ast%
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
val2% = FNmalloc(&19)
bbc-basic: Redesign storage of functions to use two cells. Functions were the only type using all three columns of Z%(). By reducing that to two (at the expense of spreading a function over two cells), we make space for storing a metadata pointer in Z%(x,3) of all types.
2019-05-12 23:43:48 +01:00
Z%(val1%,2) = val2%
Z%(val2%,1) = params%
Z%(val2%,2) = env%
=val1%
bbc-basic: Implement fn*.
2019-04-07 23:45:29 +01:00
bbc-basic: Replace PROCmake_macro with FNas_macro. FNas_macro makes a copy of its argument, converted into a macro, by analogy with FNas_list and FNas_vector.
2019-05-15 20:34:06 +01:00
DEF FNas_macro(val%)
bbc-basic: Start of step 8: minimal support for 'defmacro!'. Nothing yet treats macros any differently from ordinary functions.
2019-04-30 21:24:40 +01:00
IF NOT FNis_fn(val%) THEN ERROR &40E8091A, "Not a function"
bbc-basic: Replace PROCmake_macro with FNas_macro. FNas_macro makes a copy of its argument, converted into a macro, by analogy with FNas_list and FNas_vector.
2019-05-15 20:34:06 +01:00
LOCAL newval%
newval% = FNmalloc(Z%(val%,0) OR &80)
Z%(newval%,1) = Z%(val%,1)
Z%(newval%,2) = Z%(val%,2)
Z%(newval%,3) = Z%(val%,3)
=newval%
bbc-basic: Start of step 8: minimal support for 'defmacro!'. Nothing yet treats macros any differently from ordinary functions.
2019-04-30 21:24:40 +01:00
bbc-basic: Rename parts of a mal function to match the guide.
2019-04-10 23:59:17 +01:00
DEF FNfn_ast(val%)
bbc-basic: Implement fn*.
2019-04-07 23:45:29 +01:00
IF NOT FNis_fn(val%) THEN ERROR &40E8091A, "Not a function"
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
=FNref_local(Z%(val%,1))
bbc-basic: Implement fn*.
2019-04-07 23:45:29 +01:00
bbc-basic: Rename parts of a mal function to match the guide.
2019-04-10 23:59:17 +01:00
DEF FNfn_params(val%)
bbc-basic: Implement fn*.
2019-04-07 23:45:29 +01:00
IF NOT FNis_fn(val%) THEN ERROR &40E8091A, "Not a function"
bbc-basic: Redesign storage of functions to use two cells. Functions were the only type using all three columns of Z%(). By reducing that to two (at the expense of spreading a function over two cells), we make space for storing a metadata pointer in Z%(x,3) of all types.
2019-05-12 23:43:48 +01:00
=FNref_local(Z%(Z%(val%,2),1))
bbc-basic: Implement fn*.
2019-04-07 23:45:29 +01:00
DEF FNfn_env(val%)
IF NOT FNis_fn(val%) THEN ERROR &40E8091A, "Not a function"
bbc-basic: Redesign storage of functions to use two cells. Functions were the only type using all three columns of Z%(). By reducing that to two (at the expense of spreading a function over two cells), we make space for storing a metadata pointer in Z%(x,3) of all types.
2019-05-12 23:43:48 +01:00
=FNref_local(Z%(Z%(val%,2),2))
bbc-basic: Implement fn*.
2019-04-07 23:45:29 +01:00
bbc-basic: Basic support for atoms. 'swap!' is still missing. Trying to implement 'swap!' has caused me to suspect I have some fundamental structural deficiencies to address, so I might have to do that next.
2019-04-20 18:25:09 +01:00
REM ** Atoms **
REM Z%(x,1) = index in Z% of current referent
DEF FNis_atom(val%)
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
=FNtype_of(val%) = &01
bbc-basic: Basic support for atoms. 'swap!' is still missing. Trying to implement 'swap!' has caused me to suspect I have some fundamental structural deficiencies to address, so I might have to do that next.
2019-04-20 18:25:09 +01:00
DEF FNalloc_atom(contents%)
LOCAL val%
bbc-basic: Rework of type identifiers to be more semantically useful. Now the bottom four bits indicate the semantics of the various columns of Z%, so the garbage collector can operate with no knowledge of any specific types. Instead, it can directly tell which fields need followed when marking, and which represent strings to be freed.
2019-05-12 10:45:49 +01:00
val% = FNmalloc(&01)
bbc-basic: Basic support for atoms. 'swap!' is still missing. Trying to implement 'swap!' has caused me to suspect I have some fundamental structural deficiencies to address, so I might have to do that next.
2019-04-20 18:25:09 +01:00
Z%(val%,1) = contents%
=val%
DEF FNatom_deref(val%)
=FNref_local(Z%(val%,1))
DEF PROCatom_reset(val%, contents%)
Z%(val%,1) = contents%
ENDPROC
bbc-basic: First part of step 3: repl_env% is now an environment.
2019-04-07 16:01:55 +01:00
REM ** Environments **
bbc-basic: Document data layouts in comments. Since we're now using a two-dimensional array, the documentation in basic/mem.in.bas only loosely applies and it's probably time I had my own.
2019-04-12 23:27:36 +01:00
REM Z%(x,1) = index in Z% of hash-map
REM Z%(x,2) = index in Z% of outer environment
bbc-basic: First part of step 3: repl_env% is now an environment.
2019-04-07 16:01:55 +01:00
DEF FNis_environment(val%)
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
=FNtype_of(val%) = &0D
bbc-basic: First part of step 3: repl_env% is now an environment.
2019-04-07 16:01:55 +01:00
DEF FNalloc_environment(outer%)
LOCAL val%
bbc-basic: Simplify type codes. Z%(x,2) and Z%(x,3) are always pointers or nil, so there's no need to record whether they're used: FNgc_mark can just unconditionally mark them. This means that the only interesting question is whether Z%(x,1) is a pointer, a string, or something else, which can be encoded in two bits. This still leaves us using five bits for the type code, but I think the avoidance of special-case code is worth spending a bit on.
2019-05-13 23:27:07 +01:00
val% = FNmalloc(&0D)
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
Z%(val%,1) = FNempty_hashmap
Z%(val%,2) = outer%
bbc-basic: First part of step 3: repl_env% is now an environment.
2019-04-07 16:01:55 +01:00
=val%
DEF FNenvironment_data(val%)
IF NOT FNis_environment(val%) THEN ERROR &40E8091D, "Not an environment"
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
=FNref_local(Z%(val%,1))
bbc-basic: First part of step 3: repl_env% is now an environment.
2019-04-07 16:01:55 +01:00
DEF PROCenvironment_set_data(val%, data%)
IF NOT FNis_environment(val%) THEN ERROR &40E8091D, "Not an environment"
bbc-basic: Use a two-dimensional array for Z%(). Rather than allocating a variable number of elements of a one-dimensional array for different types of object, allocate each one as a row of a four-column array. This isn't as space-efficient, but it's clearer and will make memory management a lot easier (no need to worry about fragmentation, for instance).
2019-04-10 22:25:18 +01:00
Z%(val%,1) = data%
bbc-basic: First part of step 3: repl_env% is now an environment.
2019-04-07 16:01:55 +01:00
ENDPROC
DEF FNenvironment_outer(val%)
IF NOT FNis_environment(val%) THEN ERROR &40E8091D, "Not an environment"
bbc-basic: Take the GC in another direction again. This attempt eschews reference-counting in favour of just trying to track what might be referenced from BASIC variables at any given time in the hopes of running a mark-and-sweep collector over it.
2019-04-17 23:50:26 +01:00
=FNref_local(Z%(val%,2))
bbc-basic: Add Emacs local variables lists to stop it inserting tabs. Tab characters are harmful to BBC BASIC programs, so it's particularly unhelpful that Emacs' "indent-relative" function inserts them. Add file variables lists to all BBC BASIC source files to disable this behaviour.
2019-04-19 17:44:19 +01:00
REM Local Variables:
REM indent-tabs-mode: nil
REM End:
Reference in New Issue Copy Permalink