Merge pull request #396 from inkydragon/fix-test-on-windows

run test on cygwin

run test on cygwin

Merge pull request #389 from bjh21/bjh21-mal-kw-outer

mal: Use a keyword to link each environment to its outer one.

mal: Use a keyword to link each environment to its outer one.

Heretofore, the mal implementation has linked each environment to its
outer environment by defining a special symbol, '--outer--' in that
environment.  This causes that symbol to be unusable by programs running
under that implementation.  For instance:

  (def! foo 123)
  (def! f (fn* (--outer--) foo))
  (f)

gives an error because overwriting '--outer--' breaks the environment
chain.

Happily, mal provides a way around this.  Keywords are guaranteed to
work as hashmap keys, so by using a keyword instead of a string as the
key for the outer environment, it can be hidden from user code.  This
also provides a motivation for keywords, which aren't otherwise used by
the mal implementation.

travis_trigger.sh: Support .com and env var tokens

Travis: travis_trigger.sh script.

Merge pull request #393 from bjh21/bjh21-bbc-basic

bbc-basic: Increase Brandy heap size so we run out of memory less

bbc-basic: Enlarge Brandy's heap size.

Having found the perfect mal heap size to get self-hosting to work in
64-bit Brandy, I tried the performance tests, and they failed.  I've
therefore accepted that I need to increase Brandy's heap size, so I'm
doubling it to a megabyte.  That doesn't seem especially generous on
modern hardware.

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.

Travis: combine build into .travis_test.sh

Various small self-host mode fixes.

- clojure (cljs): self-host arity fix. Apparently ClojureScript
  functions that have metadata attached only support arity of 20. This
  is problem during self-host because the main EVAL cond macro is 22
  items so it blows up when applied in macroexpand. So we preserve the
  origin unadorned function through to macroexpand and use it there
  instead of the adorned function/macro.
- basic: fix build when in self-host qbasic mode.
- coffee, cs, dart, elisp, hy, rexx, vb: fix self-host reader errs. Preserve
  or extract the correct error message in try*/catch* loops so that it
  works for self-host error message printing as well.
- mal: pathing issue in ./run script that affected the wasm
  implementation path permissions
- miniMAL: remove extraneous command line printing of "nil".
- ps: inc function was not actually defined.
- rust: write warning about missing .mal-history to stderr to fix
  self-host failure in step6.
- wasm: the map function was stopping on nil values; fix the list end
  check. Double the macroexpand stack so that sumdown test in stepA
  tests passes without mac stack overflow.
- yorick: read from /dev/stdin in readline builtin function.

Travis: detect special self-host-test branch.

- If the branch name is "self-host-test" then do self-hosted test.
- Fix pass through of *_MODE values during self-hosting.
- Add capability to skip of build/test/perf during self-host.
- Skip self-host for basic, io, logo, make.
- Reformat travis.yml list for better alignment

Merge pull request #390 from bjh21/bjh21-bbc-basic

bbc-basic: Assorted fixes

bbc-basic: Shrink mal heap a little.

On 64-bit systems, Brandy uses rather a lot of memory for string arrays,
so having the heap too large runs it out of memory.

bbc-basic: Add comment explaining sizing of mal heap.

Merge pull request #388 from bjh21/bjh21-large-files-step6

step6: Test loading of a large (>255 byte) file earlier than before.

Merge pull request #392 from asarhaddon/ada-unterminated-string

ada: fix the fix for unterminated strings

Merge pull request #391 from asarhaddon/test-let-recursive-def

Test mutual recursion in let*

Test mutual recursion in let* without vectors, which are deferrable.

Thanks to bjh21 for spotting this inconsistency.

ada: fix the fix for unterminated strings

Thanks bjh21. I have been distracted by a less important issue (should
"\a" be read as "\a" or "a"?).

Test mutual recursion in let*

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.

step6: Test loading of a large (>255 byte) file earlier than before.

I just introduced a bug in the BBC BASIC implementation meaning that
'load-file' was broken on files over 255 bytes long, and it was only
caught by the optional test of 'time-ms' in step A.  This change brings
forward the relevant part of that test so the failure can be detected
earlier and more obviously, at the same time as the other tests of
'load-file'.

Merge pull request #386 from asarhaddon/test-let-recursive-def

test recursive definitions in let*

Merge pull request #385 from asarhaddon/ada-unterminated-string

ada: fix unterminated string and creation of object directory by Make.

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.

bbc-basic: Remove the word "partial" from the README.

bbc-basic: Slight printer tidying.

When printing a vector, don't allocate a string for "(" and then
immediately throw it away.

bbc-basic: Make metadata on string-like types work.

The new string handling makes this simpler than forbidding it.

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.

test recursive definitions in let*

Detected while attempting to rewrite let* with fn*.

ada: fix unterminated string and creation of object directory by Make.

Merge pull request #371 from asarhaddon/extend-core.mal

Extend core.mal

lib/tests: report parsing errors, move threading out of steps

When testing `foo.mal`, it makes sense to report parsing errors in
`foo.mal`.

Move tests of `->` and `->>` from `tests/step8_macros.mal` to
`tests/lib/theading.mal`.

Add `lib/trivial.mal`.

lib/ README.md should not repeat the process unless needed

Merge pull request #382 from bjh21/bjh21-unterminated-string-fixes

Unterminated string fixes: clojure, fantom, groovy, haxe, hy, io, java, julia, kotlin, livescript, matlab, miniMAL, objc, plpgsql, scala, vb, vimscript, yorick

Merge pull request #383 from asarhaddon/ada2tco-do

ada.2: optimize tail call recursion for last `do` evaluation

Merge pull request #380 from bjh21/bjh21-bbc-basic

BBC BASIC V implementation

vb: Detect more unterminated strings.

I split the string-recognizing part of the read_atom regexp in two, one part for
recognising valid strings (using a fragment of the tokenising regexp) and
another to recognize invalid strings.  This follows the practice of other
implementations with a single read_atom regexp.

objc: Detect more unterminated strings.

This is done by tightening the part of the read_atom regexp that
recognises valid strings.

matlab: Detect more unterminated strings.

Rather than treating anything beginning and ending with '"' as a valid
string, we now use a regexp to detect a valid string and treat any other
token starting with '"' as an error.

This does not fix all of the bugs found by #359, though: there remains a
problem with long strings of backslashes in the input getting expanded
into too many backslashes in the resulting string.

miniMAL: Detect more unterminated strings.

Rather than treating anything beginning and ending with '"' as a valid
string, we now use a regexp to detect a valid string and treat any other
token starting with '"' as an error.

plpgsql, scala, vimscript, yorick: Detect more unterminated strings.

This is achieved by tightening the regexp used to detect valid strings.

bbc-basic: Add a minimal Makefile.

The automated testing system needs one.

bbc-basic: Travis and top-level README updates for new implementation.

bbc-basic: README updates.

bbc-basic: Find Brandy via ${BRANDY}, not ${SBRANDY}.

The graphical versions work perfectly well here, so I don't think the
variable name should suggest the don't.  For instance, you might run:

BRANDY=brandy make repl^bbc-basic

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.

bbc-basic: Support '=' on hash-maps.

Now that keys are sorted, it's just case of comparing the list of keys
and the list of values.  In fact, two equal hash-maps will have
precisely the same internal structure, but the core library need not
know that.

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.

bbc-basic: Iterative implementation of 'get' and 'contains?'.

There's no good reason for these to be recursive.  Also they can
easily share code.

bbc-basic: Wrap BASIC and OS errors in a hash-map when they're caught.

This allows mal code to get at the error number (ERR), which is what it
should look at to determine the meaning of the error.

bbc-basic: Correct comment describing use of S%().

bbc-basic: Disallow metadata on string-like types.

Objects that have a direct reference into S$() can't safely be cloned,
because the GC assumes that when such an object is freed, the string
in S$() can be freed as well.  This assumption would be broken by
cloning, so the cloning of such types by FNwith_meta must be
disallowed.

This has the unexpected, but in retrospect obvious, consequence that
single-member hashmaps can't have metadata.  That's obviously a bit
silly, so a more comprehensive solution is probably warranted in due
course.

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.

bbc-basic: Ensure that "Escape" errors propagate beyond mal.

Rather than printing an error message and ending the program, it's
better to turn off our error handler and then re-raise the error.  This
ensures that if, for instance, mal is started from the Supervisor in
RISC OS, the error gets propagated back to the Supervisor error handler
and displayed properly.

This required a slight adjustment to the top-level ON ERROR handler.

bbc-basic: Don't try to add "deb-src" entries in Dockerfile.

Apparently that wasn't necessary, and indeed broke the build, on other
systems.

bbc-basic: Create a suitable Dockerfile and adapt "run" script.

The dockerfile uses the Ubuntu source package of Brandy to build a
text-only version for testing.  The "run" script no longer depends on
the existence of sbrandy in a particular place in my home directory.

bbc-basic: Minor README updates.

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.

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.

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.

bbc-basic: Remove unused PROClist_to_array and FNarray_to_list.

bbc-basic: Upgrade to the gensym-based 'or'.

bbc-basic: Allow metadata on non-function types.

This is currently broken, but it passes all the tests, so I'll need
some better tests.

bbc-basic: Add 'seq' core function.

bbc-basic: Add 'string?', 'number?', 'fn?', and 'macro?' core functions.

bbc-basic: Implement 'conj' core function.

bbc-basic: Add 'time-ms' core function.

It uses TIME, since that's easily available on all platforms.

bbc-basic: Add step A to the RISC OS tokenizing script.

bbc-basic: Pass '-path' to Brandy so self-hosting tests find libraries.

bbc-basic: Enlarge the reader token buffer again.

The later self-hosting steps are quite large.

bbc-basic: Stub implementations of optional step A core functions.

These need to be present (but not functional) for the self-hosted mal to work.

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.

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.

bbc-basic: Add the README file that I've had kicking around for a while.

bbc-basic: Increase reader token buffer again to 1024.

Running the self-hosting tests looks to require this.

bbc-basic: Add '*host-language*' and a startup banner.

bbc-basic: Metadata support, including 'meta' and 'with-meta'.

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.

bbc-basic: Add 'readline' core function.

bbc-basic: Beginning of step A.

bbc-basic: Make sure that '&' parameters are in a list, not a vector.

bbc-basic: Add 'dissoc' and 'vals' core functions.

bbc-basic: Add 'assoc' and 'keys' core functions.

'hash-map' is now implemented in terms of 'assoc'.

bbc-basic: Add 'get' and 'contains?' core functions.

bbc-basic: Adjust heap size so that step 8 doesn't suffer a stack overflow.

bbc-basic: PATRICIA hashmaps now mostly working.  Stack overflow in step 8.

bbc-basic: PATRICIA hashmaps now working up to step 2.

bbc-basic: Start of conversion to PATRICIA hashmaps: single-element hash-maps.

Not very useful, but enough to pass step 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.

bbc-basic: Implement 'hash-map' and 'map?' core functions.

bbc-basic: Correct error for core function argument not being a string.

bbc-basic: Make FNhashmap_contains, FNhashmap_get, and FNenv_find iterative.

Since BASIC doesn't do tail-call optimisation, we were needlessly
burning a lot of stack.

Now passes all tests (including deferrable and optional) up to step 8.

bbc-basic: Enlarge token buffer to 512 entries.

core.mal needed more than the 255 we allowed before.

bbc-basic: Add support for hash-maps to FNeval_ast (deferred from step 2).

bbc-basic: Simplify reader-macro code using FNalloc_list2.

bbc-basic: Add support for '^' reader macro.

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

bbc-basic: '*ARGV*' support when running under RISC OS.

This uses OS_GetEnv to get the command line, and OS_GSTrans to split it
into words, discarding the usual prefix for a BASIC program.