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

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

- Add clean rule to Makefile and restructure deps.

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

Basic: add read-file. Misc basicpp space savings.

- Add read-file which is similar to read-string but from a file name
  rather than a string. This allows steps 0-2 to load although each
  one eventuall crashes with out of memory after evaluating "123"
  a few times.
- basicpp:
    - Renumber the line numbers so they are ordinally increasing. This
      saves 150 or so bytes because GOTO/GOSUB calls have smaller line
      numbers.
    - Shrink 'IF 123' -> 'IF123' for almost 300 byte savings.[:w
    - Simplify PR_MEMORY_SUMMARY output. Save 75 bytes
- Add missing runtest.py change that allows basic tests to pass.

Basic: hashmap functions. Basic metadata (on funcs)

- Metadata support required expanding the type size (to 5 bits). This
  also implies that ref cnt now only has 11 bits (2048).
- Added ^ reader macro (with-meta) which required some refactoring of
  READ_MACRO to share code.
- Rename some more variables:
    ZJ  -> S
    S%  -> X%
    ZR% -> Y%
    ZM% -> Y
    RE% -> D
  This removes remaining % variables apart from the pre-allocated
  arrays Z%, S% and X%.

Basic: smarter ALLOC. Keywords. Vector fixes.

- Modify ALLOC to take a type (rather than size) and take default
  values to set for the 1-3 values/pointers. Let alloc do the
  ownership taking of the referred values when appropriate.
- Add FORCE_SEQ_TYPE function to coerce sequence to given type. Fixes
  apply and rest on vector. Simplifies concat.
- Use a double ON GOTO structure for calling the native functions in
  DO_FUNCTION.
- Add some stub core functions.
- Move CHECK_FREE_LIST to debug.in.bas
- All changes together save over 1K

Basic: variable renaming. Save 2 kbytes.

Also, add variables.txt file with start of documenting meanings of
variables.

List of renamings/savings:

ZZ%   -> S%   : 131 bytes
ZL%   -> X    : 550 bytes
A%    -> A    : 192 bytes
E%    -> E    :  32 bytes
R%    -> R    : 381 bytes
AR%   -> AR   :  30 bytes
AY%   -> AY   :  71 bytes
AZ%   -> AZ   :  33 bytes
B%    -> B    :  47 bytes
AA%   -> AA   :  64 bytes
AB%   -> AB   :  25 bytes
F%    -> F    :  21 bytes
FF%   -> FF   :  14 bytes
ER%   -> ER   :  41 bytes
PR%   -> PR   :   7 bytes
T%    -> T    :  46 bytes
R0-9% -> R0-9 :  31 bytes
T0-9% -> T0-9 :  42 bytes
S1-4% -> S1-4 :  25 bytes
U0-9% -> U0-9 :  44 bytes
ZK%   -> ZK   :  10 bytes
ZI%   -> ZI   :  10 bytes
RC%   -> RC   :  16 bytes
K%/V% -> K/V  :  21 bytes
SD%   -> SD   :  16 bytes
ZS$   -> S$   :  40 bytes
HM%   -> H    :  10 bytes
SZ%   -> SZ   :  39 bytes
LV%   -> LV   :   9 bytes
EO%   -> O    :  18 bytes
C%    -> C    :   4 bytes
P%    -> P    :   4 bytes

Basic: stepA basics.

Basic: step9 basics

- Change ER% to be -2 for no error, -1 for raw string error, and >=0
  as pointer to an error object.

Basic: step8 basics. Fix def!, let*, concat, scalars.

- Move apply logic in swap! to APPLY function in types and use that
  for macroexpand
- Abort def! if error before updating the environment
- let* wasn't properly saving A2% for the final eval. Also, the
  environment release check should be against the top-level EVAL env,
  not the root repl env.
- (concat (list) ...) was broken so fix it to ignore empty lists that
  aren't in the trailing position.
- nil, false and true in the reader were always being returned as
  references (with an ref cnt) but we have the assumption that
  references (14) are not ref cnt'd and are always part of a compound
  type so fix the reader to just return the interned addresses.

Basic: basicpp adds, other misc. Shaves 3031 bytes.

- basicpp.py:
    - Fix "ON GOTO/GOSUB" label replacment
    - Add combine line capability
    - Change "THEN GOTO" to "THEN"
- Remove some spaces and unnecessary parens
- Restructure several places with multiple "GOTO/GOSUBs" statements
  into fewer "ON GOTO/GOSUB" statements

Basic: switch to python preprocessor.

- Adds ON GOTO, ON GOSUB support.
- Simplifies REM keep/drop to just yes/no

Basic: step7 basics, reader macros. step1,3 tests.

Also:
- Add some step1 and step3 tests that were discovered during Basic
  development.
- Move PR_MEMORY* to debug.in.bas
- Simplify Makefile deps
- Fix freeing in steps4-7 when error at deeper level
  i.e. (prn (abc))
- add SLICE function to support concat implementation.

Basic: reduce memory usage by 614 bytes.

- combine some lines
- remove some unnecessary spaces and parens
- add string allocations to single routine in types

Also:
- remove blank lines in qb2cbm.sh output (does not save memory)

Basic: step6 basics and atoms. Fix strings.

Also:
- command lines arguments are implemented by creating a file
  ".args.mal" that contains a list of arguments and that is loaded by
  the run script (load-file) into -*ARGS*-. The rest is put in *ARGV*
  and the first element is pulled out and used as the script name.
- fix string reading/printing using new REPLACE function
- add RE function to skip printing and to get back evaluated value
  (result must be freed by caller). Needed for step6 to get first
  argument pointer for scripting.
- Sync earlier steps
- add cons, first, rest to support parsing the command line.
- eval is implemented as standard function in core.in.mal
- fix println bug (using PR_STR rather than PR_STR_SEQ)
- change sequence printing to save the initial sequence type on the
  stack and use that for the ending sequence delimeter. This way
  sequences of one type can still use the tail of sequences of
  a different type but still be considered the initial type.

Basic: add step5, fix recursive/error memory issues.

- Add TCO recur to let*
- Release of all memory from recursive function and let* calls.
- Fix a number of cases of trying to release already freed memory.
- Print function in memory as 2 byte unit rather than two separate
  memory locations.

Basic: fix readline to work on C64 (Vice).

Also, add cbmbasic console patch that makes it work more like the C64
where GET does not echo.

Basic: Add memory management. More step4.

Also:
- More/better detail in PR_MEMORY/PR_MEMORY_SUMMARY
- Fix *.prg image build (for running under Vice). Have to lower-case
  everything since what C64/Vice shows as capitals are actually
  lowercase.

Basic: move environment into normal memory.

Basic: most of step4.

Basic: add step3, vector/hash-map evaluation.

Also:
- qb2cbm.sh: Add KEEP_REM level variable to tweak which REM/comments
  are emitted/skipped.
- fix printer issue with recursive sequences after evaluation (with
  refeerences in them)
- add stats target

Basic: step2 basics. Vectors and hash-maps.

Adjust step2 tests to keep values within 2 byte int range.

Basic: step1 basics.

Basic (C64 v2): step0

This works with cbmbasic from https://github.com/mist64/cbmbasic. The
cbmbasic interpreter needs to be on the PATH.

The actually sources are *.in.bas which are "compiled" to *.bas using
the qb2cbm.sh. qb2cbm.sh translates from a QBasic-ish format to a line
numbered source with include files inlined (REM $INCLUDE: 'file.bas').
One additional advantage is that the *.in.bas versions can also be
indented and qb2cbm.sh will remove the indenting in the translated
code.

Merge pull request #231 from iqbalansari/master

Update README to mention CLISP implementation

Add GNU CLISP to the list of implementations

Do not start MAL REPL if code is executed in Emacs (specially via SLIME)

Add interop

- clisp-eval: allows executing Common Lisp
- define-builtin: allows defining builtin functions on the fly

Intern symbols in mal-user package while unwraping MAL values

Print startup header when REPL starts

Fix path of history file for readline

Merge pull request #230 from iqbalansari/clisp

Add MAL implementation in clisp

Add make target to clean generated files

Add readline integration support to the REPL

Use only clisp specific features

Compile clisp files before running

This step gives really good speedups, there still seem to be some
bottlenecks around evaluation which need attention

Move exports from types package to the top

Use singleton values for nil, true and false

Avoid creating unnecessary symbols for special froms in eval

Make sure dependencies are loaded only once

Coerce results of division to a non fractional value

Use find-env instead of get-env in is-macro-call

Apparently the earlier approach with all its error handling is slower

Cleanup mal-value=

Store symbols as strings

Rename mal-type to mal-data

Use maphash to print hash-tables

Use compiled string and digit regular expressions

Use compiled regex instead of raw ones

Trying out defstruct instead of defclass for MAL types

Optimize tokenizer a bit

Avoid ignore-errors forms, apparently the ignore-errors form cost around
100 milliseconds in step 1 tests

Add travis config for clisp, also add stats target for clisp

Rename common_lisp to clisp

Make mal-errors catchable, self hosting is now complete

Remove implementation of print-object for MAL objects.
Also note the slowness of the implementation

Implement step A

Implement all core functions required for step 9, completes step 9

Add nil?, true?, false? and symbol?

Add 'apply' and 'map' core functions

Add throw core function

Add try* special form

Introduce types mal-runtime-exception and mal-user-exception types

All the exceptions generated by runtime inherit from mal-user-exception
while user exceptions inherit from mal-user-exception

Improve error handling

Implement or and cond macros, completes step 8

Implement nth, first and rest

Add support for macros and macro expansion

Implement quasiquote, completes step 7

Add cons and concat

Add unwrap value to convert from mal type to native types

Eval keys of hash-map as well

Add *ARGV*, completes step 6

Add all required atom functions

Fix reading of quotes

Add atom type

Add load-file function

Add `eval` builtin

Handle non-mal datatypes in mal-value=

Implement slurp and read-string

Implement tail calls for functions, completes step 5

Implement tail calls for 'let*', 'if' and 'do'

Implement print_readably, completes step 4

Implement equality between vectors and list

Implement `not` in MAL

Treat nil as a list in list?

Add support for variadic arguments

Make sure the REPL does not crash on unknown errors

Fix wrapping of Common Lisp value into MAL values

1) Since nil and t are symbols also, we need the specific clauses
i.e. null and boolean before symbol clause
2) Since nil stands for both an empty list as well as false in common
lisp as opposed to MAL where these are distinct values, we need to use
explicit flag while wrapping them

Teach mal-value= to compare list and hash-maps

Use symbol name while comparing mal-symbols

Initial attempt at adding core functions required for step 4

Implement fn*, do and let*

Allow specifying initial set of bindings while creating new environment

Add support for printing functions

Implement step 3 (environment)

Add mal-environment class

Update apply-unwrapped-values to also wrap the result into a mal type

Complete implmentation of step 2 (eval)

Add printer for built-in functions

Export predicates for checking MAL types from types package

Teach MAL about number signs

Change the way meta is handled

This might require some more modifications in future