26/08/2002      An experimental "destructor" operator is implemented. The "~"
                        operator is automatically called when a variable drops
                        out of scope.
                A few performance optimizations in the generated pseudo-code,
                        especially for "for" loops.
                A bug where the "function should return a value" was not given
                        is fixed. This ocurred in a situation where you said
                        "new myvar = myfunc()" where "myfunc()" does not return
                        a value.
                The "expand" function now also uses the stack space while
                        expanding. This hopefully solves the (already rare)
                        cases where the expand function got short of buffer
                        space. Bug reported by Robert Daniels.
                Maurizio Ferraris reported a bug where the compiler crashed
                        when it tried to recover from a symatic error in a
                        particular context.
                Frank Condello donated a Macintosh port of the compiler and
                        abstract machine. His changes were merged with this
                        release. In addition, there is a separate directory
                        with additional source code and a CodeWarrior project.

19/08/2002      Native functions can now also force a "sleep", simply by
                        returning AMX_ERR_SLEEP.

 6/08/2002      To avoid the problem of structure fields being aligned
                        differently by different compilers, the header format
                        was changed to exploit "natural" alignment. Even
                        compilers that do not support "#pragma pack()" should
                        not have the good alignment. The changed header lay-out
                        is the main reason that this release got version number
                        2.0.
                There is a new compiler option, -A, and a new #pragma, "align",
                        which allow you to align variables on a boundary that
                        is an arbitrary power of 2. These tricks are sometimes
                        convenient (or necessary) with native functions that
                        use SIMD instructions. These changes are based on
                        code donated by Stephane Denis.
                New functions amx_Clone() and amx_MemInfo(), both to support
                        cloned abstract machines.
                For using bit masks as light-weight sets, the "enum"
                        instruction supports automatically multiplying by 2 of
                        all constants.
                As an optimization, the compiler now generates a "halt"
                        instruction at address zero, so that the "RET" and
                        "RETN" instructions do not have to check for a special
                        zero address.
                Dan Andersson found a bug in the JIT, which has now been
                        corrected. The JIT has also been brought up to date; it
                        now supports the "sleep" instruction.
                As suggested by Stephane Denis, amx_Exec() now verifies that
                        all native functions used in a script are actually
                        registered, before executing any of the script.
                The debugger can now optionally use the Unix "readline" package
                        for a more convenient command line. Due to the design
                        of the readline package, it requires that you build the
                        application, with the same compiler as the one that was
                        used to create the readline DLL or shared library. As
                        such, I recommend that you only use the "readline"
                        package with Unix/Linux or Microsoft Visual C/C++.
                One could easily make mistakes with floating point variables
                        and the user-defined operators without any warning from
                        the compiler. For example, in several situations,
                        forgetting a "float:" tag on a variable declaration
                        gives no warning but generates completely wrong code.
                        Therefore, I have modified the floating point support
                        to use "strong" tags, i.e. "Float:". You may need to
                        modify your scripts if you work with the new include
                        files "float.inc" and "console.inc". You can look up
                        the "strong tags" issues in the language guide.

 6/05/2002      Oops, skipping compound blocks in the first pass, introduced
                        at 25/02/2002, caused several regression failures; in
                        retrospect, the compiler really needs to scan every
                        statement in the first pass, to record the function
                        and variable usage.
                Maurizio Ferraris donated a modification of the compiler that
                        gives it support for multiple "include" directories.
                BUG fix: there was a peculiar parsing error that started with
                        a call to an undefined function, continued with the
                        compiler confusing code with data declarations, and
                        ended with the compiler generating faulthy code without
                        any error/warning message whatsoever (bug reported by
                        Maurizio Ferraris).
                BUG fix: when you use "#pragma ctrlchar" halfway a program,
                        the second pass uses the new "ctrlchar" value right
                        from the start, which causes trouble if include files
                        depend on the original (or default) value. (This issue
                        was brought to my attention by Florian Zschocke.)
                BUG fix: the AMX function amx_GetAddr() could return success
                        on a negative address (bug reported by Robert Daniels).
                BUG fix: when re-defining a function with more parameters than
                        the previous definition, the compiler could crash when
                        it tried to compare the parameter lists of the old and
                        the new definitions; the compiler didn't check the
                        length of both lists (bug reported by Robert Daniels).

25/02/2002      BUG fix: when the conditional operator has unindexed arrays as
                        its second and third operands, the "variable type"
                        of the resulting expression should also be an array.
                        (Bug found by Linus Nuber.)
                To increase the performance of the compiler, compound blocks
                        are skipped in the first pass (the Small compiler is
                        a two-pass compiler).

14/02/2002      The manual is split in half: there are now two "Small booklets":
                        one covering the language and one for implementing
                        Small in applications. Much of the information from the
                        README.TXT is now the the ``Implementor's Guide''.
                The new Implmentor's Guide also got a section on calling
                        public functions (other than "main()") and passing
                        parameters (both numeric and string parameters).

13/02/2002      BUG fix: the JULIAN.SMA example program had an error in the
                        check for dates in the month February (bug reported
                        by Jan Vooijs).

12/02/2002      "chop" found a series of bugs in the Small compiler and the
                abstract machine:
                BUG fix: the functions strpack() and strunpack in AMXCORE.C
                        check the validity of the memory range for the
                        destination string. However, the number of bytes that
                        were checked was far too small: the checking code
                        confused sizes of bytes and cells.
                BUG fix: the functions amx_StrLen() and amx_GetString() in
                        AMX.C, the functions amx_StrPack() and amx_StrUnpack()
                        in AMXCORE.C and the function printstring() in
                        AMXCONS.C all had a problem with determining packed
                        strings, in case you use characters above ANSI 127.
                        The manual also had an error in the "ispacked()"
                        function in the chapter ``Assorted tips'' had the
                        same error.
                BUG fix: in the Small debugger (SDBG.C) a check for an
                        available breakpoint entry was missing a semicolon.
                BUG fix: chained operators did not work correctly with
                        user-defined relational operators, because the operator
                        functions garbled the ALT register. The ALT register is
                        now saved around the call.
                BUG fix: a global variable being used prior to its definition
                        was not flagged correctly; it also caused a code
                        generation error.

 7/02/2002      BUG fix: The AMX DLLs apparently had problems when being used
                        with Microsoft Visual C/C++, due to a calling
                        convention mismatch (failure to save/restore some
                        registers).
                Clem Vasseur proposed a binary search for the opcode lookup
                        in the compiler. This has been implemented.

 5/12/2001      Linus Nuber found that double-character user-defined operators
                        and debug information (options -d2 or -d3) do not go
                        well together: the size of a SYMBOL opcode may overflow
                        the size that the compiler initially estimated and this
                        causes the function to be generated at the wrong
                        address.

30/11/2001      As per the request of Linus Nuber, I changed the way that the
                        compiler options are set and reset. Now the -C, -P and
                        -; options can have a "+" or "-" suffix that sets or
                        clears the desired option; without suffix, the option
                        is toggled. With this, you can set your default options
                        in the configuration file (SC.CFG) and toggle the
                        option on the command line.

27/11/2001      "Compact encoding" of the .AMX file has become the default; use
                        the "-C-" compiler option to return to the old (plain)
                        encoding.

23/11/2001      BUG fix: Linus Nuber found a code generation bug in the case
                        where a user-defined operator was called with a
                        constant on either size, such as "1.5 * 2.5" with
                        operator*(float:a, float:b).

20/11/2001      BUG fix: Gilad Novik found that unused public variables would
                        be stripped from the compiled file and their addresses
                        re-used by other global variables (or array literals),
                        but that the public variable was still listed in the
                        file header.
                BUG fix: when you ask for "sizeof x" and "x" is an array of
                        indeterminate size, you get a warning. The warning did
                        not occur if the "sizeof" expression appeared in the
                        default value of a function argument (in a function
                        definition). The lack of the warning makes the "sizeof"
                        default value error prone, the warning makes it safer.

 8/11/2001      The manual was updated to include the changes since the last
                        public release of the Small toolkit.
                The performance of the compiler was enhanced.

30/10/2001      You may specify a hard "index" for a native function, which
                        omits the native function from the compiled .AMX file.
                        For this to work, you need to implement your own native
                        function dispatcher; see the manual.
                As per the suggestion of Stephane Denis, I used the more
                        specific integer types int16_t and int32_t in structure
                        definitions. These are defined in the ISO C99 standard.

 9/10/2001      The default value of a function parameter can now be the
                        "sizeof" of another parameter of the same function.
                        This is convenient to pass the sizes of array
                        parameters to the function without requiring the
                        programmer to explicitly pass the size.
                The new SC_LIGHT macro allows you to exclude non-essential
                        components of the Small compiler upon recompilation.
                        These components are: the cross-reference report (-r
                        option), parsing of "response files" and the default
                        configuration file ("sc.cfg"). More may follow (for the
                        moment, the peephole optimizer is considered
                        "essential").

10/09/2001      BUG fix: getproperty() of the "core" native function set read
                        contents from a memory block after freeing it.
                BUG fix: a bit of code that writes the AMX file header still
                        assumed that a cell is always 32-bit.
                BUG fixes: in the symbol name handling of user-defined
                        operators. There were several bugs; the operator that
                        suffered the most from these is probably the unary
                        minus operator.

28/08/2001      BUG fix: defining the % operator would often introduce an error
                        in the symbol table. Cause: the % character is special
                        for sprintf() functions that the compiler uses to
                        construct symbol names.
                BUG fix: Linus Nuber reported a bug where functions that were
                        called before their definition would be marked as
                        "unused" and stripped from the compiled code.
                BUG fix: Clem Vasseur noted that on a fatal error, the local
                        variable table was not cleared; this then subsequently
                        fires an assertion in the exit code.
                A prototype mismatch (of sc_error()) between the source and the
                        header files was also reported by Clem Vasseur.

27/08/2001      BUG fix: Dario Sacca sent in a fix for an error in the
                        assembler implementation of the abstract machine. In
                        the debug hook for the line opcode, the "frame" offset
                        was not updated correctly.
                New compiler option: -r, to generate a cross reference report.
                        The report lists all constants, global variables and
                        functions and tells what function is accessing them.
                        Stock functions that are never used are still in the
                        report. Native functions that are never used are not
                        in the report. The report file is intentionally
                        formatted in a minimal way, to make it easier to have
                        it parsed by other programs (call tree, cross-reference,
                        etc).

 8/08/2001      BUG fix: Linus Nuber was surprised to find that the version
                        uploaded 5 August no longer accepted user-defined
                        operators that were declared as stock. This
                        embarrassing bug is fixed. (Oh, and a silly error in
                        the Linux include file, also reported by Linus Nuber,
                        was fixed too.)
                BUG fix: Odie Calima found a few more global variables that
                        needed to be cleared on exit.

 3/08/2001      BUG fix: Robert Daniels found a code generation bug in the
                        situation where a "for" loop contains a variable
                        declaration in its first expression and a break in its
                        body. This is now fixed.

23/07/2001      The debugger got a minor improvements (quiker redraw of the
                        screen in termibal emulation mode).
                Using a "&" where a "&&" is probably intended, or a "|" where
                        a "||" makes more sense, is now detected by the
                        compiler. (Actually, the compiler already issued a
                        warning for this, but it did it dumbly and too often;
                        now, when the compiler warns for a possibly unintended
                        bitwise operator, it is very likely indeed an error.)

16/07/2001      The general purpose DLL calling functions have been implemented
                        fully and documented in the manual.

 2/07/2001      Stock variables: if no function accesses a global variable,
                        this variable gets stripped from the compiled output
                        file, and without warning if that variable was declared
                        "stock".
                BUG fix: a bug in appending implicit extensions to #include
                        files was fixed.
                Functions and global variables can be declared "static", which
                        restricts their scope to the current file.

25/06/2001      BUG fix: if you omitted the colons on cases in a switch
                        statement, the compiler hung. This was corrected. (Bug
                        found by Joe Hansche.)
                The detection of unused functions has improved. Specifically,
                        if function is called only by other functions which
                        are never used, that function is marked unused as well.
                BUG fix: a script that was edited under DOS/Windows and
                        compiled under Linux, would give error "invalid line
                        continuation" for a "//" style comment. This was
                        corrected.

27/04/2001      BUG fix: Stéphane Bouteille corrected another error that had to
                        do with Big Endian memory layout (in amx_Exec()).
                I added "strong" tags in addition to the current "weak" tags.
                        See the manual for the differences.

17/04/2001      I added a -S<value> option to the compiler to set the size
                        of the stack+heap (what you would otherwise need to
                        do with #pragma dynamic).
                The Small compiler now parses a SC.CFG file with default
                        options (if that file exists). If the executable of
                        the compiler is called "SC16.EXE" or "a.out", then the
                        configuration file will be "SC16.CFG" and "a.cfg"
                        respectively.
                The DLL version of the abstract machine got two new native
                        functions: loaddll() and freedll(). The calldll()
                        function that was already present could only call into
                        DLLs that had already been loaded.

10/04/2001      Added a swapchars() core function that swaps all bytes in a
                        cell (so the low byte becomes the high byte).
                More new native functions are a set of date and time functions
                        in AMXTIME.C and TIME.INC.
                Dieter Neubauer made a 16-bit version of the Small tools
                        (meaning that a cell is 16-bit, instead of 32-bit).
                        His changes were merged in the original distribution.

 5/04/2001      BUG fix: Raymond Holz found that the Small compiler returned 0
                        after a "fatal error", where a return value of 2 would
                        be expected.
                BUG fix: Linus Nuber found that accented characters were
                        treated as either negative values or as positive
                        values, depending on the C compiler used to build the
                        Small compiler.
                Linus Nuber also found that the compilation instructions in
                        the README.TXT were inadequate for the Linux platform.
                        The README.TXT is corrected and a few details in the
                        Small compiler were adjusted (for Linux) as well.

23/03/2001      BUG fix: Linus Nuber found a bug in default array parameters
                        that were tagged as const. As an optimization, the
                        compiler does not copy such arrays to the heap, but the
                        compiler DID try to remove them from the heap.

12/03/2001      Overloaded operators are (finally) "operational". The manual
                        is updated to show how this new feature works.
                The compiler supports literal values with a fractional part,
                        but you must enable this support specifically: Small
                        can interpret these so-called "rational numbers" as
                        either fixed point or as floating point numbers. Again,
                        see the manual for details.
                For your convenience, I updated the FIXED.INC and FLOAT.INC
                        include files. The pre-compiled SRUN.EXE (Win32)
                        includes the "float.cpp" module.

 5/03/2001      BUG fix: native functions strpack() and strunpack() mixed up
                        the source and destination strings.
                Maintaining correct tags became inconvenient at times; I
                        therefore introduced the "default tag" override "_:".
                        This token removes any tag from its operand (on the
                        right).

23/02/2001      BUG fix: the code generation for the INC.I and DEC.I opcodes
                        was wrong (the compiler encoded one parameter).
                BUG fix: code generated for an expression like "array[index]++"
                        was wrong: the loading of the expression result
                        garbled the address of the array cell to increment
                        subsequently.

19/02/2001      Relational operators now always set a "bool" tag on their
                        expression result
                Native functions may have an "alias" name. This lifts the
                        limitation of 19 characters for a native function.

15/02/2001      On a fatal error, the Small compiler now forces a jump back
                        through the main function, rather than aborting the
                        program. This allows for easier embedding of the
                        compiler in an application.

25/01/2001      The "sleep" instruction is implemented, but quite differently
                        than the partial implementation (of 19/12/2000). The
                        sleep instruction takes an optional expression (like
                        the "return" and the "exit" instructions) and ends the
                        abstract machine in a way that it can be restarted. The
                        tagname of the expression of "sleep" is also saved (in
                        the ALT register), so that you can attach a "meaning"
                        to the expression.
                        The changes from the earlier (partial) implementation
                        are that I used the HALT opcode rather than the SLEEP
                        opcode (and I subsequently removed the SLEEP opcode).
                        The HALT opcode needed modification to support a
                        restart of the AMX.
                The AMX file format now saves exported tagnames (tagnames that
                        are used on the "sleep" and "exit" instructions) and
                        the abstract machine has three new functions:
                                amx_NumTags()
                                amx_GetTag()
                                amx_FindTagId()
                The SRUN sample is adapted for the "sleep" instruction, but
                        simply ignores it. The SDBG sample ignores the sleep
                        instructions as well, but prints an informative message
                        when it occurs.
                Due to optional semicolons, the end of an expression is now not
                        always easy to detect. Quite often, an error in an
                        expression can only be flagged when the end of the
                        expression has been found. As a result, an error is
                        now sometimes flagged one or more lines below the line
                        that really contains the error. This has been fixed
                        by giving both top and bottom line numbers between
                        which the error was found.

28/12/2000      The DBG_LINE opcode can now abort the abstract machine. This
                        makes it possible to have a simple debug hook that
                        breaks out of "hung programs" (infinite loops). The
                        SRUN sample shows how to set this function up.

19/12/2000      Søren Hannibal implemented a "sleep" opcode to have a
                        light-weight multi-tasking of abstract machines.
                        Preliminary support for the sleep is in this version
                        (basically I copied just Søren's changes).
                BUG fix: adding a "tag" to a constant declared with a #define
                        caused an error message with a garbled symbol name.
                        (Bug found by Søren Hannibal.)
                A few minor memory leaks were fixed.

12/12/2000      BUG fix: the conditional operator generated wrong code if the
                        "false" expression was a constant. (Bug found by Linus
                        Nuber.)
                Variables and function arguments can now be declared "const".
                        Two typical uses are declaring a public variable
                        const (so only the host application can modify them)
                        and declaring array arguments const (arrays are always
                        passed by reference).

 4/12/2000      BUG fix: the import library for Microsoft Visual C/C++ for
                        AMX32.DLL had an incorrect definition for amx_Exec().

24/11/2000      BUG fix: public functions should not allow default values for
                        their parameters, as their is no way that you can set
                        the defaults from the C/C++ side.
                Unused parameters of public functions do not issue a warning
                        anymore; public functions often have a "required"
                        interface, so an unused parameter cannot be simply
                        deleted.
                Parameters of a function may have multiple tags between braces.
                        This allows the function to accept a selection of
                        parameter "types". For an example of the syntax:
                            native Move({sprite,actor,weapon}:animob, x, y)
                        Function "Move()" can take as its first parameter a
                        handle tagged as "sprite", "actor" or "weapon". You can
                        use this on non-native functions too. Inside the
                        function, the parameter "animob" has the tag that is
                        first in the list (so "sprite" in this example).
                BUG fix: after an earlier fix, SDBG now removed symbolic
                        information for static variables too early. (Bug found
                        and corrected by Linus Nuber.)

18/11/2000      BUG fix: the "not" operator did not work in the Assembler
                        code of the abstract machine (AMXEXEC.ASM), due to
                        an "aggressive" optimization (by me, probably).

14/11/2000      BUG fix: an expression like "if (1==1)" gives a warning about
                        a test that is always true, but then continues to
                        generate faulthy code. (Bug found by David Burgess.)
                BUG fix: the SDBG debugger did not remove symbols for static
                        variables, causing a new one to be declared for every
                        call to a function containing the static declaration.
                        (Bug found by Linus Nuber.)

 1/11/2000      BUG fix: AMXEXEC.ASM can now finally be assembled with MASM
                        without using the "code segment" trick. This was
                        important because Visual C/C++ 6.0 returns incorrect
                        addresses for data declared in the code segment.

26/10/2000      The Small compiler is now a two-pass compiler; prototypes are
                        no longer needed.
                An internal problem, where the end of an expression could not
                        be determined (due to optional semicolons) in the
                        presence of a "preprocessor" directive, was fixed.
                Array arguments with a default value are now copied to the heap
                        if the default value is used. This *fixes* the problem,
                        rather than trying to forbid it (as in the release of
                        9/10/2000). The issue, by the way, was pointed out
                        by Søren Hannibal mid July (I may be slow, but I am
                        persistent).
                The new function amx_Execv() allows programming languages other
                        than C/C++ use the AMX DLLs. It is limited to up to
                        four parameters, however (this is easy to change if
                        you ever need more).
                A bug where a recursive function provoked a warning about a
                        missing return value was fixed.

19/10/2000      The SDBG debugger prints the return value of functions. The
                        integrated debugger in the DLL also supports a few
                        function keys:
                                F1 = Help
                                F3 = List (refresh screen)
                                F5 = Go
                                F8 = Step (trace into functions)
                                F10 = Next (step over functions)
                A new "interface function" in the compiler, sc_error(), lets
                        you intercept error/warning messages that are produced
                        by the compiler (if you statically link the compiler as
                        a "library function").

09/10/2000      BUG fix: using the -C and -d2 compiler options together caused
                        wrong encoding.
                The debugger is integrated in the AMX DLLs. If you compile
                        with debug information, the debugger will launch
                        automatically. The AMX DLLs support a subset of the
                        ANSI terminal escape codes, so that it has a slightly
                        better interface.
                The AMX DLLs have two new native functions: iswin32() allows
                        you to check whether you are running with the 16-bit
                        or 32-bit DLL and calldll() allows you to call any
                        DLL function (provided that it has a standard calling
                        convention).
                Array arguments with a default value may not be modified (as
                        arrays are always passed by reference, and allowing
                        this would change the default value).
                Updated documentation.

27/09/2000      Definition of "interface functions" (called by the compiler)
                        allows to compile the Small compiler as a "library".
                        See the README.TXT file for details.
                To use the Small compiler as a linkable library, a set of macro
                        definitions allow for a drastic reducal of namespace
                        polution (by global variables and functions).
                A function may be declared as a "stock" function, which means
                        that if it isn't used, it may be stripped from the
                        compiled program (without warning). This way, you can
                        make "library" functions in header files.

11/09/2000      A bug was fixed concerning the use of #endinput within an
                        #if ... #endif section; the compiler did not reset
                        the "#if" nesting level on #endinput. (Bug reported
                        by Jim McGinty from Artran, Inc.)
                Expressions like "1 <= var <= 10" are now allowed. The result
                        of such an expression is 1 if all conditions hold, and
                        zero otherwise. The "chained relational expressions"
                        feature was copied from BCPL.
                New opcodes SWAP.pri/alt, which are needed for chained
                        relational expressions.
                New opcode PUSHADDR, which optimizes passing a variable by
                        reference.
                By generating better pseudo-code for the "for" instruction, the
                        "Sieve of Erathosthenes" runs approximately 10% faster
                        (w/o print), and so will typically all small "for"
                        loops.
                To better cope with the ever expanding lists of error/warning
                        messages and peephole optimizer sequence strings, these
                        strings are now compressed. They are still compiled as
                        literal strings in the executable, but a separate
                        utility, SCPACK, preprocesses the files and compresses
                        the strings.

14/08/2000      Semicolons are now optional by default. This may give, in your
                        existing programs, warning 218 ("old style prototypes
                        used with optional semicolumns"). Use the "forward"
                        keyword to forward-declare functions; use the "/;+"
                        compiler option to "require" semicolons.
                As per suggestion of Søren Hannibal, you may now mix positional
                        and named parameters in a function call, with the
                        restriction that all positional parameters must precede
                        all named parameters. Thus a call like:
                                getproperty(123, .value = 456)
                        would now be valid.

24/07/2000      A large set of bugs, reported by Søren Hannibal, were fixed.
                These include:
                        * code generation error for function arguments that are
                          passed to sub-functions by reference and that were
                          passed by reference themselves too;
                        * code generation error for labels (for "goto");
                        * literal arrays passed to functions were always
                          flagged as "not the same size as the formal argument"
                        * missing "#endif" at the end of the main file was not
                          (always) detected
                        * reaching end-of-file while inside a /* ... */ style
                          comment was undetected
                        * address 0 is a valid address, so the fix in the
                          release of 17/07/2000 for amx_Exec() actually
                          introduced an error.

19/07/2000      As per the suggestion of Søren Hannibal, the NO_OPTIMIZE
                        macro is replaced by a command line option in the
                        compiler (-d3).

17/07/2000      Underscores between digits in a number are now allowed. This
                        may improve readability of large integers (for
                        example: 1_234_567) and for literals used in fixed
                        point expressions.
                #pragma library is now (finally) working. This allows you to
                        give a tag to each native function to which
                        (dynamically loaded) library it belongs. The abstract
                        machine has functions to extract the library names that
                        it needs to load.
                amx_Exec() will no longer start executing from address 0 if you
                        feed it with a program without a main() and ask to run
                        the "main" entry function.
                The DBG_CALL event now tells to which address it is about to
                        jump, so a stack trace can be built. In addtition, you
                        will get a DBG_CALL event for the entry point (so that
                        the stack trace is never empty).
                The sample debugger was extended with stack trace commands and
                        an option to print a one-dimensional array as a string.

26/06/2000      A code generation bug (found by Dark Fiber) in the last update
                        was fixed.

29/05/2000      Three bug corrections in the initialisation of the staging
                        buffer (that will teach me to easily change data
                        structures from "fixed size" to "grow as needed").
                Support for public variables (in addition to public functions).
                        Since the manual is not yet up to date, here is a
                        summary:
                        * Only simple (global) variables can be public, no
                          arrays
                        * To create a public variable, "public" replaces "new":
                            public myvar;
                        * Alternatively, the '@' prefix works as well:
                            new @myvar;
                        * To access public variables from a C/C++ program, use
                          the new AMX functions:
                            amx_NumPubVars()
                            amx_GetPubVar()
                            amx_FindPubVar()
                          amx_GetPubVar() and amx_FindPubVar() return the
                          address of the variable relative to the AMX; use
                          amx_GetAddr() to get a pointer to the cell
                There was (still) a problem with the stack clean-up. I don't
                        know what I was thinking three months ago when I made
                        my first fix, but I probably only tested the 32-bit
                        version.
                Someone sent me a bug report concerning a prototype mismatch
                        that I misclassified. I found it again by accident,
                        corrected the bug that the example demonstrated and
                        added it to regression testing.
                The BCPL manual from Martin Richards pointed out that when you
                        have statements end implicitly on a line end, but still
                        allow expressions to wrap over multiple lines, there
                        may be a problem with unary operators. I tested a few
                        cases and, indeed, found an error.

22/03/2000      Bug correction in the dynamic growth of the staging buffer.
                Bug correction in the stack handling of amx_Exec(), which did
                        not remove arguments from the "abstract machine" stack.
                        If you ran the same AMX program over and over again
                        (without reloading it), you would slowly eat up the
                        AMX stack.
                While correcting the above mentioned bug, I also added code to
                        clean up the stack "the hard way" on a run time error.
                        The extra local variable required for this also lets
                        me verify (with an assertion) that the normal route
                        indeed cleaned up the stack correctly.
                Bug correction in the assembler version of the AMX: when
                        compiling with a stack-oriented parameter passing
                        convention, it must also save the value of EBX.

13/03/2000      Using symbolic constants in the "case" statements of a "switch"
                        could cause the label to be interpreted as a tagname.
                Marc Peter converted the JIT to use __cdecl calling convention
                        and added (minimal) support for the SRANGE instruction
                        at the same time. This means that you can now use the
                        JIT with Borland or Microsoft's compilers.
                Dark Fiber contributes an AMX extensions with high quality
                        pseudo-random numbers, plus a simple card game as a
                        non-trivial example script in Small.

17/02/2000      An attempt to assign a value to a constant (or any expression
                        that is not an lvalue) inside a test, resulted in an
                        assertion failure or a crash.
                The compiler let invalid prototypes pass, while complaining on
                        correct prototypes.
                Logical expressions with && and || operators were never
                        identified as "constant expressions", even if the
                        operands on either side were constants. This prevented
                        such logical expressions to be used in preprocessor
                        expressions.
                The "loose indentation" warning works nicely if you use only
                        TABs or only space characters to indent a line, but if
                        you use a combination, the warning fires even if there
                        is no reason. To lift this problem, the current release
                        introduces the -t option and the "tabsize" pragma (with
                        which you can set the tab size).
                Years ago the compiler was changed to align all opcodes to 4
                        byte boundaries, to increase the speed of the virtual
                        machine at the expense of larger compiled files. The
                        current release introduces a -C switch with which the
                        compiler writes the output file in a more compact
                        encoding, at the cost of slightly longer load times.

16/12/1999      Marc Peter corrected a problem in the JIT.
                Path names with embedded spaces caused the compiler to fail if
                        you compiled with the -d2 option.
                Bernard Fouche ported the sources to Linux. Based on his
                        changes and comments, the portability of the compiler
                        and the abstract machine have been improved.
                Symbol names now have 31 significant characters. Native and
                        public names still have a maximum of 19 significant
                        characters.

19/11/1999      Bug correction in the "for" loop concerning local variables at
                        the same scope as the "for" loop (found by Joe Felton).
                amx_Exec() can now take NULL for the parameter for the script's
                        return value.
                New function "random()" in AMXCORE.C.

12/11/1999      Some changes for Greg Garner's module for floating point
                        support.
                Two more "interface" function for the compiler. These functions
                        allow you to set "pre-defined" tag names and constants.
                AMXCONS.C includes two more native functions to read a
                        character or a string from the keyboard.

 2/11/1999      Fixed minor annoyances in the compiler like failures to find
                        the include path on non-DOS platforms.

25/10/1999      Warning message for local variables that "shadow" a function
                        or a variable at an earlier scope (by having the same
                        name, they make the earlier symbol inaccessible).
                Warning message for the infamous "dangling else" problem.
                Bug correction: functions with upper case letters were not
                        assembled correctly (bug found by Greg Garner).
                New control character "^e" which has value 27 ("escape").

12/10/1999      The abstract machine is now also available as a DLL for
                        Microsoft Windows. Both 16-bit and 32-bit DLLs are
                        provided (including source).

 1/10/1999      Semicolons to end each statement can now be made optional with
                        the compiler switch "-;" or with:
                          #pragma semicolon false
                The assembler implementation of the abstract machine now also
                        supports __stdcall declaration. See the README for
                        information on compiling.
                There are now two "fixed point" libraries: binary (18:14) and
                        decimal (three decimal digits). The decimal fixed
                        point library may be more "exact" when working in "real
                        live" calculations (which are often based on a decimal
                        base).

27/08/1999      Bug correction: parameters passed to a Small function (called
                        with amx_Exec() were not stored at the correct
                        location (bug found & corrected by Marc Peter).
                Marc Peter's JIT underwent radical changes: on the "Towers of
                        Hanoi" benchmark the increase of performance is 80%,
                        see the history log in JIT.ASM for details.

23/08/1999      The assembler version of the abstract machine (by Marc Peter)
                        now also compiles with Microsoft Visual C/C++ 5.0 and
                        6.0.
                Bug correction: using the assembler abstract machine in a
                        program with a default calling convention of __stdcall
                        resulted in a crash.

20/08/1999      Mark Peter's Just-In-Time compiler is now integrated with
                        the standard release. The JIT gives yet another
                        major increase in performance.

18/08/1999      The assembler version of the abstract machine (by Marc Peter)
                        now also compiles with Borland C++ 5.0.
                Updated documentation; better lay-out too.

31/07/1999      Small supports two-dimensional arrays. See the manual for
                        the precise syntax and usage of this new feature.

18/07/1999      Plus debugging opcodes for the size and dimensions of an
                        array.

 2/07/1999      Trailing spaces are ignored when concatenating lines with
                        a \ at the end of the line.

 7/06/1999      Updated the Assembler AMX (by Marc Peter) for the new
                        opcodes (e.g. the SWITCH opcode and associated
                        case table).
                Bug correction: the compiler could "ignore" a fatal error
                        in a rare condition, leading to a crash or random
                        output.
                Bug correction: overflowing the stage buffer issued the
                        wrong error message ("cannot read from file").

24/05/1999      The switch statement was redesigned: the minor improvement
                        is the support for ranges (e.g. "case 1..8:"), the
                        major change is the fastly improved code generation.

10/05/1999      The compiler has an option to switch the syntaxes for packed
                        and unpacked strings; there is also a new #pragma to
                        to this.
                        and unpacked strings.

 1/05/1999      Array assignment is more relaxed for literal strings: the
                        destination array does not have to be exactly the
                        same size as the string length (in cells).

17/04/1999      Terminal support (ANSI escape sequences) for the debugger.
                The debugger supports "watches" and a few more commands.

15/04/1999      Support for static local variables.
                Bug correction: the compiler did not give an error message
                        when returning an array from a function.
                New commands in the debugger:
                        "GO RET" (run until function exit)
                        "GO n" (run until line n)
                        "LIST ON" (list 10 source lines after each step)
                        "LIST OFF" (turns above option off)
                        Pressing <Return> repeats the last STEP or NEXT

12/04/1999      Bug correction for line continuation (\ at the end of the
                        line).
                Error message when a \ appears in a single line comment.
                New predefined constants "language" (version of the Small
                        language) and "compiler" (version of the Small
                        compiler).

31/03/1999      Bug corrections for three opcodes of the abstract machine (none
                        of which were generated by the Small compiler) were
                        found and corrected by Marc Peter.
                A bug in the fixed point module (relating the division of
                        negative numbers) was found and corrected by Marc
                        Peter.
                Array assignment is permitted, under the condition that the
                        arrays at both sides of the "=" operator are of equal
                        size.

24/02/1999      The compiler has an option to skip a number of lines before
                        starting to compile; this comes handy for scripts
                        inside text files.
                The file format can now store the names of required modules
                        (that must possibly be dynamically linked); this is
                        currently supported through "#pragma library".
                The new "#endscript" directive is an alias for the existing
                        directive "#endinput".
                User data fields in the abstract machine are now "tagged", so
                        that you get some kind of name/value pair; you can
                        now determine whether a user data field is "in use".
                The compiler has a few more command line options.

 9/12/1998      Finished integration with Marc Peter's assembler abstract
                        machine, including the debugger interface.
                Updated documentation for new features.

27/11/1998      Two more warnings: nested comment and loose indentation (both
                        frequently indicate an error).

 6/11/1998      Integration of Marc Peter's abstract machine in assembler (this
                        is still an experimental version).

 4/11/1998      Major re-design of the compiler and the ANSI C version of the
                        abstract machine: opcodes are now cell sized.

30/10/1998      Major changes in the debugger interface to accomodate the
                        design of a re-entrant debugger.
                Early relocation of JUMPs and CALLs, which speeds up execution.
                Changes in instructions to make array indexing faster.
                New opcode to speed up passing long argument lists to
                        functions.
                Variable arguments may now be tagged.
                The manual got another full reading... and corrections.

23/10/1998      New directive "#emit" for those who want to program directly
                        in the assembler of the Small abstract machine.
                New directive "#endinput" to skip the rest of the file.
                New function amx_FindPublic() that returns the index of a
                        public function whose name is specified.
                Public functions are now written to the output file in sorted
                        order; this allows a quicker lookup of a public
                        function using a binary search.
                "funcidx()" is a new native function in AMXCORE.C that returns
                        the index of a function in the "public function table"
                        so that a script can return the index that the
                        application should call next.

19/10/1998      BUG fix: when calling an unknown function, the compiler would
                        issue a diagnostic and then crash or hang.
                Command line options changed; you can now also add definitions
                        on the command line of the compiler.
                The debugging interface changed (it became simpler), a console
                        mode debugger is included as an example.
                New function amx_Flags() to check whether the compiled program
                        contains symbolic (debugging) information.
                The property functions (core library) got an extra parameter
                        to avoid ambiguity in some cases.
                A new "native function" module: fixed point arithmetic.
                Clarifications and corrections in the manual.

01/10/1998      BUG fix: conditional expression was inverted!
                BUG fix: conditional expressions or logical operators generated
                        incorrect jumps when used in function arguments
                        (because arguments are evaluated right-to-left, but
                        code is generated left-to-right).
                Support for named parameters (in addition to positional
                        parameters). See the documentation for this major
                        feature.

28/09/1998      New functions pass strings between C and Small functions.
                Run-time check for Little/Big Endian machines.
                Some extra compiler checks: unused local constants and
                        side-effects of expressions.

24/09/1998      BUG fix: code generation bug when incrementing or decrementing
                        a "reference" argument with the "++" or "--" operators.
                Support for accessing (packed) characters from a (cell) array
                        with the {..} operator (function similarly to the [..]
                        operator).
                REMOVED module names for native functions. This turned out
                        to be a feature that complicated the implementation
                        without adding much.
                Several changes in the AMX, removed amx_CheckModules() and
                        amx_Unregister(). No need for callback functions
                        in an extension module. New function amx_NativeInfo().

22/09/1998      Support for Unicode characters in strings and character
                        literals.
                Support for line concatenation with a backslash at the end
                        of a line.
                Two more predefined constants: cellbits and charbits give the
                        size of a cell and a character respectively.
                More error messages (errors 41 and 42 are new).
                Functions whose name start with an '@' are always public.
                An indirect threaded interpreter of the abstract machine
                        (AMX.C) when compiled with GNU CC (I used Delorie
                        GCC). The GNU C version is twice as fast as the
                        ANSI C version.
                BUG fix: the compiler had a memory leak in the allocation of
                        the type list of function arguments.
                The #define directive can now easily be removed from the
                        language (its support is a kludge anyway).
                Packed strings are now stored in Big Endian, and no longer
                        terminated with a full zero cell; the new specification
                        makes it easier to determine whether a string is
                        packed or unpacked.

 3/09/1998      BUG fix: multiple initialized local arrays in a compound
                        block were not initialized correctly.
                Memory for function arguments was not explicitly freed.
                Support for literal arrays, just like literal strings, like
                        in "print( {'H','e','l','l','o',0} );
                Support for default values of array arguments, as in
                            "addvector(a[], b[] = {1, 1, 1}, size = 3);"
                        or
                            "messagebox(text[], caption[] = "error");"

28/08/1998      BUG fix: local arrays were not initialized to their full
                        extent.
                All unitialized variables and array elements are now set
                        to zero (default initialization).
                A few clarifications and additions in the manual.

24/08/1998      BUG fix: prototypes caused invalid code generation.
                BUG fix: expression involving constants could generate invalid
                         code.
                Added the FILL opcode in the abstract machine.
                More compact code generation for arrays initialized to a
                        single value.
                Extra error message 41 (invalid use of ellipsis).

20/08/1998      Improved portability of the compiler.

18/08/1998      First public release.
