Rune - flesh out type support

* Pointer arithmatic now able to use any integer type and not just int32_t.

* Add += and -= for pointer arithmatic.

* More namespace separation to make functions related to interpreter
  execution more obvious.

* Cleanup several structural abstractions.

Rune - Localize interpreter code

* Localize the interpreter code

Rune - Optimizations

* Inherit SF_NOZERO so arrays of types are properly flagged.

* Test for SF_NOZERO in LVSAlloc() (for heap allocations) and use
  znalloc() if possible.

* zalloc() does not need to bzero() a runevalloc()'d (anon mmap) area, so
  don't.  Document runevalloc*() to return a zero'd area.  The area does not
  have to be faulted in.

* Test 16GB virtual allocation.

Rune - Optimizations

* Break out of the array initialization loop if the first iteration does
  no work.

* Add "__nozero", remove "uninit".  Implement __nozero to allow allocations
  to skip the bzero() in certain cases (though doing so doesn't really
  improve performance, strangely enough).

* Add "pure" and refactor the pure function / pure expression code.  Do
  not overload "const" for this purpose any more.

* Allow partial compound assignments and structural assignments.
  Fix missing zeroing of compound stack declarations.

* Add more tests, including tests/gfxslider2.d which crates 6400 buttons.

* Fix bug in slab allocator, allocations of 32767 would index zone 80
  which was beyond the array.

* Relaxed storage qualifiers for type comparisons.  Simplify typeof() and
  remove the last resolve*() call from the run-time (libgen).

* Implement EXF_REQ_DCOPY, allowing the parent of an expression to supply
  the return storage for the recursive call.  This reduces bcopy()s and
  will make code generation more optimal.

  NOTE: Calls to getExpTmpData() must occur prior to any exp recursions.

Rune - Stabilization

* Fix memory corruption, parent's argsctx was being modified by the
  child thread after the child thread detached from the parent.

* Don't use the global hash table for Thread.tsleep/wakeup

* Fixup classes and tests for new tsleep/wakeup mechanic.

* Misc cleanups.

Rune - thread work

* Move Unix.waitThreads() to Thread.waitThreads()

* Cleanup sleep and wakeup methods.  Get rid of auxillary
  structure.

  Thread.sleep(ms)
  Thread.tsleep(&rendezvous, ms)
  Thread.wakeup(&rendezvous)

* Fix gfx2

* Remove 'async', go back to the thread_schedule statement and 'preempt'.

* Build cleanups

Rune - enhance LVALUE, add heap and persist, and more.

* More work on the instruction set.

* Allow LVALUE storage to work in more contexts, not just for arguments
  and return values.

* Add support for allocated and mmap()d storage via the 'heap' and 'persist'
  scope keywords.  This feature uses the LVALUE mechanic which embeds a
  LValueStor structure (addr, refstor pointer) in the context, allowing
  addr to be dynamically allocated, mmap()d or otherwise created in an
  out-of-band manner.

* Add support for casting pointers to integers (but not the other way around).
  Pointer values can be useful for in-program unique identifiers and other
  things.  Note that Rune will NEVER allow integers to be cast back to
  pointers (and we need to make sure live .map files don't get corrupted
  as well).

* Fix numerous bugs, but add even more to the TODO.

* Reorg some of the libraries.

Rune - Cleanup 1/2

* General cleanup, with some renaming to improve portability.

rune - var-args tracking, update docs, misc

* Fix refstor handling for varargs calls and arrays.

* Install to user ~/bin and ~/.rune if not root, else install to
  /usr/local/bin and /usr/local/rune.

* Flesh out instruction set a bit more.

* Change runesize_t to unsigned 64-bits and adjust related use cases.

parser - string concat, generic type case

* Add string concat, e.g. "abc" "def".

* Superclasses will match subclasses in switch(type) / case statements.

* General cleanup for type naming conventions.

alias - Fix aliases

* The alias assignment expression must be duplicated for each use case,
  with a temporary object context pushed.

* Fix the context information.

* Fix the temporary space reservation.

parser - more cleanups

* more cleanups, better compound type detection

Parse - Bring in type and variable naming rules

* We distinguish between type/class names and non-type identifiers
  by the format of the symbol.  This is something I've always wanted to
  do to enforce a little better readability for the code, but it also
  is a huge aid to the front-end parser which has far less context available
  to it than other languages might.  We can differentiate between (type)
  and (subexpression), for example.

  - Any symbol terminating in _t _u _p or _m is considered a type/class id.

  - Otherwise if it starts with a capital letter and all the alpha characters
    are not capitalized, it is a type/class id.

  - If all alpha characters are capitalized it is a constant identifier
    (not currently enforced).

  - Otherwise it is a non-type identifier.

* Examples:

  FUBAR_t - type/class
  FUBAR - constant identifier
  Fubar - type/class
  fubar - normal identifier

* Note that if you are used to a global variable starting with a capital,
  that is not allowed in Rune.  There are numerous reasons for this but
  mainly the problem, other than distinguishing types vs variables, is
  that the global might be referenced by a class path and in that context
  the capitalization can create a lot of confusion.

sync

Interpreter - reduce compiled size, improve performance

* Do not pass RefStor **prs along the exp chain (ex_Func).  Store the
  cumulative value in the run-time context.  Most expressive elements
  do not need to access it.

  This reduces call-saved registers used by one.  Unary operators can
  now run with no save-used (about 7 instructions), and binary operators
  are more streamlined.

* Turn off a debugging assertion in getExpTmpData().  Binary operators
  are also now significantly more optimal (nominally ~26 instructions)
  and code size is further reduced.

Interpreter - reduce compiled size

* Adjust st_Func to take and return the runctx_p.  By having callers reassign
  this variable, the compiler does not need to save/restore it across
  recursive calls.

* Adjust some inlines in libi/stmt.c such that actual actions taken make
  a real procedure call, to reduce unnecessary inline expansions.

Interpreter - Incremental API changes

* Pass the run-time context through the call chain and remove the
  IContext global.

* I ultimately intend to make the run-time context a pass-and-return
  entity, which C compilers can optimize to avoid register saves and
  restores, and to move the break/continue count into the runctx.

Interpreter - Add ex_TmpOffset, remove run-time temporary space reservation

* The resolver already resolves temporary space, assign the calculated
  offset to a new field exp->ex_TmpOffset.

* Remove temporary space re-resolution from the interpreter, which saves
  instructions and speeds up the interpreter.  Just use ex_TmpOffset
  instead.

Interpreter - Collapse sign-agnostic operators

* Collapse sign-agnostic operators.  For example, the result if a signed
  addition and the result of an unsigned addition are identical, so we
  do not need to generate two operator functions for it.

* Misc documentation adjustments (D -> RUNE)

Arrays - Slight unhacking of array[] expressions

* Allow IDs from const declarations to be used in array declaration.
  e.g.  const int COUNT=50; char buf[COUNT];

* We still need to handle basic interpretation to resolve calculated
  constants that might be used in array declarations.

Core - Add cast-typeof, fix core bugs

* Allow casts to use typeof, e.g. (typeof(a))b

* Fix some broken cases in FILE.show() for char, string, and integer
  handling.

* Update the grammar file, with unimplemented items in red, and make
  other corrections and additions.

* Fix bounds check for 0-length objects.

Graphics - Fix cross-window event coordinates

* Fix slider handling in virtual sub-windows when the slider is held down.
  The coordinates were not being properly translated for the mouse focus.

* Using tests/gfxsliders.d to test.

RUNE - Initial repo re-creation

* Not saving the many prior repos.

* Basic code cleanup and modernization complete.

* This is a good starting point to track in a new repo.