EEL 0.1.11 (20070105)
* Added scaling by 2 and 0.5 respectively for
fft_real() and ifft_real(), to give all bins
the same (unity) scale.
* SDL.PlayAudio():
* Takes mono or stereo data
* Supports integer samples (assumed to be
32 bit signed values)
* Supports indexable data containers
* Clamps real typed data to avoid wrapping
* eel_vdisown() renamed eel_v_disown(). (The
internal eel_v_disown() is now more appropriately
named eel_v_disown_nz().)
* Implemented slice() for 'vector' and 'array'.
* Moved the EEL compiler into a separate subdir.
* File naming conventions changed:
* API header files:
EEL_*.h
* EEL core (VM, core types...) source files:
e_*.[ch]
* Standard module source files:
e_*.[ch]
where is a reasonably short acronym.
* EEL compiler source files:
ec_*.[ch]
* "Throw in" libs and the like:
No prefix.
* e_file.[ch] renamed io.[ch]
* All standard modules (math, io, dir and dsp so far)
are now in separate subdirectories, in preparation
for some of them becoming dynamically loadable.
* DSP module:
* Added add_polynomial() optimizations for all
vector types.
* Added FFT/complex tools:
* c_abs(), c_arg()
* c_set(), c_add()
* c_set_polar(), c_add_polar()
* c_add_i(), c_add_polar_i()
* polynomial_i(), add_polynomial_i()
* EELBox:
* Added quick hack MIDI module. (ALSA only.)
* Added fftsynth.eel
* Some examples fixed for less CPU hogging
* guiscroll.eel added to the test script
* Minor code cleanup, error message type fixes etc...
* Split the TODO up into a proper TODO (things that
should actually be done), and a BRAINSTORM file,
intended for all sorts of wild ideas that may or
may not make it into the TODO eventually.
* The compiler code_fixup_*() functions now set "break
target" events as needed to ensure that the dead code
elimination doesn't kill their landing spots.
* LIST type 'modulo' field renamed 'stride'.
* Fixed various printouts that ignored LIST stride.
* Major bug fix: The LRIGHTI instruction now considers
the stride of the original LIST.
* Major bug fix: The fake callframe created when
calling a C functions is now removed whether or not
the function returns with an exception.
* slice() and metamethod SLICE renamed copy() and COPY,
to avoid confusion with the upcoming non-copying
slice objects.
* copy() (former slice()) now accepts one (copy all),
two (copy through end) and three (copy range)
arguments.
* Win32: timeEndPeriod() when unloading the built-in
module.
* Added built-in function sleep().
* Include dir "eel" renamed "EEL".
* Library/DLL base name changed from "eel" to "EEL".
EEL 0.1.10 (never officially released)
* Added the DSP module;
* sum(), average()
* polynomial(), add_polynomial()
* fft_real(), ifft_real()
* Fixed various char signedness warnings.
* Implemented #- operator for vectors.
EEL 0.1.9 (never officially released)
* All VM instructions that index constants now use
16 bit fields for this. Four instructions had to
be changed, and three new operand formats were
added;
SWITCH ABsCx ==> ABxsCx (new)
CCALL ABCD ==> ABCDx (new)
TRY ABC ==> ABxCx (new)
UNTRY AB ==> ABx
* The '&' eel_argf() format code now returns an
integer register index, rather than a pointer.
(Pointers break if the heap is reallocated!)
* Caching eel_bio_linecount() - much faster
compiles of large files with debug line number
info enabled.
* Rudimentary VM argument stack added. (Only used
by constructors right now!)
* Object constructor/cloning mess cleaned up;
* Constructors construct, period!
* Cloning is done through casting.
* More efficient buffer scaling for some types.
* for i=N, N-1 ... will no longer iterate once.
* 'for' loops are slightly faster when running.
* Implemented the Type Casting Matrix.
* Various minor optimizations and bug fixes.
* Apparently some minor slowdowns too - but
benchmark results are weird. Some code needs
more "real" time but less user time. Need to
do some serious profiling later.
* 64 bit pointer issue in relocate_limbo() fixed.
* Fixed octal number escape parsing in strings.
* Fixed some missing internal VM initializations.
* Added guiscroll.eel EELBox test.
* EBGUI:
* HScale fully implemented.
* LineEditor:OnChange() implemented.
* Recursive SetCapture().
* SetCapture() implements cursor hiding.
* Widgets no longer try to grab the mouse
multiple times when pressing multiple
buttons.
* Graph curve AutoScale now stores min and
max results for external calculations.
* ApplyTheme() now invalidates widgets.
* Widgets draw their dent outlines using
their parent's theme where applicable.
* Scales scale around the grab center point.
* Slider knob length >= width limit.
* LineEditor:SetText() now calls the
OnChange() callback.
* VScale and HScale got a vector 'ticks'
that stores the coordinates of the
currently visible tick marks.
* Added scrolling support to the
"relative" aligner.
* All widgets clipped automatically by
recursive_redraw().
* Widgets are clipped recursively to
stay inside their parents, even if
their own cliprects are outside.
EEL 0.1.8 (20060116)
* Cleaned up the moduledata handling a little.
* Turned static variables in e_file.c into moduledata.
* Implemented the "dir" module.
* EELBox:
* Added simple soft real time audio support.
* Added some simple audio demos.
EEL 0.1.7 (never officially released)
* 'return' statements in procedures will no longer
allow stray return value expressions.
* EBGUI:
* Added 'childsize' to the "grid" aligner.
* Added functions GetModal(), GetCapture()
and GetFocus().
* Added keyboard control to *Slider.
* Added LED and ProgressBar widgets.
* Added Panel styles through SetStyle().
* Removed FlatPanel. Use Panel(..., "flat").
* Removed Container. Use Panel(..., "none").
* Added Graph widget.
* Added VSlider widget.
* Added VScale and HScale widgets.
* EELBox:
* Added \t (TAB) support to text.eel.
* line.eel now handles non-integer start/end
coordinates.
* Implemented SetClipRect().
* Implemented GrabInput() and WarpMouse().
* Added optional lock-free FIFO buffering
to sockets, for non-blocking TCPSend().
* Fixed misdirected break in handle() in
chat.eel and chat2.eel.
* Fixed memory allocation bug caused by coders having
different ideas about the size of the module static
variable block.
* Added getus(), for sub ms accurate timestamps on
platforms that can provide them.
* Added the 'export import...' construct, to
transparently forward imports as exports.
* Confusing "Missing ')'..." error messages after
explists clarified; they now mention the ','
possibility.
* Character literals can now contain the usual \
escapes used in string literals.
* Trying to create a character literal that doesn't
fit in the integer type generates a compile error.
* The shift operators ('<<', '>>') now accept real
typed operands. These are truncated to integers.
* Added line numbers to the call stack dump.
* Fixed missing eel_cthrow() in expect() when using
a custom message string.
* Implemented vector INSERT.
* Putting a '{' directly after the ';' following a
("forward") declaration now generates a warning, as
this usually indicates an accidental ';' in what is
intended to be a function definition.
* Fixed a bug in apply_op() that generated code for
writing back the result even when doing inplace
operations. (This was *probably* harmless, and just
generated a "no effect" MOVE or similar.)
* Assigning objects to argument registers is now
handled by a special instruction, that should
implement correct memory management for these
objects. (For now, it throws an exception if it
sees an objref.)
* Added 'untry' blocks which "unprotect" blocks
under try blocks up the stack for debugging.
* Added rudimentary object owner tracking for
debugging memory leaks.
EEL 0.1.6 (20051112)
* Added explicit vector operators #+, #*, #/ etc.
* Changed the vector types to use the new vector
operators for vector ops.
* Implemented appending of any indexable type,
except tables, to vectors.
* table:DELETE metamethod now throws an exception if
it gets a "to" operand. (Can't do range delete() on
tables!)
* Added some tests to vector.eel.
* Fixed exception handling bugs (reference leaks) in
some operator metamethods. (Never add a ref before
you do something that may fail!)
* VM dump messages now include module and file names.
* Added hooks for generic (de)serialization subsystem.
* Added scope.eel to the test suite.
* Fixed compile error when using 'exception' in valid
sub contexts of 'except' blocks.
* Instantiating a string with a boolean initializer
now results in "true" or "false", as expected.
* eel_operate() now says EEL_XNOTIMPLEMENTED instead
of EEL_XINTERNAL when trying to perform undefined
operations on objects.
* Implemented the 'and', 'or' and 'xor' operators for
OBJREF left hand and/or right hand operands.
* Implemented concatenation (+ and .+) of tables.
* Added concatenation test to table.eel.
* The DELETE metamethod now accepts calls with two
NULL operands (corresponding to only one argument
to delete()), for deleting all elements of any
indexable type object.
* Fixed some DELETE metamethod implementations that
didn't check for 0/1/2 operands at all.
* 'array' now supports range delete().
* Implemented VM context save/restore, for reentrant
VM calls.
* eel_load_from_mem_nc() now really does not compile!
* Module unloading changes:
* After a module is compiled, but before it's
initializer is called, the refcounts of all
owned objects are summed.
* Modules refuse to destruct, and instead just
add themselves to the state 'deadmods' list,
and then call the module garbage collector.
* Unused modules are garbage collected, based
on refcount sums, when loading new modules
and when any module destructor is called.
* Fixed a bug that caused the compiler not to unroll
all contexts when handling a compiler exception.
* Added nonexist.eel test.
* Added a relex() at the end of the forstat rule, as
'for' statemenst would otherwise "eat" INIT events
under certain circumstances.
* Added forscope.eel test.
* Added read-only 'buffer' member to 'memfile'.
* Fixed wrap bug when read()ing reals on little
endian platforms.
* Added call stack dump to the VM error dump.
* Added object member call syntax. ("auto-self")
* Removed the ':' from the alternative table
initializer tuple syntax, to avoid conflict with
the member call syntax.
* Added "function by name" table item initializer.
* A memfile can now be attached to a dstring by
assigning the dstring to the memfile's .buffer
field, or by passing it to the constructor.
* The 'local' keyword is now required when declaring
variables, except in the root function.
* Anonymous functions and procedures.
* Added switch statement and SWITCH instruction.
* Corrected signedness of 'upvalues' and 'result' in
the callframe struct.
* Added line number debug info to EEL functions.
* Added line numbers to VM code dump.
* Added built-in functions __caller(), __modules()
and __clean_modules().
* Added "module" field to functions.
* Table indexing now has a generic index comparison
shortcut for "same instance" when indexing with an
OBJREF.
* Removed the "static by default root function
variables" special case.
* (function) and (procedure) can now be used as a
CFUNCTION type id literal.
* (Bonus:) The compiler knows that you cannot cast
something to type 'function'.
* Format string EEL_REAL_FMT (default "%.12g") is
used whenever converting a real to ASCII.
* More sensible source location printout when the
start position cannot be determined.
* The compiler now always looks for arguments, to
avoid stupid messages when passing arguments to a
function that doesn't want any.
* Fixed some bugs that caused the TYPEOF and SIZEOF
instructions to fail on in-place operations.
* The compiler now checks for declared but undefined
functions after compiling a module.
* math.abs() is now implemented using C fabs() rather
than the integer abs()!
* An implicit upvalue now generates a compile error.
* Fixed some error checking bugs in expression().
* Added GetPixel to EELBox.
* Added SFont compatible text rendering with demo to
the EELBox test/demo suite.
* Added circular include detection.
* Added circular module import detection.
* Fixed some bugs that caused object leaks when
aborting due to circular includes or imports.
* Added module instance data support for "global"
stuff in C modules.
* EEL built-in library converted to the new module
instance data system.
* EELBox clipping bug in Update() fixed.
* Implemented delete() for the vector types.
* Added EELBox GUI toolkit + simple test program.
* Fixed a bug that caused the .() rule to
look in the symbol table of the current scope.
* Fixed explist logic bugs when indexing an explist
and related operations.
* Implemented rudimentary peephole optimization.
* Added early checks for call arguments, and checks
for argument expressions that generate no result.
* Renamed VM instruction CGET as LDC ("LoaD Constant")
for concistency.
* Added VM instructions INITI, INITNIL, INITC, ASSIGNI,
ASNNIL and ASSIGNC, with some simple peephole
substitution rules to put them to use, for a
remarkable speedup of 1.2 % in bench.eel! ;-)
* The EELBox pigs.eel example now uses a double
buffered display when available.
* Added while optimization in whilestat().
* Added NOT/JUMP(N)Z substitution rules.
* 'continue' in do...while, do..until and while loops
now skips *into* the condition test, as most people
would probably expect. 'repeat' is added, and works
like 'continue' used to do, and like 'repeat' works
in for loops.
* Added 'constant' keyword and rudimentary constant
declarations. (Cannot evaluate expressions!)
* EELBox SDL.Rect SETINDEX now clamps negative 'w'
and 'h' to 0, to avoid nasty huge rects. (SDL_Rect
has unsigned 16 bit w and h fields.)
* Added '.' NAME key syntax to table
ctor. (Nicer looking, and avoids the problem with
unary minus "blending" the name and the value.)
* Added SDL_EnableUNICODE() and SDL_SetKeyRepeat() to
EELBox.
* Explicit casts now always create new instances of
objects. Casting to the same type gives a clone.
* Added 'clone' unary operator, that tries to clone
objects by passing the original object to the
constructor.
* Fixed a buf in dstring INSERT that would cause a
segfault when inserting starting beyond the end
of the string.
* Modified EEL_lval so the lexer can correctly hand
strings containing null bytes to the parser.
* Added '.' NAME key test to table.eel.
* Added main test script to the EELBox tests.
* ebtest.eel user abort (ESC, click etc) now actually
works.
* Fixed EELBox video surface management.
* io.read() will now return an empty string instead
of throwing an exception when 0 bytes are requested.
* io.read() no longer throws XEOF when reading 0 bytes
at the end of a memfile.
* typeof nil == nil
EEL 0.1.5 (never officially released)
* Added 'file' and 'memfile' classes.
* eel_ds_*new() now accept NULL initializer strings
for creating empty strings with preallocation.
* Support for compiling EEL code from (d)strings.
* Added compile, memfile and diskfile test scripts.
* eel_vmsg() now deals with vsnprintf() leaving the
value of the va_list undefined.
* Added wordcount test/benchmark.
* Fixed return types and error handling of some
built-in and EELBox modules.
* Fixed missing CCLASS object ownerships for the
symbol table.
* Implemented Load() in the SDL_image eelbox module.
* Added pigs.eel (bouncing pigs) to the eelbox demos.
* Fixed some memory leaks.
* 'eelbox' now closes subsystems *after* destroying
the module, to avoid problems with object refs in
static variables.
* VM bug fixed: C functions with no result are now
handled correctly.
* Added built-in index() function, to index objects
(specifically tables) by integer element index.
* Added missing jmp_buf #define for the CygWin
special case. (Thanks Frank Benoit!)
* Added built-in key() function, to get table keys
by integer element index.
* Fixed illegal compiler context type that broke the
'include' directive.
* String pool now handles strings of different
lengths but identical hash correctly.
* Added format attributes for GNU compilers to the
eel_*error() functions and co.
* Fixed some error message format/argument bugs.
EEL 0.1.4 (20050417)
* Added dstring (dynamic string) type. (Crossbreed
of string and vector_u8.)
* Fixed incorrect location of object pointer in the
EEL_value union, which made the union larger than
16 bytes on 64 bit platforms.
* Fixed copy of potentially non-existant null
terminator in eel_ps_new_ngrab().
* test.eel catches exceptions in exception_name(),
so it can handle non-xno exception values.
* Implemented special case for NOP cast.
* The compiler no longer thinks you're trying to name a
block, unless it actually sees a ':' after the name.
* Using the 'exception' keyword no longer results in
the compiler freeing the exception register.
* Fixed "double inversion" bug in JUMP(N)Z and ifstat;
now the instructions actually do what they're named.
* Implemented inplace operations with multiple source
arguments and one target. (Actually a compiler bug
fix; it was "almost" supposed to work before.)
* Updated chat.eel (EELBox) to use dstring.
* Added setjmp()/longjmp() hack for Cygwin. (It says
it has _setjmp()/_longjmp(), but EEL won't compile
if they're used.)
* Minor adjustments for 64 bit platforms in Net2.
EEL 0.1.3 (20050407)
* Upped the pickyness level of the Extreme Pickyness
Mode a notch.
* Fixed a bunch of unintentional C99 style variable
declarations.
* Fixed some missing prototypes.
* Removed some unused functions.
* text2c.sed fixes:
* No longer relies on the \t escape
* Strips comments and empty lines
* configure.in changes. *Might* fix Cygwin...
* EELBox examples that can loop indefinitely handle
SDL_QUIT, so you can stop them with ctrl+C.
* Hint added to "Reading uninitialized variable..."
EEL 0.1.2 (20050403)
* Added the eelbox sub-project. (SDL binding.)
* Objects now actually *do* count as references
to their respective classes! (Oops...)
* The EEL_object struct is now just a header, and
objects are constructed by placing one of those
and some other struct after it in a memory block
of the right size.
* The EEL_vm struct is now split in a public and a
private part; enough public stuff to eliminate most
calls from user C function callbacks.
* ARRAY, VECTOR and TABLE VM instructions replaced
by the NEW instruction. (Which is actually the
old VECTOR instruction; it had the logic already.)
* Switched to a uniform object constructor syntax
with three special cases:
1. 'array' is default for [...]
2. 'table' keeps it's two tuple syntax
variants + the "even count" test, and
3. 'enum' constructors allow passing new
names as strings to the constructor.
* Fixed type checking bug in bi__xname().
* Fixed priority of boolean 'not' operator.
* Started documenting the language.
* Built-in classes now have their own headers.
* EEL_closure built-in class (dummy) removed.
* Added type EEL_TENUMVAL and class EEL_CENUM.
* EEL_TOBJECT renamed EEL_TOBJREF, which is more
accurate and hopefully less confusing.
* vm->exception now takes ownership of objects!
* Implemented EEL_CSTRING + "pooling string engine."
(EEL_CVECTOR is no longer abused for strings.)
* Fixed a missing eel_v_own() in CTABLE::setindex().
* Fixed the broken ##push() method of EEL_DLSTACK;
it didn't set the 'prev' field of the old top!
* Added class unregister hook to EEL_classdef.
* Some of the above fixed the "__init_module" leak
from 0.1.1. :-)
* The CAST instruction can now recast enum values.
* EEL_VM_CHECKING is now disabled when compiling
EEL without DEBUG defined.
* Classes are normally registered with the compiler.
* Converted the VM dispatcher to use macro magic,
preparing for threaded dispatching by means of
computed gotos and stuff like that.
* Instructions that cannot throw exceptions can
now optionally be compiled so that they dispatch
the next instruction without the reschedule check.
* Added string cache to avoid creating new strings
all the time. (Helps the compiler a lot.)
* Added eel-presentation.txt from the registration
description for SourceForge.
* Fixed some stupid compiler event handling bugs.
* Dead code elimination is back in.
* Implemented multilevel BREAK event handling.
* Removed the incorrect initialization check when
writing upvalues. (Compiler)
* Leaving a block with potentially uninitialized
variables now results in a compile error rather
than a cryptic "internal error".
* Added C style quoted string literal continuation.
* Added hex and character literals, and the string
type name to eel.xml.
* Added binary operator tests to arithmetics.eel.
* Removed the non-optimizing version of the operator
code generation machinery.
* Removed 'vm' argument from calls that require an
object. (Objects have a 'vm' field...)
* Added some manipulator "shortcut" optimizations.
* Eliminated the CONSTVAL manipulator and merged the
special cases and code generation from e_parser.c
into the CONSTANT manipulator instead. Result:
* Unused constants are no longer added to the table.
* Added EEL_MCAST manipulator, with typeid support.
* No more piggybacking on EEL_MOP for casts to real,
integer and boolean. (EEL_MCAST)
* Implemented generic snap-in indexable->indexable
cast method. (If it works is another matter...)
* Lexer no longer looks for two-character tokens with
a whitespace character as the second character.
* Replaced strtod() hack with a generic base-n number
parser.
* Fixed a lexer bug that disregarded overflow when
testing if a number can be parsed as an EEL_TINTEGER.
* Made the '><' (bitreverse) operator binary, using
the right hand operand to specify the number of bits
to reverse.
* Cleaned up the #include dependencies a little.
* Implemented one-to-many multiple assignment.
* The LOOP instruction will now try to cast the
iterator, limit and increment operands in-place, if
they're not EEL_TREAL. (Better and much faster! :-)
* The table *INDEX methods now accept integer/real
matches if the values cast to real are equal.
* Fixed indirect calls and type casts inside explists.
(Stupid! Assumed that stuff would always be first in
'al', or be the whole 'al'. :-)
* Cleaned up the error/exception handling. Errors are
just integer return codes, until they hit the VM
dispatcher.
* C style string continuation w/o '\n' ==> WARNING.
* Cleaned up the memory management and defined strict
rules for limbo and returned objects.
* Fixed incredibly stupid bug in the coder: It now
actually calculates cleantable sizes! :-D
* NULL (NOP) destructors are perfectly acceptable.
* 'whilestat' now generates proper cleanup code.
* sbuffers are released nicely in some more places.
* An iterator variable declared in a 'for' becomes
local to that 'for' statement.
* Changed 's/\t/\\t/g' to 's/[\t]/\\t/g' in the text2c
sed script. The non-GNU sed used on Mac OS X didn't
like my original version. Thanks to Russell Y. Webb!
* EEL_state removed from the API; only EEL_vm now!
* Added __exports() to mess with module export tables.
* Exported functions are added by *export* name; not
by the name from the function object!
* Enum EEL_mmethods and EEL_exceptions renamed
EEL_mmindex and EEL_xno, respectively.
* The lexer now returns a TREAL value for any number
with a decimal point in it, regardless of value.
* Added tak.eel and heapsort.eel.
* Added "direct read" and [0..255] constant index
optimizations for indexing operations.
* Added binops for static variable right hand operand.
(Saves one instruction and avoids grabbing.)
* Added binops for constant Sint16 value right hand
operands. (Eliminates a great deal of CGET and LD*.)
* The lexer stack is invalidated when starting with a
new file, to get rid of any old garbage.
* Added a math module with a bunch of math functions
and some constants.
* Error messages are now logged rather than printed
directly, so they can be dumped when appropriate,
or thrown away. (No more whining when looking for
precompiled and source files for apps and modules.)
* Dedicated, cleaned up prototypes for constructor
and destructor callbacks.
* Undefined metamethods are now wired to a dummy, to
avoid checking in the main path.
* VM uses an inlined version of eel_o_metamethod().
* Constructor semantics cleaned up:
* Constructors are responsible for cleaning
up if they fail.
* Constructors must generate an EEL_value
result; not just a pointer.
* Added the "Module Injection API", for creating
modules and adding exports to them properly.
* Added shared modules "zombie" table, to keep track
of loaded modules and ask them to unload when there
are no actual users left.
* Added INSERT and DELETE metamethods.
* Table uses dynamic array instead of linked list.
* C modules can now export constants. (EEL modules
can do it by means of __exports().)
* 'throw' takes an expression rather than a simplexp,
so you don't have to parenthesise expressions.
* Removed some old cruft from the symbol table code.
* The compiler (and module export/import) now handles
types and classes by their classdef objects rather
than type IDs. Thus, exported constants can now be
references to classes. :-)
* Added autoconf checks for the setjmp stuff, along
with support for _setjmp/setjmp/_longjmp/longjmp
or sigsetjmp/siglongjmp, in order of preference.
* Tweaked eel.m4 to make automake 1.8+ happy. (?)
* Build scripts now work for Linux->Win32 cross
compiling with gcc 3.3.x. (Here, at least. ;-)
* Fixed a bug that caused expression2() to do nothing
when supposed to apply an operator to two terms
with multiple manipulators.
* Conditional jumps considers any typeid true.
* The NOT instruction takes any OBJREF or TYPEID as
true. (Generates a false result, that is.)
EEL 0.1.1 (20050126)
* Added RETX, RETXR, XRETURN and XRETURNL.
* Added the 'flags' VM special register.
* Some minor code cleanups.
* The returnstat rule now issues the new
RETX* instructions when inside 'try' and
'except' blocks.
* random.eel now casts the command line
argument to integer.
* random.eel updated to 'for' loops.
* Added tests for returns from within 'try'
and 'except' bodies to exceptions.eel.
* Added function name to VM "crash" message.
* VM code dump is 99 chars wide instead of 59.
* No more (pointless) warnings about implicit
upvalues in 'try' and 'except' blocks.
* Changed call syntax to C-style, everywhere.
* Just a function name now evaluates to a
reference to the function.
* No more "Expected '=' or ';'!" when only ';'
applies. (It is known whether the term is
writable or not when that message is printed.)
* Compiler error messages now contain start and
end line and column position.
* Exception handling bug fixed: The VM now
terminates correctly when an unhandled
exception occurs.
* No exceptions should print error messages
unless they exceptions are unhandled.
* Fixed broken code generation for upvalue
function argument write.
* VM error/exception handling reworked: Text
messages replaced with an exception registry
and integer return/error codes.
* Turned the 'string' class into a set of
generic vector classes.
* Added eel_null_terminate(). EEL does *not*
guarantee that strings (or other vectors)
are null terminated!
* eel_throw() no longer loses the remaining
instruction count if multiple exceptions
are thrown before the scheduler gets a
chance to run. Note that it's still only
the last exception that's seen! The others
are silently ignored. (We assume that if
a single VM instruction results in multiple
exceptions, they're all triggered by the
same event, and the one that gets through
is hopefully the most descriptive one.)
* Fixed backslashed quote ("\) and multiline
string literal bugs in eel.xml.
* XRETURN* now throws XEND if it lands in the
dummy top call frame, as it should.
* Compiler RETURN and RESULT events now propagate
up from xblocks. This lets us get away without
a dead 'return ;' when the only way out
is through try and except blocks.
* The 'throw' statement now generates appropriate
compiler events.
* Initialization events no longer (incorrectly)
depend on the EXIT state.
* CGET now adds objects to limbo, so ownership
is passed to callers if constants are returned.
* THROW hands limbo object ownership over to
vm->exception.
* Added keyword/special variable 'exception', to
access the exception value in 'except' blocks.
* Array constructor now accepts empty initializer
list to construct empty arrays. (DOH!)
* Comparison operators no longer corrupt the
target register before testing, so in-place
should work now.
* Moved operator stuff into e_operate.[ch] and
refactored it a little.
* Added CAST VM instruction, to cast to any type.
* CASTR, CASTI and CASTB can cast from typeid.
* Fixed bug when coder adds constants: Functions
are now only added once. (OBJECT/WOBJECT...)
* Coder now actually compares objects when adding
constants, to avoid identical instances.
* Removed some unneeded operations when entering
and leaving eel_run(), and throwing exceptions.
* Created a bug. :-( The "__init_module" name
string in load() leaks, apparently because the
__load() call somehow screws up load()s limbo
list. Can't seem to figure out why, and I'm in
one h*ll of a hurry to get things going, so I'll
have to leave it for now.
* Implemented the table class + constructor syntax.
* Fixed some bugs where empty initializer lists
would screw up the register allocation.
* Implemented the vector class, with some
"optimized" vector operations.
* Refactored the operator mess into one large
switch() for all operations on all simple types.
* Implemented in-place and copy operations on
objects, with operator