# AngelScript Change Log

## Version 1.10.1d - 2005/01/21

- Bug fixes
  - asGetActiveContext() now returns 0 if there are no active contexts
  - It is now possible to overload arrays of registered types
  - Removed an assert failure when compiling math operator on non-math types
  - On GCC/Linux all classes/structs are always returned in memory regardless of size and complexity
  - Some compilers complained about the negative array size in the template code that is never instanciated. The code was commented.
  - Fixed an assert failure when trying to use a unregistered object type (thanks Alain "abrken" Bridel)

## Version 1.10.1c - 2004/12/19

- Bug fixes
  - ExecuteString() could sometimes return an invalid context pointer when an error occurred.
  - Application functions that returned float or double failed on GNUC based compilers with optimizations turned on. (thanks Marcin "Szpak" Zajaczkowski)
  - Prepare() could crash if the function id was incorrect.

## Version 1.10.1b - 2004/12/01

- Bug fixes
  - Temporary objects created explicitly by calling the object's constructor weren't properly handled by the exception handler (thanks Alain "abrken" Bridel)
  - Values were not implicitly converted to the parameter type when sent as function arguments

## Version 1.10.1a - 2004/11/26

- Bug fixes
  - The tokenizer wasn't able to handle string constants that ended with two backslashes (thanks Scott "waheyluggage" Newby)
  - The calling convention asCALL_CDECL_OBJFIRST wasn't working for functions with parameters
  - rvalue was not verified to be initialized in assignments

## Version 1.10.1 - 2004/11/21

- Bug fixes
  - The -> operator didn't compile correctly (thanks Adrian Licu)
  - If the ?: operator returned literal constants there was an assert failure (thanks Alain "abrken" Bridel)
  - Arrays of pointers were wrongly reported as uninitialized by the compiler
  - Dereferencing temporary variables didn't release the variable
  - Multidimensional arrays weren't working on GNUC based compilers
  - Arrays of pointers to objects where causing problems (thanks Dan "Aggrav8d" Royer)
  - Conversions to and from double failed in the VM (thanks Jetro Lauha)
  - CALLBND didn't work in the ASM vm
  - ExecuteStep() still didn't work as before with BUILD_WITH_LINE_CUES (thanks Josh Passenger)
  - ++ and -- failed in ASM VM for float values
  - Temporary variables where at times prematurely released (thanks Jetro Lauha)
- Library interface
  - asIScriptContext::Prepare() can now be called with the argument asPREPARE_PREVIOUS to prepare a context for calling the same function that was previously called.
- Script language
  - All number types are now implicitly converted for assignments and function arguments
  - When evaluating math operations of two different number types the types are first implicitly converted to the largest type
  - bits datatype is implicitly converted to and from uint/int
- Virtual machine
  - Optimized the ASM VM
- Compiler
  - Greatly improved build times
- Multithreading
  - Multithreading support is off by default, to add the support define the flag USE_THREADS
  - The flag NO_THREADS no longer have any effect
- Project files
  - Added as_typeinfo.h and as_typeinfo.cpp

## Version 1.10.0 - 2004/11/02

- Virtual machine
  - Optimized the C++ VM
  - Jumps no longer suspend the VM
  - New byte code BC_END, only used by exception handler.
  - Added a new module as_context_x86.cpp with an optimized VM using assembly. Compile with the flag USE_ASM_VM to utilize this new VM. (contribution by Andres "Lioric" Carrera) NOTE: This is currently slightly slower than the C++ VM, but will be optimized further in future releases.
  - Removed the NOP instructions as they are no longer needed for alignment
  - Added the SUSPEND bytecode again. It's used to guarantee that the host application always can suspend a context, i.e. all loops have a SUSPEND instruction.
- Bug fixes
  - Exception handler would continue the execution
  - Temporary variables were not always freed after compiling a function call
  - Constants were not always successfully converted to reference when making function calls (thanks Anthony "Deyja" Casteel)
  - The switch case didn't treat 8 and 16 bit integer types correctly (thanks Alain "abrken" Bridel)
  - The exception handler failed when objects where returned by reference
  - There was a memory leak when adding script sections but not actually building them (thanks Alain "abrken" Bridel)
- Script language
  - Added the operator 'xor' for boolean types. Alias '^^' (suggestion by Thomas Suter)
  - Added native support for arrays
- Library interface
  - Changed the parameter type for callConv to asDWORD in the interface
  - If the configuration is wrong the engine writes the message "Invalid configuration" to the outstream if available. People keep forgetting to verify the return code, this may help them understand why the build isn't done.
  - RegisterObjectBehaviour() should only be used for object behaviours. Global behaviours should be registered with RegisterGlobalBehaviour().
  - GetFunctionName(), GetFunctionDeclaration(), GetGlobalVarName(), GetGlobalVarDeclaration(), GetImportedFunctionDeclaration(), and GetExceptionString() have changed to return a pointer to the string, so it is no longer necessary to pass a buffer to them.
  - GetImportedFunctionSourceModule() and GetModuleNameFromIndex() now return the length as well.
  - New global function asThreadCleanup() (see multithreading)
  - Fixed ExecuteStep() to work as before
    - By default ExecuteStep() is guaranteed to suspend execution at least once per loop
    - Added the compile flag BUILD_WITH_LINE_CUES, which makes the script compiler add extra bytecodes that allow ExecuteStep() to return after each statement.
  - Improved ExecuteString()
    - Calls to ExecuteString() can now be nested.
    - ExecuteString() now takes an extra parameter, which allow the application to receive the context pointer directly, or even pass its own context by using the flag asEXECSTRING_USE_MY_CONTEXT.
    - GetContextForExecuteString() is deprecated.
    - ExecuteString() now reports build errors with line and column number starting with the passed string.
  - Overridable array objects
    - It is now possible to register array objects, overriding the native array object
    - New error code: asLOWER_ARRAY_DIMENSION_NOT_REGISTERED
    - The library now returns asAPP_CANT_INTERFACE_DEFAULT_ARRAY if the application tries to register a function that uses arrays that haven't been registered by the application.
- Multithreading
  - Added support for multithreading (can be disabled by defining NO_THREADS)
  - Multithreading should now work with both MSVC and MinGW. Still only for Windows though.
  - asGetActiveContext() is now thread safe
  - Reference counting is thread safe
  - The engine now deletes all unused modules when Discard() is called, this simplifies the context's interaction with the modules making the engine more stable for multithreading
  - Created the global function asThreadCleanup() that will allow AngelScript to cleanup some thread local data. Should be called before exiting any extra threads that access AngelScript.
- Miscellaneous
  - Added the module as_thread.cpp that abstract the OS's thread functions
  - New module as_arrayobject.cpp for the default array implementation
  - Added as_debug.h
  - Made minor code changes to make compilation on Linux smoother (thanks Johannes Plass)
  - Changed MSVC projects to output to a different file when in debugmode (thanks Dan "Aggrav8d" Royer)
  - Added std::vector binding code to the library download (thanks Anthony "Deyja" Casteel)
  - as_compiler_expression.cpp was merged with as_compiler.cpp

## Version 1.9.2a - 2004/10/12

- Bug fixes
  - Subtraction was optimized as if it was associative (thanks Lennart Denninger)
  - SetArguments() failed for script functions that returns registered object types by value. (thanks Thomas Suter)
  - The application would crash if an exception was raised in ExecuteString() (thanks Joe "Desdemona" Wright)
  - GetFunctionName() and GetFunctionDeclaration() now works for the ExecuteString() function id as well.
  - The compiler didn't warn when passing uninitialized variables to function parameters (thanks Alain "abrken" Bridel)
  - Constructors with parameters could cause assertion failure in GenerateExceptionHandler(). (thanks Alain "abrken" Bridel)

## Version 1.9.2 - 2004/09/30

- Library interface
  - The interface now uses default argument value where applicable to make it easier to use
- Script language
  - Added support for global objects using constructors with parameters (contribution by Andres Carrera)
  - Improved constructors with parameters to work with local objects as well
  - Constructors can now be used in expressions to create temporary objects
- Virtual Machine
  - Removed the bytecode EID, which speeds up execution when there are objects in the scripts
  - The exception ID is found by looking in a separate array
  - Added the bytecodes RDGA4 and MOVGA4 for faster access to global variables
  - Removed the bytecodes SET1 and PSP
  - Added the bytecodes ADDIi, SUBIi, ADDIf, SUBIf, CMPIf

## Version 1.9.1 - 2004/09/21

- Bug fixes
  - Switch-case didn't work correctly if the cases were not ordered in ascending order (thanks Dmitry "RCL" Rekman)
  - The ternary operator ?: didn't release temporary variables as it should, causing an assert failure in the debug version (thanks Dmitry "RCL" Rekman)
  - Passing string constants to condition operator would cause an assertion failure. (thanks Joe "Desdemona" Wright)
  - Implicit conversion of pointer to a reference to a pointer caused assert failure (thanks Joe "Desdemona" Wright)
  - The ternary operator ?: still wasn't working ok (thanks Joe "Desdemona" Wright)
- Virtual Machine
  - Added 4 new conditional jump byte codes JS, JNS, JP, and JNP
  - Renamed JMP0 and JMP1 to JZ and JNZ respectively
  - Added the bytecodes CMPIi and CMPIui
  - Removed the bytecodes LINE and SUSPEND.
  - Line numbers are now stored in a separate array for the functions that need them
  - Added bytecode CALLSYS for calling system functions and CALLBND for calling bound functions
  - RET now pops the function arguments
- Script language
  - String constants are now concatenated by the compiler if only whitespace separate them
  - If the first case in the ternary operator ?: is a constant 0 it's type will be converted to the type of the second case.
- Compiler
  - Added many optimizations
  - Code that can't be reached is now removed by the compiler
  - If statements that have constant expressions are optimized to go directly to the correct case
  - If there are no objects in the function the exception handler will only have a return instruction
- Library interface
  - ExecuteStep() no longer suspends execution after each statement because of the remove bytecodes LINE and SUSPEND.
  - Added support for asCALL_CDECL_OBJFIRST (thanks Tristan "Kurioes" Hartskeerl)
  - The value of boolean true can now be configured in as_config.h (the default is set to 1)

## Version 1.9.0 - 2004/09/02

- Library interface
  - Renamed RegisterTypeBehaviour() to RegisterObjectBehaviour()
  - Removed the flags asCALL_RETURNBYVAL and asCALL_RETURNBYREF
  - Removed the flags asOBJ_IS_COMPLEX and asOBJ_IS_NOT_COMPLEX
  - Included support for saving and loading compiled bytecode (thanks Dennis Bollyn)
  - Removed the need to pass stack size when calling Prepare() or ExecuteString()
  - Added the method SetDefaultContextStackSize()
  - New error message asINVALID_CONFIGURATION, which is returned by Build() if the configuration failed
  - Removed AS_CALL from the interface. This changes the exported function names.
  - Added new methods for binding module functions from different modules.
  - Removed GetModuleID()
  - Added GetModuleIndex(), and GetModuleNameFromIndex()
  - Added GetFunctionIDByIndex() and GetGlobalVarIDByIndex()
  - Added functions for automatically binding all functions imported in a module. New error code asCANT_BIND_ALL_FUNCTIONS
  - Added the lineOffset parameter to AddScriptSection()
- Compiler
  - Compiler no longer outputs unecessary messages, such as "Building..."
  - Each error message now follows a standard format: {section name} ({row}, {col}) : {Error or Warning} : {Message}
- Virtual machine
  - The context stack now dynamically grows as needed
  - New byte code BC_STR, that pushes the constant string address and length on the stack. The direct memory address is no longer stored in the compiled byte code
- Script language
  - Added the global statement 'import FUNC_DEF from "MODULE NAME";'. 'import' is a reserved keyword, but 'from' isn't.
- Miscellaneous
  - Renamed acCString to asCString and acCArray to asCArray
  - Minor code improvements and potential bug fixes (thanks Wade Brainerd)
- Bug fixes
  - Returning complex objects in script functions didn't work as expected. (thanks Joe "Desdemona" Wright)
  - An assert failed in GenerateExceptionHandler() when returning large types.
  - The macros asFUNCTIONP() and asFUNCTIONPR() wasn't working (thanks Joe "Desdemona" Wright)
  - When a Build() fails, the module is cleaned up so that ExecuteString() can't call half compiled functions

## Version 1.8.3 - 2004/08/31

- bug fix: An object with asBEHAVE_ASSIGNMENT registered could be assigned even though it was declared as const (thanks Lee "_MrC_" Clark)
- bug fix: Two functions with the same name and parameters would cause an assertion failure in compiler (thanks Alain "abrken" Bridel)
- bug fix: Discarding a module with Discard() could sometimes cause the module object to be deleted twice (thanks Alain "abrken" Bridel)
- bug fix: There was a typo in macro asMETHODPR() (thanks Joe "Desdemona" Wright)
- bug fix: An unclosed statement block could lead to assert failure in the parser (thanks Alain "abrken" Bridel)

## Version 1.8.2 - 2004/08/13

- Methods from classes with multiple inheritance are now supported
- Changed how the byte code references script functions, so that they are now local to each module, i.e. independent of module ID
- BC_PGA now takes an int instead of a dword
- Changed so that registered global properties are referenced by index instead of their memory address
- Global script variables are referenced by their local index, i.e. independent of module ID
- Added support for switch case statements (thanks Jeff White)
- Added support for the negative operator behaviour. The new flag is asBEHAVE_NEGATE

## Version 1.8.1 - 2004/08/13

- Changed debug output to be put in subdirectory AS_DEBUG
- bug fix: Some errors were always reported on line 1 column 1, no matter where they were located
- bug fix: An assertion failed when a function call used a temporary variable and the function wasn't found (thanks Jakub "krajzega" Wasilewski)
- bug fix: Non-complex objects with 2 DWORDs in size is now correctly returned from system functions
- bug fix: Objects returned in memory is now correctly handled by MinGW for cdecl calling convention
- bug fix: Objects registered with asOBJ_IS_COMPLEX was not treated correctly by MinGW
- bug fix: BC_PGA didn't mask out the module ID when retrieving the address of the global variable. (thanks Anders "Dentoid" Stenberg)
- bug fix: Class methods can now return objects in MSVC
- bug fix: Local variables in the top statement block could be destroyed at return even though they were declared after the return statement. (thanks Anders "Dentoid" Stenberg)
- bug fix: Class methods can now return objects in memory on MinGW
- bug fix: ExecuteString() could cause a crash when executed on a script compiled for the second time using the same module name. (thanks Jakub "krajzega" Wasilewski)
- Registering methods from classes with multiple inheritance are detected and reported as not supported
- Registering methods from classes with virtual inheritance are detected and reported as not supported on MSVC. Can't be detected on GNUC
- Cleaned up as_callfunc_x86.cpp
- Added support for virtual methods in GNUC
- New flags for RegisterObjectType(): asOBJ_CLASS, asOBJ_CLASS_CONSTRUCTOR, asOBJ_CLASS_DESTRUCTOR, asOBJ_CLASS_ASSIGNMENT, asOBJ_PRIMITIVE, asOBJ_FLOAT
- The flags asCALL_RETURNBYREF and asCALL_RETURNBYVAL no longer have any effect, and will be removed in a future version

## Version 1.8.0c - 2004/07/19

- bug fix: When creating a module its ID wasn't set correctly if another module had previously been released (thanks Lennart Denninger)
- bug fix: An assert failed when calling function in global variable initialization (thanks Lennart Denninger)

## Version 1.8.0b - 2004/07/17

- bug fix: Overloaded functions in multiple modules didn't compile correctly (thanks Anders "Dentoid" Stenberg)
- bug fix: MinGW reported duplicate labels when compiling as_callfunc_x86.cpp (thanks Jakub "krajzega" Wasilewski)

## Version 1.8.0a - 2004/07/12

- bug fix: asOBJ_IS_NOT_COMPLEX incorrectly identified objects smaller than or equal to 8 bytes (thanks Lennart Denninger)
- bug fix: Function calls in a second module didn't compile correctly (thanks Lennart Denninger)

## Version 1.8.0 - 2004/07/10

- Removed the flags parameter from RegisterGlobalProperty() and RegisterObjectProperty()
- Added RegisterStringFactory()
- Removed the bstr type from the library
- Added new behaviour flags for assignment operators, changing the values of the others
- Overloading assignment operator and compound assignment operators now work
- Added changes to remove level 4 warnings for MSVC .NET (thanks Ricard)
- Added C++ code alternative to the assembler code (thanks Eric Love)
- Changed the way function pointers and method pointers are registered. Use as asFUNCTION(f) and asMETHOD(c, m) macros.
- bug fix: Object method calls didn't free the object if it was temporary. (thanks Peter Marshall)
- Support for compilation of scripts into separate modules have been implemented.
- BC_PGA now takes a DWORD instead of a WORD
- @init() and @exit() are no longer reported by GetFunction...()
- Added support for STDCALL (contribution by Adam Hoult)
- bug fix: Functions with arguments of object types sent by value didn't pop all the arguments from the stack (thanks Adam Hoult)
- Added the method Discard() which allows the application to discard a module when it is no longer needed
- Added the method GetModuleID() which can be used to enumerate script functions in modules
- RegisterObjectType() should now use the new flags asOBJ_IS_COMPLEX and asOBJ_IS_NOT_COMPLEX
- ExecuteString() now take the name of the module in which it is to be executed
- Added support for enumeration of global script variables
- Added new macros to make it easier to take the pointer of overloaded functions and methods

## Version 1.7.1a - 2004/06/10

- bug fix: Arguments received by reference was erronously destroyed (thanks Peter Marshall)
- bug fix: MSVC++.Net 2003 crashed when compiling scripts. (thanks Fredrik Malmer)
- bug fix: Unnamed parameters wasn't treated by the exception handler
- bug fix: Some temporary variables wasn't correctly freed, leading to memory leakage

## Version 1.7.1 - 2004/05/27

- bstr has become an internally registered type
- bstr.length() is now a method instead of a property
- Removed the byte code STRMKE
- RegisterObjectType() now accepts the flags asCALL_RETURNBYVAL and asCALL_RETURNBYREF
- bug fix: Prepare() should no longer crash when receiving invalid function id (thanks Xavier "meink" Shay)
- The unexpected token message now shows what token was found
- It is now possible to use function overloads for scripted functions as well
- GetFunctionIDByName() returns asMULTIPLE_FUNCTIONS if more than one function with the same name exists
- GetFunctionIDByDecl() is now supported
- bug fix: The -> operator now works with direct pointers as well as pointer references (thanks Joe "Desdemona" Wright)
- bug fix: multiple variables per global declaration statement now works again (thanks Lennart Denninger)
- bug fix: scripts with errors in global variables could crash the application if no output stream was specified (thanks Fredrik Ehnbom)
- bug fix: calling ExecuteString() without first building a script didn't work (thanks Fredrik Ehnbom)
- ExecuteStep(asEXEC_STEP_OVER) is now supported
- Added support for the indexing operator
- The asBEHAVE_INDEX flag is used to register the overloaded indexing operator
- bstr[int] returns a reference to the indexed byte
- The library is now working on the Dreamcast (thanks Fredrik Ehnbom)
- bug fix: When compiling function calls the compiler didn't discard alternatives with more parameters than used arguments (thanks Lennart Denninger)

## Version 1.7.0 - 2004/05/03

- Included the makefile for Linux compilers (thanks Stefan Diepenbrock)
- Added the methods ExecuteString() and GetContextForExecuteString() to the engine interface
- ExecuteStep() now takes a parameter that defines how to execute, only asEXEC_STEP_INTO is supported at the moment
- ExecuteString() is able to work with compiled script
- ExecuteString() now takes a flag that can be either 0 or asEXECSTRING_ONLY_PREPARE (thanks Joe "Desdemona" Wright)
- Removed the concept of global constants, they are instead global variables that are read-only
- bug fix: global variables ignored any type modifiers, thus global pointers were not possible (thanks Gunder Wulde)
- condition operator can be used when initializing global variables
- Global variables can now be initialized with expressions using other global variables, not just constants
- When finding the matching overloaded function, a conversion between signed and unsigned integers are given priority over conversion between integer and float (thanks Joe "Desdemona" Wright)
- bug fix: A pointer with an assignment behaviour can now be assigned a null pointer.
- Changed the library license from LGPL to the zLib license

## Version 1.6.1b - 2004/03/30

- bug fix: Declaring multiple global variables in the same statement resulted in compiler error (thanks Jayanth)
- Added the tokens &&, ||, and ! as aliases to 'and', 'or', and 'not'

## Version 1.6.1a - 2004/03/23

- Removed compilation warning for VSC++ .NET 2003 (thanks Daniel Krenn)
- bug fix: When reading booleans as object properties the compiler failed to mask out value (thanks Joe "Desdemona" Wright)

## Version 1.6.1 - 2004/03/21

- bug fix: There was a memory leak in the tokenizer (thanks Philip Love)
- bug fix: An exception occured when compiling method calls with objects as parameters (thanks Bartosz "Hans" Czuba)
- More code cleaned up
- BCONSTR and BDESTR are no longer used, instead BC_CALL is used
- BCONSTR, BDESTR, BCOPY, STRDEL, STRCPY, STRMOV, STRCAT, STRCMP and STRWRT has been removed
- bug fix: break, continue, and return sometimes caused GenerateExceptionHandler() to fail since objects were destroyed more than once
- Added support for the for-loop (thanks Erik J Baran)
- Return values are now returned in a special register instead of on the stack
- Added bytecodes SRET4, SRET8, RRET4, RRET8 for managing the return register
- Added the calling convention asCALL_CDECL_OBJLAST for object methods. This calls the method as a normal C function with the object reference as the last parameter
- The asMETHOD and asFUNCTION types are now defined macros instead
- Type behaviours must be registered as either asCALL_THISCALL or asCDECL_OBJLAST
- Pointers can now be compared with other pointers of the same type and level, or with 0 for null pointer tests
- It is now possible to register overloaded operators for all dual operators, except assignment operators
- bstr is now handled with operator overloads
- bug fix: booleans are now 1 byte large, just as for C++ (thanks Josh "nihlist" Passenger for spotting the bug).
- Cleaned up the code that compiles overloaded operators and function calls
- Changed all the JMP instructions to use a 4 byte offset
- Function overloading for registered functions and object methods is now supported
- bug fix: When converting a constant to another type the value would become 0

## Version 1.6.0 - 2004/02/18

- Added parameter flags for RegisterObjectType, but should be set to 0
- The flag asCALL_WITHCONTEXT is no longer available, use asGetActiveContext() to retrieve context instead
- GetFunctionCount() can now be used to obtain the number of script functions compiled
- The way type behaviours are registered have been changed to allow more flexibility
- Cleaned up the code
- bug fix: RegisterObjectMethod() didn't accept asCALL_RETURNBYVAL and asCALL_RETURNBYREF flags
- If any of the engine configuration methods fail the engine object will no longer let the application build scripts.
- Function parameters and variables can now be declared as const
- The flag asPROPERTY_READONLY has been removed, use const in declaration instead
- bug fix: exceptionID wasn't initialized to zero in Prepare() and the program could crash at an exception
- Lot's of changes to allow compilation with DJGPP (thanks Eric Love)
- Added as_config.h that may be used to configure some aspects of the compilation to acomodate for compiler differences
- Improved the angelscript.h by allowing the user to define exactly the way AngelScript is linked
- bug fix: Equality comparison between bits types didn't work (thanks Bartosz "Hans" Czuba)

## Version 1.5.2 - 2004/01/30

- bug fix: When sending objects with behaviours by value in function arguments the exception handler didn't correctly destroy the objects
- bug fix: Pointers now work correctly with behaviours
- Added the flags asCALL_RETURNBYVAL and asCALL_RETURNBYREF that can be used to register how a system function returns if the engine isn't able to correctly determine it
- Cleaned up the method CallSystemFunction() giving about 10% performance improvement

## Version 1.5.1 - 2004/01/26

- bug fix: The compiler no longer crashes when an object method name is not found (thanks Lennart Denninger)
- Changed where and when objects are constructed and destructed
- Changed bstr to use behaviour functions for construct, destruct, and copy
- Changed the STRMKE and the STRCAT byte codes
- STRDEL, STRCPY, STRMOV, and STRWRT are no longer used
- Added bytecodes JMPP, EID, and PEID
- Completely remade the way the script engine cleans up the stack in case of exceptions
- It is now allowed to register behaviours for pointers to objects
- Exceptions may be thrown in the construct and copy behaviour functions

## Version 1.5.0 - 2004/01/19

- When registering object types the name is checked against all other names registered
- It is no longer possible to register two object members with the same name
- Contexts now hold a reference to the engine object
- Added RegisterTypeBehaviour() that allows the application to register helper function that will be call when a script variable is initialized, uninitialized, and copied
- Added bytecodes BC_BCONSTR, BC_BDESTR, and BC_BCOPY
- Objects with behaviour cannot be sent by value
- Returning objects with behaviour requires special care for system functions

## Version 1.4.1 - 2004/01/14

- bug fix: SetArguments() and GetReturnValue() didn't work
- Change the message for when implicit conversion is not possible to a more descriptive one
- Added int32 as alias to int, uint32 to uint, and bits32 to bits

## Version 1.4.0 - 2004/01/12

- Created the asIScriptContext interface for communicating directly with the contexts
- Context::Prepare() now takes a function ID instead of a string, making it faster for repeated preparations with the same function
- Get/SetStackData() has been renamed to GetReturnValue() and SetArguments()
- GetReturnValue() and SetArguments() now takes an array of dwords instead of a single dword
- System functions now receive a pointer to the context instead of the engine
- Added RegisterGlobalProperty() giving the script engine access to variables in the host application
- bug fix: properties are now properly treated as read only if the flag is set

## Version 1.3.9 - 2004/01/06

- bug fix: the compiler determined the size of the returned value incorrectly for large types
- bug fix: the script engine crashed the program when calling system functions that returned large types
- warnings and errors during compilation of constants are now correctly shown
- Improved performance for repetetive execution of the same script function by caching some values

## Version 1.3.8 - 2003/12/10

- Explicit conversions no longer generate warnings about precision
- bug fix: global constants of type double didn't hold the correct value
- float constants can now be declared explicitly by including the f modifier after the number

## Version 1.3.7 - 2003/11/27

- Added datatype `double`
- lots of new byte codes to handle the `double` data type
- Added missing conversions `bits` -> `bits8`, `bits16` -> `bits8`, `bits` -> `bits16`
- bug fix: Conversions in constant expressions now work
- bug fix: `bits` constants are now correctly parsed

## Version 1.3.6 - 2003/11/07

- Fixed a memory leak
- Multiple global constants of the same type can now be declared in the same statement
- Conversion on constants now continue being constants if possible
- Constant declarations now correctly report error if expression type is wrong
- Constant expressions are now implicitly converted to correct type for constant declarations
- Global variables can now be declared and initialized with constant expressions
- Added byte code PGA (Push Global Address) used to access global variables

## Version 1.3.5 - 2003/09/23

- Fixed a bug with returning a pointer to a float from a system function
- Fixed bug in CleanStack, that crashed program on an exception
- bstr.length is now uint
- Changed data types for functions asCreateScriptEngine, asBStrAlloc, and asBStrLength
- Improved speed of object method calls with almost 10%
- Added new bytecode PUSHZERO improving speed about 3%
- Added new bytecode COPY for copying memory blocks
- Simple structs are now supported, those that don't need special treatment for construction, destruction and assignments
- Added bytecode PSP (again)
- Fixed a bug that sometimes crashed the program if a system function declaration was wrong

## Version 1.3.4 - 2003/09/16

- Added data types: `int8`, `int16`, `uint8`, `uint16`, `bits8`, `bits16`
- Bitwise shift operators now takes an unsigned integer to the right
- bits, int, and uint can be implicitly converted to a larger type but never to a smaller
- Added byte codes BC_SB, BC_SW, BC_UB, BC_UW, BC_WRT1, BC_WRT2, BC_INCi16, BC_INCi8, BC_DECi16, BC_DECi8
- Implemented ++, -- for uint type (missing from last version)

## Version 1.3.3 - 2003/09/10

- Added data type: `uint`
- Integer constants are now `uint`
- Added byte codes BC_UI2F, BC_F2UI, BC_CMPui
- Fixed a bug that affected unary operations on constant values

## Version 1.3.2 - 2003/09/02

- Separated texts from the code for easier maintenance
- Separated library code from Windows DLL code
- Library code is now following the ANSI standard
- Fixed bug that at crashed program when the engine was destroyed
- System functions may now returns references that the script engine can write to

## Version 1.3.1 - 2003/08/22

- RegisterObjectMethod() is now supported for non virtual object methods

## Version 1.3.0 - 2003/08/19

- Reduced windows .dll size 10% by using the linker option /OPT:NOWIN98
- Reduced size another 20% by turning off exception handling (something that can't safely be used in a dll anyway as other compilers don't implement it the same way)
- Interface functions and methods are now explicitly declared as _stdcall
- The script language now allows the use of pointer declarations, although no pointer arithmetic
- Added the -> operator to access members from pointers
- Changed the RegisterObjectProperty() parameters
- RegisterObjectType() now takes an object size as property as well (although, only 0 is supported)

## Version 1.2.1 - 2003/08/12

- Registered object types are checked already when registering them
- Registered global functions are checked at inclusion
- Fixed bug, a script exception could sometimes crash the app
- Object properties can now be registered by the application.

## Version 1.2.0 - 2003/08/05

- The engine now supports multiple contexts for executing several script functions in parallel
- The application can now set a script exception in system functions
- The application can query the current function and line number being executed
- Changed the status codes returned by Execute()
- It is now possible to suspend a context
- The last context executed is returned with GetLastContextExecuted()
- EnumerateContexts() enumerates all existing context IDs.
- PrepareContext() uses an existing context created with CreateContext() to improve performance of execution
- A pointer to the scripting engine is sent as the last parameter to the system functions
- Improved error codes for interface methods
- ExecuteStep() allows the application to step through the script.

## Version 1.1.2 - 2003/07/31

- Added the access operator `.` for object properties
- Added `length` property to the `bstr` type
- Added ADDOFF that adds an offset to a pointer in a variable
- Fixed a bug in CompileDeclaration()
- Fixed a bug in Execute() where it returned 1 when finished succesfully
- Fixed bug in CallCDeclFunction(), where printf() and OutputDebugString() didn't work in the called function
- asCDataType now allows references to be marked as read-only

## Version 1.1.1 - 2003/07/25

- Cleaned up the code for the instruction set
- Added instruction set statistics
- Removed NOP, PSP, END
- Added MOVSF4, SWAP4, STORE4, RECALL4
- Improved performance of the switch case in asCThread::ExecuteNext()
- Improved performance for compound assignments
- Fixed a bug in CompileConversion()

## Version 1.1.0 - 2003/07/18

- The thread now reserves space on the stack for arguments and return value
- It is now possible to send arguments and retrieve return value
- The declarations of the script functions can be retrieved for verification
- Compiler error on divide by zero with constant
- Throws divide-by-zero on DIVi, MODi, DIVf, MODf
- Added byte code LINE that the thread uses to report on which line an exception ocurred
- The output stream is now only used during build.
- Made the string methods global because the memory is shared anyway
- Information about exceptions ocurred can now be retrieved from the engine
- The engine interface now uses reference counting to control memory deallocation
- Changed the name of the thread functions, as they create the misconceptions that multiple threads are allowed
- The output stream is now sent with the Build() method, as it is only used during build.

## Version 1.0.4 - 2003/07/16

- Improved compiler code to be easier to maintain
- Improved the implicit conversion to include assignment and return expressions.
- Improved compiler message output, doesn't write "Parsing..." or "Compiling..." unless there is an error or warning.
- Improved verification of extended types and system functions

## Version 1.0.3 - 2003/07/08

- Undeclared variables are only reported once
- Doesn't give assert failed when lvalue is a temporary variable (gives a compile error instead)
- A warning is now given if a variable is used before being assigned a value
- Added implicit conversion between int and float for constant values
- Constant expressions are evaluated into a single constant
- Constant declarations may now take constant expressions
- Constants can only be declared one per statement.

## Version 1.0.2 - 2003/07/03

- Fixed minor error where the script engine treated the argument to STRMKE as short instead of WORD as it should.
- Added an extra SUSPEND in both while and do-while loops to make sure that at least one exist in every loop.
- Fixed a bug where assigning a string to a variable breaks the code.
- Added post compile optimizations
- Added byte code RDSF4 that the optimizer puts in the place of PSF followed by RD4
- Added asGetLibraryVersion() to the API

## Version 1.0.1 - 2003/06/30

- Corrected the missing return type for operator = in asCDataType (thanks Marc Fascia for spotting that)
- Fixed a bug where the script engine crashed when initializing variables with a declared bstr constant.
- Improved version check so that it is backwards compatible for changes in build version (bug fixes)

## Version 1.0.0 - 2003/06/25

- Improved temporary variable reutilization
- Removed bug in release version
- Cleaned up the code for public release
- Prepared for compilation as DLL