# AngelScript Change Log

## Version 2.26.3 - 2013/05/08

- Bug fixes
  - Compiler was generating invalid bytecode when compiling var declaration with initialization using void opAssign (Thanks Andrew Ackermann)
  - RegisterObjectProperty() will now return an error if the offset is larger than a signed 16bit value which is what the VM supports (Thanks Adrian Bibby Walther)
  - Fixed bug in compiler where the class constructor could become invalid if two classes with the same name was declared in different namespaces (Thanks loverlin)
  - A null pointer access error could happen when compiling a script with enums after discarding a script with global variables (Thanks Robert Weitzel)
  - The context could in some situations attempt to destroy objects on the stack that had never been initialized upon cleanup (Thanks Philip Bennefall)
  - Multi-template types where both subtypes are of the same script class no longer crash the GC (Thanks Polyák István)
- Library interface
  - The new enum asFUNC_DELEGATE is used to identify function objects that are delegates
  - The engine property asEP_DISALLOW_VALUE_ASSIGN_FOR_REF_TYPE disables value assignments for reference types
- Script language
  - Delegates can now be instanciated with a construct call for a funcdef with the class method as argument
  - Function handles for overloaded functions are now implicitly resolved by the compiler by deferring the choice of the function until its used
  - Parent namespaces are now searched recursively for matching entities
- Add-ons
  - Script array add-on will not allow subtypes of reference types unless they are handles if asEP_DISALLOW_VALUE_ASSIGN_FOR_REF_TYPE is turned on (Thanks Polyák István)
  - Added methods GetSectionCount() and GetSectionName() to builder for enumerating the included script sections
  - Added fpToIEEE and fpFromIEEE to the math addon. These allow platform agnostic conversion between floating point and IEEE 754 representation (Thanks Maarten van Berkel)

## Version 2.26.2 - 2013/03/31

- Bug fixes
  - Fixed bug in compiler when compiling implicit cast of global variable of ref type to a primitive value (Thanks jrick)
  - Fixed crash that could happen on releasing the engine if some garbage collected object was still kept alive by application (Thanks thd.MM)
  - Fixed the native calling conventions on Android (Thanks Grimshaw)
  - Fixed problem with shared global functions being recompiled in all modules and thus causing memory leaks (Thanks thd.MM)
  - Fixed crash with native calling conventions on Linux 64bit (Thanks darthvolvo)
  - The compiler wasn't giving error when default arg expression didn't match the parameter type (Thanks Philip Bennefall)
  - Evaluating -2147483648 / -1 is now treated properly with a script exception (Thanks TyRoXx)
  - Initializing class member in declaration with a non-default constructor produced invalid bytecode (Thanks fanwars)
  - Fixed the native calling conventions on MinGW64 4.7 (Thanks Neuntoter)
- Library
  - Improved garbage collector to give better error messages when it can't release all objects
  - Added engine property asEP_COMPILER_WARNINGS to allow applications to turn off warnings
  - Changed the code back to emit a warning instead of an error on unreachable code as it was often used by developers to temporarily skip parts of the code during testing
  - Increased maximum limit of number of functions in the engine from 65535 to approximately 10^9 (Thanks TheAtom)
- Script language
  - Integer constants are now considered signed by default (Thanks cellulose)
- Add-ons
  - Implemented helper function GetTypeTraits<T> to aid in the registration of value types. Relies on C++11 features (Thanks Heuristics)
- Project
  - Updated the Android makefile to make sure the library is compiled with thumb mode turned off (Thanks quarnster)
  - Modified the gnuc makefile to make it easier for Linux package maintainers (Thanks Michael Shigorin)
  - Updated trolltech makefile to allow it to compile as_callfunc_x64_msvc_asm.asm on 64bit Windows (Thanks Markus Mönig)

## Version 2.26.1 - 2013/03/02

- Bug fixes
  - Fixed compiler error on Mac OS X in with the atomic functions (Thanks thd.MM)
  - Fixed segfault in GetGlobalVarIndexByDecl on passing invalid declaration (Thanks Nate Kent)
  - AssignScriptObject and CopyFrom wasn't using the script class' opAssign method (Thanks Polyák István)
  - Fixed bug in compiler with complex expressions in default args (Thanks Philip Bennefall)
  - Fixed the line numbers for for-loops (Thanks FDsagizi)
  - Fixed bug with the allocation of function ids, which could cause random behaviour for very large scripts (Thanks TheAtom)
  - Fixed bug with loading bytecode that used registered value types that could cause unexpected behaviour (Thanks TheAtom)
  - The compiler wasn't considering the correct namespace when parsing methods of classes and interfaces within namespaces (Thanks Wipe)
  - Interfaces that inherited other interfaces didn't expose the inherited methods (Thanks Wipe)
  - Fixed assert failure in compiler with use of copy constructor for value type with unsafe reference (Thanks FDsagizi)
  - Fixed assert failure in compiler with nested access to virtual property accessors (Thanks AgentC)
  - Fixed null pointer access in compiler when compiling default constructor for a class with invalid member initialization expressions (Thanks FDsagizi)
  - Fixed crash in compiler when compiling call to imported function with default arguments (Thanks Wipe)
  - Compiler no longer emits warnings on implementing the same interface multiple times (Thanks Wipe)
  - Compiler generated invalid bytecode when compiling expression that called function pointer returned from virtual property accessor (Thanks Wipe)
  - Fixed crash in GetLineNumber after loading module from bytecode (Thanks FDsagizi)
  - Fixed memory leak that could happen upon script exception (Thanks Wipe)
- Library
  - Improved error message from CreateScriptObject when called for type that doesn't have default constructor (Thanks izackp)
  - Parser doesn't complain with empty declaration, i.e. a single ;, in classes (Thanks FDsagizi)
  - Improved error message when encountering non-terminated string literals (Thanks FDsagizi)
  - Templates now support multiple subtypes (Thanks Amer Koleci)
  - Added support for native calling conventions on Linux with ARM and gnuc compiler (Thanks Carlos Luna)
  - Compiler will report error if virtual property in shared interface doesn't match first declaration of the interface (Thanks Wipe)
  - Funcdefs are now automatically shared between modules if they are identical (Thanks Wipe)
- Script language
  - Primitives can now be implicitly cast to value types via a call to the appropriate constructor
  - Added support for octal and binary constants with prefixes 0o and 0b respectively (Thanks ketmar)
  - Heredoc strings keep the last linebreak (Thanks Scott Bean)
- Add-ons
  - Script any, dictionary, and file add-ons now uses asAtomicInc/Dec to provide threadsafe reference counting
  - Implicit casts from primitives to the complex math type can be done with the new constructor

## Version 2.26.0 - 2013/02/03

- Bug fixes
  - Fixed rare crash after an object type had been deleted prematurely by the engine
  - Fixed incorrect static_cast on MSVC when attempting to register method for class with virtual inheritance (Thanks David Rosen)
  - Fixed compiler warnings when compiling with AS_NO_THREADS (Thanks Papirosnik)
  - Namespaces are now properly considered when compiler searches for property accessors (Thanks Violet CLM)
  - Fixed crash that occurred when using asCALL_GENERIC with asBEHAVE_TEMPLATE_CALLBACK (Thanks Andre Santee)
  - Fixed problem with saving/loading bytecode that passed function pointers in a function parameter (Thanks Andre Santee)
  - Fixed global variables of scoped reference types
  - Fixed bug in XBox 360 native calling convention code when returning simple objects by value (Thanks Jason Dorie)
  - Fixed compiler errors on Wii U (Thanks virious)
  - Shared types would get the implemented interfaces duplicated if compiled in multiple modules (Thanks Andrew Ackermann)
  - Fixed bug in compiler with passing temp handle to function taking inout ref to object (Thanks kozec)
  - RegisterObjectType no longer accepts combination of asOBJ_VALUE and asOBJ_NOHANDLE (Thanks Paril101)
  - Compiler wasn't considering the correct implicit namespace when looking up datatypes (Thanks Paril101)
  - Loading bytecode always failed if global variables had been disabled, even if the saved bytecode didn't have any global variables (Thanks Paril101)
  - Constructor with const &inout is now recognized as copy constructor with asEP_ALLOW_UNSAFE_REFERENCES (Thanks FDsagizi)
  - Fixed parser error when function declaration had default argument that used paranthesis (Thanks Thomas Grip)
  - Fixed null pointer access in GetLineNumber() if called on function without debug info (Thanks ketmar)
  - Fixed crash that could happen discarding a module and the garbage collector held a reference to an object declared in the module (Thanks Thomas Grip)
  - Script arrays could be falsely marked as non-garbage collected as the asOBJ_GC flag wasn't set when the template callback was invoked
  - Fixed bug where a script class could be incorrectly marked as non-garbage collected when including a garbage collected member by value
- Library interface
  - Added asCALL_THISCALL_ASGLOBAL for registering a class method as a global function
  - RegisterGlobalFunction() now takes an optional object pointer to be used with THISCALL_ASGLOBAL (Thanks zerochen)
  - asPrepareMultithread now takes an optional argument for using a shared thread manager in multiple dlls (Thanks Damien French)
  - asGetThreadManager and asIThreadManager for retrieving an existing thread manager (Thanks Damien French)
  - Added GetDefaultNamespace to engine and module (Thanks dkrusu)
  - Prepared asIObjectType for future implementation of templates with multiple subtypes
  - Added asAtomicInc and asAtomicDec as global functions to aid in development of portable and threadsafe add-ons
- Library
  - Unreachable code in script functions is now considered an error by the compiler, instead of just a warning
  - Compiler avoids misleading error message about not all paths having a return value after encountering unreachable code (Thanks zerochen)
  - Marmalade is now identified as an OS with its own ABI (Thanks Braden MacDonald)
  - Added configuration for compiling the library with gnuc on Linux with mips. Though only with AS_MAX_PORTABILITY (Thanks Andris Jaunzeikars)
  - Added compile time option AS_NO_MEMBER_INIT to disable member initialization for backwards compatibility (Thanks Andrew Ackermann)
  - Reduced size of executable by avoiding code inlining in templated functions for taking function pointers (Thanks AgentC)
  - Slight reduction on overhead of calling system functions (Thanks Andrew Ackermann)
  - Improved algorithm in compiler for determining if objects needs to be garbage collected or not by taking advantage of the 'final' flag (Thanks Andrew Ackermann)
- Script language
  - It is now possible to initialize class members directly in the declaration
- Add-ons
  - Implemented the generic calling convention wrappers for the missing methods in the script array add-on
  - Implemented the generic calling convention wrappers for the script handle add-on
  - Implemented the generic calling convention wrappers for the missing methods in the std::string add-on
  - Fixed bug in script array when comparing two arrays for equality and only opCmp had been implemented in the element type (Thanks virious)
  - Fixed fopen_s compiler error on Marmalade in the scriptfile and scripthelper add-ons (Thanks Braden MacDonald)
  - CScriptBuilder::AddSectionFromMemory() now requires a name and an optional length for the buffer in case it is not null terminated (Thanks Paril101)
  - Fixed null pointer access in CDebugger when stepping over a function without debug info (Thanks ketmar)
  - Script array's reference counter is now threadsafe by using the global functions asAtomicInc and asAtomicDec

## Version 2.25.2 - 2012/11/24

- Bug fixes
  - Problem with template types when non-default factory was registered before the default factory (Thanks zeta945)
  - import functions can now be declared with default arguments without crashing (Thanks Wipe)
  - Fixed bug in IsNested() that could sometimes give false positives
  - Fixed incorrect error messages for mismatching property accessors when this had been disabled by application (Thanks Philip Bennefall)
- Library
  - Changed to localized bytecode optimizations for greatly enhanced compilation speeds in large complex functions
  - Added new bytecode optimizations for improved runtime performance
  - Script functions are now only added to the GC when the owning module releases them
  - Some more unused methods in the code are excluded when compiling with AS_NO_COMPILER
  - Global properties are also only added to the GC when the owning module releases them
  - Object types are no longer added to the GC while the module still references them
  - Changed style of comments in as_callfunc_arm_gcc.S to avoid compiler errors with Marmalade (Thanks Papirosnik)
- Script language
  - Mixin classes can now implement interfaces
- Add-ons & Samples
  - Fixed some compiler errors with gnuc in the sample projects (Thanks Aapo Rantalainen)
  - ScriptBuilder now supports metadata for entities in namespaces (Thanks Chase W)
  - Changed the code in the string factory to avoid confusing the Marmalade memory leak detector (Thanks Papirosnik)

## Version 2.25.1 - 2012/10/28

- Bug fixes
  - Fixed including mixin from a different script section (Thanks Nick Robinson)
  - Registering template specializations for templates without default constructor is now working (Thanks slicer4ever)
  - Fixed compiler assert on unary negate operator on void expression (Thanks FDsagizi)
  - Fixed bug with NOCOUNT object when copying script class members (Thanks FDsagizi)
  - Problem with exception handling after loading pre-compiled bytecode when class constructor takes object in argument (Thanks FDsagizi)
  - GetLineNumber() could crash when called for nested context calls (Thanks saejox)
  - Compiler would incorrectly find global functions when compiling function calls as post ops (Thanks FDsagizi)
  - Fixed bug in compiler when compiling property get expression that returned a reference to an object, but the reference wasn't used (Thanks Eero Tanskanen)
  - Fixed bug with virtual methods returning objects in memory on ARM platforms (Thanks Cordan)
  - Fixed compiler bug when compiling function that takes out reference of a type where opAssign returned a value (Thanks _Engine_)
  - Compiler wasn't showing error for virtual properties without any accessor (Thanks FDsagizi)
  - Shared enums in pre-compiled bytecode were not treated as shared when loading (Thanks _Engine_)
  - Shared classes will now validate that declared members exist in the original declaration during compilation (Thanks _Engine_)
- Library
  - Implemented an inline profiler to get better understanding of bottlenecks in the code
  - Added support for the new ABI in MinGW32 4.7 (Thanks Heuristics)
  - Improved error messages when loading bytecode with shared types that doesn't match existing shared types
  - The context's line callback is now invoked one extra time just before leaving the Execute() method to allow listeners to catch state changes (Thanks saejox)
  - Made some improvements towards compatibility with Marmalade
  - Added validation against duplicate registration of global functions or class methods (Thanks Jason Dorie)
- Script language
  - Class properties of the same type can now be declared together separated by ,
  - Interfaces can now inherit from other interfaces
  - Improved the way function overloads are matched against arguments so least conversion cost for all arguments wins (Thanks Adam Hoult)
- Add-ons
  - Slight optimization in the string pool when a string is inserted for the first time (Thanks thewavelength)
  - Fixed bug in script builder add-on with parsing metadata for invalid script (Thanks FDsagizi)

## Version 2.25.0 - 2012/09/17

- Bug fixes
  - GetEnumByIndex and GetTypedefByIndex wasn't returning a valid typeId when the type was not in the default namespace (Thanks Polyák István)
  - Inheriting from a class or interface in a different namespace didn't work (Thanks Polyák István)
  - Functions and class methods didn't accept the scope operator in the return type (Thanks Polyák István)
  - Compiler missed adding a validation for a null pointer when compiling a return statement for a function returning object by value (Thanks Philip Bennefall)
  - Fixed crash when cleaning up after a script exception in a function that returns a value object by value (Thanks Philip Bennefall)
  - Fixed memory leak when compiling script that declares interface with virtual properties (Thanks brumi)
  - Functions that take 64bit types as arguments now work with Android native calling conventions (Thanks Fredrik Ehnbom)
  - Fixed bug in compiler when assigning value from property accessor to array element (Thanks Philip Bennefall)
  - Fixed crash in garbage collector when using automatic collections (Thanks Polyák István)
  - Compiler failed to compile default argument expression that accessed an index in global array (Thanks Philip Bennefall)
  - Avoid temporary copy of script object without explicit opAssign method when assigned from global variable (Thanks Andrew Ackermann)
  - Duplicate class methods are now detected at their declaration (Thanks FDsagizi)
  - Local function pointers variables now properly take precedence over class methods of the same name (Thanks cellulose)
  - Serializing bytecode that called funcions with variable arguments didn't work properly (Thanks Markus Lenger)
  - Construct calls in expressions are now parsed properly when the type is preceeded with the namespace (Thanks Andrew Ackermann)
  - Compiler gave error when compiling non-const methods that returned const references to members (Thanks Polyák István)
- Library
  - The VM will catch C++ exceptions thrown by the registered functions and set a script exception. This can be turned off by AS_NO_EXCEPTIONS if exception handling is not supported (Thanks Polyák István)
  - Loading large precompiled bytecode files will now be significantly faster. Performance should now be similar to pre 2.23.0 (Thanks loboWu)
  - Improved build performance of tokenizer for large initialization lists (Thanks Markus Lenger)
  - Improved build performance of parser for scripts with a lot of statements
  - Improved build performance of searching for global properties by name (Thanks Markus Lenger)
  - Improved build performance of searching for global script functions (Thanks Markus Lenger)
  - Compiler will now implicitly convert rvalue to handle when doing a handle assignment to ASHANDLE type
  - Types registered with asOBJ_APP_PRIMITIVE or asOBJ_APP_FLOAT can now be passed by value in native calling convention on 64bit Linux and Mac (Thanks Cordan)
  - Error message now includes the error code when an improper call to an engine function is made
  - Improved error message when parser encounters unexpected end of file (Thanks Philip Bennefall)
  - Improved build performance when optimizing bytecode with a large amount of conditions
- Virtual Machine
  - float and double comparisons in the VM now properly handle infinity (Thanks GGLucas)
- Library interface
  - Added asOBJ_APP_CLASS_ALIGN8 used to inform AngelScript that a type may need to be aligned on 8byte boundaries (Thanks Fredrik Ehnbom)
  - The template callback behaviour now take a second argument to allow the application to tell the engine if an instance shouldn't be garbage collected
  - Added asOBJ_SCRIPT_FUNCTION flag to identify the object type that represents script functions
  - Added asIScriptFunction::IsCompatibleWithTypeId() and GetTypeId() to work with function pointers as generic types
  - Added an optional argument to asIScriptModule::SaveByteCode to strip the debug info
  - Added an optional argument to asIScriptModule::LoadByteCode to determine if the bytecode contains debug info or not
- Script language
  - Added keyword 'mixin'
  - mixin classes can now be declared with default implementations to be included into a class
- Add-ons
  - The script array is no longer garbage collected if the type cannot form circular references (Thanks Philip Bennefall)
  - Implemented the C++ copy constructor for the CScriptArray
  - Added GetType() to CScriptHandle
  - CScriptHandle::Cast() properly handles function pointers
  - Fixed bug in CScriptArray::SetValue() when replacing a handle in an element (Thanks Andrew Ackermann)
  - Added wrapper for std::string::operator== to fix compile error on gcc 4.7 (Thanks Piotr Rak)
  - Fixed bug in CSerializer related to extra objects (Thanks FDsagizi)

## Version 2.24.1 - 2012/08/07

- Bug fixes
  - Parser now recognizes declarations where the type is declared in a different namespace (Thanks alraz)
  - Parser can now parse templates where the subtype is in a different namespace (Thanks sylexer)
  - Stack pointer wasn't restored correctly when reusing context, which lead to memory invasions (Thanks virious)
  - Fixed problem with loading bytecode that contained arrays of function pointers (Thanks TheAtom)
  - GetFunctionByDecl() failed to find functions with parameters when they were declared in a namespace (Thanks alraz)
  - The scope operator can now be used in the inheritance list when a class is deriving from a class in another namespace (Thanks alraz)
  - IsVarInScope() and GetAddressOfVar() now works properly even before Execute() (Thanks Friggle)
  - The garbage collector could enter an infinite recursive loop if invoked while calling a class destructor (Thanks Philip Bennefall)
  - Aborting a nested script call could cause a crash in the VM (Thanks Philip Bennefall)
  - AS_64BIT_PTR is now defined in angelscript.h instead of in as_config.h (Thanks quarnster)
  - Saving bytecode with functions that take enums by value could fail on 64bit platforms (Thanks m4ttbush)
  - asIScriptContext::GetLineNumber() will now return the line where the function call was made from (Thanks quarnster)
  - Registering object properties when both object and property type is in a namespace is now working properly (Thanks Starfox)
  - Fixed memory invasion when script allocated script class that had other script classes as members (Thanks Andrew Ackermann)
  - Registering global properties with a type from another namespace failed (Thanks _Engine_)
  - Fixed 64bit bug when saving bytecode (Thanks quarnster)
- Library
  - Removed functionality where interfaces would be automatically shared if the declaration was identical. This was already deprecated in version 2.23.0
  - Improved internal handling of namespaces
  - Reduced the size of saved bytecode by not storing the namespace of class methods
  - Bytecode optimizer exchanges some more sequences with shorter ones for better performance
  - When the engine receives a request to abort a script in a nested call it will now forward the request to the outer call, after aborting the inner call (Thanks Philip Bennefall)
  - Reduced recursiveness in compiler to allow it to compile extremely long expressions without stack overflow (Thanks Philip Bennefall)
  - Added JitEntry instructions in the factory stub functions and generated default constructor
- Script language
  - Function pointers can now be invoked from arbitrary expressions without first assigning them to a variable (Thanks TheAtom)
- Virtual machine
  - Each call to Execute() will now tell the GC to process at least one step unless automatic garbage collection is turned off
- Add-ons
  - Corrected the implementation of Complex::operator/() to calculate the proper result (Thanks CMRM)
  - Fixed compilation error in scriptbuilder.cpp on XCode 4.3 with CLang++ 3.1 (Thanks Ricky C)
  - The script array will forward requests to abort a script to the outer call when performing comparisons, which uses nested calls (Thanks Philip Bennefall)
  - Fixed linker error in scriptstdstring.cpp on XCode 4.3 with CLang++ 3.1 (Thanks Ricky C)
  - Fixed crash in script array when the array was created with a very large initial size (Thanks Philip Bennefall)

## Version 2.24.0 - 2012/06/24

- Bug fixes
  - Fixed a potential crash if context is prepared but never executed (Thanks Andrew Ackermann)
  - Fixed crash with release of the thread manager if the last engine was released as part of destructor in global variable (Thanks Friggle)
  - Accessing entitites in global scope from a function in a namespace didn't work (Thanks _Vicious_)
  - Fixed assert failure on compiling unary plus operator on non-primitive (Thanks FDsagizi)
  - Fixed error in compiler with index operator on a value returned by a property index accessor (Thanks Andrew Ackermann)
  - Fixed error in compiler when compiling function call with @& parameter and asEP_ALLOW_UNSAFE_REFERENCES (Thanks FDsagizi)
  - Fixed problem in parsing enum declarations where unexpected tokens might get ignored (Thanks virious)
  - Fixed crash on 64bit Mac OS X when calling native function that receives and returns large objects by value (Thanks Markus Mönig)
  - Namespaces are now properly considered for registered types as well (Thanks Ricky C and adam4813)
  - Improved compatibility with native calling convention on Android with gnuc (Thanks Lasse Öörni)
  - SaveByteCode() was crashing when the script contained assignment of POD types without explicit opAssign method (Thanks Andrew Price)
  - Fixed crash with releasing a suspended context when a function was returning a value type by value (Thanks Andrew Price)
  - The engine allowed to register multiple ref cast behaviours to the same type, which would cause assert failure in compiler (Thanks Andrew Ackermann)
  - Improved compatibility with native calling conventions on iOS (Thanks Lasse Öörni)
  - Templates with const subtypes are now properly handled (Thanks Andrew Ackermann)
  - Fixed SegV with gnuc when using a virtual method for the message callback (Thanks Tzarls)
  - Fixed problem with calling registered functions with more than 8 parameters on XBox 360 (Thanks virious)
  - Fixed problem with returning float/double on XBox 360 when the library is compiled with optimizations (Thanks virious)
  - Fixed bug with virtual property access with index and variable type argument (Thanks virious)
  - IsHandleCompatibleWithObject() was ignoring inheritance for script objects (Thanks saejox)
  - Fixed bug in compiler when compiling a cast on temporary ASHANDLE object (Thanks saejox)
- Library interface
  - Added the global functions asPrepareMultithread() and asUnprepareMultithread()
  - The engine and object type can now hold multiple different user data
  - Added the global functions asAcquireExclusiveLock(), asReleaseExclusiveLock(), asAcquireSharedLock() and asReleaseSharedLock()
  - Deprecated engine::GetGlobalFunctionIdByIndex()
  - Deprecated module::GetFunctionIdBy...() and module::RemoveFunction(funcId)
  - Changed asIScriptContext::GetAddressOfVar() to dereference parameter references to make it easier to use (Thanks virious)
  - Changed BindImportedFunction to take a asIScriptFunction pointer
  - Deprecated context::Prepare(int id)
  - Deprecated generic::GetFunctionId() and GetFunctionUserData()
  - Deprecated objecttype::GetFactoryId...() and GetMethodId...()
  - Changed objecttype::GetBehaviourByIndex() to return asIScriptFunction*
  - Added the method engine::CreateUninitializedScriptObject() that will create an object without calling the constructor
  - Added module::GetObjectTypeByName()
  - Renamed engine::CopyScriptObject() to AssignScriptObject() to avoid common confusion with the intent of the method
  - Added PushState(), PopState(), and IsNested() to the context that can be used to reuse an active context in a system call
- Library
  - Improved stability in out-of-memory conditions to allow graceful exits (Thanks Zylann)
  - Improved error handling when loading incorrect bytecode (Thanks Andrew Price)
  - Improved thread safety in XBox 360 native code
- Add-ons & Samples
  - SetValue is now a public method in the CScriptArray (Thanks saejox)
  - The array add-on takes advantage of the multiple user data types to share its cache between arrays of the same type
  - The array uses the new global functions to create the shared cache in a thread safe manner
  - CScriptBuilder::GetMetadataStringForFunc() and GetMetadataStringForTypeMethod() now takes a asIScriptFunction*
  - The string pool is now threadsafe and supports multiple engines
  - CSerializer now works when script class constructors modify global variables too (Thanks FDsagizi)
  - Added method AddExtraObjectToStore on CSerializer to allow serializing objects not referenced by global variables in module (Thanks FDsagizi)
  - Improved C++ interface for the CScriptHandle class to make it easier to use from application
  - The CScriptHandle is now capable of casting to inherited script classes or implemented interfaces (Thanks saejox)
  - The script array is using the nested context functionality to avoid instanciating temporary contexts
  - PrintException() is properly reporting nested calls when printing the callstack

## Version 2.23.1 - 2012/04/28

- Bug fixes
  - Fixed assert failure when loading bytecode containing calls to functions returning value types by value in an if-case (Thanks Markus Larsson)
  - Fixed crash when compiling constructor and base class doesn't have default constructor (Thanks Ekimr)
  - Fixed bug in asCScriptFunction (Thanks Richard Viney)
  - Compiler no longer accepts non-handles with the identity operator 'is' (Thanks SadSingleton)
  - Shared global functions didn't fail to compile unless the return type was 'void' (Thanks TheAtom)
  - Fixed problem with global get property accessor that returns a POD value type (Thanks Andrew Ackermann)
  - Fixed problem with global get property accessor with index that returns an object type (Thanks Andrew Ackermann)
  - Fixed crash when loading bytecode that contained shared classes in specific scenarios (Thanks TheAtom)
  - Fixed crash with native calling convention on 32bit Mac OS 10.7 with XCode 4.3 (Thanks Matt Bush)
  - Fixed crash with compiling private virtual property accessors (Thanks SadSingleton)
  - Fixed assert failure when compiling identity operator on non-handle operands (Thanks FDsagizi)
- Script language
  - Added proper support for const overloads in property accessors (Thanks Andrew Ackermann)
- Library
  - Changed config to enable multithread support on Mac OS X 64bit (Thanks Radu Braniste)
  - Bytecode optimizer replaces PshNull, RefCpyV, PopPtr with FREE
  - Bytecode optimizer removes CHKREF instructions before and after the ADDSi instruction
  - Bytecode optimizer removes CHKREF instructions before RDSPtr instruction
  - Bytecode optimizer replaces ChkRefS, RDSPtr with RDSPtr, CHKREF
  - Removed unnecessary ADDREF to object pointer in some class methods
  - For loop has been rearranged to avoid one JMP instruction
  - Context writes messages to callback if application does something wrong with Prepare or Execute.
  - Improved thread safety of the thread manager when multiple threads create separate engines (Thanks Carsten Orthbandt)
- Virtual machine
  - Changed ADDSi to check if the pointer is a null pointer
  - Changed RDSPtr to check if the pointer is a null pointer
  - Renamed the bytecode POP to PopPtr, and removed it's argument as it was always popping a single pointer.
  - Created the new instruction RefCpyV that is used to replace the oft occurring pair PSF and REFCPY
  - Added JLowZ and JLowNZ to replace ClrHi + JZ and ClrHi + JNZ
  - Added PshGPtr that replaces PGA + RDSPtr
  - Removed the PUSH instruction
  - The VM is guaranteed to call line callback at least once per function to allow interruption of inifinitely recursive calls (Thanks Philip Bennefall)
  - LoadThisR and LoadRObjR raises exception if the loaded object pointer is null
- Add-ons & Samples
  - Added GetSize() and IsEmpty() to the dictionary add-on (Thanks _Vicious_)
  - Added IsEmpty() to the array and string add-on (Thanks _Vicious_)
  - Added Reserve() to the array add-on (Thanks Philip Bennefall)
  - The string pool is now turned off by default, since it is not threadsafe. Turn it on with AS_USE_STRINGPOOL=1
  - Array, string, and dictionary now register their methods using the names from STL if AS_USE_STLNAMES=1 is defined (Thanks Thomas Grip)
  - Corrected the syntax in autowrapper add-on to allow it to compile for Android (Thanks brumi)

## Version 2.23.0 - 2012/03/11

- Bug fixes
  - Returning floats and doubles with native calling conventions wasn't working on Mac OSX Lion x64 with LLVM and -O0 (Thanks Jason Filsinger)
  - The string factory can now be registered to return a reference to the string object (Thanks Philip Bennefall)
  - The condition operator didn't accept when the two results differed in type with the only difference being const (Thanks Philip Bennefall)
  - The information on local variables is now saved with the bytecode
  - Fixed crash on Mac OS X 32bit with GCC 4.2 when compiling the library with optimizations (Thanks Matt Bush)
- Library
  - By defining AS_NO_COMPILER the library can now be compiled without the script compiler for reducing the executable size (Thanks Philip Bennefall)
  - The compiler will no longer share interface type ids unless the interfaces are explicitly marked as shared. Previous behaviour is still temporarily available with AS_DEPRECATED
  - Improved some compiler messages
  - Added configuration to allow the compilation for the Marmalade SDK (Thanks Kite and robt)
  - Removed several compiler warnings for different compilers and target platforms (Thanks Richard Viney)
  - Added asOBJ_NOCOUNT to support ref types that are not reference counted (Thanks virious)
  - The saved bytecode is now independent of the platform's pointer size
- Library interface
  - Added asIScriptContext::GetSystemFunction() that returns the registered function that is currently being called (Thanks rviney)
  - Added asIScriptEngine::SetDefaultNamespace() permitting the application to register the interface in different namespaces
  - Removed previously deprecated functions
  - Added asIScriptEngine::GetGlobalPropertyIndexByName() and ByDecl()
  - asIScriptContext::GetExceptionFunction() now returns a asIScriptFunction* instead of the function id
  - Changed NotifyGarbageCollectorOfNewObject() to take asIObjectType* instead of type id
  - Added asIScriptEngine::GetObjectTypeByName()
  - Added accessMask argument in GetGlobalPropertyByIndex(), GetEnumByIndex(), GetTypedefByIndex(), and GetProperty()
  - Removed configGroup argument in GetFuncDefByIndex() as this is already available in the asIScriptFunction interface
  - Added GetAccessMask() to asIObjectType and asIScriptFunction
  - Added asIScriptModule::RemoveFunction() that takes a pointer to asIScriptFunction
  - Added asIScriptModule::GetObjectTypeByName()
  - Added IsFinal(), IsOverride(), IsShared(), and GetNamespace() to asIScriptFunction
  - Added includeNamespace argument to asIScriptFunction::GetDeclaration(), asIScriptModule::GetGlobalVarDeclaration(), and asIScriptEngine::GetTypeDeclaration()
  - Added GetNamespace() to asIObjectType
  - Added namespace argument to GetGlobalPropertyByIndex(), GetEnumByIndex(), GetTypedefByIndex(), and GetGlobalVar()
- Script language
  - Enums can now be declared as shared across modules too
- Add-ons & Samples
  - Placed the CDebugger in the AngelScript namespace (Thanks Thomas Fischer)
  - Fixed compilation problem in CScriptBuilder on XBox360 with regards to missing getcwd (Thanks virious)
  - Updated CSerializer to support namespaces
  - Updated WriteConfigToFile() to write the access mask and namespace
  - Updated asbuild sample to support access mask and namespace
  - Removed the C lib as standard add-on
  - Implemented memory pool for string literals in the string add-on which will improve performance for scripts that uses a lot of string literals
  - New implementation for the auto wrapper that eliminates the need to declare the wrappers before they can be registered (Thanks SiCrane)
  - Added opEquals to the script array
  - Added getKeys to the script dictionary (Thanks Philip Bennefall)
  - Fixed script arrays with enums (Thanks Philip Bennefall)
  - Fixed the script arrays so it can accepts opEquals and opCmp that take the other value by handle (Thanks Philip Bennefall)
  - Sort, Find, and opEquals now works for arrays of handles too (Thanks Philip Bennefall)
- Project
  - Renamed as_callfunc_arm_xcode.s to as_callfunc_arm_xcode.S to fix problem with scons on Mac (Thanks Richard Viney)

## Version 2.22.2 - 2012/01/29

- Bug fixes
  - Arrays of interfaces weren't properly handled when resolving equal interfaces in different modules (Thanks cvet)
  - Shared code couldn't call template factories (Thanks TheAtom)
  - Classes that contained shared classes as members would fail in the second module that declared the shared class (Thanks TheAtom)
  - RegisterGlobalProperty was accepting null pointers (Thanks Quillraven)
  - In some situations the value assign of a class member to an object would recieve the wrong reference (Thanks Philip Bennefall)
  - Fixed segfault when compiling with -O2 on x86 32bit gnuc 4.6.1 (Thanks gdmarkou)
  - Fixed problem with shared classes when the were orphaned (Thanks Thomas Grip)
  - GetGlobalFunctionByDecl would return the wrong function (Thanks _Vicious_)
  - Context failed when calling a system function through a function pointer (Thanks _Vicious_)
  - Fixed problem when releasing engine while still holding a reference to a script function (Thanks _Vicious_)
- Virtual machine
  - Created the instruction SwapPtr and removed the SWAP4, SWAP8, SWAP48, and SWAP84 instructions that were no longer used
  - Created the instruction RDSPtr and removed the RDS4 and RDS8 instructions that won't be used anymore
  - Created the instructions PshVPtr, PshNull that will be used for pointers instead of PshV4/8 and PshC4/8
  - Created the instruction ClrVPtr that will be used for pointers instead of SetV4/8
  - Created the instruction CmpPtr that will be used for pointers instead of CMPi or CMPi64
- Library
  - Separated the bytecode loader and saver in two different classes
  - Some code can be left out to create a smaller library if only pre-compiled bytecode is going to be used
  - Replaced internal use of strtod() with my own implementation to improve portability
- Script language
  - Global functions can now be marked as 'shared' too
  - Added keyword 'namespace'
  - It is now possible to declare entities in namespaces to avoid name conflicts
  - The scope operator :: is used to explicitly specify in which namespace to look for symbols
- Add-ons & Samples
  - Made the script array more robust against out-of-memory conditions (Thanks Philip Bennefall)
  - CScriptBuilder now properly extracts metadata for class methods and virtual properties (Thanks Ciaran Davies)

## Version 2.22.1 - 2011/12/28

- Bug fixes
  - Fixed bug where passing inout ref to handle to a function didn't work properly with unsafe references turned on (Thanks TheAtom)
  - Fixed bug with returning reference from temporary value type on stack (Thanks AgentC)
  - Fixed assert failure on compilation error involving get_opIndex (Thanks Philip Bennefall)
  - Fixed bug where a temporary variable was improperly reused under certain situations (Thanks Philip Bennefall)
  - Fixed bug in native calling conventions for 64bit gnuc that was causing crashes on Mac OS X (Thanks dutt)
  - Fixed bug with GetTypeIdByDecl when the declaration was a handle (Thanks scypior)
  - Fixed problem where the compiler wasn't detecting that a class property didn't have a default constructor (Thanks pifor106)
- Library
  - Added asOBJ_NOINHERIT that can be used to identify the script classes declared as final (Thanks InvalidPointer)
  - Improved compiler performance when scripts have a lot of literal string contants (Thanks vroad)
  - Optimized the algorithm for tokenizing the script, which will provide a significant performance improvement when compiling large scripts (Thanks m4ttbush)
  - Added asEP_ALWAYS_IMPL_DEFAULT_CONSTRUCT to allow application to force the automatic implementation of default constructor and opAssign
  - The compiler now avoids creating unecessary temporary copies of objects when calling opAssign or copy constructor for the same type
  - Engine writes more verbose errors for application interface configuration errors
  - Added support for passing objects by value on 64bit GNUC when used with asOBJ_APP_CLASS_ALLINTS or asOBJ_APP_CLASS_ALLFLOATS
- Script language
  - Added 'final' and 'override' keywords for improved control on how inheritance is implemented (Thanks InvalidPointer)
  - Implemented an alternative shorter version for declaring get and set property accessors (Thanks InvalidPointer)
  - Default constructor and opAssign is no longer implemented automatically if the script class has a non-default constructor
  - The compiler no longer warns if 0 is passed to an output parameter, as it then assumes the result is meant to be ignored
  - The compiler performs implicit conversions to objects registered as ASHANDLE by calling the available constructor
- Add-ons & Samples
  - Added GetMetadataStringForTypeMethod to CScriptBuilder (Thanks InvalidPointer)
  - Added property accessors for length on the CScriptArray (Thanks InvalidPointer)
  - Added scriptmathcomplex.cpp that implements a value type for mathematics with complex numbers
  - Improved performance of script compilations with CScriptBuilder (Thanks m4ttbush)
  - Fixed compilation error in CScriptBuilder when turning off metadata (Thanks Philip Bennefall)
  - Removed scriptmath3d.cpp as a standard add-on
  - Fixed some compiler warnings in CScriptFile add-on
  - Implemented formatInt(), formatFloat(), parseInt(), and parseFloat() as string utilities
  - Added property accessors for length on the string registration
  - Removed the use of CGameObjLink in the game sample and registered the CGameObj directly with the script engine
  - The game sample is now using the CScriptHandle to pass the message data between game objects
  - Fixed a problem where the CScriptBuilder didn't find the metadata for class properties of non-primitive types (Thanks Carrot)

## Version 2.22.0 - 2011/11/06

- Bug fixes
  - Fixed bug where compiler would incorrectly reuse a temporary variable when preparing arguments for a function call (Thanks Philip Bennefall)
  - Fixed bug in CSerializer add-on that wasn't properly handling the fact that typeIds change for each compilation
  - Fixed bug with indexed property accessor where only set accessor was available (Thanks virious)
  - Fixed bug where default args for registered functions were not recognized (Thanks Takashi Yamamoto)
  - Fixed problems when compiling the library with optimizations on 64bit GNUC (Thanks Jameson)
  - Fixed assert failure in VM when using JIT compiled functions (Thanks Andrew Ackermann)
  - Fixed a null pointer exception in the compiler when compiling an assignment and the left hand expression was invalid (Thanks TheAtom)
  - Fixed bug with value cast operator that returned an object by value (Thanks pifor106)
  - Fixed crash when compiling scripts that import global property accessors from other modules (Thanks Andrew Ackermann)
- Library interface
  - Added user data to the asIObjectType and asIScriptModule interfaces, and corresponding cleanup callbacks to the asIScriptEngine interface
  - Changed some return types from int to asUINT where the methods couldn't return a negative value
  - Added a Prepare method to the context that takes the asIScriptFunction pointer instead of the function id
  - Added GetGlobalFunctionByIndex and Decl to asIScriptEngine
  - Deprecated GetFunctionDescriptorById in asIScriptEngine and asIScriptModule and replaced it with asIScriptEngine::GetFunctionById
  - Added GetFunctionByName and Decl to asIScriptModule
  - Deprecated asIScriptModule::GetFunctionDescriptorByIndex and replaced it with GetFunctionByIndex
  - Deprecated asIScriptGeneric::GetFunctionDescriptor and replaced it with GetFunction
  - Added GetFactoryByIndex and Decl to asIObjectType
  - Added GetMethodByName and Decl to asIObjectType
  - Deprecated asIObjectType::GetMethodDescriptorByIndex and replaced it with GetMethodByIndex
  - Added asIScriptEngine::SetDefaultAccessMask and asIScriptModule::SetAccessMask, which deprecates SetConfigGroupModuleAccess
  - The asJITFunction now takes a asPWORD as the second argument incase the compiler wants to store a pointer as the argument (Thanks Andrew Ackermann)
  - Added Implements, DerivesFrom, and GetSubType to the asIObjectType interface
  - Added overloads for AddRefScriptObject and ReleaseScriptObject that take a pointer to asIObjectType which makes them more efficient than the previous version
  - Created the macro asOFFSET that does the same thing as offsetof, except that GNUC doesn't complain about using it
- Library
  - The module's access to types, functions, properties, and even class members can now be set individually for each object through an access mask and is no longer tied to the configuration group
  - Improved library against registered types that can form circular references but don't register the GC behaviours (Thanks Quittouff)
  - Added engine property asEP_DISALLOW_GLOBAL_VARS
  - Classes can now be shared between modules if they are compiled with the 'shared' keyword
  - Added object type flag asOBJ_SHARED that identifies script classes that are shared between modules
- Virtual Machine
  - Added the context pointer to the asSVMRegisters so the JIT function can immediately access this without calling asGetActiveContext (Thanks Andrew Ackermann)
  - The JitEntry instruction will now invoke the JIT function without decreasing 1 from the argument set by the JIT compiler
  - The JitEntry instruction can also immediately return from the execution in case the context has been suspended, aborted, or an exception has been set
- Script language
  - Added the keyword 'shared' that can be used with classes and interfaces that should be shared between modules
- Add-ons & Samples
  - Improved the game sample to take advantage of the object type user data
  - Improved the game sample to take advantage of the shared classes in the messaging between script objects
  - Improved the game sample to report the compilation errors, instead of just continuing the execution without
  - The #include directives in the CScriptBuilder add-on now accept strings within single-quotes too
  - Added GetModule to the CScriptBuilder add-on

## Version 2.21.2 - 2011/09/25

- Bug fixes
  - Fixed a bug when passing value from property accessor to function inout reference parameter (Thanks scypior)
  - Fixed a bug with function overloading and default args (Thanks cvet)
  - Minor change to fix compiler error with CLang (Thanks Jeremy Harmon)
  - The library was not detecting return of simple value type on Linux 64bit. It should give error as this is not supported due to the use of different registers based on type of class members. (Thanks toukkapoukka)
- Library
  - Value types returned by value are now returned on the stack to reduce dynamic memory allocations
  - Added the flag asOBJ_APP_CLASS_ALLINTS to inform that a registered type should be treated like all members are integers
  - Added the flag asOBJ_APP_CLASS_ALLFLOATS to inform that a registered type should be treated like all members are float or doubles
- Add-ons & samples
  - The CScriptBuilder now supports metadata for class properties too (Thanks Thomas "Hardguy" Grip)
  - Created a sample game that shows one way of integrating the script engine for game management

## Version 2.21.1 - 2011/08/21

- Bug fixes
  - Fixed crash when doing a value assignment to a handle obtained from a property accessor (Thanks _orm_)
  - Compiler will now give error when assigning to property of an object that is returned by value from a function
  - Fixed bug in the std::string add-on in the boolean operators that concatenates a bool type to the string (Thanks Altren)
  - Fixed bug when pass null to output parameter and the compiler didn't properly clean up the stack
  - Fixed bug with ternary condition operator when the first option was null (Thanks TheAtom)
  - Fixed bug with instanciating templates with subtypes of the same name as the internal template subtype (Thanks TheAtom)
  - Fixed bug in debugger add-on when printing the value of an uint8 (Thanks Friggle)
  - Fixed bug with handle assignment with set_opIndex (Thanks Lasse Öörni)
- Library
  - Added the asOBJ_ASHANDLE type flag. This will be used together with asOBJ_VALUE to allow application to register a container type that can store any handle type
  - Implemented support for asBEHAVE_REF_CAST with the signature 'void f(?&out)' which allow a cast to any handle type, evaluated at runtime
  - asIScriptContext::Unprepare no longer free's the stack memory, so there is no performance penalty for that
  - Added support for native calling conventions on Win64 with MinGW64 (Thanks _Vicious_)
- Script language
  - The compiler will no longer warn if passing null to a function argument that is declared as an output handle
- Add-ons
  - Added the CScriptHandle add-on which provides a default implementation of the new asOBJ_ASHANDLE type
  - Updated the clib add-on to the latest interface (Thanks lexa-skripa)
  - Added the CSerializer add-on which allow the application to backup values of variables in a module and then restore them (Thanks FDsagizi)

## Version 2.21.0 - 2011/07/03

- Bug fixes
  - Fixed more compiler warnings for maximum warning level on MSVC (Thanks Thomas Fischer)
  - Fixed crash if script tries to call function that has been declared incorrectly with default args (Thanks Károly Pintér)
  - Fixed crash on MSVC when basic behaviour methods was implemented with multiple inheritance (Thanks Thomas Grip)
  - Fixed bug when application compiles modules with imported functions over and over again, eventually crashing (Thanks loboWu)
  - Fixed implicit conversion of negative float constant to uint making the value become 0 (Thanks Jeremy Harmon)
  - Fixed bug with passing value types on stack to a function taking a var arg (Thanks immortius)
  - Fixed native calling convention for objects with copy constructor on 64bit Windows with MSVC
  - Fixed assembler code in as_Callfunc_x64_msvc_asm to allow stack unwinding in debugger (Thanks Zoner)
  - It's now possible to use property accessor of another object of the same type from within a member property accessor (Thanks _orm_)
  - Fixed crash if context is unprepared or released after SetObject but without calling Execute (Thanks immortius)
- Virtual machine
  - The garbage collection is now automatically done by the VM during the execution, unless turned off by the application
  - Improved the GC so now keeps 2 generations of objects. This will allow faster clean up of objects that live short times, thus improving performance
- Library interface
  - Removed all previous deprecated code
  - It is now possible to debug the initialization of global variables by passing a context to the ResetGlobalVars method
  - Added asIScriptContext::IsVarInScope that the application can use to determine that the variable is actually visible at current program position
  - Added engine property asEP_AUTO_GARBAGE_COLLECT that can be used to turn off the automatic garbage collection
  - Added more parameters to the GetGCStatistics methods to get info on the new generation of objects
  - Added asIScriptFunction::FindNextLineWithCode that a debugger can use to find a valid line with code to set breakpoints at
- Library
  - Added configurations for native calling conventions on the Illumos operating system (Thanks Alexey A. Fakeyev)
  - Improved error message in compiler when typing the wrong name for the data type in a variable declaration (Thanks Jeremy Harmon)
- Script language
  - It is no longer prohibited to call functions in the expressions that initialize global variables.
  - Implementation of interface methods can now be inherited from base class (Thanks Hardguy)
- Project
  - Renamed as_callfunc_x64_msvc.asm to as_callfunc_x64_msvc_asm.asm to avoid conflict with as_callfunc_x64_msvc.cpp (Thanks Zoner)
- Add-ons and samples
  - Added substr, findFirst, findLast, split, and join to the std::string registration
  - Created the asrun sample
  - Created the CDebugger add-on
  - Removed CScriptString as standard add-on as it caused too many confusions

## Version 2.20.3 - 2011/05/14

- Bug fixes
  - Fixed compile warning on 64bit Mac (Thanks kainjow)
  - Fixed native calling conventions on 64bit Mac for older GNUC compiler (Thanks Asgeir)
  - Fixed bug in array add-on when declaring an array of void (Thanks Damian T0MALIK)
  - Made the use of emms or fninit dynamic by defining macro CLEAR_FPU_STACK, as some projects needed it to be fninit (Thanks cvet)
  - Fixed bug in compiler when a property that takes a reference in set accessor was used in a dual operator expression (Thanks Philip Bennefall)
  - Properly handling loading bytecode that attempts to instanciate invalid template type
  - Fixed a long standing bug with native class methods on iPhone (Thanks Pogacha)
  - Fixed bug with asEP_ALLOW_UNSAFE_REFERENCES where it would allow casting a primitive type to another for reference parameters (Thanks cvet)
  - Fixed crash with invalid script (Thanks arpeggiodragon)
  - Fixed bug with private methods where the compiler was incorrectly invoking the base class constructor (Thanks Quittouff)
  - Fixed bug with identifying shared interfaces in modules (Thanks TheAtom)
  - Fixed some bugs related to enums (Thanks behc)
  - Fixed compile error when attempting to assign to a member of a handle returned from another function (Thanks AgentC)
  - Fixed null pointer access when compiling scripts that used write-only property accessors (Thanks Lasse Öörni)
  - Fixed problem with native calling conventions on PS3 and XBox 360 (Thanks kdroben)
- Library
  - Added the flag asOBJ_APP_CLASS_COPY_CONSTRUCTOR so classes with non-trivial copy constructor can be recognized and treated properly in the native calling conventions (Thanks namtabmai)
  - Improved the bytecode optimization
- Script language
  - Added support for default arguments in functions
- Virtual machine
  - Added bytecode instructions LoadRObjR, LoadVObjR
- Add-ons
  - Added the methods sortAsc, sortDesc, reverse, and find to the script array add-on (Thanks Damian T0MALIK)
  - Removed duplicated functions in string utils as they can now use default arguments instead

## Version 2.20.2 - 2011/02/17

- Bug fixes
  - Fixed bug with division and modulo operations where the most significant bit of the value was set (Thanks loboWu)
  - Fixed bug when calling copy constructor for value types allocated on the stack (Thanks speps)
  - Using emms instead of fninit to preserve FPU configuration on x86 (Thanks Lasse Öörni)
  - Set property accessor that takes the value by ref was incorrectly accepted for increment/decrement operators (Thanks Philip Bennefall)
  - When copying an object to remove constness the compiler wasn't handling objects allocated on the stack correctly (Thanks Philip Bennefall)
  - Value cast of an object retrieved from a get accessor wasn't working properly (Thanks speps)
  - Value types allocated on the stack didn't work correctly with the condition operator (Thanks speps)
  - Fixed a bug in the std::string add-on add operator implementations where the input string was incorrectly modified (Thanks speps)
  - Fixed bug with compiling explicit ref cast of temporary handle that produced invalid bytecode (Thanks mandrav)
  - Fixed bug with bool, int8, and int16 types in native functions on xbox 360 (Thanks speps)
  - Added validation to prevent registering function pointers without @ (Thanks behc)
  - Fixed bugs when invoking a function pointer directly as class member (Thanks behc)
  - Fixed bug in parser that didn't report error for not closing brackets when using index operator in expressions (Thanks speps)
  - Fixed bug in compiler with unsafe references and value types (Thanks hemicube)
  - Fixed inline assembly in as_callfunc_x64_gcc to support gcc optimizations (Thanks Samuel E. Henley)
- Virtual machine
  - Added bytecode instructions DIVu, MODu, DIVu64, MODu64
  - Unified a good part of the platform specific code into one common function
- Library
  - Added configurations for Cygwin and Linux/ARM (Thanks Adrian Batzill)
- Script language
  - It is now possible to declare function definitions that take other types as argument before the declaration of the other types
- Add-ons
  - Added the copy constructor to the std::string registration
  - Added swizzle operators xyz, yzx, zxy, zyx, yxz, and xzy to the vector3 add-on

## Version 2.20.1 - 2010/12/10

- Bug fixes
  - All the methods on asIScriptContext to inspect the call stack had an inverted index (Thanks Philip Bennefall)
  - Fixed a problem during clean up of configuration groups in the engine destructor (Thanks Friggle)
  - Fixed bug in calling convention for 32bit PPC when a value type is passed by value
- Virtual machine
  - Local variables using registered value types are now allocated on the stack
- Library interface
  - RegisterObjectType now returns the type id of the newly registered type to indicate success.
- Add-ons & samples
  - Added methods to CScriptFile add-on for reading and writing integers and floats, with configurable byte ordering
  - The CContextMgr now invokes the garbage collector automatically

## Version 2.20.0 - 2010/11/02

- Bug fixes
  - Fixed bug in parser when a function or method returned a handle to a template type (Thanks yzslhawk)
  - Fixed the initialization order of some global variables that might get used by the engine if it is created in a global (Thanks heqing)
  - If global variables in scripts were accessed during destruction of the script objects the application could crash when releasing the engine (Thanks TheAtom)
  - Fixed bug on Android/GNUC involving the function type enum (Thanks Fredrik Ehnbom)
- Library
  - Removed the built-in array type, the array type must be registered by the application instead
  - Added support for native calling conventions on PS3 with SNC compiler (Thanks Kidneythief)
  - Improved compiler error message when trying to declare variable in switch case
- Library interface
  - Deprecated asBEHAVE_INDEX. Use opIndex method instead
  - Improved const correctness of interface methods
  - Added asIScriptFunction::IsPrivate and asIScriptObject::IsPropertyPrivate
  - Removed asIScriptArray interface
  - Added RegisterDefaultArrayType and GetDefaultArrayTypeId to asIScriptEngine
  - Added asEP_EXPAND_DEF_ARRAY_TO_TMPL that tells the engine to format the declaration of the default array in the template form
  - Removed the previously deprecated ExecuteString from script engine interface
  - Added user data to the script function interface, and methods to retrieve it from the generic interface (Thanks Pierre Fortin)
  - Added methods to asIScriptFunction to enumerate local variables (Thanks Ciaran "Carrot" Davies)
  - Deprecated IsClassMethod and IsInterfaceMethod, use the new GetFuncType instead
  - Added a parameter to the GetMethod methods to allow retrieving the real method instead of the virtual method
  - Added the script section name to the functions that previously returned only line and column number
  - Added GetGlobalVar to asIScriptModule
  - Deprecated GetGlobalVarName and GetGlobalVarTypeId in asIScriptModule
  - Added GetProperty and GetPropertyDeclaration to asIObjectType
  - Deprecated GetPropertyName, GetPropertyTypeId, IsPropertyPrivate, and GetPropertyOffset in asIObjectType
  - Added ability to set callback functions for cleaning up the user data when the objects are destroyed
  - Deprecated GetCurrentFunction and GetCurrentLineNumber from asIScriptContext
  - Removed GetCallStackFunction and GetCallStackLineNumber from asIScriptContext
  - Added GetFunction and GetLineNumber to asIScriptContext
  - Changed index parameter for the methods GetVarXXX, GetAddressOfVar, GetThisXXX in asIScriptContext so the current function is on 0
- Script language
  - Added support for the opPostInc, opPostDec, opPreInc, and opPreDec operator overloads (Thanks droz)
  - Added support for get_opIndex and set_opIndex to allow property accessors for the index operator
  - Property accessors can now accept an index argument to emulate an array
- Project
  - Removed as_arrayobject.h and as_arrayobject.cpp
- Add-ons & samples
  - The script array add-on can now be registered as the default array type
  - Improved asbuild to support registration of template types and default array
  - Improved WriteConfigToFile the same way
  - Implemented InsertAt, RemoveAt, InsertLast, and RemoveLast for the array add-on
  - Fixed compiler warnings in autowrappedcall.h when working with functions that take parameters by reference (Thanks Pierre Fortin)
  - Further improvements to autowrappedcall to support asCALL_CDECL_OBJLAST and OBJFIRST (Thanks Pierre Fortin)
  - Added PrintException as helper function

## Version 2.19.2 - 2010/09/05

- Bug fixes
  - Compiler no longer crashes on empty heredoc strings (Thanks Thy Reaper)
  - Fixed problem in compiler when switch condition had deferred parameters (Thanks Philip Bennefall)
  - It is no longer possible to register a global function with const modifier (Thanks cvet)
  - Fixed bug in built-in array object that prevented the GC from breaking circular references (Thanks cvet)
  - Fixed bug in restoring bytecode that didn't properly detect when arrays needed to be garbage collected (Thanks cvet)
  - Restoring bytecode to multiple modules with shared interfaces no longer crashes the application (Thanks TheAtom)
  - Fixed bug with comparison of primitive returned by reference from property accessor (Thanks mk1x86)
  - Fixed implicit conversion from enum to double (Thanks Philip Bennefall)
- Library
  - Added explaining messages to callback when failing to initialize a global variable after a compilation
  - Improved validation during loading bytecode to avoid crashes on invalid files
  - Improved the way class methods with virtual inheritance on MSVC 32bit is registered, so that this is now properly detected and gives an error (Thanks vroad)
  - Added configurations for native calling conventions on FreeBSD x64 and Haiku (Thanks droz)
- Script language
  - It is now also permitted to return a reference to the 'this' pointer
  - A get accessor can now return a handle, while the set accessor takes a value or reference. This allow the property to behave as a value property, even though a new object is created each time it's value is taken.
  - Class methods can now be declared as private
  - Float numbers can now be written as .42, without the leading 0
  - Enum types prioritizes implicit conversions to int before other primitive types when matching multiple function overloads
- Virtual machine
  - Added PshV8 for improved bytecode optimizations on 64bit platforms
- Add-ons & Samples
  - Made the addref/release methods on the add-ons const, so they can be used on const pointers as well
  - Added operators to the string add-ons to allow conversion of bool to string
  - Changed the index behaviour for the string add-ons to opIndex methods
  - Implemented a generic offline script compiler, that shows how a dummy application interface is registered to allow compiling scripts to file
  - Added WriteConfigToFile helper function that automatically creates the config file for the generic offline compiler

## Version 2.19.1 - 2010/08/09

- Bug fixes
  - Fixed null pointer exception on specific compiler error (Thanks _orm_)
  - Fixed precompiled byte code with enum types and arrays (Thanks hoboaki)
  - The CAST instruction wasn't properly saved and loaded (Thanks hoboaki)
  - Fixed bug with implicit conversion from 'const obj' to 'obj' (Thanks hoboaki)
  - Fixed crash on compiler error where a variable is declared twice (Thanks Philip Bennefall)
  - It is no longer possible to declare a class method with the name of the class (Thanks xadhoom)
  - Fixed bug with implicit conversion from reference to primitive (Thanks Thy Reaper)
  - asIScriptModule::GetFunctionIdByIndex is now returning the correct id (Thanks mandrav)
  - Compiling the library with AS_DOUBLEBYTE_CHARSET is now working again (Thanks UeSyu)
  - Removed unnecessary creation temporary copy when doing an assignment using the default copy behaviour (Thanks mandrav)
  - Fixed assert failure on clean-up with registered function definitions (Thanks Engin Lee)
  - Fixed problem with temporary variable being overwritten when evaluating the output parameters (Thanks IndependentHat)
  - Fixed error in compiler where the expression in the switch case wasn't converted correctly if it wasn't a local variable (Thanks mandrav)
- Library
  - The saved bytecode is now independent of object property offsets
  - The script section names are now stored with the saved bytecode
  - Added compatibility with Mac OS X on x64 CPUs (Thanks Zerotri)
- Script language
  - Added support for returning references from script functions
  - Added support for the opIndex operator overload method
  - It is now allowed to declare functions with 'void' parameter lists
  - Added reserved keyword 'private'
  - Class properties can now be declared as private (Thanks InvalidPointer)
- Virtual machine
  - Added the instruction LoadThisR that is used to load the address of a property into the register.
- Add-ons
  - Implemented the opAssign method for the dictionary add-on so it can be copied.

## Version 2.19.0 - 2010/06/27

- Bug fixes
  - The compiler was incorrectly treating enums as having 8 bytes on 64bit platforms (Thanks Nalin)
  - Fixed crash when compiling scripts that contains inheritance of invalid classes (Thanks Tyler Spivey)
  - Fixed bug when compiling a return statement that calls a get accessor (Thanks Tyler Spivey)
  - Fixed calling property accessor surrounded by parenthesis (Thanks cvet)
  - Compiler no longer hangs on compiling enum declarations with name conflicts (Thanks hoboaki)
  - Property accessors will no longer call themselves if attempting to access true property of the same name (Thanks Philip Bennefall)
  - Fixed bug with property accessors in switch expression (Thanks Philip Bennefall)
  - Fixed bug with incremental garbage collector (Thanks hoboaki)
  - Saving byte code that used template classes didn't work properly (Thanks hoboaki)
  - Fixed bug with property accessors in type conversions (Thanks Philip Bennefall)
  - Fixed assert failure on compílation error with undeclared variable (Thanks Philip Bennefall)
  - Fixed bug with implicit ref casts for global variables (Thanks Gilad Novik)
  - Fixes to the Xbox 360 calling convention codes (Thanks Cyril Tissier)
  - Fixed bug in the bytecode optimization on big endian CPUs (Thanks Remi Gillig)
  - Fixed buffer overflow in as_callfunc_x64_gcc.cpp (Thanks Mikhail Efremov)
  - Fixed a bug with use of templates in script classes (Thanks xadhoom)
  - Fixed problem with loading script that contained template types that refer to classes defined later in script (Thanks hoboaki)
  - Fixed memory leak when cyclic reference between script class types and templates existed (Thanks hoboaki)
  - Fixed assert failure when compiling script with void expression in while condition (Thanks Philip Bennefall)
  - Fixed bug in compiler where in a very specific case it would lose the value of a reference (Thanks Lars Peter)
- Library
  - Improved the size of the saved bytecode
  - The saved bytecode is now byteorder independent
  - Added the ability to disable property accessors through the engine property asEP_PROPERTY_ACCESSOR_MODE (Thanks Philip Bennefall)
  - Improved support for Borland C++Builder (Thanks Moritz Beutel)
- Library interface
  - Added RegisterFuncdef that allows the application to register function definitions for function pointers it wishes to receive
  - Added GetFuncdefCount and GetFuncdefByIndex to enumerate the registered function definitions
- Script language
  - Added a factory for the built-in array to allow setting the default value of elements upon initialization. This in turn allows the initialization of multidimensional arrays in one call.
- Add-ons
  - Added a factory for the template array to allow setting the default value of elements upon initialization

## Version 2.18.2 - 2010/03/14

- Bug fixes
  - Fixed a bug in the compiler where in certain condition it would incorrectly reuse a temporary variable (Thanks Thy Reaper)
  - Fixed a bug for property accessors in while and do-while conditions (Thanks Philip Bennefall)
  - Fixed a bug for property accessors for objects in arrays (Thanks Philip Bennefall)
  - Fixed a bug in the compiler where an invalid script could crash it (Thanks klusark)
  - Variable declaration of script class with opAssign and assignment initialization wasn't releasing a temporary variable (Thanks hoboaki)
  - When growing the stack the virtual machine wasn't copying the object pointer for class methods, leading to crashes (Thanks klusark)
  - Implicit conversion from handle to reference is no longer giving compiler error (Thanks Thy Reaper)
  - Fixed property accessors when used from within a class method (Thanks hoboaki)
  - Fixed a bug with native calling conventions on 64bit Linux (Thanks namtabmai)
  - Fixed bug with posix threads on 64bit platforms (Thanks Hideaki Imaizumi)
- Script language
  - The language now supports function pointers to global functions.
  - Added the keyword 'funcdef' that is used to declare function signatures for function pointers.
- Virtual machine
  - Added the instruction CallPtr that is used to call a function stored in a function pointer.
  - Added the instruction FuncPtr that is used to push the pointer of a function on the stack.

## Version 2.18.1 - 2010/01/17

- Bug fixes
  - Fixed compiler error on GNUC (Thanks Samuel E. Henley)
  - Missing text literal on 64bit Linux (Thanks Gibbon_99)
  - Aborting a context only suspended the execution (Thanks Friggle)
  - Characters above 127 were incorrectly converted to UTF8 when the scanner was set to ASCII (Thanks Friggle)
  - When saving the bytecode the string constants got shuffled around (Thanks kk)
  - Reference casts for null values incorrectly raised null pointer exceptions (Thanks Thy Reaper)
- Virtual machine
  - Changed the bytecode instructions PGA, LDG, LdGRdR4, CpyVToG4, CpyGToV4, SetG4, and PshG4 to hold the address of the global variable in the argument directly
  - Removed the globalVarPointers from the asSVMRegisters structure
  - Changed the bytecode FREE to take the variable index directly in the argument instead of reading the reference from the stack
- Library interface
  - Added the behaviour asBEHAVE_LIST_FACTORY, that is exclusively used to initialize a reference type with an initialization list.
- Library
  - The compiler now attempts to use the copy constructor when creating temporary copies of objects (Thanks Wracky)
  - Added support for native calling conventions on Win64 with MSVC
  - Added several bytecode optimizations that should reduce the number of instructions and increase runtime performance
- Script language
  - Property accessors may now be used for global variables as well
- Add-ons
  - Improved the script array add-on to support initialization of the arrays through initialization lists
- Project
  - Added as_callfunc_x64_msvc.asm and as_callfunc_x64_msvc.cpp to add support for native calling conventions on 64bit Windows

## Version 2.18.0 - 2009/12/16

- Bug fixes
  - Fixed assert in compiler when accessing property through temporary object (Thanks Scarabus2)
  - Fixed crash with too large array sizes, both for built-in array and array add-on (Thanks loboWu)
  - Fixed memory leak when an exception occurred in ExecuteString, and another ExecuteString was called afterwards
  - Fixed improper re-use of temporary variable by property get accessor when compiling binary operators (Thanks Scarabus2)
  - Fixed a bug in array template add-on with max portability mode (Thanks quarnster)
- Library interface
  - Added asIScriptModule::CompileFunction() for dynamically compiling a single function that can be executed, and optionally added to the module
  - Added asIScriptFunction::GetId()
  - Added asIScriptModule::RemoveFunction() for dynamically removing a single function from the scope
  - Deprecated the asIScriptEngine::ExecuteString method. An add-on has been provided to replace it
  - Removed the error code asMODULE_IS_IN_USE as it is no longer used
  - Removed old deprecated methods
  - Added asIScriptModule::CompileGlobalVar() and RemoveGlobalVar() for dynamically adding and removing single global variables to and from the module
- Library
  - Added support for UTF-16 encoded string literals through dynamic engine property asEP_STRING_ENCODING (Thanks Jubok Kim)
  - Each global variable has it's own intialization function now, which will allow individual globals to be added or removed dynamically
  - Each script function now holds its own list of accessed global variables, so they do not have to go back to the module for that info
  - Added support for native calling conventions on iPhone (Thanks Fredrik Ehnbom)
  - String constants are now stored in the engine and shared between modules
  - The context no longer references the module, as script functions no longer depend on the module for anything
  - Changed the script functions to use reference counting
  - Improved compiler messages when function arguments doesn't match available functions (Thanks droz)
- Add-ons
  - Added the global helper function ExecuteString, which replaces the asIScriptEngine::ExecuteString method
- Project
  - Renamed the as_callfunc_armasm.asm to as_callfunc_arm_msvc.asm
  - Renamed the as_callfunc_armasm.S to as_callfunc_arm_gcc.S
  - Added as_callfunc_arm_xcode.s which is the Apple XCode assembler code for arm CPUs (Thanks Gilad Novik)
  - Added as_globalproperty.cpp

## Version 2.17.2 - 2009/10/18

- Bug fixes
  - Fixed assert failure after compiler error in construct call (Thanks loboWu)
  - Fixed bug in compiler that freed objects returned by value too early (Thanks xivVerge)
  - Class methods are now allowed to be registered to types registered in previous config groups (Thanks Wavesonics)
  - Template factory stubs weren't removing arguments from the stack (Thanks loboWu)
- Script language
  - Ref classes without default factory can now be instanciated by explicitly calling one of the non-default factories (Thanks Wracky)
- Library
  - Added the object behaviour asBEHAVE_TEMPLATE_CALLBACK, which is used to perform compile time validation of template instances
- Add-ons
  - Fixed bug in CScriptBuilder to avoid endless loops in default include handler (Thanks leave)

## Version 2.17.1 - 2009/09/16

- Bug fixes
  - Loading pre-compiled bytecode for scripts that used registered functions that included the built-in array type in the signature crashed (Thanks loboWu)
  - Fixed the parsing of templates to accept handles as subtypes (Thanks dxj19831029)
  - Fixed bug with &inout and constants for invalid scripts (Thanks scypior)
  - Fixed crash when loading pre-compiled bytecode that had classes with enums as members (Thanks huangyous)
  - Fixed memory access violation in CContextMgr add-on (Thanks Kim PoongHo)
- Library
  - Improved the registerable template types to also support a template type as subtype.
  - Loading pre-compiled bytecode is now agnostic of the order that global properties were registered.
- Script language
  - Added support for class property get and set accessors.
- Project
  - Added compile time option to GNUC makefile to build a shared library (Thanks Dan Horák)
  - Added as_callfunc_armasm.S, which is an adaption of the MSVC assembler code in as_callfunc_armasm.asm to GNUC assembler (Thanks darktemplar216)
  - Added configurations in as_config.h to detect the Android OS and enable support for native calling conventions on ARM for it (Thanks sliao)
- Add-ons
  - Improved the script builder to allow custom processing of include directives via a callback
  - Improved memory management in CContextMgr to reduce run-time allocations by pooling objects

## Version 2.17.0 - 2009/08/09

- Bug fixes
  - Fixed compiler error in the XBox 360 specific code. (Thanks Marc Hanson)
  - Scoped reference types can now be members of script classes. (Thanks Jeff Slutter)
  - Fixed crash in compiler on invalid script (Thanks cvet)
  - Reference types that had been registered with zero size wasn't allowed as members of script classes. (Thanks Friggle)
  - Added validation for duplicate switch cases in script compiler (Thanks loboWu)
- Library
  - Removed all old deprecated functionality
  - The built-in array type is now completely unaware of the library internals and uses only the public interface
  - Unified parts of the code for native calling conventions to improve maintainability
  - Informing the application type when registering a value type is now only required if the type is returned by value or passed by value to a function with native calling convention
  - Added engine property asEP_INCLUDE_JIT_INSTRUCTIONS to indicate if the JIT bytecode instructions should be included or not. Defaults to off.
  - The variant parameter, ?, now receive a reference to the actual object if the argument is not a handle (Thanks IndependentHat)
- Library interface
  - Added GetTypeId, GetSubTypeId, AddRef, and Release to asIObjectType
  - Created the interface for an external JIT compiler plug-in (Thanks Fredrik Ehnbom)
  - Deprecated RegisterGlobalBehaviour, GetGlobalBehaviourCount, and GetGlobalBehaviourByIndex. These behaviours should use the new class methods instead.
  - Deprecated CompareScriptObjects. Use the helper functions CompareRelation or CompareEquality from the add-ons instead.
  - Deprecated all assignment behaviours and the negate behaviour. These behaviours should use the new class methods instead.
  - Changed asBEHAVE_REF_CAST and asBEHAVE_IMPLICIT_REF_CAST to be registered as object behaviours. Verify the documentation for implementation changes.
  - Added AddRef, Release, IsReadOnly, and GetByteCode methods to asIScriptFunction.
  - Deprecated asIScriptObject's GetPropertyPointer, which has been replaced with GetAddressOfProperty.
  - Deprecated asIScriptContext's GetArgPointer, which has been replaced with GetAddressOfArg.
- Virtual machine
  - Added bytecode instruction JitEntry that transfers control to the JIT compiled function
  - Renamed SET8 to PshC8
- Add-ons
  - Added the atan2 function to the math add-on
  - Added the helper functions CompareRelation and CompareEquality as add-ons
  - Added a template script array object
  - Implemented the CContextMgr add-on that supports co-routines and concurrent script threads
- Project
  - Removed as_bytecodedef.h as its content has been moved to angelscript.h
  - Renamed as_scriptstruct files to as_scriptobject

## Version 2.16.3 - 2009/07/05

- Bug fixes
  - Fixed bug in compiler when passing a constant to argument expecting out ref.
- Library
  - Added support for native calling conventions for ARM processors with MSVC compiler (Thanks Fredrik Ehnbom)
- Script language
  - Script classes can now implement operator overloads for all dual operators with specific class methods
  - Script classes can also implement overloads for the unary negate and bit complement operators
  - An if condition followed by an empty statement will now give a compiler error (Thanks asterix12)

## Version 2.16.2 - 2009/06/07

- Bug fixes
  - Fixed crash after call to DiscardModule where GC held objects declared by the module (Thanks Jeff Slutter)
  - Fixed crash on compiling invalid script (Thanks cvet)
  - Fixed bug with virtual function table and multiple levels of inheritance (Thanks huangyous)
  - Fixed some compatibility issues with MSVC and 64bit targets
  - Fixed bug with implicit cast of const ref type to non-const ref type (Thanks cvet)
  - The asFUNCTIONPR and asMETHODPR no longer accepts pointers to functions that are not exactly like the specified one (Thanks Wavesonics)
  - Fixed crash on compiling global variable of registered type with missing copy behaviour (Thanks 39ster)
  - Fixed value of asTYPEID_SCRIPTOBJECT to be just 1 bit (Thanks SiCrane)
  - Fixed bug in string add-ons where the full string wouldn't be created by the factory if it contained null characters.
  - Fixed rare bug when script called application function with float args and the application uses full optimization (this time on GNUC/x86) (Thanks kunitoki)
  - Fixed alignment bug for script class properties (Thanks Fredrik Ehnbom)
- Library
  - Build and ResetGlobalVars now return an error if the initialization of the global variables fails.
  - Changed initialization of global variables so that variables of primitive types are initialized first. (Thanks Friggle)
  - Added informational message to better explain the error 'missing behaviours' on invalid registration.
  - It is now possible for the application to register template types, though the feature is still not considered complete.
  - Added asEP_SCRIPT_SCANNER property for choosing between ASCII and UTF8 script encoding. Default is UTF8.
- Script language
  - Added support for string escape sequences \uFFFF and \UFFFFFFFF for inserting unicode characters in string constants.

## Version 2.16.1 - 2009/05/09

- Bug fixes
  - Fixed bug with implicit conversion from temporary 'const obj @' to 'obj &' (Thanks Jeff Slutter)
  - Fixed problem with float values and locale (Thanks scypior)
  - Fixed incorrect conversion of null handle to primitive (Thanks cvet)
  - Fixed crash when assigning array to itself (Thanks cvet)
  - Fixed assert failure after invalid conditional expression (Thanks Jeff Slutter)
  - Fixed bug in compiler when attempting to return null handle for a function declared to return object by value (Thanks marvi)
  - Compiler is now giving a proper error when script function returns reference (Thanks marvi)
  - Fixed crash when a script constructor that receives object handle throws an exception (Thanks cvet)
  - Fixed implicit value cast to another object type (Thanks SiCrane)
  - Fixed multithread support on FreeBSD (Thanks droz)
  - Character literals for characters above ASCII 127 are now compiled correctly (Thanks cvet)
  - Fixed rare bug when script called application function with float args and the application uses full optimization (Thanks Jeff Slutter and DaBono)
- Library
  - The built-in array type is now implemented using a template type.
  - The tokenizer now recognizes the UTF8 byte-order-mark as whitespace permitting the compilation of UTF8 encoded scripts.
  - Added support for multibyte character sets through the preprocessor flag AS_DOUBLEBYTE_CHARSET, it's recommended to use UTF8 instead though. (Thanks loverlin)
  - Added asEP_REQUIRE_ENUM_SCOPE to force the use of enum scope when accessing enum values. (Thanks Jeff Slutter)
  - The value cast behaviour can now be used to instanciate an object type if the type doesn't have the appropriate constructor. (Thanks SiCrane)
  - The callstack is no longer cleaned up immediately on an exception, thus allowing the examination of it even after Execute returns.
- Script language
  - Enum values can now be prefixed with the enum type to give the exact enum value when multiple enums declare the same name. (Thanks Jeff Slutter)
- Add-ons
  - CScriptBuilder is now better at handling relative include paths (Stuart Golodetz)

## Version 2.16.0 - 2009/03/30

- Bug fixes
  - Fixed bug in compiler where temporary variable was freed twice during compound assignments with some complex lvalue expressions (Thanks _Vicious_)
  - Fixed crash when parsing invalid typedefs.
  - Typedefs declared in scripts now accept float and double as well.
  - Fixed crash when compiling handle comparison with invalid types (Thanks _Vicious_)
  - It's now possible to determine type id for handle to scoped reference types (Thanks Jeff Slutter)
  - Unary operators weren't supported for enum types (Thanks jal_)
  - Fixed crash when declaring a script class that inherits from a class declared below it (Thanks Zeu5)
  - Fixed bug when registering an interface after previously removing dynamic config group (Thanks Zeu5)
  - Fixed bug in CScriptBuilder add-on that broke global declarations with array types (Thanks except134)
  - Fixed problem with class inheritance and order of declaration (Thanks Zeu5)
  - Fixed assert failure after compile error (Thanks Cliff Cawley)
- Library
  - All primitive types now have fixed type ids, so it is no longer necessary to call the GetTypeIdByDecl method to obtain their ids.
  - Removed the AS_NO_USER_ALLOC config option.
  - Enumeration of functions in the modules now only return global functions.
  - Enumeration of object types in modules now only return classes and interfaces.
  - Added engine property asEP_BUILD_WITHOUT_LINE_CUES (replaces the config option).
  - Added engine property asEP_INIT_GLOBAL_VARS_AFTER_BUILD, which will allow compiling scripts without having the implementation of the application functions.
  - Enumeration of object types in the engine now only return registered object types.
- Library interface
  - Removed some functions that had been deprecated in version 2.14.0.
  - Renamed asIScriptStruct to asIScriptObject.
  - Renamed GetStructTypeId to GetTypeId in asIScriptObject.
  - Added enumeration of factory functions and behaviours to asIObjectType.
  - Added GetBaseType, GetFlags, GetSize, and GetPropertyOffset to asIObjectType.
  - Deprecated GetSubType and IsInterface in asIObjectType.
  - Added enumeration of enums and typedefs to asIScriptModule.
  - Added enumeration of registered functions, properties, enums, and typedefs to asIScriptEngine.
  - Added parameter to asIScriptFunction::GetDeclaration to include or not the object name in the returned string.
  - Removed all output length parameters for functions that returned strings, all strings are null terminated anyway.
  - Deprecated GetReturnPointer in asIScriptGeneric, replaced by GetAddressOfReturnLocation.
- Add-ons
  - Added registration of std::string as a standard add-on, complementing the CScriptString
  - Added resize method to the string add-ons
  - Changed CScriptFile to be compatible with both std::string and CScriptString
  - Modified CScriptBuilder to permit enabling/disabling metadata processing through preprocessor define
  - Added autowrapper add-on that automatically generates wrappers for the generic calling convention for functions and class methods (Thanks George Yohng)
  - Added registration of the double counter parts to the math functions

## Version 2.15.2 - 2009/02/22

- Bug fixes
  - The pre-compiled bytecode didn't store the script class destructors, nor the implemented interfaces
  - Script class factories didn't work for constructors with more than 1 argument (Thanks BornToCode and scypior)
  - Changed as_atomic.cpp to use critical sections for older versions of GCC on Linux (Thanks _Vicious_)
  - Fixed some 64bit compatibility issues (Thanks Ionut "gargltk" Leonte and _Vicious_)
  - Fixed dangling pointer problem after removing dynamic configuration group (Thanks Ionut "gargltk" Leonte)
- Script language
  - Added support for single inheritance for script classes
  - Added support for scope resolution operator
- Library
  - Added support for native calling conventions on 64bit Linux (Thanks Ionut "gargltk" Leonte)
- Add-ons
  - Implemented readLine, isEndOfFile, writeString, getPos, setPos, and movePos for the CScriptFile
  - Removed use of bool in the C library header (Thanks Gibbon_99)
  - Added support for #if/#endif preprocessor directives to the CScriptBuilder

## Version 2.15.1 - 2009/01/25

- Bug fixes
  - Fixed a bug with bitwise operators and 8/16 bit integer types (Thanks jkhax0r)
  - Fixed the error message when no matching constructor is found for a construct call
  - Fixed bug when compiling expressions that called index operator that returned an object by value on a temporary variable (Thanks dxj19831029)
  - Saved pre-compiled bytecode didn't store the read-only flag for class methods
  - Fixed bug where class method calls that returned a reference to a member of the class would release the class before the reference was used
  - Fixed bug that allowed object handles for value types (Thanks Wavesonics)
  - Modified as_atomic.h to avoid use of kernel specific atomic.h on Linux (Thanks namtabmai)
  - Fixed compile error in as_callfunc_x86.cpp on GNUC when using -O3 option (Thanks bigjo)
  - Fixed the calling conventions for MinGW on Windows
- Library
  - Internally reference types (including script classes) are now allocated by calling the factory function directly
  - Updated as_config to properly identify operating system, thus improving multithreading performance
  - Created script factory stub functions for instanciating template types, thus simplifying script compiler
  - The memory for global variables declared in scripts is now allocated individually, which will allow more flexibility
- Add-ons
  - Added the generic interface to the CScriptFile object

## Version 2.15.0 - 2008/12/13

- Bug fixes
  - Fixed assignments where the rvalue is a temporary object instanciated with a construct call (Thanks SiCrane)
  - The parser no longer accepts other digits than 0 to initiate a hex literal value (Thanks SiCrane)
  - Fixed compiler error in as_callfunc_ppc_64.cpp (Thanks James Chan)
  - Fixed saving bytecode with enums (Thanks loboWu)
  - Fixed the index operator call on temporary object that caused an invalid reference (Thanks dxj19831029)
  - Fixed bug in the tokenizer and the !in token versus identifier (Thanks xivVerge)
  - Script functions can now be declared to return const types (Thanks SiCrane)
  - Fixed multithread problem in memory manager for the script node pool (Thanks xivVerge)
  - Fixed assert failure after compilation error with ref cast operator (Thanks Jeff Slutter)
  - Fixed compiler warnings for g++ 4.3.2 (Thanks Matt Williams)
- Library interface
  - Changed the parameters for the engine's GarbageCollect method to give more control to the application
  - Replaced GetObjectsInGarbageCollectorCount in the engine interface with GetGCStatistics
  - Added GetEngine to asIScriptStruct and asIScriptArray
  - Replaced GetVarPointer and GetReturnPointer in the context interface with GetAddressOfVar and GetAddressOfReturnValue respectively
  - Replaced GetArgPointer in the generic interface with GetAddressOfArg
  - Added SetUserData/GetUserData to the engine interface
  - Added the ParseToken method to the engine interface, useful for IDEs that provide syntax highlighting or intellisense
  - Removed deprecated GetMethodDescriptorByIndex, GetMethodCount, GetMethodIDByIndex, GetMethodIDByName, GetMethodIDByDecl from engine interface
  - Removed deprecated GetFunctionDeclaration, GetFunctionModule, GetFunctionSection, GetFunctionName from engine interface
  - Removed deprecated SetDefaultContextStackSize from engine interface
  - Added asIScriptModule, which will be used to interact with the modules directly, instead of through the engine interface
  - Added GetModule to the engine
  - Deprecated the methods in the engine for interacting with the modules, as these methods are now available in the module interface
  - Added GetGlobalVarTypeId to the module interface. There were no corresponding method for this in the engine interface
  - Renamed Discard in the engine interface to DiscardModule
  - Modified the GetTypeIdByDecl in the engine interface to take only the declaration and not the module name
- Library
  - Configured the library to work with Nintendo Wii (Thanks James Chan)
- Project
  - Added as_criticalsection.h
  - Moved as_c.cpp out of the main project, and into the C lib add-on project
- Add-ons
  - Added CScriptBuilder with support for include directive and metadata through a pre-processing pass
  - Improved const correctness to CScriptAny and CScriptDictionary
  - Removed the 'as' prefix from CScriptString and CScriptFile

## Version 2.14.1 - 2008/11/02

- Bug fixes
  - Removed the need to inform @ when performing explicit ref cast with an implicit ref cast behaviour
  - Added the namespace macros to the scriptnode module (Thanks SiCrane)
  - Fixed an application crash in the asCThreadManager when the script engine was released by a global var upon application exit (Thanks BornToCode and SiCrane)
  - Fixed application freeze on compiling scripts that declare a const return value for class methods (Thanks SiCrane)
  - Fixed some assert failures after compilation errors (Thanks SiCrane)
- Library
  - Added engine property asEP_ALLOW_IMPLICIT_HANDLE_TYPES to turn on the experimental feature.
  - Added compiler warning when compiling handle comparison where either of the operands have not been explicitly set as handle.
  - Updated as_config.h to support MSVC 2008 + x64 processor (native calling conventions is still not supported). (Thanks wildmild and SiCrane)
  - Improved thread safety in the library.
  - Added multithread support for MacOS X, x86 and ppc
- Script language
  - Added experimental support for implicit handle types. These are declared with 'class@ name {}' (Thanks George Yohng)
  - Class methods can now be declared as 'const' in the script class declaration.
  - Implemented the 'is' operator for identity comparisons, i.e. comparing two object handles.
- Project
  - Added as_gc.h and as_gc.cpp, which holds the garbage collector previously in the script engine module.
  - Added as_atomic.h and as_atomic.cpp, which provides a threadsafe reference counter.

## Version 2.14.0 - 2008/10/05

- Bug fixes
  - Fixed some issues with the scoped reference type (Thanks Jeff Slutter)
  - Improved validation of type flags on RegisterObjectType with asOBJ_VALUE (Thanks dxj19831029)
  - Fixed bug with for loop that was not using primitives in the loop increment statement (Thanks jal)
- Library interface
  - The C interface now has a dedicated header file with it's own project in the add_on directory.
  - Added WriteMessage to the engine interface, for writing to the message callback.
  - Deprecated GetGlobalVarIDByIndex, GetGlobalVarIDByName, GetGlobalVarIDByDecl, and GetGlobalVarPointer.
  - Added GetGlobalVarIndexByName, GetGlobalVarIndexByDecl, and GetAddressOfGlobalVar.
  - The method GetAddressOfGlobalVar that replaces GetGlobalVarPointer now returns the address of objects directly, rather than a pointer to the address of the objects, for object variables.
  - Added asBEHAVE_IMPLICIT_VALUE_CAST to differenciate between implicit and explicit value cast behaviours.
- Library
  - Identical interfaces declared in different modules will now share type id.
  - Added constraint against multiple threads trying to compile scripts at the same time.
  - The script compiler no longer uses constructor/factory behaviours in implicit value casts.
  - The engine's GetObjectTypeCount and GetObjectTypeByIndex now return application registered types as well.
  - The context can be used to call registered functions/class methods directly.
- Script language
  - The cast<type>(expr) operator can now only be used for reference casts. Value casts must use the construct cast, i.e. type(expr).

## Version 2.13.1 - 2008/08/17

- Bug fixes
  - Fixed reference casts when the source handle is a script class member (Thanks Marcin "Pris" Musial)
  - Fixed the declaration of the CRITICAL_SECTION on 64 bit Windows (Thanks Viktor Levitin)
  - Fixed bug with temporary variables being reused too early (Thanks loboWu and Dentoid)
  - Fixed bug with temporary variable not being released (Thanks dxj19831029)
  - Fixed bug with enum lists not ended with comma (Thanks Shurwint)
  - Fixed bug with compiler optimization of constant expressions (Thanks loboWu)
- Script language
  - Single quoted strings can now be used instead of double quoted strings.
- Library interface
  - Added asEP_USE_CHARACTER_LITERALS to allow applications to interpret single quoted strings as character literals.
  - Added asEP_ALLOW_MULTILINE_STRINGS that will allow the compiler to accept string constants with line breaks.
  - Added extra validation to register functions to minimize user errors.
  - Added support for asBEHAVE_IMPLICIT_REF_CAST.
- Library
  - Added support for posix threads on the platforms that support it (Thanks kunitoki)
  - Support for multithreading is now turned on by default, it can be turned off by defining AS_NO_THREADS.

## Version 2.13.0 - 2008/06/08

- Bug fixes
  - Fixed compile error on non-standards compliant compilers, e.g. MSVC6 (Thanks Shurwint)
  - Updated as_config.h to remove compiler warning for stdcall on 64bit linux (Thanks Alraz)
  - Moved enum declarations to top of header to fix compile error on GNUC (Thanks Samuel E. Henley)
  - Global variables declared with enum types crashed the engine (Thanks mono2k)
  - Fixed bug with shift operators and byte operands that should have been converted to dword (Thanks loboWu)
  - Fixed compile error on GNUC/Linux. (Thanks droz)
  - bool[] objects didn't use the correct element size on Mac OS X with PPC (Thanks Edward Rudd)
  - Enum values are now correct on big endian CPUs as well.
  - Illegal casts without arguments would crash the compiler (Thanks loboWu)
  - Fixed a bug in compiler that could make the script engine release invalid objects (Thanks Milleniumas)
  - Fixed a bug where global arrays of handles where initialized with handles of other global variables (Thanks sunwoolee)
- Library interface
  - Added engine property asEP_MAX_STACK_SIZE
  - Added methods for enumerating object type methods and properties to the asIObjectType interface
  - Added methods for enumerating parameter types to the asIScriptFunction interface
  - Added GetFunctionDescriptorById to the asIScriptEngine interface
  - Added methods for getting function declaration and script section to asIScriptFunction
  - Deprecated SetDefaultContextStackSize in asIScriptEngine
  - Deprecated GetFunctionName, GetFunctionDeclaration, GetFunctionModule, GetFunctionSection in asIScriptEngine
  - Deprecated GetMethodCount, GetMethodIDByIndex, GetMethodIDByName, GetMethodIDByDecl, GetMethodDescriptorByIndex in asIScriptEngine
  - Deprecated global behaviours LOGICAL_OR and LOGICAL_AND as these operators are exclusive to boolean types
  - Added global behaviour asBEHAVE_REF_CAST, that allow explicit casts between handles to application registered types
- Library
  - Added initial support for native calling conventions on 64bit platforms (Thanks niteice)
  - Updated as_config.h to add support for native calling conventions on FreeBSD (Thanks Jeremy "droz" Harmon)
- Project
  - Added as_callfunc_x64_gcc.cpp

## Version 2.12.0 - 2008/03/22

- Bug fixes
  - Fixed assert failure when compiling if statement with incorrect expression (Thanks Chet Simpson)
  - Fixed assert failure when returning an input reference by reference from script function (Thanks Chet Simpson)
  - Fixed potential heap corruption when internally copying system function information (Thanks Chet Simpson)
  - Fixed asOBJ_VALUE | asOBJ_APP_FLOAT with RegisterObjectType (Thanks RsblsbShawn)
  - Fixed access to global variables when the object method is from another module (Thanks Chet Simpson)
  - A const object can now be passed to a function expecting a non-const object by making a copy (Thanks Jeff Slutter)
  - Fixed a bug in tokenizer on 64 bit platforms (Thanks DaBono)
- Script language
  - Added typedef. Currently it allows to define aliases of built-in primitive types (Thanks Chet Simpson)
  - Added enum. (Thanks Chet Simpson)
- Library interface
  - Added RegisterEnum and RegisterEnumValue to asIScriptEngine (Thanks Chet Simpson)
  - Added RegisterTypedef to asIScriptEngine (Thanks Chet Simpson)
  - Added GetObjectTypeId, GetArgCount, and GetReturnTypeId to asIScriptGeneric.
  - Added the asIObjectType interface (Thanks Chet Simpson)
  - AngelScript is now capable of differentiating between global functions, class methods, and functions using the generic calling convention.
  - Added asWRONG_CALLING_CONV return code when the wrong calling convention is used.
  - Changed constants to enums for better grouping.
  - Added asIScriptFunction interface (Thanks Chet Simpson)

## Version 2.11.2 - 2008/01/21

- Bug fixes
  - Compiler didn't warn when using post incremental/decremental operator on uninitialized variable (Thanks Noelia Rodriguez Matilla)
  - Switch cases didn't work properly for uint8 and uint16 types (Thanks Noelia Rodriguez Matilla)
  - Compound assignments in conjunction with arrays could give incorrect results (Thanks loboWu)
- Library interface
  - Added behaviour asBEHAVE_VALUE_CAST that allow objects to be cast to other types, including primitives
- Library
  - ExecuteString no longer locks dynamic configuration groups. (Thanks mono2k)
  - Compiler gives better error message when it cannot match class methods for a call (Thanks Jeremy Harmon)

## Version 2.11.1 - 2007/12/16

- Bug fixes
  - Expressions that tried to use indexing operator on primitive types caused assert failure (Thanks Anders Hansson)
  - GetFunctionIDByDecl returned asINVALID_DECLARATION for functions that returned or passed reference types by value (Thanks loboWu)
  - Corrected as_config.h in regards to vsnprintf for MSVC9 (Thanks Schrompf)
- Library interface
  - Added the new object type flag asOBJ_SCOPED, that allows applications to register reference types that behaves like value types but with special memory management needs
- Library
  - Compiler emits less error messages that are concequences of previously detected errors

## Version 2.11.0 - 2007/11/30

- Bug fixes
  - Copying script classes that held object handles crashed (Thanks Jeff Slutter)
  - Script class methods with the same name as an object type was incorrectly causing compilation error
  - Compiler didn't find objects methods when compiling a method call if the method had the same name as an object type (Thanks Jeff Slutter)
  - The bytecode optimizer failed in a specific situation (Thanks Jeff Slutter)
  - The multithread support in as_thread.cpp was broken (Thanks Martin Kaeser)
  - Garbage collector could in certain cases removed type definitions that were still needed causing application crashes (Thanks Jeff Slutter)
  - Script classes inheriting from other classes didn't give a compiler error (Thanks Pris)
  - The script allow called to non const methods for handles to const objects (Thanks virtualcodewarrior)
  - Fixed a few null pointer accesses when passing null handles to and from application (Thanks behc)
  - asIScriptContext::GetState can now return asEXECUTION_ABORTED as well (Thanks Anders Hansson)
  - Fixed uint64 to double conversion
- Library interface
  - Added new flags asOBJ_REF, asOBJ_VALUE, asOBJ_GC, asOBJ_POD, and asOBJ_NOHANDLE that represents how the type is intended to work in AngelScript
  - Changed prefix for previous asOBJ flags to asOBJ_APP. They should only be used with asOBJ_VALUE.
  - AngelScript now validates the behaviours, to check for missing behaviours or behaviours that shouldn't be registered for the type
  - Types registered as reference counted won't be allowed to be passed by value to system functions, nor returned by value
  - Reference types must now use the new FACTORY behaviour instead of the CONSTRUCT behaviour.
  - Removed the asBEHAVE_ALLOC and asBEHAVE_FREE behaviours.
  - Added Unprepare to context interface.
- Library
  - Added native calling conventions for XBox 360 (Thanks Laszlo Perneky)

## Version 2.10.0 - 2007/09/23

- Bug fixes
  - Fixed a bug with matching functions with boolean arguments (Thanks Jeff Slutter)
  - CopyScriptObject is now able to copy registered types that have no registered copy behaviour (Thanks Jeff Slutter)
  - Script classes crashed on construction with AS_MAX_PORTABILITY (Thanks Carlos Campaña)
  - Fixed a null pointer access on stack clean up (Thanks Thomas Cowell)
  - Fixed an assert failure in the compiler (Thanks Jeff Slutter)
  - When compiling assignment the compiler made incorrect implicit conversions to object type (Thanks Anders Hansson)
  - Fixed access violation in RegisterGlobalProperty when the property had already been registered in another group (Thanks mono2k)
  - The condition operator didn't handle void expressions in the results (Thanks Anders Hansson)
  - Comparison with local boolean variable toggled the variable's value (Thanks Anders Hansson)
- Script language
  - The any type is no longer a built-in type
  - Bitwise operators will maintain the signed/unsigned type of the left operand (Thanks Trikko)
- Library interface
  - Added GCEnumCallback and NotifyGarbageCollectorOfNewObject to engine
  - Added behaviours GETREFCOUNT, SETGCFLAG, GETGCFLAG, ENUMREFS, RELEASEREFS
  - The any type is no longer a built-in type, thus the asIScriptAny interface and the asTYPEID_SCRIPTANY constant have been removed (CScriptAny add-on was created to replace them)
  - Added CompareScriptObjects method to engine (Thanks Jeff Slutter)
- Project
  - Removed as_gcobject.cpp and as_gcobject.h
  - Removed as_anyobject.cpp and as_anyobject.h

## Version 2.9.1 - 2007/08/19

- Bug fixes
  - The default constructor wasn't called for script class members of script class types (Thanks Jeff Slutter)
  - ReleaseScriptObject failed for types that didn't have the release behaviour, nor the destructor (Thanks Jeff Slutter)
- Script language
  - Implemented support for destructors in the script classes. (Thanks Jeff Slutter)

## Version 2.9.0 - 2007/08/12

- Bug fixes
  - Parser could hang on scripts with non-terminated strings. (Thanks derefed)
  - Compiler died when compiling a return statement with a void expression. (Thanks SiCrane)
  - A bug when calling class methods with 1 or 2 byte arguments was fixed for PPC, both 32bit and 64bit. (Thanks Jeff Slutter)
  - Fixed a bug with &inout references and script class member variables (Thanks Jeff Slutter)
- Library interface
  - GetGlobalVarPointer returns the pointer to the pointer to the object for object variables. Likewise for object handles a pointer to the object handle is returned (Thanks Jeff Slutter)
  - Added GetArgByte(), GetArgWord(), SetReturnByte(), SetReturnWord() to asIScriptGeneric for better support on big endian processors
  - Added SetArgByte(), SetArgWord(), GetReturnByte(), GetReturnWord() to asIScriptContext for better support on big endian processors
  - GetArgDWord(), SetReturnDWord(), SetArgDWord(), and GetReturnDWord() now validates that type is 4 bytes
  - Added GetThisTypeId and GetThisPointer to asIScriptContext (Thanks Jeff Slutter)
  - GetTypeIdByDecl is now able to understand const type declarations. (Thanks Jeff Slutter)
  - Added GetArgTypeId and GetFunctionId to the generic interface
  - Removed the makeCopy parameter from AddScriptSection, and instead added a new engine property asEP_COPY_SCRIPT_SECTIONS
  - Added CreateScriptObjectCopy, CopyScriptObject, AddRefScriptObject, ReleaseScriptObject, and GetSizeOfPrimitiveType to engine for easier development of generic container classes
  - All methods for registering functions, methods, or behaviours are now returning the function id as a success indicator. Negative values still indicate an error.
  - Implemented support for variable parameter type, ?&, in object constructor, object methods, and global functions

## Version 2.8.1 - 2007/07/09

- Bug fixes
  - Fixed the behaviour of the AS_USE_NAMESPACE macro (Thanks SkunkGuru)
  - Fixed misleading message when compiling statement like 'Object &ref' (Thanks Steve Williams)
  - Fixed bug in compiler where it didn't reuse temporary variables properly
  - Fixed problem with C++ compiler optimizations that changed the result of AngelScript code and thus breaking (Thanks Jeff Slutter)
  - Fixed the as_config.h file for GNUC/Apple
  - Fixed conversion of negative floating point values to unsigned int on GNUC based compilers
  - Fixed bug with booleans returned from functions that didn't evaluate to false when expected. (Thanks Rakkar2)
  - Fixed bug where the compiler failed when passing constant references as function parameters. (Thanks Rakkar2)
  - Engine no longer permits the registration of functions with void parameters (Thanks Juan Pablo Bettini)
  - Fixed compiler assert when assigning a void value to a variable (Thanks Anders Hansson)
  - Fixed bug in compiler where the property name wasn't validated correctly for name conflicts (Thanks Andy R)
  - Fixed intermittent bug in the byte code optimization that affected only big endian processors.
  - Fixed incorrect name conflict between script class methods and global functions (Thanks Anders Hansson)
  - Fixed assertion failure when declaring variables as void (Thanks Anders Hansson)
  - Fixed bug with GetGlobalVarID that didn't return the id with the moduleId (Thanks Julian Storer)
  - Fixed bug with initialization lists for arrays of object handles.
  - Fixed bug with loading bytecode that used registered array types. (Thanks Juan Pablo Bettini)
  - Fixed bug with loading bytecode with script classes that were declared out of order. (Thanks Juan Pablo Bettini)
  - Fixed bug where CHKREF was placed incorrectly to verify only the first parameter on the stack. (Thanks CyberGorgolith)
  - Fixed bug with boolean operations that treated false values as true due to trash data in upper bytes of the boolean variable.
  - The default constructor for script classes wasn't called for classes in arrays. (Thanks Jeff Slutter)
  - Fixed bug with explicit handle for class members and array elements (Thanks Juan Pablo Bettini)
- Library
  - Improved memory foot print of the compiler.
  - When parsing statements the parser now has full knowledge of available types so it is able to better distinguish the true semantic of identifiers.
  - Added support for PS3 native calling conventions. (Thanks Jeff Slutter)
  - GNUC assembler for native calling conventions now guarantee stack pointer alignment on 16 bytes.
  - Added support for Mac OS X with Intel native calling conventions.
  - Added support for Mac OS X with PPC native calling conventions.
- Library interface
  - Added OPTIMIZE_BYTECODE as engine property.
  - Removed restriction on registered object type's sizes, they can now be of any size, even non-multiple of 4. (Thanks Tonin)
- Virtual machine
  - New byte codes: ChkNullS, ClrHi
- Project
  - Added as_callfunc_ppc_64.cpp

## Version 2.8.0a - 2007/02/18

- Bug fixes
  - Fixed memory leak with exception handler inside script class method
  - Fixed the DELETEARRAY macro that didn't work on gnuc (Thanks Jeremy "droz" Harmon)
- Library
  - Improved the memory management facility
  - Added the config option AS_NO_USER_ALLOC. Define this to turn off the user defined memory managements. The default memory management in the library may not be compatible with all compilers yet. By defining this macro when you compile the library, you should be able to use the library anyway, though without the functionality of asSetGlobalMemoryFunctions().
- Project
  - Removed as_objectarray.h

## Version 2.8.0 - 2007/02/04

- Bug fixes
  - Fixed incorrect use of temporary variables during evaluation of function argument expressions (Thanks Gilad Novik)
  - Fixed error with exception handler inside script class method (Thanks Anders "Dentoid" Stenberg)
- Library interface
  - Added Set/GetEngineProperty() that will allow you to dynamically changes some settings that previously required a recompilation of the library.
  - ALLOW_UNSAFE_REFERENCES is now an engine property instead of a compile time flag.
  - Removed some deprecated functions.
  - Added GetArgPointer() and GetReturnPointer() to asIScriptContext and asIScriptGeneric.
  - Removed the SetCommonObjectMemoryFunctions() from the script engine.
  - Added the global SetGlobalMemoryFunctions() and ResetGlobalMemoryFunctions().
  - Added SetUserData() and GetUserData() to the context interface (Thanks Steve Williams)
- Library
  - Fixed a lot of compiler warnings (Thanks Manu Evans)
  - All dynamically allocated memory now uses the memory functions registered with SetGlobalMemoryFunctions.
  - By changing the asCString implementation I was able to decrease the number of memory allocations by 15%.
- Script language
  - Deprecated the bits type. All bitwise operators are now performed on the uint type. There is no longer any bitwise conversion of float to uint.
  - Added the int64 and uint64 types.
  - The this keyword is now optional when accessing class members from within a class method.
  - Object constructors can now be used to perform implicit conversions in expressions.
- Virtual machine
  - New byte codes: i64TOi, uTOi64, iTOi64, fTOi64, dTOi64, fTOu64, dTOu64, i64TOf, u64TOf, i64TOd, u64TOd, NEGi64, INCi64, DECi64, BNOT64, ADDi64, SUBi64, MULi64, DIVi64, MODi64, BAND64, BOR64, BXOR64, BSLL64, BSRL64, BSRA64 CMPi64, CMPu64
- Project
  - Added as_memory.h, as_memory.cpp, and as_objectarray.h

## Version 2.7.1b - 2006/12/03

- Bug fixes
  - Save/load of bytecode followed by ExecuteString() that called one of the script functions failed during compilation. (Thanks coollofty)

## Version 2.7.1a - 2006/11/04

- Bug fixes
  - Constant bits8 and bits16 variables didn't work properly (Thanks Cheetah3d)

## Version 2.7.1 - 2006/11/02

- Bug fixes
  - Minor bug fix with an incorrect error message (Thanks Alraz)
  - Empty switch statements would crash the compiler (Thanks the_bateman)
  - Registering global properties didn't update a cache in compiled script modules, sometimes invalidating pointers (Thanks Anthony Rufrano, a.k.a "paradoxnj")
  - Fixed compiler differences for 64bit integer constants
  - Fixed some compiler asserts (Thanks Anders Hansson)
  - The index operator on handles to array objects didn't work (Thanks Anders Hansson)
  - The compiler would crash if a script class inherited from an undeclared type (Thanks Anders Hansson)
  - The compiler incorrectly reused temporary variables (Thanks MrC_XBMC)
- Library
  - The non-reserved tokens, any, from, and this, are now also defined in the as_tokendef.h file (Thanks Deyja)
  - Adjustments have been made to make the library indepentent of CPU memory layout of words. This if for PPC. (Thanks Edward Rudd)
  - Cleaned up as_config.h to make it easier to maintain
  - Changed compiler to do proper conversion between types of different sizes, for the sake of big-endian CPUs.
- Script language
  - Added the reserved keyword 'cast'
  - Support for dynamic casts between object handles with cast<type>(expr)
- Virtual machine
  - Added byte codes iTOb, iTOw, SetV1, and SetV2 to support big endian CPUs
  - Added byte code Cast for dynamic casts of object handles

## Version 2.7.0 - 2006/07/23

- Bug fixes
  - Fixed a problem with script classes and multiple modules where the engine failed to find the class methods (Thanks Dentoid)
  - Fixed bug where an assert fails when the operands for an assignment has compiler errors (Thanks Dentoid)
  - Parser entered endless loop if the script ended before closing the class declaration (Thanks Dentoid)
  - Parser entered endless loop if a method declaration had syntax error (Thanks kunitoki)
  - Fixed assert hit for some compiler errors (Thanks kunitoki)
  - Discard() would remove array types from the configuration, leading to failure in following builds (Thanks loboWu)
  - Fixed bug with the any type and AS_MAX_PORTABILITY
  - Fixed bug with AS_MAX_PORTABILITY and script classes that were not constructed properly
  - Fixed a bug with the bytecode optimization for 64bit processors
  - Fixed some bugs with the internal array object and AS_MAX_PORTABILITY and AS_64BIT_PTR
  - Fixed bug with null value and AS_64BIT_PTR
  - Fixed some bugs in the virtual machine on 64bit processors
  - Added check to see if script property has a size 0 (Thanks Maddi)
- Library interface
  - The engine methods GetMethodCount(), GetMethodIDByIndex(), GetMethodIDByName(), and GetMethodIDByDecl() were changed to take the typeId instead of the module name and object type name. This makes it unnecessary to know the module if you only have the type id, and it is also much more efficient.
  - Added methods RegisterInterface() and RegisterInterfaceMethod() that allow the application to register a script interface which can be passed to the application
  - Added method GetFunctionModule()
  - Deprecated the methods GetModuleIndex() and GetModuleNameFromIndex()
  - Added GetVarTypeId() to the context interface
  - Replaced SetCommonMessageStream() with SetMessageCallback() which is more flexible in that it receives a structure with info instead of a string
  - asIOutputStream is removed
  - Added asGetLibraryOptions() which returns a string with the compile time options. Mostly used for testing.
- Library
  - Applied changes to make the library work better with 64bit platforms (Thanks Yiannis Mandravellos)
  - Fixed a couple of compiler warnings (Thanks Alraz)
  - Added support for native calling conventions on MIPS processors. (Contribution by Manu Evans)
  - Added first support for native calling conventions on PPC processors. (Contribution by Pecan Heber)
  - Unified the way registered functions and script functions are stored in the engine
  - Improved performance of Prepare() when using the same function as last Prepare()
- Script language
  - Added new token 'interface'
  - Semi-colon after class declaration is now optional
  - It's now possible to declare interfaces in the scripts
  - Added support for the '\t' escape sequence in strings. (Thanks Lbas)
  - Deprecated the keyword 'struct' in the script language
- Virtual machine
  - Added bytecode CALLINTF which resolves interface methods to the real class method
- Project
  - Added as_callfunc_mips.cpp
  - Added as_callfunc_ppc.cpp

## Version 2.6.0 - 2006/04/08

- Bug fixes
  - Fixed a bug with RegisterGlobalProperty() (Thanks loboWu)
  - Type conversions may now be used in initialization of global variables. (Thanks iram)
- Script language
  - It's now possible to define class methods and constructors for the script declared structures. The definition of the method must be written inside the struct declaration.
  - The this keyword can be used to access the object and its members from within the class method. It's not yet possible to access the struct members without using the this keyword.
  - Added the keyword 'class' as synonym for 'struct'
  - For &inout parameter references the 'inout' keyword is now optional
  - Only object types that support object handles can now use the &inout parameter references. Other types must use &in or &out, unless AS_ALLOW_UNSAFE_REFERENCES is defined.
  - Added the reserved keyword: int64. Currently this is only used internally, but in time it will be a fully implemented primitive.
- Library interface
  - Removed the deprecated version of the Build() method.
  - Added SetArgAddress() and GetReturnAddress() methods to the context interface. These should be used to handle references
  - Added GetArgAddress() and SetReturnAddress() methods to the generic interface.
  - Changed AddScriptSection() to accept a size_t for the script length instead of int
  - Improved the way the [Set|Get][Arg|Return][Address|Object]() methods work.
  - Added the method SetObject() to the context for calling object methods
  - ExecuteString() now adds a line break after the given string. This allows for one-line comments to be used without producing an invalid script. (Thanks B_old)
  - Added the methods GetMethodCount(), GetMethodIDByIndex(), GetMethodIDByName(), and GetMethodIDByDecl() that should be used to obtain the function id for a script declared class method.
- Library
  - Fixed a lot but not all of the compiler warnings that MSVC8 reports for 64bit incompatibilities.
  - If native calling conventions are not supported for the target platform, then AS_MAX_PORTABILITY will automatically be defined to allow compilation of the library. (Thanks mandrav)
  - Added a new compiler flag AS_64BIT_PTR, which should be defined for 64bit platforms. Ideally the as_config.h file should automatically set the flag according to the target platform. When this flag is defined, all pointers will be stored in the bytecode as 64bit words.
  - Made improvements to better handle 64bit platforms

## Version 2.5.0c - 2006/02/16

- Bug fixes
  - Using named constants, i.e. variables declared and initialized with constants, would in certain situations give the wrong value. (Thanks Villemon)
  - Added null checks to fix memory access failure related to dynamic configurations. (Thanks mandrav)
- Project
  - Removed as_structs.h

## Version 2.5.0b - 2006/01/31

- Bug fixes
  - Comparison with object handle in a local variable produced incorrect byte code. (Thanks Villemon)
  - A bug in the VM for the BC_ChkNullV byte code caused script exceptions when using asCScriptString compiled with VC++ 2005. (Thanks topcatse)
  - When releasing the engine, the internal resources were released in the wrong order, causing assert failures in the memory manager with VC++ 2005.
  - The assignment operator for the internal type 'any' wasn't properly registered, causing memory management problems.
  - Global variables were not initialized properly when loading pre-compiled bytecode. (Thanks Villemon)

## Version 2.5.0a - 2006/01/20

- Bug fixes
  - Using assignment behaviours that took a reference as &inout with asALLOW_UNSAFE_REFERENCES would crash the application. (Thanks Deyja)
  - Using the default constructor for script structures to create temporary objects didn't work.

## Version 2.5.0 - 2006/01/12

- Bug fixes
  - asCALL_CDECL_OBJLAST that returned objects by value didn't work correctly (Thanks Deyja)
- Script language
  - Primitive types can be implicitly converted to a reference of another primitive type for function calls. This is something C++ doesn't accept.
  - Parameter reference specified as &inout no longer copies the value. The argument is only computed once. The function receives a reference to the true value. Expressions where the reference cannot be guaranteed during the execution of the function generates a compiler error. The value must then be copied to a local variable instead.
  - Added support for character literals.
- Library interface
  - Overloaded operators may now use &inout references. Since this type of references now guarantees a pointer to the true object this is useful if the operand has to be modified, e.g. a stream class.
  - Overloaded operators may now use &out references. The order of evaluation will change, but precedence order is kept.
  - Added functions to the asIScriptContext interface that allow the application to enumerate variables on the stack and examine their values. (Thanks Ivan Marinov)
- Library
  - A couple of minor code changes to make it easier to compile the library on Metrowerks CodeWarrior for NintendoDS (Thanks Fumihiro KanaYA)
  - The script compiler was changed to generate less copies of objects when doing function parameters by reference.
  - Added a new compile time flag: AS_ALLOW_UNSAFE_REFERENCES. When this is defined the library will allow parameter references without the in, out, or inout keywords. These parameters references will also work just like normal C++ parameter references, without any restrictions.
- Virtual Machine
  - The VM has been changed to use three op instructions instead of stack based instructions. In some situations the new VM is faster, in others it is about the same.
- Project
  - as_types.h was removed.

## Version 2.4.1e - 2006/02/04

- Bug fixes
  - When releasing the engine, the internal resources were released in the wrong order, causing assert failures in the memory manager with VC++ 2005.
  - The assignment operator for the internal type 'any' wasn't properly registered, causing memory management problems.
  - asCALL_CDECL_OBJLAST that returned objects by value didn't work correctly (Thanks Deyja)
  - Global variables were not initialized properly when loading pre-compiled bytecode. (Thanks Villemon)
  - Using the default constructor for script structures to create temporary objects didn't work.
  - Comparison with boolean values resulted in the value -1 instead of 1.

## Version 2.4.1d - 2005/12/09

- Bug fixes
  - The compiler didn't raise an error when doing an handle assignment where the lvalue was a normal object (Thanks Lbas)

## Version 2.4.1c - 2005/11/22

- Bug fixes
  - Overloaded indexing operators that take an object as parameter and returns a reference, crashed the application when compiling the script. (Thanks Desdemona)

## Version 2.4.1b - 2005/11/08

- Bug fixes
  - Chained expressions with overloaded operators and registered types could cause null pointer violations (continued) (Thanks __Avatar__)

## Version 2.4.1a - 2005/10/18

- Bug fixes
  - Registering global properties, after removing a config group with global properties, caused a null pointer violation. (Thanks DaesDemon)
  - An assert failed when initializing variables with a function that took reference parameters. (Thanks mandrav)
  - Chained expressions with overloaded operators and registered types could cause null pointer violations. (Thanks Anders Stenberg, a.k.a Dentoid)
  - Expressions with multiple levels of indirections (.) and object handles as arguments in each level, caused incorrect bytecode. (Thanks Vexorian)

## Version 2.4.1 - 2005/09/23

- Script language
  - Added support for heredoc string constants. (Thanks Ashish Ranjan)
  - Added support for array initialization lists.

## Version 2.4.0 - 2005/09/15

- Bug fixes
  - The bitwise negate operator, ~, now works with integer types as well, e.g. int and uint. (Thanks Suudy)
  - Save and load of compiled bytecode with script arrays now work. (Thanks Evgeny Efremov, a.k.a wolfenstein)
- Library interface
  - Added methods BeginConfigGroup(), EndConfigGroup(), and RemoveConfigGroup() for asIScriptEngine.
  - The engine no longer allow overriding the array types if they are already being used elsewhere.
  - All methods taking asUPtr as parameter was changed to take const asUPtr& instead, which ought to help avoid ESP problems that some people have encountered.
  - Added an optional namespace. Define the flag AS_USE_NAMESPACE when compiling to put the script engine in the namespace AngelScript.
  - Added a method SetCommonObjectMemoryFunctions() that allow the application to register an alloc()/free() function pair that will be used for all script objects.
  - asIBinaryStream was changed to use asUINT instead of int for the block size, and const void * instead of void * for Write().
  - Added a method SetCommonMessageStream(). The engine uses this output stream to output error messages when registering configurations, and also if the Build() method is called with a null pointer for the output stream. A second version of this method is available that takes a simple function pointer and an optional parameter, like a normal callback function.
  - Build() and ExecuteString() no longer takes a pointer to an asIOutputStream. The old version is still available by defining the flag AS_DEPRECATED.
  - Added method SetConfigGroupModuleAccess() which is used to set both default module access mode and individual module accesses.
- Script language
  - Constant variables that are initialized with a constant expression, can now be used as named constants in for example switch cases. (Thanks juhnu)
- Library
  - Changed the way the modules free global variables. Instead of a script function, it is now just a simple loop freeing each of the variables.
  - asBSTR is no longer used internally to store constant strings, asCString is used instead.
  - Converted the asCMap to template code.
  - The assembler VM was removed as it will no longer be possible to keep it compatible with the C++ VM.
- Project
  - Added as_configgroup.cpp and as_configgroup.h.
  - Removed as_map.cpp
  - Removed as_context_x86.cpp
  - Removed as_bstr_util.cpp and as_bstr_util.h.

## Version 2.3.0b - 2005/08/09

- Bug fixes
  - Parameters where freed before the returned reference was used, which caused errors if the reference pointed to one of the parameters. (Thanks Suudy)

## Version 2.3.0a - 2005/07/29

- Bug fixes
  - Structure definitions and function declarations where not order independent. (Thanks Carl Ĺdahl)
  - Added the old CreateContext() and GetGlobalVarPointer() as deprecated methods.
  - Fixed some more compiler warnings.

## Version 2.3.0 - 2005/07/14

- Bug fixes
  - RegisterGlobalProperty() for object handles wasn't working correctly, the wrong address was used by the VM.
  - The C interface for asIScriptGeneric wasn't declared correctly.
  - Fixed a few compiler warnings. (Thanks Rain Dog)
  - When calling methods on null handles, the application crashed with a memory access violation (Thanks Robert Manuszewski)
  - If accessing the elements of a script array handle, the compiler wrongly made the elements handles as well (Thanks Scott Dillman, a.k.a AlphaDog)
- Library interface
  - Added an interface to manipulate the any type, asIScriptAny.
  - Added an interface to manipulate script structures, asIScriptStruct.
  - Added an interface to manipulate script arrays, asIScriptArray.
  - Added methods GetTypeIdByDecl() and GetTypeDeclaration().
  - Added the method asIScriptEngine::CreateScriptObject() that allow the application to create objects from a type id.
  - Added the method asIScriptEngine::GetObjectsInGarbageCollectorCount() which can be used to finetune how often the GarbageCollect() is called.
  - Changed the asIScriptEngine::CreateContext() to return the context pointer instead of placing it in the parameter.
  - asIScriptEngine::GetGlobalVarPointer() now returns the pointer directly, instead of putting it in the argument.
  - Removed the deprecated asIScriptContext::ExecuteStep().
- Script language
  - New built-in type: any. This type will be able to hold any other type, as a generic container, though currently it can only hold object handles. It is possible to pass this type to the application.
- Library
  - Changed the implementation for asCGCObject, since it is not possible to use multiple inheritance with anonymous pointers.
  - Slimmed down the internal datatype representation, for the typeid feature.
- Virtual machine
  - A new bytecode TYPEID has been implemented.
  - The object types are now passed as pointers directly in the bytecode, instead of by index.
- Project
  - Added as_anyobject.h and as_anyobject.cpp

## Version 2.2.0 - 2005/06/08

- Script language
  - New reserved keyword: struct
  - The scripts can now declare and use structures.
  - The compiler now automatically converts objects to object handles, when it is obvious a handle is wanted, i.e. there will be less need to use the @ operator.
- Library interface
  - It is now possible to tell the library to automatically handle reference for handles passed to and from application functions. Simply add a + after the @. This makes it possible to pass handles to functions that do not call the release method before returning.
  - A new method GarbageCollect() has been implemented that will free unused script objects. For long running programs it is necessary to call this every now and then. It can do either a full cycle or just a small incremental step, depending on the needs of the application.
- Virtual machine
  - The bytecode now identifies object types locally to each module.
  - There is a new bytecode OBJTYPE that translates a local object type id to the engine's object type id.
- Library
  - Added a new preprocessor flag, AS_MAX_PORTABILITY, which removes all calls to assembler routines, which should make the library work on all platforms. In this mode, only asCALL_GENERIC can be used for application functions.
  - Changed the internal data type description class to be easier to work with. The intention is to allow the application to access this to get information about types for global variables, function declarations, etc.
  - Changed the implementation of the internal script array object to work more similar to the way script structures work.
- Project
  - New files: as_scriptstruct.cpp and as_scriptstruct.h
  - Added as_callfunc.cpp which implements the portable functions when AS_MAX_PORTABILITY is defined.
  - Added the files as_gcobject.h and as_gcobject.cpp

## Version 2.1.0c - 2005/05/26

- Bug fixes
  - When getting the function declaration the library didn't set the 'in', 'out', 'inout' flags for parameter references (Thanks Andrey Kraynov, a.k.a _Dreamer)
  - After loading precompiled bytecode script functions that took objects by handle couldn't be identified (Thanks Andrey Kraynov, a.k.a _Dreamer)

## Version 2.1.0b - 2005/04/25

- Bug fixes
  - The C interface wasn't exporting the functions. (Thanks Lars Peter Christiansen)
  - Variables of types int and uint of any size weren't implicitly converted to bits.
  - Uninitialized variables passed to &out parameters were incorrectly reported as uninitialized.
  - The compiler was accepting assignments of any type to objects with no registered assignment operator.

## Version 2.1.0a - 2005/04/11

- Bug fixes
  - The null pointer access in the compiler when matching function arguments was removed (Thanks Lennart Denninger)
  - The ?: operator was reusing temporary variables incorrectly.
  - The compiler failed to compile the boolean not operator for variables. (Thanks SharkBait)

## Version 2.1.0 - 2005/04/03

- Bug fixes
  - The line numbers reported by the VM were incorrect.
  - GetGlobalVarPointer() was returning a pointer to a pointer for registered object types. (Thanks Rain Dog)
  - Fixed a possible crash when calling AddScriptSection() with 0 for section name.
  - The operands for overloaded operators are now evaluated left-to-right.
  - Output parameters weren't working correctly for object methods (Thanks Mĺrten Svanfeldt, a.k.a thebolt00)
  - The engine failed when calling registered functions that received objects both by value and by reference (Thanks Lennart Denninger)
  - Registered object types without registered constructor couldn't be used to create temporary objects in expressions.
  - Global variables couldn't use overloaded assignment operators to initialize the variables.
  - Object properties declared as object handles were not handled correctly by the compiler.
  - Fixed a bug that crashed the application when compiling a function declared with a void parameter. (Thanks SharkBait)
  - Sending complex objects by value to class methods caused a crash on GNUC based compilers. (Thanks Torsten, a.k.a torsten_pf)
  - Passing objects by reference to constructors in declarations caused an assert failure. (Thanks Rain Dog)
- Script language
  - The script language now allows statements like: func(expr), where the function doesn't take any arguments and the expression evaluates to a void type. This is especially useful when using dynamically generating scripts where the expression type isn't known before hand.
  - Object variables and properties can be declared as const again
  - Properties of a const object are automatically const as well
  - When the object is const, the compiler doesn't allow non-const methods to be called
  - It is possible to take a handle for a const object, but it can only be assigned to a handle to a const object
  - The object held by a handle that is member of a const object, is not automatically const
  - An object handle that is member of a const object is also const
  - Const can be used for parameters again
- Virtual machine
  - The calling convention used by the script engine now passes the object pointer as the first parameter instead of the last.
  - GETOBJ was changed to read the offset from the stack instead of the address to the variable.
  - Added GETOBJREF and GETREF to handle parameter references.
  - Parameter references to overloaded operators are also protected by copying them to temporary variables.
  - Added SWAP48 and SWAP84 to swap two values of different bytesizes.
  - The compiler has been changed to output bytecode that don't keep unprotected pointers on the stack where they cannot be controlled. This will prove especially useful when I will later implement context serialization and co-routines.
  - Calling the constructors with arguments are now also protected by not pushing the object pointer on the stack before the arguments.
- Library interface
  - Implemented a C wrapper for the library. Compile the library with AS_C_INTERFACE to use it.
  - Added a dummy array in asUPtr to make the size equal on all compilers (even when the C++ interface is disabled)
  - Added SetLineCallback()/ClearLineCallback() to the context interface. These should be used instead of ExecuteStep() to control how much is executed each frame.
  - Added SetExceptionCallback()/ClearExceptionCallback() to the context interface. These methods can be used for debugging purposes and allow the application to examine the callstack when an exception is raised.
  - Added GetCallstackSize() and GetCallstackFunction() to the context interface.
  - Added the possibility to turn off support for registering class methods. Compile the library with AS_NO_CLASS_METHODS. This can be used on compilers where class methods don't currently work.
  - Added GetFunctionSection() to the engine interface.
  - ExecuteStep() is now a deprecated method. Use the line callback method instead, which is much more flexible.
  - Added GetCallstackLineNumber() to the context interface.
  - All methods that return line numbers can now optionally return column number as well.
  - Added the asCALL_GENERIC flag for functions using the generic calling convention.
  - Added a new asIScriptGeneric interface for handling generic functions.
  - Added GetObject() to the generic interface, that will return the object pointer when a method function using the generic calling convention is called.
  - Added GetArgDWord(), GetArgQWord(), GetArgFloat(), GetArgDouble(), and GetArgObject() to the generic interface.
  - Added SetReturnDWord(), SetReturnQWord(), SetReturnFloat(), SetReturnDouble(), and SetReturnObject() to the generic interface.
  - Added two new behaviours asBEHAVE_ALLOC and asBEHAVE_FREE, that can be used to register custom memory allocation functions for an object type.
  - Overloaded operators have been limited to only allow parameter references marked as 'in' (non-references are still allowed). This means that you cannot rely on that you receive a reference to the actual operand, as it might be a copy.
  - The extra call to addref/release for the object pointer when calling class methods has been removed. The responsibility of making sure the pointer is valid during the call has been moved to the application.
  - RegisterObjectType() now returns asALREADY_REGISTERED if name has already been registered as a type. (Suggestion by Adrian Licu)
  - It is now possible to declare object methods as const, so that they can be called for constant objects. Ex: "void GetVal() const"
  - Const overloading is now available for object behaviours and methods, i.e. if the object is const then the const version will be used, otherwise the non-const version will be used.
  - AddScriptSection() now has an extra parameter that can be used to tell the library not to make a copy of the script code, and instead use the original pointer directly. (Thanks Adrian Licu)
  - A new method ResetModule() was added to the engine. This can be used to reset the value of global variables for a module.
- Project
  - Added as_generic.cpp and as_generic.h with the interface for generic functions.
  - Removed the #include <memory.h> from the angelscript.h file.
  - Added as_c.cpp with the C wrapper functions.

## Version 2.0.0a - 2005/01/31

- Bug fixes
  - GetCurrentFunction() and GetExceptionFunction() didn't return the function ID with the module index, affecting applications that were using module bindings (Thanks Tomas Stepanek)
  - The library crashed when trying to register a function that used a handle to a type that had no addref/release behaviours registered (Thanks Adrian Licu)
  - It wasn't possible to return null in a function which return type is a handle (Thanks Adrian Licu)
  - Passing object handles by value to application functions could cause a crash (Thanks Adrian Licu)
  - Fixed a minor memory leak when RegisterGlobalFunction() failed.

## Version 2.0.0 - 2005/01/23

- Bug fixes
  - GNUC: Classes with destructors can now be sent by value to system functions
  - The compiler failed to successfully parse/compile temporary array constructors, e.g. int[](3).
  - On GCC/Linux all classes/structs are returned in memory regardless of size, complexity, or calling convention. (Thanks Fredrik Ehnbom)
  - Some compilers complained about the negative array size in the template code that is never instanciated. The code was commented.
  - Overloaded assignment operators that take types other than the target can now be used in initializations. (Thanks Alan Kemp)
  - asGetActiveContext() would cause an assert failure if called when no context was active. (Thanks Chee Chong Tay, a.k.a Iram)
  - It was not possible to register arrays of registered types. (Thanks Tomas Stepanek)
- Library interface
  - Removed deprecated functionality
  - Removed the flag asOBJ_GUESS for RegisterObjectType().
  - Removed the macros asFUNCTIONP() and asMETHODP().
  - Removed GetReturnValue()
  - Added GetReturnDWord(), GetReturnQWord(), GetReturnFloat(), GetReturnDouble(), and GetReturnObject()
  - Removed SetArguments()
  - Added SetArgDWord(), SetArgQWord(), SetArgFloat(), SetArgDouble(), SetArgObject()
  - Protected destructors have been added to the interfaces so that the application doesn't call them by mistake (thanks Dan "Aggrav8d" Royer)
  - Function declarations with arguments by ref must use the in, out, or inout flags
  - Added the behaviours ADDREF and RELEASE that will be used by object handles to do memory management
  - New context state: asEXECUTION_ERROR, that is set if one of the SetArg...() functions failed.
- Script language
  - Removed the pointer type modifier
  - Removed the -> operator
  - In declarations the array brackets are now part of the type, i.e. for "int[] a, b;" both a and b are arrays
  - Arrays can now be resized by using the method resize().
  - Parameter references are now protected by copying the value into a temporary variable when calling the function, and then copying the temporary variable back to the original location when the function returns. The expression is computed twice for in/out references.
  - Function parameters by reference should use the flags in, out, or inout to allow the compiler to optimize the use of the parameters.
  - Added the object handle type modifier so that object handles can be declared. The token @ is used so as not to confuse it with C++ pointers or references.
  - Added the null keyword for object handles.
  - const is now only available for variable and property declarations, and only for primitive types. This change was made for consistency and because the script language was not able to guarantee that an object isn't changed by object methods.
  - Arrays have been limited to only allow four dimensions
- Virtual machine
  - Removed the bytecode ADDOFF
  - Objects are stored in dynamically allocated memory. A pointer to the memory is stored on the stack
  - Created ALLOC/FREE instructions for allocating and freeing the objects
  - Objects are returned in a register
  - Created LOADOBJ/STOREOBJ that moves an object pointer from a variable into the object register, and vice versa
  - Created GETOBJ which moves an object pointer from a reference to the stack, overwriting the reference
  - Removed END and PEID.
  - Simplified the exception handler to free objects based only on their position on the stack
  - A script function receives an object by value and by ref the same way. The difference is if the function is the owner of the object or not.
  - Added REFCPY to support reference assignments for object handles
  - Added CHKREF to validate object handles when used as normal objects
  - Added the bytecodes RD1 and RD2 to fix alignment problems on CPUs that requires data to be aligned.
  - The VM keeps a reference to the object when calling a method, to protect the object from being released before the method returns.
- Library
  - The library was made to work with Dreamcast once more. (Thanks Fredrik Ehnbom)
  - The compile time flag BUILD_WITH_LINE_CUES was replaced with BUILD_WITHOUT_LINE_CUES. This flag is not defined by default making ExecuteStep() work as specified, but for those that do not use this function the performance may be increased a little by specifying this flag when compiling the library.