Merge pull request #439 from bjh21/bjh21-perl

Final (?) perl improvements

perl: Add a README file containing some facts.

Update version requirement for perl.

I don't think it's worked on perl 5.8 for a long time.

perl: Rework 'do' to not use 'splice' and 'rest' methods.

I feel that it's more perly to directly use Perl's array manipulation
functions.  It's certainly more consistent with the other special forms.

perl: Replace $a1, $a2, and $a3 in EVAL with usefully-named veriables.

This means that most of the special forms have an assignment at the top
giving names to the members of @$ast.  I think this makes the code a
little more readable.

perl: Use a proper Mal::Keyword type.

Representing a keyword as a Mal::String with a magic first character was
beginning to annoy me, so instead create a proper Mal::Keyword class.
To support using both Mal::String and Mal::Keyword as hash keys,
overload stringification on all Mal::Scalar subclasses.

This means that now instead of a Mal::String stringifying to something
like "Mal::String=SCALAR(0x5744ea58)", it will stringify to something
more like "Mal::String abc", which is readable, has the correct
properties for a hash-map key, and is easy to convert back into a
Mal::String.

This turns out to work perfectly well, and entirely accidentally
arranges that 'keyword' now works properly when fed a keyword as input.

make: revert/correct fix for plain undef symbol.

The return value from _error was causing some breakage in other error
handling. Instead, return a value from the spot where the undefined
symbol error is set. This achieves the desired fix without breaking
other unclosed sequence errors.

graph: update bbc-basic. Exclude more from LOC.

Pull in bbc-basic update that allows loccount to properly count the
files.
Exclude more documentation and configuration files from LOC counts.

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

bbc-basic: Switch to filenames ending ".bas".

bbc-basic: Changes consequent upon file renaming.

To allow the same BASIC source (and in particular, LIBRARY statements)
to work on both Unix and RISC OS (the latter of which doesn't allow '.'
in file names), create symlinks to all the libraries from their
unadorned names.

bbc-basic: Rename all files of BASIC code to *.bas.

This should help things to recognise what they are.  Consequential
amendments in the next commit.

This also removes toktest, which is unnecessary now.

graph: BASICs are statically typed.

docs/graph: add bbc-basic, vala. General updates.

Incorporates fixed LOC stats that correctly ignores steps 0-9 and
ignores generated files and external downloaded dependencies.

stats: exclude steps 0-9 & generated/extern files

make: fix catch of undefined plain symbol

The _error function was returning an empty string which meant that in
the try*/catch* implementation, the lack of result was preventing
foreach from being used as a "let" form and because of that it was
skipping the catch* handling path.

Merge pull request #359 from bjh21/bjh21-unterminated-strings

New test for reading an unterminated string that nonetheless ends with a quotation mark

Merge pull request #436 from dubek/vhdl-fix-unterminated-strings

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

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

Issue #359

factor: detect unclosed strings.

Detect strings that are not properly terminated.

perl6, r, skew: detect unclosed strings.

Detect strings that are not properly terminated.

swift: detect unclosed strings.

Detect strings that are not properly terminated.

wasm: check for invalid string in read_form

rpython, swift3, wasm: detected unclosed strings.

Detect more cases where strings are unterminated.

guile, matlab, nim, ps: detected unclosed strings.

Detect more cases where strings are unterminated.

coffee, dart, elixir, elm: detect unclosed strings.

Detect more cases of strings being unterminated.

Merge pull request #435 from bjh21/bjh21-perl

perl: New metadata and TCO and other changes

perl: Remove a temporary variable in functions defined by 'fn*'.

I'm in favour of meaningful names for the members of @_, but naming a
reference to @_ "$args" really doesn't gain much.

perl: Use // instead of ?: when evaluating "else" clause of 'if'.

perl: Simplify string unescaping code.

perl: Sightly simplify 'swap!'.

perl: Use '//' operator to make pr_str slightly simpler.

perl: Use pairmap to make printing hash-maps simpler.

Also tidy up printing code for sequences a little.

perl: Use more string interpolation in the printer.

perl: Avoid substr in favour of $1 and $'.

It just seems more perlish to use regexps where they're sensible.

perl: Remove experimental given/when syntax from interop.pm.

It doesn't gain anything over for/if, and removing it avoids a warning.

perl: Avoid excessive copying in Mal::Sequence::rest and ::slice.

There's no need to copy the input into @arr and then copy the bits we
care about into the output array.

perl: Replace _string_Q with ->isa('Mal::String') && !->isa('Mal::Keyword')

That's a bit ugly, but it gets rid of the last type-predicate function.

perl: Replace _keyword with Mal::Keyword->new.

It's not really a constructor for Mal::Keyword (because there's no such
class), but it looks similar enough for most purposes.

perl: Replace _keyword_Q with ->isa('Mal::Keyword').

There isn't actually a Mal::Keyword class, but perl lets us override
"isa" so we can pretend there is.

perl: Enhance Mal::HashMap::new to take an array reference.  Use this.

This replaces _hash_map and has the nice feature that it looks just like
the constructors for Mal::List and Mal::Vector, so the reader can treat
them all the same.

perl: Abolish most of the type predicates in favour of ->isa().

_string_Q and _keyword_Q survive because they distinguish two mal types
that are represented by the same Perl class.

perl: Abolish most of the complexity of function classes.

Now there's just Mal::Function, which is the old Mal::CoreFunction.
Macros are represented by Mal::Macro, a different subclass of the same
parent.

perl: Use goto &NAME for tail-call optimisation.

This is rather contrary to the guide, which expects a loop in EVAL, but
perl is unusual in having native support for (manual) tail-call
optimisation and it would seem a shame not to take advantage of this.

This leaves macros broken since all functions are now implemented as
core functions, and we don't yet have support for turning them into
macros.

perl: Convert sequences into blessed array references.

The extra hash was only used to hold metadata.

perl: Remove FunctionRef class.

Now that metadata can be attached to a CoreFunction, there's no need
for the proxy class.

perl: Convert atoms into simple scalar references.

perl: Replace _clone() with a ->clone method.

This means that each class is responsible for cloning itself, which
helps with encapsulation.

perl: Simplify hash-map implementation.

Now that metadata is external, we can remove the layer of indirection
in the HashMap class and have the top-level hash contain the hash-map
contents.

perl: Remove old metadata implementation.

Several objects are now single-member hashes, which is obviously silly.

perl: Introduce fieldhash-based metadata implementation.

Rather than attaching metadata directly to objects, hold it in a
auxiliary hash keyed by object ID.  Perl's Hash::Util::FieldHash
provides a means to do this with proper garbage-collection.  This does
mean that cloning an object no longer brings its metadata along, but I
think the only use of _clone outside of attaching metadata is to make
macros, and (for now) mal doesn't require that 'defmacro!' preserve
metadata.

This commit only adds the new metadata system.  Most of the old one is
still lying around.

perl: Replace _sequential_Q in step files with ->isa('Mal::Sequence').

Skip perf for second-order self-hosted tests.

Fix second-order self-hosting.

The `_map?` function was introduced when transitioning the macro
property being stored in metadata to uinsg a regular map with
a special key. The `_map?` function causes issues in a few places but
the biggest issue is that it breaks the `_macro?` function for the
second order self-hosted mal instance. The `_macro?` function contains
a `(map? x)` call that returns false resulting in the `_macro?` call
returning false.  I'll push something later that fixes this and also
that activates second order self-hosted tests so we can catch this
sort of issue in the future.

Merge pull request #387 from asarhaddon/test-macroexpand-no-quasiquote

test macroexpand without assuming that quasiquote is a special form

Merge pull request #415 from asarhaddon/load-file-trailing-new-line-nil

load-file: accept final comment without new line, return nil

Java: fix escaping of '/'.

Switch to escapeJava which won't do escaping of forward slash.

Merge pull request #432 from bjh21/bjh21-perl

More perl improvements

Merge pull request #433 from bendudson/fix-nasm-empty-args

Fix nasm zero argument function call

Applying changes to step6 - stepA

Tested stepA, function with empty args still working.

Fix step 5 call function no args

Previously failed on
```
((fn* () 4))

```
due to freeing the list containing the function too early.

perl: Simplified and tightened implementation of 'try*'.

This also fixes a bug where the last character of the stringification of
an exception object might get removed.

perl: Remove _nil_Q(), _true_Q(), and _false_Q().

They were almost unused, and 'eq' is slightly more self-explanatory.

load-file: accept empty file or final comment, return nil

Let `load-file` append a new line in case last line contains a
comment.

Also append `nil` so that the return value is predictible. Remove the
existing explicit `nil` from existing sources.

Adapt documentation and tests.

perl: Polish _equal_Q a little.

It now uses "unless" rather than "if", uses "isa" rather than
_sequential_Q, doesn't bother with temporary variables for the types
of the arguments, and doesn't special-case symbols.

perl: Re-FATALise the "recursion" warning from step 5 onwards.

The step 5 tests expect that deep recursion will cause an exception, and
not just a warning, so they can prove that TCO is working properly.

perl: Use "foreach" for variable bindings in Mal::Env::new.

perl: Move 'pl*' to core.pm.

The guide says that 'quux-eval', which the perl implementation calls
'pl*', should be a core function.  I can't see any good reason why it
shouldn't be, so I've turned it into one.

perl: De-FATALise warnings.

The documentation says, 'the use of "FATAL => 'all'" is discouraged', so
it better to leave them non-fatal.

perl: Tidy up imports at the top of each file.

I kept not knowing where to add things, so I've roughly sorted them into
pragmas, then external modules, then internal modules.  This helps with
the situation that internal modules are named in lower case, which is
odd for Perl (but normal for mal).

perl: Remove step 0.5.

It seems to be just a less-complete version of step 0.

perl: Simplify call to Mal::Env->new in 'catch*'.

Mal::Env->new doesn't need its array references to be blessed, so just
pass them plain.  This saves a bit of messing about with Mal::List->new.

perl: Use autodie in 'slurp', getting us better error messages.

perl: Propagate exceptions through 'pl*'.

perl: Be more careful when investigating the type of an exception.

It's not safe to call "isa" on unblessed references, and not all
reference types are valid mal values.  Now only actual mal values get
treated as such and everything else gets printed as-is or converted to a
Mal::String.

perl: When converting perl values to mal ones, convert undef to nil.

perl: Introduce Mal::Type: a superclass for all the mal value classes.

This makes it simple to check if a perl object is one that can be passed
to mal code (e.g. in an exception handler).

perl: Remove use of "autodie" in REPL.

"autodie" has lexical scope and doesn't affect "print", so it's useless
using it in a scope that only contains a "print" and a call to EVAL.

perl: Make a Mal::Scalar superclass for scalars.

It contains a constructor that can be shared by all of them.

perl: Rename all mal classes to begin with "Mal::".

Perl package names (and hence class names) are global, meaning that if
any module that we use loads a module called "Symbol", it will clash
with mal's Symbol class.  It turns out that something does this already,
which breaks inheritance from mal's Symbol class.  Since most of mal's
class names are very generic, it seems wise to rename all of them.

perl: Remove now-unused HashMap::get method.

perl: Use '//' instead of '||' to provide defaults.

This avoids depending on the fact that all mal values are true.

perl: Simpler handling of symbols in step 2.

perl: Use string interpolation on "not found" error message.

perl: Simplify code of eval_ast as applied to sequences and hash-maps.

Specifically, the hash-map case now uses 'pairmap' to avoid the need for
a 'for' loop.  The code for sequences is now shared between lists and
vectors, since only the destination type differs.

perl: Abolish _assoc_BANG.

_hash_map and assoc both get simpler by not using it.

perl: Fold some simple core functions into %core::ns.

perl: Tidy up whitespace in table of core functions.

perl: Fold _dissoc_BANG into dissoc and simplify.

I particular, Perl allows for batch deletion of hash elements, so we can
delete all the unwanted keys at once.

perl: Use List::Util::pairs instead of "for (;;)" in 'let*' and 'assoc'.

basic: args file that doesn't rely on return value.

Instead, the file itself does the def of -*ARGS*-. The behavior that
the final value of a loaded file is returned is not necessarily
something we want to assume.

Merge pull request #430 from bjh21/bjh21-perl

perl: Idiomaticity improvements (and some bug fixes too)

Merge branch 'master' into bjh21-unterminated-strings

This should fix ocaml.

perl: Clone functions before turning them into macros.

This ensures that the original function can still be used as a function
if need be (and fixes a soft test failure).

perl: Overload '@{}' and '%{}' on Nil.

This means that various core functions that used to special-case $nil
can now just treat it as a list or a hash-map and it will behave like
one.

perl: Take advantage of all mal values' being true to simplify code.

Where a function retrieves a mal value from a collection, use '||' to
provide the default case rather than checking the index or hash key in
advance.  This requires that all mal values (even $false) be true in
Perl, but EVAL already requires that.

perl: Replace 'scalar(@x) > 0' with simply '@x'.

Using an array in a boolean context to check if it's non-empty is a
common Perl idiom.

There are still explicit uses of 'scalar' to get the precise length of
arrays, because I think the implicit behaviour there might be confusing.

perl: Remove a completely useless use of 'scalar'.

perl: Don't use regexps in 'when' clauses to match fixed strings.

perl: Replace %core::core_ns with %core::ns.

This follows the naming scheme recommended by the guide, and seems
natural in Perl.

perl: Turn $core_ns into %core_ns.

I found myself assuming it was the latter, which is a pretty good sign
it's unidiomatic.