Blame: impls/bbc-basic/printer.bas - kanaka/mal

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 > printer library for mal in BBC BASIC

							

bbc-basic: Minimal step 1.

2019-03-31 22:44:13 +01:00

bbc-basic: Add the print_readably% parameter to FNpr_str (deferred from step 1). This is a pre-requisite for string support.

2019-04-20 13:42:00 +01:00

								DEF FNpr_str(val%, print_readably%)

							

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

								  LOCAL ret%, term$, val$, keys%, vals%

							

bbc-basic: Support for reading and printing booleans (deferred step 1 task).

2019-04-07 11:01:11 +01:00

								  IF FNis_boolean(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

								    IF FNunbox_boolean(val%) THEN =FNalloc_string("true")

							

bbc-basic: Support for reading and printing booleans (deferred step 1 task).

2019-04-07 11:01:11 +01:00

  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

								  IF FNis_int(val%) THEN =FNalloc_string(STR$(FNunbox_int(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

								  IF FNis_string(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

								    IF FNstring_chr(val%, 1) = CHR$(127) THEN =FNalloc_string(":" + MID$(FNunbox_string(val%), 2))

							

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

  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

								  IF FNis_symbol(val%) THEN =FNalloc_string(FNunbox_symbol(val%))

							

bbc-basic: Extend vector support throughout steps 2 to 9.

2019-05-05 23:52:31 +01:00

								  IF FNis_seq(val%) THEN

							

bbc-basic: Slight printer tidying. When printing a vector, don't allocate a string for "(" and then immediately throw it away.

2019-05-26 13:38:25 +01:00

								    IF FNis_vector(val%) THEN

							

bbc-basic: Minimal step 1.

2019-03-31 22:44:13 +01:00

								    WHILE NOT FNis_empty(val%)

							

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

								      IF FNstring_len(ret%) > 1 THEN ret% = FNstring_append(ret%, " ")

							

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: Minimal step 1.

2019-03-31 22:44:13 +01:00

    ENDWHILE

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

								    =FNstring_append(ret%, term$)

							

bbc-basic: Minimal step 1.

2019-03-31 22:44:13 +01:00

  ENDIF

bbc-basic: Reading and printing support for hash-maps (deferred from step 1).

2019-05-11 16:47:12 +01:00

								  IF FNis_hashmap(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

								    ret% = FNalloc_string("{")

							

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

								    keys% = FNhashmap_keys(val%)

							

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

								    vals% = FNhashmap_vals(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

								    WHILE NOT FNis_empty(keys%)

							

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

								      IF FNstring_len(ret%) > 1 THEN ret% = FNstring_append(ret%, " ")

							

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

								      keys% = FNrest(keys%)

							

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

								      vals% = FNrest(vals%)

							

bbc-basic: Reading and printing support for hash-maps (deferred from step 1).

2019-05-11 16:47:12 +01:00

    ENDWHILE

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

								    =FNstring_append(ret%, "}")

							

bbc-basic: Reading and printing support for hash-maps (deferred from step 1).

2019-05-11 16:47:12 +01:00

  ENDIF

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

								  IF FNis_atom(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

								    ret% = FNalloc_string("(atom ")

							

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

								    ret% = FNstring_concat(ret%, FNpr_str(FNatom_deref(val%), print_readably%))

							

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

  ENDIF

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

								  ERROR &40E809F0, "Unprintable value"

							

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

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 FNformat_string(strval$)

							

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:

							

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 > printer library for mal in BBC BASIC`
bbc-basic: Minimal step 1. 2019-03-31 22:44:13 +01:00
bbc-basic: Add the print_readably% parameter to FNpr_str (deferred from step 1). This is a pre-requisite for string support. 2019-04-20 13:42:00 +01:00			`DEF FNpr_str(val%, print_readably%)`
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			`LOCAL ret%, term$, val$, keys%, vals%`
			`IF FNis_nil(val%) THEN =FNalloc_string("nil")`
bbc-basic: Support for reading and printing booleans (deferred step 1 task). 2019-04-07 11:01:11 +01:00			`IF FNis_boolean(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			`IF FNunbox_boolean(val%) THEN =FNalloc_string("true")`
			`=FNalloc_string("false")`
bbc-basic: Support for reading and printing booleans (deferred step 1 task). 2019-04-07 11:01:11 +01:00			`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			`IF FNis_int(val%) THEN =FNalloc_string(STR$(FNunbox_int(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			`IF FNis_string(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			`IF FNstring_chr(val%, 1) = CHR$(127) THEN =FNalloc_string(":" + MID$(FNunbox_string(val%), 2))`
			`IF print_readably% THEN =FNalloc_string(FNformat_string(FNunbox_string(val%))) ELSE =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			`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			`IF FNis_symbol(val%) THEN =FNalloc_string(FNunbox_symbol(val%))`
			`IF FNis_corefn(val%) OR FNis_fn(val%) THEN =FNalloc_string("#<function>")`
bbc-basic: Extend vector support throughout steps 2 to 9. 2019-05-05 23:52:31 +01:00			`IF FNis_seq(val%) THEN`
bbc-basic: Slight printer tidying. When printing a vector, don't allocate a string for "(" and then immediately throw it away. 2019-05-26 13:38:25 +01:00			`IF FNis_vector(val%) THEN`
			`ret% = FNalloc_string("[") : term$ = "]"`
			`ELSE`
			`ret% = FNalloc_string("(") : term$ = ")"`
			`ENDIF`
bbc-basic: Minimal step 1. 2019-03-31 22:44:13 +01:00			`WHILE NOT FNis_empty(val%)`
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			`IF FNstring_len(ret%) > 1 THEN ret% = FNstring_append(ret%, " ")`
			`ret% = FNstring_concat(ret%, FNpr_str(FNfirst(val%), print_readably%))`
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: Minimal step 1. 2019-03-31 22:44:13 +01:00			`ENDWHILE`
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			`=FNstring_append(ret%, term$)`
bbc-basic: Minimal step 1. 2019-03-31 22:44:13 +01:00			`ENDIF`
bbc-basic: Reading and printing support for hash-maps (deferred from step 1). 2019-05-11 16:47:12 +01:00			`IF FNis_hashmap(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			`ret% = FNalloc_string("{")`
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			`keys% = FNhashmap_keys(val%)`
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			`vals% = FNhashmap_vals(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			`WHILE NOT FNis_empty(keys%)`
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			`IF FNstring_len(ret%) > 1 THEN ret% = FNstring_append(ret%, " ")`
			`ret% = FNstring_concat(ret%, FNpr_str(FNfirst(keys%), print_readably%))`
			`ret% = FNstring_append(ret%, " ")`
			`ret% = FNstring_concat(ret%, FNpr_str(FNfirst(vals%), print_readably%))`
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			`keys% = FNrest(keys%)`
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			`vals% = FNrest(vals%)`
bbc-basic: Reading and printing support for hash-maps (deferred from step 1). 2019-05-11 16:47:12 +01:00			`ENDWHILE`
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			`=FNstring_append(ret%, "}")`
bbc-basic: Reading and printing support for hash-maps (deferred from step 1). 2019-05-11 16:47:12 +01:00			`ENDIF`
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			`IF FNis_atom(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			`ret% = FNalloc_string("(atom ")`
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			`ret% = FNstring_concat(ret%, FNpr_str(FNatom_deref(val%), print_readably%))`
			`=FNstring_append(ret%, ")")`
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			`ENDIF`
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			`ERROR &40E809F0, "Unprintable value"`
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
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 FNformat_string(strval$)`
			`LOCAL ptr%, c$, out$`
			`IF strval$ = "" THEN =""""""`
			`FOR ptr% = 1 TO LEN(strval$)`
			`c$ = MID$(strval$, ptr%, 1)`
			`CASE c$ OF`
			`WHEN "\", """": out$ += "\" + c$`
			`WHEN CHR$(10): out$ += "\n"`
			`OTHERWISE: out$ += c$`
			`ENDCASE`
			`NEXT ptr%`
			`="""" + out$ + """"`

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:`