Basic: various memory savings.

- simplify DO_CONCAT.
- inline MAL_READ/PRINT.
- comment out memory debug/sanity checks.
- more aggressive space removal.

Saves over 900 bytes.

Increase Z% value memory by 374 to 9216 (8192+1024).

Basic: more efficient/correct file reader.

- read one character at a time from the file instead of chunking it
  into the A$ string.
- fix an overflow that was happening during reads of long forms.

Merge pull request #250 from dubek/skew

Add Skew implementation

Merge pull request #248 from iqbalansari/common-lisp

Portable implementation in Common LISP

Common Lisp: Add support for running on ABCL

Common Lisp: Use a custom hash-function when running on ABCL

Common Lisp: Load libraries silently

Add Skew implementation

See http://skew-lang.org/ for details on the Skew language. Currently
Mal only compiles to Javascript, as there are some issues with the C#
backend for Skew (https://github.com/evanw/skew/issues/19).

Tested with Skew 0.7.42.

Basic: miscellaneous memory savings.

- Use variables A1, A2, B2 for Z%(A+1), Z%(A+2), Z%(B+2) respectively.
- Replace Z%(R)=Z%(R)+32 with GOSUB INC_REF_R
- Add functions TYPE_A and TYPE_F for (Z%(A)AND 31) and (Z%(F)AND 31)
  respectively.
- Inline NATIVE_FUNCTION and MAL_FUNCTION.

All together saves over 500 bytes so increase Z% value memory by 250
entries.

Common Lisp: Remove GNU CLISP specific implementation

Common Lisp: Add documentation

Common Lisp: Add wrapper shell code to change to script's directory when
cl-launch scripts are run

Common Lisp: Use a custom hash-function when running on ECL

ECL's sxhash function does not seem to be consistent for compound data types

Common Lisp: Suppress messages from CMUCL while restoring image

The 'Reloaded library ... ' messages were causing some tests to fail

Common Lisp: Fix `println` on GNU CLISP

Use `write-line` instead of `(format *standard-output* ... )` since the former
seems to be printing an extra newline at the start

Common Lisp: Initialize standard streams in GNU CLISP on startup

Without the initialization CLISP seems to be interacting wierdly with PERL_RL
flag

Common Lisp: Keep track of the implementation used to build a step

Rebuild the step if the implementation changes

Common Lisp: Allow user to select the implementation to use for building MAL

Common Lisp: Ignore fasl and lib files

Common Lisp: Enable travis for Common Lisp

Common Lisp: Add Dockerfile for Common Lisp implementation

Common Lisp: Add tasks for stats and stats-lisp for Common Lisp implementation

Common Lisp: Implement step A

Common Lisp: Implement step 9

Common Lisp: Implement step 8

Common Lisp: Implement step 7

Common Lisp: Implement step 6

Common Lisp: Implement step 5

Common Lisp: Implement step 4

Common Lisp: Implement step 3

Common Lisp: Implement step 2

Common Lisp: Implement step 1

Common Lisp: Implement step 0

Basic: refactor memory layout.

Use a one dimensional array for the Z% value array. This enables
lists, vectors, environments and metadata pointers to all save off
1 word (2 bytes) of space.

Split the memory init and functions into mem.in.bas.

In addition, change type 14 to be metdata rather than any type 16-31.

This change saves about 560 bytes (no second array dimension
subscripts) and reduces Z% value usage by 10%-15%.

Bump the number of Z% words by 200 (to 8591). This enables
self-hosting up to step7 (without step8-stepA functions in core.mal).

Basic: use RE from REP.

Basic: refactor of hashmaps, map loops, remove derefs.

- Alternate memory layout of hash-maps:

Instead of hash-maps being an alternating sequence of keys and values,
combine the key/values into a single entry. In other words, switch
from this:

    8   ->  next Z% index (0 for last)
    14      key/value (alternating)

To this:

    8   ->  next Z% index (0 for last)
    key     value

This requires refactoring of the sequence reader, EVAL_AST and
especially DO_HASHMAP and DO_KEY_VALS. So that leads to the next big
refactoring:

- Change mapping/lapping constructs to share code:

Several pieces of mapping/looping code have a common structure, so
this moves that common structure to types.in.bas: MAP_LOOP_START,
MAP_LOOP_UPDATE, MAP_LOOP_DONE. Then use this code in:
    - EVAL_AST
    - READ_SEQ_*
    - DO_MAP
    - DO_HASH_MAP
    - DO_KEYS_VALS

This also fixes the issue that several of these looping constructs
were creating new empty sequence entries instead of using the common
ones at the beginning of memory.

- Remove the use of DEREF_*.

This isn't actually needed because we no longer create structure that
refer to multiple levels of type 14 references. Replace DEREF_* with
VAL_* which gets the value of a particular sequence element i.e.
Z%(A+1,1).

All together, the above changes save over 300 bytes.

Also:

- Fix empty nil/false/true entries so they
  are treated the same as other types of data with regards to
  reference counting and ALLOC/RELEASE.
- Add a new memory summary function in debug.in.bas that just prints
  out free, value count, and references for the early scalar and empty
  list elements. Comment out the larger one. This saves about 90
  bytes.

Merge pull request #249 from hterkelsen/dart2

Add Dart implementation

add dart/Makefile stub

update travis file

add dart Dockerfile

update number of languages Mal is implemented in

update readme

use tabs for Makefile

fix makefile

Merge branch 'master' into dart

add Dart implementation

Basic: more reductions. RELEASE refactor.

Save about 400 bytes.

Increase value Z% array by 100 to 4195.

Reduce string array by 1 (to 199) since in BASIC the value is the last
index not the size.

Basic: memory savings and variable simplifications.

In core move incrementing of function index into
INIT_CORE_SET_FUNCTION. Switch 3 IF GOTO to ON GOTO. Reuse some
temporary variables.

Saves about 480 bytes.

Bump value array from 3950 to 4096. This allows step4 (sumdown 2) to
pass. Previously only (sumdown 1) passed.

Basic: add pr-memory-summary core function.

- Remove test POKE commands.

Ada: add ada/obj to .gitignore

README: note ChucK tested on more than just Arch.

Basic: move logic/release stack to $C000

Uses stack PUSH*/POP*/PEEK* routines instead of direct X% and Y%
access. Seems to be about the same performance (maybe a 5% performance
hit at most).

This gives us a larger stack (1920 2-byte words of $C000 rather
than 200 words as before). The release stack at $CF00 stays the same
size (64 4-byte addr/level entries).

Also saves over 1K or program and array space. So take the opportunity
to expand Z% entry space from 3712 to 3950.

Basic: reduce variables. Fix func printing.

- Save over 450 bytes. Bump up Z values by 128.
- Fix function printing when function is embedded in something else by
  using strings storage as a stack while printing rather than using
  RR$
- Simplify some error messages and sanity checks in RELEASE.

Basic: add string memory mgt. Fix eval, symbol fns

Basic: more memory savings

- Do the pop of CALL return value at the end of the subroutine
  (callee) rather than at the call point (caller)
- shorten some character variables (CH$->C$, CH->C)
- remove spaces after OPEN, GET
- print REPL header directly in BASIC code

Together saves 404 bytes of memory.

Basic: more aggressive space removal

Saves over 1200 bytes so that Z% value space can be bumped up by 256
entries.

Ada, C: fix step3 error handling.

New step3 tests were added during basic implementation that broke Ada
and C.

Basic: capitalize BASIC

I guess.

Basic: update to 61 impls after merge.

Merge branch 'master' of github.com:kanaka/mal

Merge branch 'basic'

Basic: update the README.

Merge pull request #247 from chr15m/php-interop-extended

Php interop extended

Basic: add QBasic support.

make MODE=qbasic stepA_mal.bas
qb64 stepA_mal.bas

Added interop notes to README.

Merge branch 'master' into php-interop-extended

Tests for new PHP interop functions.

Tighter PHP interop using '$' and '!' fns.
($ _SERVER) returns a mal hash-map holding the contents of the $_SERVER superglobal from PHP.
(! file_get_contents "https://github.com") returns a string containing the github homepage.
file_get_contents is a native PHP function.

Allow printing of more PHP types.
In case return type from interop is a complex native PHP type.

New functions for converting between PHP and mal types.

Basic: enable Travis testing.

Basic: pass required tests. Printer fix.

Also, move dissoc and hashmap equality tests to optional/soft since
they aren't actually needed for self-hosting.

Basic: add Dockerfile

- installs patch cbmbasic

Basic: d64 disk image build rules.

- Include .args.mal file and core.mal into the image.

Merge pull request #246 from def-/master

Update Nim to 0.15.2, clean up compiler warnings

Update Nim to 0.15.2, clean up compiler warnings

Merge pull request #245 from dubek/vimscript-use-vim8

Vimscript: Use Vim 8.0

Basic: fix step6 arg test. Gensym. Misc cleanup.

- Strip linefeeds in run_argv_test.sh so that step6 arg test passes
  for basic.
- Add gensym and convert or macro.
- Add gitignore entries for transpiled basic sources.
- Add conj/seq stubs so that step4 self-host loads (if non-step4
  functions are commented out in core.mal)
- Bump up Z% value space by 256 spaces (1K)
- Remove old qb2cbm.sh

Merge pull request #244 from chr15m/php-web-run

Allow web exec of a .mal file via symlinked php script.

Basic: fix errors, reader, if form. Self-host 0-3

- Stop let binding eval on error. Also don't continue into EVAL if
  error.
- if without a false position was freeing up too much when it
  finished.
- fix reader so that it doesn't keep incrementing ref cnt of static
  empty sequences.

Basic: use static empty sequences in reader.

- Add vector and hash-map empty static sequences in types

vimscript: Use map and lambda in EvalAst

vimscript: Remove useless calls to ObjQ

vimscript: Remove calls to ObjType

vimscript: Remove calls to ObjValue

Basic: implement CALL in basicpp.py and use it.

- Add clean rule to Makefile and restructure deps.

Documentation for the web-run functionality.

vimscript: Simplify *ARGV* setting using map and lambda

vimscript: Update Dockerfile to install Vim 8.0

vimscript: Use Vim 8.0 lambdas to reduce boilerplate code

vimscript: Increase the unixtime base to make sure time-ms fits in a *positive* integer

vimscript: Fix misinformation in comment

Merge pull request #239 from wasamasa/picolisp

Picolisp

Add interop and tests

Extend README

Add docker support

Merge pull request #243 from wasamasa/assoc-update-tests

Ensure assoc updates maps properly

Merge pull request #242 from wasamasa/elisp-emacs25

Emacs 25.1 fixes

Basic: Reduce GOSUB use. Partial self-host to step3

step4 runs out of space attempting to load the program. Step2 and
step3 run out of memory (stack exhaustion) for more complicated forms.

- Use GOTO with return label on our stack instead of GOSUB for:
    - APPLY function in types.in.bas
    - "apply", "map" and "swap!" core functions
- Implement DO TCO. Change EVAL_AST to detect if we are called from DO
  and exit one element early.
- Remove GOSUB recursion from EQUAL_Q
- Inline PAIR_Q. Reduce REPLACE stack use.
- Remove one level of GOSUB/stack by calling REP with GOTO
- Simplify mal/step2_eval.mal to remove use of (or ) macro in
  eval_ast.
- Fix ON GOTO/GOSUB line detection in basicpp

Allow web exec of a .mal file via symlinked php script.
ln -s  mal.php myscript.php
Then create myscript.mal will get run when the user visits /myscript on a PHP capable webserver.