bbc-basic: Minimal step 1.

bbc-basic: convert reader to follow Hints.md.

bbc-basic: Rework tokenizer.

Now all tokens are emitted after reading the next character, rather
than emitting some as soon as their last character is read.  This
simplifies the token-emission code at the expense of adding a state to
the DFA.

bbc-basic: Remove PRINT statements from tokenizer.

bbc-basic: Tokenizer based on a DFA.

DATA statements are pretty much perfect for this job.

bbc-basic: Working step 0.

I'm far from sure the I/O is actually reliable, but the tests pass.

Minimal structure for BBC BASIC implementation.

scheme: fix unterminated string handling for chibi

scheme: fix unterminated string handling

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

Unterminated string fixes: gnu-smalltalk, go, js, lua, objpascal, php, powershell, racket, rust, ts

picolisp: fix unterminated string handling

objpascal, powershell, racket: Detect more unterminated strings.

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

gnu-smalltalk, go, js, lua, php, rust, ts: 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.

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

cs, crystal, es6: Detect more unterminated strings.

cs, crystal, es6: Detect more unterminated strings.

Specifically, correctly handle invalid strings that nonetheless end with
a '"' character, by using the full string-matching regexp to check that
a string token is valid.

ps: properly ignore multiple comments in a row.

Merge pull request #378 from asarhaddon/test-macro-not-changing-function

Test that defining a macro does not mutate an existing function.

Move test that macro do not mutate functions as optional in stepA

test macro/functions: ignore results of preliminary definitions

Merge pull request #377 from asarhaddon/fix-runtests-pre-eval

runtest: fix pre-eval option

Merge pull request #376 from bjh21/bjh21-withmeta-empty

step A: Test that metadata doesn't break empty collections.

Merge pull request #375 from bjh21/bjh21-stepA-optional

Document the requirements for optional step A functions

step A: Test that metadata doesn't break empty collections.

In the BBC BASIC implementation, the empty list, vector, and hash-mapp
are distinguished values and detected by their address.  Adding metadata
to them makes a copy, and then they don't work properly any more.

guide, step A: Note that stub functions are replaced with real ones.

step A: Add a mandatory test that 'string?' etc are defined.

Self-hosting currently requires that these functions be defined so
that the mal implementation can pass them through.  This test
minimally ensures that.

guide, step A: Document that 'string?' etc need to be defined.

The functions 'time-ms', 'string?', 'number?', 'seq', an 'conj' don't
need to work for self-hosting, but they do need to be defined, since
mal/core.mal unconditionally references them when the interpreter
starts up.

Test that defining a macro does not mutate an existing function.

runtest: fix pre-eval option

Merge pull request #372 from bjh21/bjh21-empty-hashmap

step1: Test that an empty hashmap can pass through read and print.

step1: More systematic testing of empty collections.

Now we test empty lists, vectors, and hash-maps, all with and without a
space between the opening and closing bracket.

wasm: fix platform_wasi preopen search.

This better supports both wasmtime and wasmer. One key issue is that
we need to handle string endings differently between the two projects.

haskell: fix parsing empty literal sequences.

Specifically the problem is that parsing sequence literals breaks if
there are only empty spaces between the opening and closing character.

This is to address issues found in: https://github.com/kanaka/mal/pull/372

Merge pull request #374 from sgtatham/vala-fixes

Vala fixes

make, swift3: fix parsing empty literal sequences.

Specifically the problem is that parsing sequence literals breaks if
there are only empty spaces between the opening and closing character.

This is to address issues found in: https://github.com/kanaka/mal/pull/372

vala: implement a garbage collector.

This fixes a lot of memory leakage due to me having relied on the Vala
reference-counting system to do my memory management.

The most obvious bad result of that design decision was the memory
leak from Mal.Nil pointing to itself as metadata. But fixing that
didn't solve the whole problem, because other kinds of reference cycle
are common.

In particular, the idiom `(def! FUNC (fn* (ARGS) BODY))`, for defining
a function in the most obvious way, would create a cycle of two
objects: from the outer environment in which FUNC is defined, to the
function object for FUNC itself, back to that same environment because
it was captured by FUNC.

And _either_ of those objects could end up being the only element of
the cycle referred to from the rest of the system: it could be the
environment, if nothing ever uses that function definition, or it
could be the function, if that function object is looked up and
returned from an outer function that was the last user of the
environment. So you can't break the cycle in the way that reference
counting systems would like you to, by making a well-chosen one of the
links weak: there's no universally right choice for which one it needs
to be.

So I've fixed it properly by writing a simple garbage collector. In
Vala's ref-counted environment, that works by being the only thing
allowed to hold an _owning_ reference to any derivative of GC.Object.
All the normal kinds of link between objects are now weak references;
each object provides a gc_traverse method which lists all the things
it links to; and when the garbage collector runs, it unlinks any
unwanted objects from its big linked list of all of them, causing the
one owned reference to each one to disappear.

Now the perf3 test can run without its memory usage gradually
increasing.

vala: expose length/get/set methods for Mal.Vector.

Partly, this makes the external API less cumbersome. Mostly, it hides
the details of the class's implementation, which I'm about to want to
change.

vala: make Env's internal storage private.

This enforces that nothing outside the Env class refers directly to it, which will allow me to

vala: remove the as_glib_list helper function.

It turned out I only ever called in one place, and I'm about to change
that call site to do things differently anyway.

vala: allow metadata pointer to be null.

My base class Mal.ValWithMetadata defaulted to filling in an object's
metadata pointer with an instance of Mal.Nil. Since Mal.Nil objects
are not all commoned together in this implementation, it seems like a
lot of pointless effort to create all those extra Nil objects, when
most of them will never be consulted at all. So now we initialise the
metadata pointer to null rather than an instance of Nil, and
manufacture a Nil as the return value only when the core 'meta'
function is asked to return the metadata from such an object.

(Also, Mal.Nil itself is a subclass of ValWithMetadata, and to avoid
infinite recursion of constructors, I linked it to itself as its own
metadata, creating a trivial reference cycle. That created quite a big
memory leak all by itself! But since I'm about to introduce a garbage
collector which will solve the leakage problem much more generally,
that's no longer an important reason to make this change.)

vala: fix handling of unterminated strings.

This fixes the two test cases in Ben Harris's unmerged PR #359.

vala Makefile: add a VFLAGS variable.

This makes it easy to recompile with debug flags.

Merge pull request #370 from asarhaddon/hide-gensym-counter

gensym: hide the counter in an environment, define inc in stepA.

vala Makefile: define an empty .SUFFIXES.

This fixes an annoying make behaviour where, if the Vala compiler
leaves around a file called foo.vala.c (as it does in some forms of
compile failure), make will automatically try to rebuild foo.vala from
it. This fails, because a single valac-output source file will
basically never compile using make's default cc command – and it's
lucky it does fail, because it would overwrite a real Vala source file
if it didn't!

Defining .SUFFIXES to the empty string suppresses all the built-in
things GNU make thinks it knows about how to compile things, and
forces it to rely only on the rules actually written down in this
Makefile.

step1: Test that an empty hashmap can pass through read and print.

My BBC BASIC implementation currently fails this.

gensym: changes forgotten in last commit

Fix typos detected by automated tests.

gensym: hide the counter in an environment, define inc in stepA.

tests: check that `inc` is present in stepA.
nasm: split lines in mal_startup_string for readability.
objpascal: remove obsolete .orig file
swift: remove an unneeded line in template
swift4: remove duplicate definition of `or` macro

d: support ldc2 and dmd modes from top-level.

Symlink dmd to /usr/bin in the dockerfile so that no PATH modification
is necessary.

Also, add a runtime modes count to the README.

vala: more standard form for vala/Dockerfile

For more efficient layer sharing with other implementations.

Merge pull request #368 from sgtatham/vala

Vala

Update counters and .travis.yml.

Merge pull request #367 from kuettler/master

D: Get the code to compile with all three current d compilers

Add build rules for dmd and ldc in addition to gdc. Update Dockerfile to install all three compilers.

Add an implementation written in Vala.

I needed to learn Vala in order to work on an existing program written
in it, and since Ben Harris had been enthusing about mal to me
recently, I thought this would be a good way to learn the language.

In other words, this is my first Vala project, so I can't promise it's
perfectly idiomatic by the standards of experienced Vala programmers!

Also, the style isn't all that consistent. For example, sometimes I
implement a function for every value type by adding a method to the
Mal.Val base class, and sometimes instead I do it by having a function
(e.g. pr_str) dynamically test all the possible subtypes in a chain of
else-ifs.

Those decisions were partly because of the source file structure
required by this project (pr_str is supposed to live in its own file);
partly because for my own learning goals I wanted to try both
strategies and find out how easy they both were; and mostly just
because of indecision and bad planning.

guide.md: fix a few trivial typos.

D: Get the code to compile with all three current d compilers

- Work around a D bug to get exception handling going
- Fix imports
- Modernize pointer downcasts

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

Some fixes for unterminated strings

bash, ruby: Fix reading of unterminated strings that happen to end with '"'.

In both cases by re-using the string-matching regexp fragment from the
tokenizer.

awk: Fix reading of unterminated strings that happen to end with '"'.

perl, python, tcl: Correctly detect more unterminated strings.

In all cases, this is just by using the equivalent of the full
string-matching regexp from 'tokenize'.

While I'm in the area, also remove an unnecessary ".*" from the regexp
to match a leading quotation mark in Perl and Tcl.

nasm: fix empty list handling

Merge pull request #365 from asarhaddon/cpp-ada.2-conformance

Cpp ada.2 conformance

Merge pull request #358 from bjh21/bjh21-extra-tests

A couple of extra tests

ada.2 switch back `do` from built-in function to special form

The benefit of this devianceto the process is dubious.

C++ convert map from native to built-in

step 7 test: Add test of 'concat' on a single vector.

I thought I'd accidentally made it just return that vector, but it
turned out I hadn't.  Still, it seems like a plausible mistake to
make.

step 8 test: Check a corner case of cons/rest on vectors that I got wrong.

In the BBC BASIC implementation, lists and vectors are essentially the
same, and are only distinguished by a flag on the head node.  This makes
it cheap to convert between lists and vectors, but it does require a
little care to ensure that a vector doesn't escape where it shouldn't.
The new test checks for a case where I'd got this wrong:

(rest (cons 10 [11 12]))

Here the 'cons' returns a list, but the tail of the list is just the
original vector (complete with vector flag), so a naïve implementation
of 'rest' can end up returning that vector instead of an equivalent
list.  The test proves that it doesn't.

Merge pull request #363 from bjh21/bjh21-concat-ocaml

ocaml: Fix result of (concat [1 2]), so it returns a list not a vector.

crystal,java: fix empty list handling.

Merge pull request #362 from bjh21/bjh21-concat-ps

ps: Fix result of (concat [1 2]), so it returns a list not a vector.

ocaml: Fix result of (concat [1 2]), so it returns a list not a vector.

swift4: exit on EOF/Ctrl-D.

rpython,rust,swift4,ts: fix empty list handling.

In these implementations there is no empty list check before
macroexpansion and so empty lists from step8 onwards produce a crash
or other misbehavior.

Also, add a test to step8 to test empty list again (first time it's
tested is in step2).

ps: Fix result of (concat [1 2]), so it returns a list not a vector.

Merge pull request #360 from asarhaddon/convert-divergent-native-to-builtin

Convert divergent native functions to built-in functions.

Livescript Convert `not` from native to built-in.

Guile Convert `not` from native to built-in.

Forth Convert `not` from native to built-in.

C++ Convert `< > >= list` from native to built-in.

Converting `map` is less trivial.

Merge pull request #357 from bjh21/bjh21-minor-fixes

Another round of minor doc/test fixes

step 7 test: Correct a heading to match contents.

'first' and 'rest' applied to vectors are now tested in step 8, not step 7.

guide.md: Move description of 'sequential?' to a more logical place.

It's still a deferrable part of step 9, but now it's listed with the
other vector-related functions rather than after the hash-map-related
ones.

step9: Don't use vectors in a non-deferrable test.

According to the guide, vectors are deferrable until step A, so use
(nth () 1) in place of (nth [] 1) as a form that will generate an error.

step9: Make test of throwing a hash-map deferrable.

According to the guide, hash-maps are deferrable until step A.

Merge pull request #354 from asarhaddon/simplify-core-mal

Trivial simplifications in core.mal.

Merge pull request #356 from asarhaddon/swift4-duplicate-lines

swift4: remove duplicate definition of load-file

swift4: remove duplicate definition of load-file

Trivial simplifications in core.mal.

Replace many (= (count xs) 0) with (empty? x).

Stop definining 'not', 'or' and 'cond' in core.mal, they are defined
in the process steps.

In 'some', avoid computing the same result twice.

Explain the final nil evaluation.

Merge pull request #355 from asarhaddon/improve-ada.2

Clarify and optimize ada.2.

Clarify and optimize ada.2.

Makefile:
Drop OPT and -gnat2020, not used anymore.
Simplify file list now that each unit has a body.

README:
Remove obsolete items.

Global:
Restrict most pointers to a provable non-null value.

Types: merge intermediate Types.Mal into the Types package.  (the
intermediate package was created in order to prevent a circular
dependency, but is not needed anymore).
Most of the noise in the diff is caused by this change.
This allows to remove most Elaboration pragmas.
Declare most types abstract in the visible part,
enforcing the use of the constructor outside the declaring package.

Envs:
Replace the Get recursion with a more efficient loop.
Use MAL objects as key, string pointers do not change speed.
This delegates some checks from the step files.
Split the constructor and Set_Binds, so that an existing environment
can be reused during TCO.

Err:
Attempt to group the calls.
Avoid computing the message when the assertion holds.

Fns:
Declare and use the eval callback only here.
Separate function and macro interfaces.
Keep a reference to the provided parameter list instead of copying them.

Garbage_Collected:
Make explicit that Keep is not inherited.

Printer:
Remove obsolete inline indications and redundant Print_Function helper.

Maps:
Provide a cleaner interface copied from standard library.

Sequences: stop encapsulating the implementation because of the
performance hit.

Steps:
Move map and vector evaluations into separate functions for readability.
Replace return blocks with normal blocks (MAL values are not finalized
anymore).
Rename standard arrays instead of sequence_ptr when possible.
Remove some duplication and indentation from the apply phase.
Move the frequent special forms in front of the test cascade.
When an environment has been created in the same Eval, reuse it.

Strings:
Use the same garbage-collected storage model for all strings.
This seems faster than the default (mutable) string types.
Hide most of the implementation to avoid leaks.

Symbols: stop ensuring unique allocation of symbols. The reduced
garbage collection and comparison time was compensed by the
maintainance of a global hash.

Merge pull request #353 from bjh21/bjh21-minor-fixes

Minor doc/test fixes

Guide: when introducing read_atom, don't mention complex types.

Vectors, hash-maps, and atoms wouldn't be read by read_atom anyway.
Atoms don't even have a read syntax.  While I'm there, also correct
which step keywords turn up in (step A, not step 9).

Step 6: Make tests of '*ARGV*' deferrable.

The Guide says that '*ARGV*' is deferrable at step 6.

wasm: wax runtime. Use WASI preopen process.

Add wasi-sdk to Dockerfile to be able to compile C code to wasm that
uses WASI API calls.

README: add webassembly embeddings/runtimes.

wasm: Support/add wasmtime runtime. WASI platform.

wasm: use wam-1.0.8 which supports new binaryen.

New binaryen doesn't allow data section to contain multiple strings to
be concatenated together any more. So wamp-1.0.8 does the
concatenating for it.

wasm: direct platform, wam memory

- Rename platform_os.wam to platform_direct.wam and update the direct
  interface to use printline instead of fputs/stdout.
- Update to wamp 1.0.7 and new memory/memoryBase semantics: in
  platform_direct and platform_libc, import memory and memoryBase
  rather than relying on wamp to add it because wamp add direct memory
  and memoryBase defintions (not imports) if the program doesn't
  already define or import memory/memoryBase.
- Simplify entry point logic by moving it into the platform files.

README: reorganize slightly.

Move external implementations and other mal projects above the long
implementation details section. The implementation details are linked
to from the overview section so it's fine to have that lower on the
page.

guide.md: In step 1, correctly state how long strings can be deferred.