TODO

• [X] class:abstract-class
• [X] class:character-sequence
• [X] class:collection
• [X] class:condition-class
• [X] class:<function>
• [-] class:function-class
• [-] class:hash-table
• [X] class:list
• [X] class:metaclass
• [-] class:method
• [X] class:name
• [X] class:sequence
• [-] class:simple-class
• [-] class:simple-function
• [-] class:simple-method
• [-] class:simple-thread
• [X] class:super-class
• [X] condition:condition
• [X] condition:no-converter
• [X] condition:methods-exists
• [X] condition:read-error
• [X] defform:defmacro
• [X] defform:defun
• [X] function:eq
• [X] function:eql
• [X] function:end-of-stream
• [X] function:fill-buffer
• [X] function:=
• [X] generic:binary<
• [X] generic:binary=
• [X] generic:eql
• [X] generic:eq|
• [X] generic:equal
• [X] generic:generic-prin
• [X] generic:method
• [X] generic:mod
• [X] generic:read
• [X] keyword:accessor
• [X] keyword:export
• [X] setter:method-function
• [X] syntax:unquote-splice

• Comptime2/64bit/cg-exec.em
• Comptime2/32bit/cg-exec.em

Into

• Comptime2/cg-exec.em
• Comptime2/64bit/cg-exec-nbit.em
• Comptime2/32bit/cg-exec-nbit.em

• ARGDECL
• PROTOTYPE

• Add header-files including the ffi definitions to all the Modules libraries.
  

(defmodule youtoo
;; Final, proper executable!
(import (level-1 math eval i-aux0 syntax-1))

(main *argv*)

)  ; end of module

but sometimes remains in the intermediate build state

(defmodule youtoo
;; Preliminary executable!
(import (level1 math eval))

(main *argv*)

)  ; end of module

during the boot-strap build. The consequence is that the final executable is unable to compile module files correctly issuing errors like

*** ERROR [nuseq][top-level]: exported lexical binding subseq not available
*** ERROR [nuseq][top-level]: no lexical binding defgeneric available
*** ERROR [nuseq][top-level]: no lexical binding subseq available
*** ERROR [nuseq][top-level]: no lexical binding seq available

This is resolved by using an external previous build of youtoo to bootstrap.

• There is a problem with the need for double escaping: #\\x000, #\\\ etc.
• Hexadecimal sequences are hard-coded to 3 digits, if not where is the end?
• How should the character '^' be written given that it is used to define control sequences e.g. #^c ? Perhaps #^ ?
• Proposed solution
  To remove support for control sequences which are unusual, system-dependent and can be created using hexadecimal characters. Also fix the number of hexadecimal digits for a character to 4 which is sufficient to support unicode but also avoids parsing problems.

• [X] Add level-1 as copy of level1
• [X] Change all uses of level1 level-1
• [X] Remove level1

(defmodule test
  (import (level-1
           (rename ((something something-else))
                   (only (something)
                         things))))
  ) ; end of module

• Add additional optional module argument to eval to set the environment in which the eval evaluates which defaults to the current module.

However, unlike the proposal in the report an additional restriction is added that it is exported environment in which eval operates rather than the complete lexical environment within the module. This restriction is necessary because only the exported environment is guaranteed to exist at "eval" time; the rest of the internal lexical environment may not be complete due to, for example, compiler optimisations.

The basic functionality is now complete and a simple example provided in Examples/Eval but currently there is no way to know what the current module is so the additional "optional" argument is currently required e.g.:

(eval (read lispin () ()) 'eval-test)

It may be possible to remove this limitation by either keeping a local variable in each module holding the module name or by converting eval into a macro so that the module name can be expanded into the optional argument slot during compilation. This is now implemented.

• remove <simple-string>, <simple-vector> etc.
• add <sequence>, <character-sequence> etc.

(rename
  ((begin progn)
  (pair? cons?)
  (real? float?)
  (real? double-float?)
  (procedure? function?)
  (eq? eq)
  (eqv? eql)))

• Currently symbols or interned with capitalised names.
• This can only be corrected by enabling case-preservation in CL:
• (setf (readtable-case readtable) :preserve)
• The consequence is that all standard CL symbols must be written in uppercase.

1. the macro definitions are not yet moved to the def-file;
2. variables imported from c are not moved to the def-file because include-statements for the c-preprocessor can't be generated, due to the explicit declaration of c-import in the module interface without connection to the variable declarations.

(%define-function (class-precedence-list <cons>)
  ((cl <class>))
  (%select cl <class> class-precedence-list))

(print (class-precedence-list <null>))

• Rename <execution-condition> as <general-condition>
• Rename <syntax-error> as <read-error>
• Rename <slot-description> as <slot> (and all other such references)
• To remove <structure> and <structure-class>