AngelScript Changes

This page presents changes that have been done each release of AngelScript.

See the changes for release 2.x.x, 1.x.x, and 0.x.x.

You may also want to check out the upcoming changes in the work-in-progress version.

Version 2.37.0 - 2024/07/20

• Bug fixes
  • thiscall method with multiple inheritances was not working properly with composite offset (Thanks Denis Naumov)
  • Fixed compiling the library with AS_NO_CLASS_METHODS (Thanks gris)
  • Fixed exception handling not restoring stack pointer in some cases, leading to buffer overflow and crashes after repetition (Thanks Miss)
  • Fixed problem with parsing non-terminated heredoc strings (Thanks Jason Goepel)
  • Fixed assert failure on invalid expression with assignment (Thanks xertrov)
  • Fixed assert failure on warning in function argument with ternary operator (Thanks xertrov)
  • Fixed crash in asIScriptContext::GetArgsOnStackCount when using unsafe references (Thanks glcolor)
  • Fixed bug in IsVarInScope that wouldn't identify an object variable declared just after a } as being in scope (Thanks Jason Goepel)
  • Fixed problem with funtion overload between Obj@ and const Obj@ (Thanks Patrick Jeeves)
  • Fixed bug in compiler that allowed passing string literal to function as non-const references with unsafe references turned on (Thanks Raphtaliyah)
  • Fixed bug in native calling convention for arm64 with ?& arguments (Thanks Alexander Orefkov)
  • Fixed crash if passing negative value to GetTypeInfoById
  • asCDataType::GetSizeInMemoryBytes was not returning the correct size of handles (Thanks Rob McDonald)
  • Fixed crash when attempting to use init list with enum type (Thanks Miss)
  • Fixed assert failure on passing anonymous init list to function argument expecting a handle (Thanks xertrov)
  • Registered copy factories were not properly identified as copy factories if the parameter used &inout instead of &in
  • Fixed GetLineNumber that could randomly return the last line number of a function if called between Prepare and Execute (Thanks Sam Tupy)
  • Fixed support for returning structs with 2 doubles in native calling conventions on arm64 (Thanks Sam Tupy)
  • Fixed a bug in bytecode serializer that could cause errors if composite properties were used (Thanks tomek0055)
• Library
  • Added configuration to support native calling conventions on Android with 64bit x86 CPU (Thanks 1vanK)
  • Added engine property to disable garbage collection for script classes (Thanks 1vanK)
  • Improved runtime performance by reducing overhead in script function calls (Thanks Denis Naumov)
  • It is now possible to register factory functions receiving an auxiliary pointer with asCALL_CDECL_OBJLAST/OBJFIRST (Thanks Salvage)
  • Improved runtime performance with gnuc or clang compilers by using computed goto extension (Thanks Patrick Jeeves)
  • as_config.h now has configuration to detect Linux with RISC-V 64bit CPU (Thanks Vixea 0)
  • asEP_ALWAYS_IMPL_DEFAULT_COPY can be set to 1 to tell compiler to always implement default copy even if other opAssign is declared
  • asEP_ALWAYS_IMPL_DEFAULT_COPY_CONSTRUCT can be set to 1 to tell compiler not to always implement default copy constructor even if other copy constructor is declared
  • asEP_ALWAYS_IMPL_DEFAULT_CONSTRUCT, DEFAULT_COPY, and DEFAULT_COPY_CONSTRUCT can now be set to 2 to tell compiler never to implement these
  • A new flag asOBJ_APP_CLASS_UNION is added to inform when a registered class contains unions, needed for Risc-V native ABI
• Library interface
  • Added GetLastFunctionId to the engine, so it is possible to iterate over all functions with GetFunctionById
  • Introduced a new JIT compiler interface asIJITCompilerV2, use asEP_JIT_INTERFACE_VERSION to set which should be used (Thanks Denis Naumov)
  • The new JIT compiler interface can use SetJITFunction to set the JIT compiled function at a later time, to allow better optimizations (Thanks Denis Naumov)
  • Added asIScriptFunction::GetDeclaredAt
  • RegisterObjectType now takes a qword for the flags to make room for asOBJ_APP_CLASS_UNION
  • asITypeInfo::GetFlags also returns a qword to make room for asOBJ_APP_CLASS_UNION
• Script language
  • A default copy opAssign method is provided for script classes if none has been explicitly defined
  • A default copy constructor is provided for script classes unless another copy constructor is explicitly defined (Thanks Patrick Jeeves)
  • An implicit conversion to primitive of same type by different size takes precedent over change in sign in function matching
  • It is now possible to explicitly delete auto generated constructor, copy constructor, and copy operator if they are not wanted
  • Templates can now be instantiated with const sub types (Thanks tomek0055)
• Add-ons & Samples
  • Added thread safety for creating the string factory singleton (Thanks Igor Green)
  • filesystem now replaces backslashes for forward slashes in the file path
  • Fixed compiler warnings in script array with MinGW (Thanks Jordon Moss)
  • Added auto wrappers WRAP_MFN_GLOBAL(_PR) for class methods that will be used as global functions (Thanks a-k-)
  • Script builder now supports including files with international characters on Windows (Thanks Remy Stivani)
• Project
  • Added support for native calling conventions on Linux with Risc-V 64bit CPU (Thanks Vixea 0)
  • Added support for native calling conventions on Apple OS's with M1/M2 CPUs (Thanks Sam Tupy)

Version 2.36.1 - 2023/05/21

• Bug fixes
  • Fixed assert failure with void expression in initialization list (Thanks chipsTM)
  • Fixed assert failure with unsafe references turned on and temporary copy of value in function call (Thanks Polyak Istvan)
  • Fixed crash when doing handle assign from object handle received by reference parameter (Thanks Miss)
  • Fixed error in compiler with unsafe references turned on and destruction of temporary variables in boolean expressions (Thanks Polyak Istvan)
  • Fixed crash when passing null to a ?&inout param with unsafe references turned on (Thanks donadigo)
  • Fixed assert failure when compiling switch case with registered global const property
  • Fixed error in parser with default array and initialization lists
  • Fixed crash in compiler when same funcdef declaration is compiled multiple times in different modules (Thanks Alexander Orefkov)
  • Fixed lookup bug with use of partial namespace in scope when already within a namespace (Thanks xertrov)
  • Fixed assert failure in compiler when class has invalid opCast method with parameters (Thanks Patrick Jeeves)
  • Parser failed to understand lambda functions with explicit argument types with &in, &out, or &inout (Thanks Patrick Jeeves)
  • Fixed bug with use of default array on types without default constructors (Thanks Patrick Jeeves)
  • Fixed bug with named args and construct calls (Thanks Patrick Jeeves)
  • Fixed bug with variables declared in for loop being seen as in-scope by debugger after the loop ended (Thanks gmp3 labs)
  • Fixed name conflict error for lambdas being rebuilt multiple times with CompileFunction (Thanks gmp3 labs)
  • Fixed assert failure when explicitly casting anonymous init list to an object (Thanks xertrov)
  • Fixed assert failure on bitwise operation with boolean value (Thanks Miss)
  • Fixed issue in compiler with unsafe references enabled and &out parameters (Thanks Dragonstorm97)
  • Compiler now gives proper error when using temporary object for lvalue in assignment
  • BindImportedFunction was not giving error when attempting to bind class method (Thanks Denis Naumov)
  • Fixed bug in save bytecode when there were multiple variables in different scope occupying the same stack position (Thanks Sam Tupy)
  • Fixed bug in as_callfunc_x64_gcc.cpp when compiling with optimizations on gnuc (Thanks Patrick Jeeves)
  • Fixed bug in compiler with compound assignment, virtual property, and unsafe references (Thanks Sam Tupy)
  • Saved bytecode didn't store the 'property' function trait (Thanks Sam Tupy)
  • Fixed crash with template instance referred by other template instance being deleted prematurely (Thanks Polyak Istvan)
  • Fixed specialization of templates with multiple subtypes (Thanks Stefan Blumer)
• Library
  • Improved the error message when a boolean expression is required to inform the type that was given (Thanks Solokiller)
  • Improved error message when delegate object cannot be created (Thanks Patrick Jeeves)
• Script language
  • Compiler now recognizes when switch cases have return in all paths (Thanks alpines)
  • Anonymous functions can now be declared with nameless arguments (Thanks Patrick Jeeves)
• Add-ons & Samples
  • Improved error message when array cannot be instantiated due to subtype not having any default constructor (Thanks Patrick Jeeves)
  • Operations with strings and primitives can now be easily disabled by compiling the add-on with AS_NO_IMPL_OPS_WITH_STRING_AND_PRIMITIVE=1 (Thanks Solokiller)
  • ScriptBuilder no longer accepts #include directives with non-terminated strings for the filename
  • The serializer add-on is now capable of restoring objects only referenced from handles (Thanks Varrok)
  • Fixed compiler warnings on deprecated sprintf in scriptarray and scriptstdstring with xcode (Thanks ramcdona)
• Project
  • Fixed cmake project for compiling on apple arm64 (Thanks David Carlier)
  • Changed the cmake project to allow it to be included in other projects directly (Thanks Solokiller)

Version 2.36.0 - 2022/09/25

• Bug fixes
  • Fixed 32bit/64bit compatibility of saved bytecode with unsafe references enabled (Thanks Alexander Orefkov)
  • Fixed 32bit/64bit compatibility of saved bytecode in functions returning handles (Thanks Alexander Orefkov)
  • Destructor for template value types now get a unique function with correct object type (Thanks Miss)
  • Fixed crash in compiler when compiling initialization lists for a global variable with a higher index than 2^15 (Thanks Miss)
  • Fixed crash that could happen on cleaning up stack when unsafe references is used (Thanks Polyak Istvan)
  • Fixed crash in context stack unwind if it happened at a position after a branch return that returns a value object by value (Thanks Miss)
  • Fixed GetAddressOfVar returning null for registered value pod types without constructor (Thanks mghughes)
  • Fixed GetAddressOfVar returning null for registered value types when the same offset is shared in multiple scopes (Thanks Alexander Orefkov)
  • asIScriptEngine::AssignScriptObject didn't return any error when a type didn't have a value assignment operator
  • Fixed assert failure when two funcdefs with same name in two different classes (Thanks chipsTM)
• Script language
  • Improved implicit conversion rules to reduce number of type ambiguity errors for function overloads and ternary operators (Thanks Violet CLM)
  • Ternary condition will now return the result as handle if possible to avoid unnecessary copy of objects (Thanks Violet CLM)
• Library
  • Added engine property asEP_IGNORE_DUPLICATE_SHARED_INTF to add backwards compatibility with 2.35.0 when scripts include declaration of shared interfaces more than once (Thanks Violet CLM)
  • Compiler now stores info on temporary variables too to allow these to be inspected at runtime
  • Added engine property to dynamically turn off debug output
  • When asEP_ALLOW_UNSAFE_REFERENCES is turned on the destruction of temporary objects will be deferred to end of expressions (Thanks Alexander Orefkov)
• Library interface
  • asIScriptContext::GetAddressOfVar now supports returning the address of a reference parameter without dereferencing it
  • asIScriptContext::GetAddressOfVar now supports returning the address of local value types even when not initialized yet
  • Added asIScriptContext::GetVar to retrieve static information on variables on the stack
  • Deprecated asIScriptContext::GetVarName and GetVarTypeId
  • asIScriptContext has new methods to support serialization of context state (Thanks Patrick Jeeves)
• Add-ons & Samples
  • Fixed script array comparison for 64bit integers (Thanks Violet CLM)
  • CScriptArray with CScriptHandle as sub type can now be correctly copied (Thanks Cyprinus Carpio)
  • CScriptArray::SetValue now works with CScriptHandle as sub type (Thanks Cyprinus Carpio)
  • Fixed a compatibility issue in autowrapper WRAP_MFN_PR on clang compilers (Thanks ramcdona)
• Project
  • Added support for Linux with arm64 in gnuc project (Thanks Aracadian)
  • Added MSVC2022 project files

Version 2.35.1 - 2021/09/27

• Bug fixes
  • Fixed invalid bytecode sequence on calling method on explicit temporary object of value type (Thanks Alexander Orefkov)
  • Fixed freeze in compiler when compiling script that declared the same interface twice and inherited from another (Thanks Jarrett Chisholm)
  • Fixed a problem with lambdas declared within shared functions not being considered shared (Thanks Phong Ba)
  • Fixed invalid bytecode sequence on creating a delegate from a lambda (Thanks Phong Ba)
  • Declaring arrays using the type[] syntax will now properly add implicit handle for the type when needed (Thanks Quentin Cosendey)
  • Fixed crash if attempting to call CreateScriptObjectCopy with an asITypeInfo for a script function (Thanks HoShiMin)
  • Fixed error in compilation of ternary condition operator with regards to deferred arguments (Thanks Polyák István)
  • Fixed compilation error in C++Builder with older compiler (Thanks Savas Savvides)
  • Added more sanity checks in LoadByteCode to avoid crash on invalid stream data (Thanks LeonMrBonnie)
  • Compiler didn't give an error on declaring mixin classes abstract or external (Thanks Dantrell B)
  • Fixed crash when instantiating shared class after original module was discarded (Thanks Miss)
  • Fixed problem on 64bit platforms with unsafe references and value types smaller than 8 bytes (Thanks Polyak Istvan)
  • Fixed assert failure in compiler on implicit conversion between unsigned integer types of different sizes (Thanks Miss)
  • Fixed invalid bytecode sequence in initialization lists with value types whose opAssign returns void (Thanks jiandingzhe)
  • Fixed registering asBEHAVE_LIST_CONSTRUCT on value type templates (Thanks Suedwest)
  • Fixed compiler error in as_symboltable.h on GCC 11 (Thanks shirubax)
  • Compiler no longer silently accepts implicit conversion from null handle to object type registered with ASHANDLE if there is no matching implicit constructor (Thanks Patrick Jeeves)
  • Fixed problem in native calling convention on arm64 when function returned a reference to a class with asOBJ_APP_CLASS_ALLFLOATS (Thanks Max Waine)
• Library
  • Library can be compiled without C++11 support again (Thanks BaiYang)
  • Added config and cmake changes to make the library buildable for Mac M1 (Thanks David Carlier)
  • asIScriptModule::CompileFunction now also invokes JIT compiler if set (Thanks gjl)
  • asIScriptModule::GetImportedFunctionDeclaration now includes the namespace (Thanks Phong Ba)
  • asITypeInfo::GetFactoryByDecl now matches the factory even if the informed function name is different (Thanks Yauheni Akhotnikau)
  • Added configuration in as_config.h to support native calling conventions on Android with arm64 (Thanks Alexander Oganesyan)
  • Added configuration in as_config.h to support native calling conventions on Nintendo Switch (Thanks Max Waine)
• Script language
  • Ternary condition operator is now able to implicitly convert the types in the expressions to a common type (Thanks _Vicious_)
  • Declarations of shorthand nested namespaces is now supported (Thanks Stefan Koch)
• Virtual machine
  • Changed asBC_REFCPY and asBC_RefCpyV to avoid reading from uninitialized memory when used for value types
  • asBC_CallPtr is now able to work with imported functions too (Thanks Phong Ba)
• Add-ons & Samples
  • Fixed compilation errors in asrun sample on non-Windows platforms (Thanks Steve Schow)
  • Fixed compilation error in filesystem add-on on Linux (Thanks Wipe)
  • Fixed datetime add-on to properly handle timezones with day-light-savings in a portable way (Thanks Wipe)
  • Added gnuc makefile for asrun sample
  • Added generic calling convention bindings for script exception routines add-on (Thanks gjl)
  • Fixed problem in script builder that caused it to fail to recognize meta data on members of shared classes (Thanks noizex)
  • Script builder can now gather meta data on members of interfaces too
  • Fixed WRAP_MFN_PR when used with method without overload in derived class on MSVC (Thanks 1vanK)
  • Script builder now removes lines starting with #! to support shebang interpreter directives
  • Fixed the samples concurrent and events on Linux (Thanks Dantrell B)
  • Fixed WRAP_MFN on gnuc when used within templated functions (Thanks vballDrummer)
  • Fixed issue in array::sort with callback that could cause objects in the array to be destroyed by gc (Thanks Miss)
  • weakref now has its constructor that takes a handle marked as explicit
• Project
  • Added support for arm64 in meson project (Thanks Guillaume Gardet)

Version 2.35.0 - 2020/12/05

• Bug fixes
  • asIScriptModule::GetGlobalVar was returning asSUCCESS when the given index was out of range
  • Compiler would give an error when compiling functions returning a reference to a type that cannot be instantiated
  • Fixed problem with LoadByteCode and shared classes (Thanks MrFloat)
  • Fixed crash when using copy constructor declared as taking the object by value (Thanks Miss)
  • Fixed memory invasion in compiler when compiling initialization lists with expressions using default arguments (Thanks jsd1982)
  • Fixed memory invasion in compiler when compiling default arguments
  • Fixed an issue in compiler with auto type and constness (Thanks Polyák István)
  • Fixed symbol lookup of child type from within class method while compiling a construct call (Thanks Polyák István)
  • Fixed crash after a discarding a module that compiled a shared object type that continues to be used by other modules (Thanks MrFloat)
  • Funcdefs are marked with asOBJ_GC as they can form circular references when used with delegates (Thanks cmann)
  • Fixed memory leak when using CompileGlobalVar to add a variable to a module with an object type (Thanks gmp3)
  • Fixed error when loading bytecode that is using a list constructor for a value type (Thanks Phong Ba)
  • Fixed memory invasion in compiler when compiling default argument after an argument with index operator (Thanks Phong Ba)
• Library
  • asIScriptModule::GetFunctionByName now supports informing the scope in the name (Thanks Boost113)
  • asIScriptModule::GetGlobalVarByName and GetTypeInfoByName also support informing the scope in the name
  • asIScriptEngine::GetTypeInfoByName and GetGlobalPropertyIndexByName also support informing the scope in the name
  • The default opAssign implementation for script classes will use the base class' opAssign method to copy inherited properties (Thanks hiago desena)
  • Added config for 64bit x86 CPU on Haiku OS (Thanks Panagiotis Vasilopoulos)
  • Added flag asOBJ_APP_CLASS_MORE_CONSTRUCTORS to inform when a class with defaulted constructors has additional non-trivial constructors (Thanks Miss)
  • Added support for native calling conventions on Linux with ARM64 (Thanks Max Waine)
  • Minor code changes to make the library buildable on DragonFly BSD (Thanks David Carlier)
  • Improved time for compilation and loading pre-compiled bytecode for scripts with lots of type definitions (Thanks Len Deuel)
  • Added config to make the library buildable for Linux with Elbrus 2000 CPU (Thanks Sattarov Ramil)
• Library interface
  • asIScriptObject::CopyFrom now takes a const pointer
  • RegisterGlobalProperty and RegisterObjectProperty now return the index of the property upon success (Thanks Marc Oude Kotte)
• Virtual machine
  • asBC_Thiscall1 bytecode instruction is now capable of catching and translating C++ exceptions to script exceptions (Thanks Quentin Cosendey)
• Add-ons & Samples
  • Implemented to-string debug callback for datetime in asrun
  • Fixed a problem due to daylight time when initializing a datetime object with specific date
  • debugger add-on handles incorrect user commands better
  • Implemented a version of exec for asrun sample that captures the standard output from the system command into a string
  • Implemented getCreateDateTime and getModifyDateTime on the filesystem add-on
  • Improved performance on array sort for arrays holding object types
  • Fixed registration of the virtual property accessors in the game sample (Thanks Marc Oude Kotte)
  • Fixed compilation error in scriptstdstring.cpp with AS_USE_NAMESPACE (Thanks Wipe)
  • Added mingw makefile for console sample
  • Registered the script array add-on in the console sample
  • Added generic calling convention bindings for datetime and filesystem add-ons (Thanks gjl)
• Project
  • Added option to the cmake project to allow linking statically with CRT on MSVC (Thanks Ilya)
  • Added MSVC2019 project files
  • Fixed cmake project for MSVC2019 (Thanks Wipe)
  • Fixed gnuc makefile to detect arm target and add a compiler flag to accept implicit IT constructs in thumb mode (Thanks Maya Posch)

Version 2.34.0 - 2019/09/22

• Bug fixes
  • Fixed problem in compiler with bool property returned as reference in conditions (Thanks Miss)
  • Fixed problem with catching exceptions in functions with multiple try-catch blocks (Thanks johannesg)
  • Fixed read from unallocated memory in compiler when compiling default args (Thanks Patrick Jeeves)
  • Fixed problem with doing a value assign from array holding handles (Thanks Aaron Baker)
  • Fixed crash in compiler when there are multiple matching global functions for set accessors (Thanks Aaron Baker)
  • Fixed crash that could happen when loading bytecode with shared classes that doesn't match current declared shared classes (Thanks MrFloat)
  • Fixed assert failure when compiling a construct call with an anonymous initialization list (Thanks perost86)
  • Fixed incorrect bytecode sequence when doing value assignment from handles for script classes using default assignment operator (Thanks Aaron Baker)
  • Fixed problem with default arg not being able to access members in expression (Thanks Aaron Baker)
  • Fixed crash when releasing engine with template specialization containing child funcdefs (Thanks BertS)
  • Fixed asCALL_THISCALL_ASGLOBAL to function correctly with multiple inheritance (Thanks stalker#3829)
  • Compiler now identifies match for functions taking object as inout ref when passing anonymous init list (Thanks Max Waine)
  • Compiler now interrupts compilation after identifying error while compiling use of get property accessor (Thanks Patric Jeeves)
  • Compiler no longer identifies global script functions as property accessors when this is turned off with asEP_PROPERTY_ACCESSOR_MODE (Thanks Aaron Baker)
  • Fixed config for FreeBSD on non-x86 64bit targets (Thanks Greg V)
• Library
  • asEP_PROPERTY_ACCESSOR_MODE has a new mode (3) to require property accessors to be flagged with 'property'
  • Property accessors are validated upon declaration when flagged with 'property'
  • asEP_PROPERTY_ACCESSOR_MODE is now set to 3 by default
• Script language
  • Handles can now be declared read-only (Thanks Max Waine)
  • Functions and methods intended to be used as virtual property should now be declared with a 'property' decorator
  • Added non-reserved keyword 'property'
• Library interface
  • Added asIScriptFunction::IsProperty
• Add-ons & Samples
  • Removed an invalid assert() statement in ExecuteString (Thanks Pto)
  • Debugger commands 'n' and 'o' no longer prints 'No script is running' when used as first command
  • Debugger command 'p' prints 'Invalid expression. No matching symbol' when the symbol doesn't exist in the current context
  • Fixed missing check for failed memory allocation in CScriptArray::Precache (Thanks Zelerin)
  • The string factory in the std::string add-on is now thread safe
  • Enabled Virtual Terminal Processing in asrun for colored text on Windows console

Version 2.33.0 - 2018/12/22

• Bug fixes
  • Fixed crash when compiling is null comparison with ASHANDLE object without any opEquals operator (Thanks Boost113)
  • Fixed bug with anonymous initialization lists when used to initialize value type passed by value to function (Thanks Patrick Jeeves)
  • Loading bytecode that included use of template value types with a template type as argument crashed
  • Compiler would crash on compiling ternary operator with anonymous list in one of the conditions (Thanks doctorgester)
  • Fixed error when saving bytecode for scripts containing interfaces that derives from interfaces (Thanks y18a)
  • Saving bytecode for a never returning function would cause assert failure (Thanks y18a)
  • Fixed an error when compiling a class method call as post-op and the name matches a type name (Thanks y18a)
  • Template types are now properly identified in separate namespaces (Thanks ASBai)
  • Fixed memory build-up due to delayed cleanup when discarding modules with shared entities (Thanks y18a)
  • opImplCast with variable type won't be used for non-ref types
  • Fixed compiler error when both opConv and opImplConv are implemented (Thanks Ali Gerami)
  • Fixed bug when loading bytecode containing shared interfaces with inheritance (Thanks Zakhar)
  • auto declarations now works correctly with implicit handle types (Thanks y18a)
  • Initializing an ASHANDLE type with overloaded opHndlAssign taking a var type as a handle wasn't done correctly
  • Fixed loading byte code that uses external shared classes in namespace (Thanks y18a)
  • The bytecode for external shared entities is no longer saved in the module when inherited from (Thanks y18a)
  • Bytecode with external shared classes with virtual methods failed to load from bytecode (Thanks y18a)
  • Fixed assert failure on call to opCast(?&out) with a non-variable expression (Thanks Miss)
  • Passing a string literal to function expecting &out will now give compiler error (Thanks Jordan Verner)
  • Fixed problem in compiler that didn't release a temporary variable when passing anonymous object to function expecting ?&in (Thanks y18a)
  • Fixed a bug when loading bytecode having identical shared functions in different namespaces (Thanks y18a)
  • Compiler will now detect name conflict between property and function
  • asIScriptFunction::GetDeclaration(false, true) no longer includes the namespace before the function name for class methods (Thanks IronHawk)
  • Fixed assert failure in asIScriptEngine::RefCastObject when object has multiple opCast methods (Thanks gjl)
  • Compiler no longer accepts primitives in the right hand expression for handle assignments (Thanks gjl)
  • Fixed compiler warning with use of asOFFSET on 64bit platforms (Thanks Miss)
  • Fixed crash caused by CreateScriptObjectCopy when script class' constructor takes argument by handle (Thanks Boost113)
  • Child funcdefs in templates will no longer convert parameter types to @const& (Thanks Dinkleberg)
  • Fixed problem when compiling anonymous initialization list from default arg (Thanks Dinkleberg)
  • Ownership of shared template instances wasn't correctly transferred when discarding modules (Thanks Jason Goepel)
  • Fixed crash in compiler when matching anonymous list to function taking funcdef (Thanks Miss)
  • Fixed assert failure in builder when compiling external shared interfaces with inheritance (Thanks Chisser98)
  • Fixed crash in compiler when invalid script has inheritance from class with duplicate methods (Thanks Miss)
• Library
  • Changed the compiler to do less copies of objects and especially string constants
  • Engine error messages now include the symbol name for the error code for easier interpretation
  • All methods for template instances now get unique functions to show the template instance as the object type (Thanks Miss)
  • Template types can now be registered with methods taking parameters as &inout (Thanks ASBai)
  • Implemented engine property asEP_GENERIC_CALL_MODE to make the generic calling convention treat handles the same way that the native calling convention do
  • By default asEP_GENERIC_CALL_MODE is set to use the new behaviour
  • Registered value types can now register GC behaviours to solve circular references involving these types
  • Reduced the size of the saved byte code, especially when there are lots of functions without parameters
  • AssignScriptObject will now set a script exception for ref types if asEP_DISALLOW_VALUE_ASSIGN_FOR_REF_TYPE is used
  • The copy constructor of script classes are now used properly by the compiler (Thanks MrFloat)
  • Refactored how he compiler does symbol lookups to better handle namespace hierarchies and child types. (Thanks y18a)
  • Added engine property asEP_INIT_STACK_SIZE to set the initial data stack size for contexts (Thanks Karoly Pinter)
  • Added engine properties asEP_INIT_CALL_STACK_SIZE and asEP_MAX_CALL_STACK_SIZE to set initial and max call stack size for nested calls (Thanks Karoly Pinter)
  • asIScriptContext::PushState will return an error if the call stack is already too big
  • context's GetExceptionString, GetExceptionFunction, GetExceptionLineNumber will now return the last exception even if it has been caught
  • CreateScriptObject no longer writes to the message callback if the object type doesn't have constructor/factory
• Library interface
  • Implemented a callback to allow application to translate C++ exceptions thrown by registered functions (Thanks Boost113)
  • Added the engine methods ForwardGCEnumReferences and ForwardGCReleaseAllReferences
  • Included SetCircularRefDetectedCallback to allow application developers to easier identify the origin of circular references (Thanks baiyang)
  • SetException now has an optional argument to allow exception to be caught or not
  • Added WillExceptionBeCaught that the exception callback can use while inspecting the exception
  • Added IsExplicit to asIScriptFunction
• Script language
  • Now it is possible to resolve ambiguity with lambda functions by explicitly specifying the parameter types (Thanks Miss)
  • The compiler will now give an error on bitwise operator with floats instead of silently converting to integer (Thanks Jason Goepel)
  • Class constructors can now be declared with private and protected too (Thanks noizex)
  • The correct resolution is now done for types implementing both opCast and opImplCast and the const overloads. The same for opConv and opImplConv
  • Initialization lists will implicitly assume objects by handle if asEP_DISALLOW_VALUE_ASSIGN_FOR_REF_TYPE is used (Thanks y18a)
  • When unsafe references is allowed the stream operator (<<) can now be implemented on value types with correct behaviour for chained expressions (Thanks ASBai)
  • Virtual property accessors must not have the same name as real property or function in the same scope
  • Namespace and class with the same name must not have name conflicts between members as it would cause ambiguity in the symbol lookup (Thanks Phong Ba)
  • Added support for try/catch statements
  • Implemented support for flagging constructors as explicit
  • Factories for ref types with only one argument can now be used for implicit type conversion too
  • 'auto' declarations will now always prefer handle if the type allows it (Thanks Miss)
• Virtual machine
  • The asBC_REFCPY and asBC_RefCpyV instructions can now be used with value types too
• Add-ons & Samples
  • Added the methods isLink and getSize to filesystem add-on
  • Added methods setDate and setTime to datetime add-on and operators to add seconds, compare, and determine difference in seconds
  • The asrun sample now waits for user input before closing on any error when executed from file explorer on Windows
  • filesystem's changeCurrentPath doesn't modify anything if the new path is invalid
  • Implemented the methods makeDir, removeDir, deleteFile, copyFile, and move on the filesystem add-on
  • Changed the clean-up of the string factory in the stdstring add-on to avoid crash if the script engine is stored in global singleton (Thanks howie_007)
  • Fixed incorrect use of setlocale in parseFloat (Thanks Miss)
  • Implemented a #pragma callback in the builder add-on
  • asrun can now turn on debugging with #pragma debug (works the same as -d command arg)
  • Fixed crash in debugger add-on when printing call stack in template function
  • weakref now properly identifies different object instance when the address is the same as the previously freed object (Thanks y18a)
  • meta data is now correctly extracted for class methods with decorators (Thanks Patrick Jeeves)
  • CScriptBuilder now supports having multiple meta data blocks for each entity (Thanks noizex)
  • CScriptHandle registers the ENUMREFS and RELEASEREFS gc behaviours
  • CScriptArray, CScriptDictionary, CScriptGrid, and CScriptAny now support forwarding gc enum callbacks to value types with gc behaviour
  • The array's and string's length property accessors is now only registered if AS_USE_ACCESSORS is defined to avoid conflict with the length() method
  • Implemented the functions throw() and getExceptionInfo() that can be registered with RegisterExceptionRoutines
  • dictionary add-on is better prepared to work with string type registered as reference type (Thanks Wracky)
  • dictionary get method didn't always return true/false to indicate success or failure (Thanks Miss)
  • Fixed a problem in filesystem's CopyFile on non-Windows platforms (Thanks cvet)
  • Fixed string's findLastNotOf
  • The datetime add-on now has a constructor to initialize date and time directly
  • dictionary raises script exception if it cannot create a copy of a value being assigned
  • array::less will now take const handles when T is a handle
• Project
  • Updated the cmake project for better usability (Thanks Solokiller)
  • Added MSVC 2017 projects

Version 2.32.0 - 2017/12/16

• Bug fixes
  • Registered funcdefs can now be used by shared script functions (Thanks Sir Ementaler)
  • Fixed compiler error on MSVC2008 due to missing stdint.h (Thanks Friggle)
  • Fixed a problem where the use of a get accessor could incorrectly reuse temporary variables (Thanks Phong Ba)
  • Fixed the symbol search order so class name with same name as type is properly handled (Thanks Ansjh)
  • Fixed compiler error in asFUNCTIONPR on MSVC2017 (Thanks Farbod)
  • Fixed problem that could happen when saving bytecode that used shared functions (Thanks Phong Ba)
  • Fixed problem with calling function expecting @&in where the argument was itself a & argument (Thanks Alexander Orefkov)
  • Fixed crash when compiling expression using opIndex property accessor without arguments (Thanks Aaron Baker)
  • Fixed compiler warning in assert (Thanks David Binderman)
  • Fixed a couple of bugs on platforms with 4 byte booleans (Thanks Joseph Tilley)
  • Fixed bug in parser that would produce misleading error message on invalid code (Thanks Kirill Artemov)
  • Fixed assert failure when compiling ref cast and multiple matching cast operators are found (Thanks Jordan Verner)
  • Template instances now correctly replaces child funcdefs
  • Fixed bug where compiler didn't allow default arguments to be name of global functions (Thanks Aaron Baker)
  • as_callfunc_x64_gcc.cpp now compiles correctly with address sanitize on g++ 5 (Thanks a light breeze)
  • Fixed memory leak in RemoveGlobalProperty as the property wasn't uninitialized before it was removed (Thanks Quentin Cosendey)
  • Fixed bug in compiler that would in complex expressions overwrite a temporary variable before it was used (Thanks Aaron Baker)
  • Handles received by reference is now properly treated when passed to function expecting variant type (Thanks Quentin Cosendey)
  • Fixed compiler error in derecated IsHandleCompatibleWithObject when using AS_DEPRECATED (Thanks Asu)
  • Fixed assert failure when compiling comparison expressions with primitives smaller than 32bit (Thanks Asu)
  • Fixed crash in compiler when compiling type conversion with invalid use of named arguments (Thanks Adrian Bibby Walther)
  • Fixed assert failure when compiling expression with anonymous initialization list (Thanks Patrick Jeeves)
  • Explicitly creating a copy of a const object to get a non-const handle would give a compiler error
  • Value type without opAssign but with a copy constructor can now be implicitly copied in type conversions
  • Saved byte code with scripts that used child funcdefs couldn't be loaded (Thanks Quentin Cosendey)
  • Compiler was allowing to pass a const object by reference to a parameter expecting a non-const when using unsafe references
  • Fixed buffer overflow when formatting error message with very long tokens
  • RefCastObject was allowing explicit cast from base class to derived class even though the true type was of the base class (Thanks Miss)
• Library interface
  • RegisterFuncdef, RegisterInterface, RegisterTypedef, RegisterEnum now returns the type id on success
  • Added asEP_MAX_NESTED_CALLS to control the maximum number of nested calls that should be allowed
  • Both Read and Write in asIBinaryStream can now return an error code to signal failure
  • Added a new interface asIStringFactory to allow the application to hold the string constants in native format
  • The RegisterStringFactory now takes a pointer to asIStringFactory instead of a function callback
  • Removed deprecated code from previous versions
  • Added support for registering class methods for composite objects without wrappers (Thanks Patrick Jeeves)
  • Object properties can also be registered for composite objects
• Library
  • Handles explicitly initialized with null in declarations no longer produce any bytecode (Thanks Solokiller)
  • Saved bytecode now takes advantage of shared entities declared as external and includes less bytes
  • The VM now raises an exception when application performs too many nested calls (Thanks Jordan Verner)
  • Improved compiler error message when identifier before parenthesis doesn't evaluate to a function (Thanks Patrick Jeeves)
  • Objects that rely on asGetActiveContext during clean-up can now do so even during exception handling
  • String constants are now evaluated at compile time and a pointer to the application native format is kept in the bytecode
• Virtual machine
  • The asBC_STR instruction no longer has any use and will be deprecated
• Script language
  • Added the keyword 'external'
  • shared enum can now be declared as external to explicitly include a shared enum from previously compiled module
  • shared interfaces, classes, functions, and funcdefs can also be declared as external
  • funcdefs can now be explicitly declared as shared
  • Implemented support for typeless anonymous initialization lists (Thanks Patrick Jeeves)
  • The compiler will implicitly convert string literals to local variables if a non-const reference is needed
• Add-ons
  • Fixed bug in CScriptArray::RemoveRange (Thanks Michael Cohen)
  • ScriptBuilder add-on now support metadata for enums too
  • ScriptBuilder add-on properly handles 'external' and 'shared' keywords when parsing metadata
  • WriteConfigToStream now resets the namespace for the string factory (Thanks Solokiller)
  • Implemented sort in CScriptArray that takes as input a script function to compare two elements
  • Dictionary storing a const handle now allows retrieving by value
  • ConfigEngineFromStream takes an optional pointer to asIStringFactory
  • scriptstdstring add-on implements a string factory for asIStringFactory with a cache
  • WriteConfigToStream and ConfigEngineFromStream properly handles composite properties
  • Debugger is capable of inspecting value of composite properties

Version 2.31.2 - 2016/12/18

• Bug fixes
  • Fixed compiler warning about missing GNU-stack on gentoo Linux (Thanks James Le Cuirot)
  • Fixed asGetTypeTraits on clang 3.8 (Thanks Ansjh)
  • Fixed big endian errors in the compiler related to enum values (Thanks rfonseca)
  • CreateScriptObject crashed when called for template value types (Thanks noizex)
  • Fixed crash when discarding modules containing shared funcdefs (Thanks Violet CLM)
  • Fixed big endian errors in the compiler related to implicit conversions of constants (Thanks rfonseca)
  • Fixed bug with saved byte code not being portable between 32bit and 64bit platforms when including ChkNullS instruction (Thanks cvet)
  • Fixed assert failure in compiler when compiling invalid switch case (Thanks Jordan Verner)
  • Fixed bug in compiler when passing a @& argument to a function (Thanks IronHawk)
  • Fixed bug when compiling get property accessor returning a registered type that is then implicitly converted to another (Thanks Phong Ba)
  • Fixed assert failure when compiling boolean not operator on constant (Thanks gkfkdk404)
  • Fixed incorrect compiler warning about too large value when assigning negative value to const int8/int16 (Thanks gkfkdk404)
  • Compiler emits warnings if 64bit integer constants cannot fit when implicitly converted to smaller types (Thanks Sir Ementaler)
  • Compiler didn't support implicitly converting constant uint64 values to uint32 values
  • Fixed compiler error on Linux with non-x86 64bit platforms, e.g. arm64, mips, and s390x architectures (Thanks deveee)
  • Fixed assert failure when compiling comparison operator on boolean constant (Thanks Autious)
  • Fixed bug in bytecode serialization when adjusting pointer sizes for calls using asBC_ALLOC (Thanks Autious)
  • Fixed problem with registering types using the asOBJ_IMPLICIT_HANDLE flag (Thanks cvet)
  • Fixed assert failure on implicit conversion from 8/16 bit uint constant to integer (Thanks Sir Ementaler)
  • opCast(?&out) on null handle now works without raising null pointer exceptions (Thanks Ansjh)
  • Corrected as_config.h so Linux for 64bit ARM doesn't try to compile as_callfunc_x64_gcc.cpp (Thanks Igor Gnatenko)
  • Fixed crash on GCC 6 due to CastToObjectType accepting this == null (Thanks Anjsh)
• Library
  • Introduced a new keyword 'if_handle_then_const' that is used to tell template that a handle should be to const object
  • Compiler now emits an error if an integer constant is larger than 2^64-1
  • Non-pod value types are now allowed to be registered without default constructor, as long as at least one constructor is registered (Thanks Phong Ba)
  • Reduced the number of calls to addref and release that the compiler includes in the bytecode in some cases (Thanks Thomas Grip)
  • Non-assignment dual operators, e.g. +, now evaluates left to right even when using overloaded operators (Thanks Scott Bean)
• Add-ons & Samples
  • Fixed a minor bug in ExecuteString that could cause problem in rare cases (Thanks Solokiller)
  • Fixed a bug in asrun example where the context was returned to the pool before being unprepared (Thanks noizex)
  • Registered the opAssign method for weakref to allow value assignments for this type (Thanks noizex)
  • Array add-on uses 'if_handle_then_const' on find methods (Thanks IronHawk)
  • Fixed bug in script builder for meta data on functions with default arguments (Thanks Thomas Grip)

Version 2.31.1 - 2016/06/26

• Bug fixes
  • Fixed assert failure in compiler when attempting to implicitly convert primitive to function pointer (Thanks Sir Ementaler)
  • Fixed compiler bug when passing funcdef by reference to a function (Thanks Sir Ementaler)
  • The auxiliary pointer wasn't stored with object methods registered with the asCALL_GENERIC calling convention (Thanks Phong Ba)
  • Fixed null pointer access crash in asBC_Thiscall1 when calling opIndex on a null pointer (Thanks gjl)
  • The generic calling convention wasn't properly handling funcdefs in arguments or return type (Thanks Ansjh)
  • Fixed null pointer access crash in compiler when compiling invalid script with value assign of function pointer (Thanks Phong Ba)
  • Expressions like (expr ? null : null) is now compiled correctly (Thanks Sir Ementaler)
  • auto var = null; no longer causes a crash in the compiler (Thanks Sir Ementaler)
  • Compiler wasn't giving an error on 'void &' (Thanks Sir Ementaler)
  • Fixed error when discarding a module if a context was still holding a reference to global var (Thanks GuyWithBeard)
  • Offset for bytecode ClrVPtr wasn't adjusted correctly when saving/loading bytecode when the referred to variable was a null pointer (Thanks _Engine_)
  • Fixed assert failure in compiler with AS_DEBUG when compiling anonymous function from class method (Thanks Phong Ba)
  • Fixed crash in compiler when compiling 'null();' (Thanks Nikola Stojsic)
  • Incorrect constructor could be used when declaring variable of object type and the initialization expression was of the same type but type had no copy constructor (Thanks loboWu)
  • Returning a function pointer from a registered function wasn't working properly (Thanks Sir Ementaler)
  • Function pointers in initialization lists would crash the application (Thanks Sir Ementaler)
  • opCast can now be used on types registered with asOBJ_NOHANDLE too without crashing
  • Function pointers wasn't properly handled in context's SetArg and GetReturn methods
  • Fixed some big endian compatibility issues in compiler (Thanks rfonseca)
• Script language
  • Enum to int32 conversion is now preferred over enum to int of other sizes in function overload resolution (Thanks Sir Ementaler)
  • Anonymous objects initialized with initialization lists are now parsed as expression terms, rather than expressions by themselves
• Library
  • Added asEP_HEREDOC_TRIM_MODE to allow application to decide how/if heredoc strings should be trimmed
• Add-ons
  • Implemented parseUInt, findFirstOf, findLastOf, findFirstNotOf, findLastNotOf, insert, and erase for the string add-on
  • Implemented removeRange for the array add-on
  • Implemented insertAt for the array add-on that inserts all the elements from another array
  • Fixed big endian compatility problems in script dictionary (Thanks rfonseca)
  • Fixed compiler error in datetime add-on on gnuc (Thanks rfonseca)

Version 2.31.0 - 2016/02/26

• Bug fixes
  • Compiler no longer crashes when assigning anonymous function to variable declared with auto type (Thanks glcolor)
  • Compiler will no longer match funcdefs for datatype if the namespace is not the correct one
  • Fixed bug with template value types and loading bytecode (Thanks glcolor)
  • Fixed bug with namespace and class member initialization (Thanks Solokiller)
  • Ternary condition can now return function pointers (Thanks Sir Ementaler)
  • Fixed problem with named args and registered behaviours (Thanks Solokiller)
  • Linux with PPC64 Little Endian is now working with AS_MAX_PORTABILITY (Thanks Rafael Fonseca)
  • Functions with generic calling conventions now catch application exceptions (Thanks Jason Goepel)
  • Fixed a bug in compiler with calling function with const reference and the function expected non-const reference (Thanks cvet)
  • Fixed compiler error in as_memory.cpp on OpenBSD (Thanks David Carlier)
  • Fixes for Big Endian CPUs (Thanks Rafael Fonseca)
  • Fixed crash on Linux 32bit when application threw C++ exception and library had been compiled with optimizations
  • Fixed bug in compiler when passing a handle from function argument to copy constructor (Thanks GGLucas)
  • Compiler properly resolves namespace when calling base classes method and the base class is declared in a different namespace (Thanks Ansjh)
• Library interface
  • Added GetAuxiliary to asIScriptGeneric and asIScriptFunction for retrieving the auxiliary object registered with the function (Thanks cvet)
  • Added GetChildFuncdefCount and GetChildFuncdef to asIObjectType
  • Renamed GetFuncDefFromTypeId to GetFuncdefFromTypeId for consistency
  • It is now possible to register child funcdefs with RegisterFuncdef too
  • Renamed asIObjectType to asITypeInfo
  • Renamed asCLEANOBJECTTYPEFUNC_t to asCLEANTYPEINFOFUNC_t
  • Implemented GetTypeInfoByDecl, GetTypeInfoByName, and GetTypeInfoById
  • Implemented SetTypeInfoUserDataCleanupCallback
  • Implemented asITypeInfo::GetEnumValueCount and GetEnumValueByIndex
  • Deprecated GetObjectTypeByName/Decl, GetEnumValueCount/ByIndex, GetObjectTypeById, SetObjectTypeUserDataCleanupCallback in engine
  • Deprecated GetObjectTypeByName/Decl, GetEnumValueCount/ByIndex in module
  • Deprecated asIObjectType
  • Changed GetEnumByIndex and GetTypedefByIndex to return an asITypeInfo and removed all the output parameters
  • Implemented GetTypedefTypeId in asITypeInfo
  • GetChildFuncdef now returns an asITypeInfo instead of asIScriptFunction
  • Added GetFuncdefSignature to asITypeInfo
  • Deprecated GetFuncdefFromTypeId
  • Implemented GetParentType in asITypeInfo to allow querying the parent type for child funcdefs
• Library
  • The asCALL_GENERIC calling convention now also supports storing an auxiliary pointer during registration (Thanks cvet)
  • Improved parser error message when finding unexpected token to inform if the token is reserved or not (Thanks Solokiller)
  • Implemented asEP_ALLOW_UNICODE_IDENTIFIERS (Thanks Alexander Orefkov)
  • Added configuration in as_config.h to identify GNUC+Linux+PPC64 (Thanks Rafael Fonseca)
  • Access mask in the engine now defaults to all bits set to make sure built-in functions are available to all modules (Thanks Solokiller)
  • Included the asOBJ_FUNCDEF value to allow asITypeInfo to represent funcdefs too
  • asOBJ_SCRIPT_FUNCTION has been removed
  • RefCastObject can now be used for function pointers too
  • Refactored the code with regards to how types are stored, specifically funcdefs, resulting in more unified code and less memory use
  • Clang is now recognized in angelscript.h as supporting C++11 features (Thanks Derric McGarrah)
• Script language
  • It is now possible to declare funcdefs as members of script classes
  • Partially specializing the scope as the enum type when referring to enums in namespaces is now possible (Thanks cvet)
• Add-ons & Samples
  • Fixed compiler error in scriptstdstring.h when using AS_USE_NAMESPACE (Thanks Sami Vuorela)
  • Fixed compiler error in aswrappedcall.h when using AS_USE_NAMESPACE
  • WriteConfigToStream and ConfigEngineFromStream is properly handling child funcdefs
  • Fixed problem in CScriptAny with constructing any object from primitive (Thanks gjl)
  • ScriptHandle and Dictionary no longer need special code for function pointers
  • Implemented CScriptDictionary::find for easier lookup of key/value pairs from application side
  • dictionary::delete now returns a bool to indicate if the delete was successful or not
  • Implemented CDateTime as a basic way of getting the time in scripts
  • The asrun sample exposes the CDateTime add-on to scripts
  • Implemented getInput in the asrun sample to allow it to get user input from standard input
  • CScriptAny released asITypeInfo that it didn't own when a null handle was stored in it (Thanks GGLucas)
  • CScriptBuilder incorrectly replaced /./ in include paths with nothing (Thanks Solokiller)
• Project
  • Fixed cmake project files so library can be built as stand-alone without including the game sample (Thanks Wipe)
  • Corrected the name of the shared object filename in the gnuc makefile (Thanks hasufell)

Version 2.30.2 - 2015/08/30

• Bug fixes
  • Throwing exception from application code would cause a crash if the library had been built without optimizations on 64bit GNUC (Thanks dkrusu)
  • Fixed crash with asCALL_THISCALL_ASGLOBAL and objects passed by value in argument (Thanks justin12343)
  • Fixed bug in parser related to virtual properties and datatypes in namespaces (Thanks dkrusu)
  • Fixed compiler bug with nested namespaces, when the outer namespace has not been explicitly registered (Thanks BasicMind)
  • Fixed a bug with SaveByteCode on 64bit platforms when the script called constructor with primitive arg before object arg (Thanks Idarion)
• Library
  • Built-in function names and object types are now prefixed with $ to make it quicker to identify them while loading bytecode
  • Optimized logic for finding registered function/method in LoadByteCode (Thanks _Engine_)
  • Reduced size of pre-compiled bytecode
  • Optimized logic for determining typeId for object types, which can improve compile time and LoadByteCode for applications with a lot of different object types
  • Improved thread safety to support multiple threads querying typeIds simultaneously
  • Improved performance for saving bytecode that uses lots of global properties
  • Improved the compiler to generate less temporary copies of objects
  • Optimized some byte code sequences generated by the compiler
• Script language
  • Added the non-reserved keyword 'function' that will be used to declare anonymous functions
  • Anonymous functions can now be declared as part of expressions
  • Initialization lists can be used to initialize variables declared as handles too (Thanks Peter Jensen)
• Add-ons
  • ConfigEngineFromStream appropriately treats names of behaviour functions before registering them since they are now prefixed with $ in WriteConfigToStream
  • Fixed compiler error in as_scriptbuilder.h on MinGW (Thanks DarkPizzaX)
  • Minor code changes to CScriptDictionary (Thanks Sir Ementaler)
  • The options argument in formatInt, UInt, and Float now has a default argument of an empty string
  • On C++11 enabled compilers the string pool is now using the unordered_map container for faster look-up
  • CScriptDictionary now uses a typedef for the key type to make it easier for applications that uses custom string types (Thanks Solokiller)
  • Changed to use std::unordered_map in CScriptDictionary when C++11 is used
  • The CScriptDictionary now caches its object type to avoid looking it up in the engine for each instance

Version 2.30.1 - 2015/07/03

• Bug fixes
  • Fixed bug in compiler when using compound assignment on virtual property on temporary variable (Thanks Violet CLM)
  • Compiler no longer gives error when access global variable in global namespace from class in namespace (Thanks Sir Ementaler)
  • Fixed bug with compiler accepting null handle in initialization lists that didn't support it (Thanks Phong Ba)
  • Parser properly handles template type and non-template type of same name in different namespaces (Thanks Polyák István)
  • Fixed problem with ternary conditions returning references to global variables (Thanks Jonathan Sandusky)
  • Fixed bug with opIndex when global variable had same name as datatype in a different namespace (Thanks dkrusu)
  • Saving bytecode that used templates with multiple subtypes is now working properly (Thanks Phong Ba)
  • Fixed assert failure in compiler when creating delegate from temporary object (Thanks Solokiller)
  • Fixed crash on Win64 when calling native function that takes object by value that requires clean-up after call and the function also return an object by value (Thanks Jason Goepel)
  • Fixed a bug with native calling conventions on Win32 when using Clang with MinGW 4.7+ (Thanks Joshua Cearley)
  • Fixed a null pointer access failure that could happen in asGetActiveContext (Thanks Gwinnell)
  • Fixed compiler warnings in asGetTypeTraits on gnuc 5.1 (Thanks Boost113)
  • Fixed a possible null pointer access while releasing a script function (Thanks Andreas Fobian)
  • Fixed some compiler errors on Linux with ARM (Thanks Vincent Cheng and James Cowgill)
  • Fixed compiler bug when using construct call for a reftype on an object with opConv(?&out) (Thanks dkrusu)
  • Fixed compiler bug that allowed class method handle to be converted to primitive (Thanks Solokiller)
• Library
  • It is now possible to register member properties as references if the member should be dereferenced before access (Thanks cvet)
  • Added supported for native calling conventions on Linux and Android with MIPS
  • Improved performance for loading saved byte code (Thanks _Engine_)
  • XBox 360 now supports 64bit integer arguments in native functions (Thanks Anthony Clark)
• Virtual machine
  • Implemented asBC_Thiscall1 for faster calls to class methods that take an int argument and return a reference
• Script language
  • for-loops now support multiple increment expressions separated by , (Thanks dkrusu)
• Add-ons & Samples
  • Fixed memory leak in serializer when using extra objects
  • Fixed bug in serializer with incorrect refcount on registered types when restoring the script object that references them
  • Serializer attempted to backup non-pod types that had no user type registered with bitwise copy potentially causing errors
  • Added GetBuffer to the CScriptArray object (Thanks Solokiller)
  • Added GetRef to the CScriptHandle (Thanks zerochen)
  • Added formatUInt for strings (Thanks iraxef)
  • Included asserts in CScriptAny to detect improper usage from application (Thanks Solokiller)
  • Script array is now constructed even if the current script context has a script exception set (Thanks iraxef)
  • Fixed a compiler problem in asrun when C++11 support is not available (Thanks Anthony Clark)
  • Implemented GetAddressOfValue in the dictionary value and iterator to simplify inspecting the content with the debugger
  • Added a Set/GetEngine to the CDebugger to hold an engine pointer that can be used by the callbacks
  • The debugger's ToString method and Callbacks now take a expand members recursively
  • Implemented DictionaryToString debugger callback in asrun sample (Thanks Anthony Clark)
  • CScriptBuilder now does case insensitive compares for duplicate include files on Windows (Thanks Solokiller)
• Project
  • Added meson project files (Thanks Igor Gnatenko)
  • Improved the android project files

Version 2.30.0 - 2015/02/22

• Bug fixes
  • Fixed bug with use of scoped reference types declared in global variables (Thanks ic0de)
  • Fixed bug when comparing two handles and one is a handle to a read-only object (Thanks mbwac)
  • Compiler will now give error if there is an overflow when evaluating power-of in constant expression (Thanks ThyReaper)
  • Funcdefs can now have template types with script classes as subtypes (Thanks Sir Ementaler)
  • Fixed an incorrect error code when registering a template specialization and the template type instance already existed (Thanks glcolor)
  • Template specialization failed to remove generated template instances that has been created as a consequence (Thanks Sami Vuorela)
  • Engine detects if application attempts to register method or property for generated template instances (Thanks glcolor)
  • Fixed bug with asOBJ_APP_ARRAY in arm and ppc64 calling conventions (Thanks Brandon Bare)
  • Fixed bug in Linux arm hardfloat ABI (Thanks Brandon Bare)
  • Fixed an assert failure in the compiler when compiling an assignment with non-temporary deferred arguments (Thanks iraxef)
  • The constructor stubs for value template types didn't pop the object pointer from the stack (Thanks iraxef)
  • GetFunctionByDecl wasn't able to find the global function if the name was prefixed with :: (Thanks Ser Ementaler)
  • The compiler was producing wrong bytecode when calling asBEHAVE_IMPLICIT_REF_CAST on value type
  • Fixed crash when script class contained value template type as member
  • Class method can refer to base class' method with fully specified namespace (Thanks iraxef)
  • It is possible to register an enum with the same name in a namespace after it has been registered in the global namespace (Simon Geilfus)
  • No more memory build-up when the script has circular references between classes and templates (Thanks iraxef)
  • Private class properties are not accessible from derived classes (Thanks iraxef)
  • Fixed bug in compiler where default argument could use temp var used in previous arguments (Thanks Solokiller)
  • Compiler didn't properly check the access masks for registered class methods (Thanks Solokiller)
  • Directly calling a funcdef retrieved from member property accessor would get wrong arguments (Thanks Solokiller)
  • Methods declared in mixins in namespaces weren't compiled with the correct namespace (Thanks Sir Ementaler)
  • Fixed problem with compiler not detecting incorrect type when passing class method as argument to constructor (Thanks Polyák István)
  • Fixed bug in asBC_u64TOd and asBC_u64TOf on non-MSVC compilers (Thanks Turo Lamminen)
  • Fixed crash on iOS/arm64 with thiscall callback functions (Thanks _Engine_)
  • Fixed incorrect compiler warning about converting to handle after get accessor (Thanks agentprog)
• Library interface
  • Deprecated asBEHAVE_VALUE_CAST and asBEHAVE_IMPLICIT_VALUE_CAST
  • asIScriptEngine::AssignScriptObject now returns an int with the success or error code
  • The tokenLength arg for ParseToken is changed to asUINT
  • Added asIScriptObject::GetWeakRefFlag
  • Implemented asIScriptEngine::RefCastObject
  • Deprecated asIScriptEngine::IsHandleCompatibleWithObject
  • Implemented SetArgVarType to the context for calling functions with variable argument types
  • Added ShutDownAndRelease to explicitly tell when the engine should be shut down, compared to simply releasing the reference
  • Implemented support for user data in script object instances
  • Included asIScriptFunction::IsProtected
  • asIObjectType::GetProperty has an additional parameter to return if the property is protected
  • Deprecated asBEHAVE_REF_CAST and asBEHAVE_IMPLICIT_REF_CAST
  • Added engine property asEP_PRIVATE_PROP_AS_PROTECTED
• Library
  • Improved the algorithm for verifying if script classes require garbage collection
  • Added support for native calling conventions on PS Vita (Thanks Brandon Bare)
  • GetModule and DiscardModule are now thread-safe (Thanks Brandon Bare)
  • Returned declarations with namespaces no longer prefix symbols with :: when declared in the global namespace (Thanks iraxef)
  • When compiling a default argument expression the namespace of the called function is used as default (Thanks iraxef)
  • Implemented asEP_DISALLOW_EMPTY_LIST_ELEMENTS to allow application to disable empty elements in initialization lists (Thanks theoutfield)
  • Application can now register types with asOBJ_IMPLICIT_HANDLE if this option is turned on
  • Improved some compiler error messages
  • Updated gnuc makefile to automatically retrieve version number from angelscript.h for the shared library file name (Thanks Cody Ferguson)
  • Minor runtime optimizations have been made
  • Changed SetLineCallback so that it is safe to call it from a second thread while the context is running (Thanks ziomau)
  • Completely re-factored the way the memory management for the internal script code is done
  • Discarding modules is much faster, and doesn't burden the garbage collector (Thanks ziomau)
  • Compiler no longer warns on empty sections since this may be a valid situation (Thanks iraxef)
  • When formatting type declarations for messages the namespace will always be included if different than the current namespace (Thanks Solokiller)
  • Included check to avoid modifying template types registration after a template instance has already been generated
  • module's GetFunctionByName/Decl, GetGlobalVarIndexByName/Decl, GetObjectTypeByName recursively search parent namespaces
  • engine's GetGlobalPropertyIndexByName/Decl, GetGlobalFunctionByDecl, GetObjectTypeByName recursively search parent namespaces
• Script language
  • The ternary condition operator can now be used as lvalue if both options are lvalues of the same type (Thanks Polyák István)
  • opImplConv can now be used to allow implicit conversion to bool for registered value types
  • imported functions can now be placed in namespaces too (Thanks cvet)
  • Compound assignment operators can now be used with virtual properties
  • Included 'protected' as reserved keyword
  • Class members can now be declared as protected
  • Script classes can now implement opCast and opImplCast to provide custom ref cast behaviours
• Add-ons & Samples
  • The script array and grid add-ons avoid flagging themselves as garbage collected for handle subtypes that are known not to be garbage collected
  • CScriptHandle, CScriptAny, and CScriptDictionary use the new RefCastObject to properly cast to all supported types of the contained handle
  • The dictionaryValue was missing a copy opAssign method so it wasn't possible to directly assign one dictionaryValue to another (Thanks iraxef)
  • The weakref is now a value template type
  • The syntax for using weakref in script is much more like a normal handles
  • Implemented a CScriptFileSystem add-on to complement the CScriptFile add-on
  • Changed ContextMgr::AddContext to allow application to tell manager that it want to keep the context after execution
  • Added ContextMgr::DoneWithContext to return the context after the application has retrieved what it wants from it
  • Fixed the asrun sample so now returns the status from the script again
  • Improved asrun to support international languages better when writing to the console on Windows
  • Changed CScriptFile::ReadLine and ReadString to return the string by value instead of as an output parameter
  • Fixed some compiler warnings on gnuc in the add-ons (Thanks Bertram25)
  • dictionaryValue has better support for boolean values
  • Added support for asrun to execute system commands
  • Debugger now accepts namespace for printing variables
  • CScriptBuilder expands relative paths to absolute paths before verifying if the include file is duplicate (Thanks cuipeng)
  • Fixed WriteConfigToStream/ConfigEngineFromStream to keep the valid object type flags and properly handle namespaces (Thanks Solokiller)
  • Fixed ScriptArrayIsEmpty_Generic that didn't set the return value (Thanks _Engine_)
  • Improved WriteConfigToStream so that template types are fully registered before other types (Thanks Solokiller)
  • Prepared CContextMgr for use with AS_MAX_PORTABILITY
  • Fixed bug in dictionary's opIndex when generic calling convention was used
  • Fixed bug in CScriptHandle when AS_MAX_PORTABILITY was used

Version 2.29.2 - 2014/10/21

• Bug fixes
  • Fixed bug when compiling expressions using opCall on objects returned by reference from previous call (Thanks Sir Ementaler)
  • Empty initialization lists are now properly working where a repeat pattern is expected (Thanks cvet)
  • Fixed bug when global variable expression had casts between script classes (Thanks cvet)
  • Fixed incorrect warning on literal -9223372036854775808 (Thanks iraxef)
  • Compiler was incorrectly accepting syntax as object@(expr) (Thanks iraxef)
  • Taking the address of an imported function now works as it should (Thanks Wipe)
  • Fixed crash in compiler when compiling initialization lists with 'null' as one of the elements (Thanks iraxef)
  • Identity comparison on handle received as parameter by reference wasn't working (Thanks iraxef)
  • Application no longer crashes if an asIObjectType is released after the engine has been released
  • Template instances now receive the member properties that were registered for the template (Thanks Samichama)
  • Template types can now use other template types as method arguments where the sub-types are shared (Thanks Samichama)
  • Fixed bug in compiler with use of implicit value conversion and temporary variables (Thanks Jason Goepel)
• Library interface
  • Improved compiler compatibility of asGetTypeTraits to support Xcode/Clang (Thanks PhilCK)
  • Script interfaces now return the module that owns them with GetModule (Thanks cvet)
• Library
  • Added asEP_DISABLE_INTEGER_DIVISION that makes all divisions with integer values result in doubles (Thanks Jason Goepel)
  • Improved performance of shutting down the engine (Thanks ThyReaper)
  • Compiler warns when variable in inner scope hides variable of same name in outer scope (Thanks carew)
  • Compiler warns when overloading inherited class method and default args in the methods cause conflicts (Thanks Aaron Baker)
  • Compiler automatically resolves ambiguous enum values on comparisons (Thanks Jason Goepel)
• Script language
  • Script classes can now implement opConv and opImplConv to support type conversions
  • Passing a non-lvalue expression to a &out argument will now yield compiler error instead of warning
• Virtual machine
  • Updated asBC_CALLBND so that imported functions can now be bound to application registered functions too (Thanks gjl)
• Add-ons
  • The array and grid add-ons no longer set a script exception if the initialization list is empty
  • Fixed problem with storing/retrieving enum values from the dictionary (Thanks iraxef)
  • Concatenation with integers and string now properly supports 64bit types (Thanks iraxef)
  • dictionary::get now supports retrieving stored handle by value if type is compatible (Thanks iraxef)
  • CScriptBuilder::AddSectionFromMemory now has an optional lineOffset argument (Thanks Boost113)
  • CScriptBuilder will report the correct path to the include files that fails to load (Thanks gjl)
  • Fixed bug in CScriptFile when reading ints for least significant byte first (Thanks gjl)

Version 2.29.1 - 2014/07/20

• Bug fixes
  • Fixed compiler assert failure with unsafe references and deferred arguments (Thanks AgentC)
  • Fixed problem with enumerating entities after removing a config group (Thanks Robert42)
  • Fixed buffer overflow problem when Prepare() with virtual script function near the end of the stack memory (Thanks GGLucas)
  • Fixed parser bug when local variable had the same name as a type in different namespace (Thanks cvet)
  • Fixed errors with saved bytecode when using template types declared in namespace (Thanks cvet)
• Library
  • Improved compiler error messages
  • The module's ResetGlobalVars uses the context callbacks to support debugging initialization of global variables without informing a pre-created context
  • The context callbacks are disabled before destroying the engine to avoid creation of new contexts while cleaning up objects
  • Added asEP_ALTER_SYNTAX_NAMED_ARGS to optionally support the previous syntax for named args
  • asOBJ_TEMPLATE can now be used with value types too
• Library interface
  • Added asGetTypeTraits<T>() as part of the official interface
• Script language
  • Changed the syntax for named arguments to "arg: expr" to avoid confusion when local variable has the same name as the argument (Thanks Kevin Ingwersen)
  • Added support for declaring classes as abstract to prevent instantiation (Thanks Scott Bean)
• Add-ons & Samples
  • Added null-pointer check in CDebugger::ToString and fixed some compiler warnings (Thanks Dominique Dumont)
  • Array elements are initialized to zero by default (Thanks cvet)
  • Fixed null pointer access bug in grid add-on (Thanks Bitsauce)
  • GetTypeTraits<T>() has been removed from the helper add-on
  • Replaced the helper function PrintException with GetExceptionInfo that returns the information in a string
  • The asrun sample is now using the ContextMgr add-on to support co-routines
  • The ContextMgr uses the RequestContext instead of CreateContext to take advantage of the context callbacks
  • Fixed bug in closeTo math function when one of the arguments was 0

Version 2.29.0 - 2014/06/09

• Bug fixes
  • Function handles were incorrectly treated as handles in value assignment
  • Fixed RWX section in as_callfunc_arm_gcc.S (Thanks Julian Ospald)
  • Fixed assert failure with implicit cast and get accessor (Thanks Amer Koleci)
  • Fixed opCall on global variable (Thanks gjl)
  • Fixed crash when calling opCall on a property accessor on a global variable (Thanks gjl)
  • Fixed bug in compiler where temporary variable could be overwritten when calling overloaded operators (Thanks Jason Goepel)
  • Fixed bug in tokenizer for one line comments on the last line of a script (Thanks Jason Goepel)
  • Fixed bug with explicit construct call and reference types (Thanks Roel Binnendijk)
  • Fixed bug in GetDeclaration when returning the list pattern (Thanks agentprog)
  • GetSubTypeId and GetSubType now works for registered template specializations too (Thanks Jason Goepel)
  • Loading bytecode with funcdefs declared from script wasn't working identical to building from source (Thanks cvet)
  • GarbageCollect(asGC_FULL_CYCLE | asGC_DESTROY_GARBAGE) will now properly destroy the garbage in the new generation too (Thanks Maciej Biedrzycki)
  • Stack unwinding now works on Linux 64bit with native calling conventions
  • Fixed bug in compiler that allowed expression with name of function without doing anything with it (Thanks iraxef)
  • Engine no longer silently accept registering template methods where the template subtype is passed by value
  • Mixin classes in parent namespace can now be properly included in a class (Thanks cvet)
  • Compiler now gives an error when script declares handle to handle (Thanks iraxef)
• Library
  • Added the flag asOBJ_APP_ARRAY to support registering types that are really C arrays
  • The parameter names from the declaration are now stored in the functions (Thanks GGLucas)
  • The parameter names are stored with the saved bytecode, unless debug information is stripped
  • Improved C++ exception handling to avoid deleting object that was never returned (Thanks Polyák István)
  • CreateScriptObject will return null if the object constructor throws C++ exception
  • The template callback can now write error messages to facilitate the understanding of why a template cannot be instantiated (Thanks JaviCervera)
  • Compiling the library with Sun CC for SPARC is now possible, though without native calling conventions (Thanks Andrey Bergman)
  • Improved error message when trying to pass class method as argument (Thanks Grimshaw)
  • Types registered with asOBJ_ASHANDLE should now provide the opHndlAssign method to support handle assignments
  • Types registered with asOBJ_ASHANDLE can also register the opAssign method to support value assignments
  • CreateScriptObjectCopy now uses the copy constructor for value types, if available
  • The asBEHAVE_VALUE_CAST behaviour now supports the generic form 'void f(?&out)'
  • Improved runtime performance by avoiding increasing/decreasing refcount of script object in class methods (Thanks GGLucas)
• Library interface
  • asIScriptFunction::GetDeclaration has an optional argument to include the parameter names (Thanks GGLucas)
  • Added asIScriptFunction::GetParam that can optionally return both the name and default argument in addition to the type id
  • Deprecated asIScriptFunction::GetParamTypeId
  • Added GetObjectTypeByDecl to both engine and module
  • Removed old deprecated methods
  • Modules, contexts, and functions now also support multiple user data
  • Added the global functions asAllocMem and asFreeMem that call the registered custom memory functions
  • Added RequestContext, ReturnContext, SetContextCallbacks to engine
  • Added the argument numIterations to GarbageCollect to support multiple iterations without having to call the method multiple times
  • GetStringFactoryReturnTypeId now has an optional argument to return information on the reference (Thanks agentprog)
  • Added support for registering functor objects as class methods with asCALL_THISCALL_OBJLAST and asCALL_THISCALL_OBJFIRST (Thanks Jordi Oliveras)
• Script language
  • Named arguments in function calls are now supported (Thanks GGLucas)
  • auto can now be used to tell the compiler to resolve the type of a variable from the initialization expression (Thanks GGLucas)
• Add-ons
  • The GetTypeTraits<T>() helper function automatically detects when to use asOBJ_APP_ARRAY
  • Added default factory and resize method to the grid
  • Array and grid properly handle exceptions while constructing elements (Thanks Polyák István)
  • Fixed compilation error with xcode 5.1 in dictionary (Thanks Jordi Oliveras Rovira)
  • The array and grid addons use the asAllocMem and asFreeMem as default memory routines
  • CScriptHandle implements the opHndlAssign instead of the opAssign
  • Dictionary now has the opIndex that can be used to directly assign and retrieve values without using the set/get methods
  • Dictionary uses asAllocMem and asFreeMem, and has factory functions to create instances
  • The context manager now uses funcdefs and dictionary to create co-routines
  • WriteConfigToFile wasn't saving the return type for the string factory correctly (Thanks agentprog)
  • Added helper functions WriteConfigToStream and ConfigEngineFromStream
  • Fixed compilation error with CScriptArray in asrun

Version 2.28.2 - 2014/03/18

• Bug fixes
  • The Library can now be compiled for WinXP with multithread support again (Thanks carnalis)
  • Fixed crash after loading bytecode with initialization lists holding ref types by value (Thanks loboWu)
  • Fixed bug with saved bytecode and initialization lists that skip values
  • Tokenizer was splitting identifiers that started with keywords that ended with numbers, e.g. int8 (Thanks loboWu)
  • GetObjectTypeById crashed if the typeId represented a template instance type that had already been released (Thanks iraxef)
  • Corrected some compiler warnings (Thanks arpeggiodragon)
  • Fixed crash when returning primitive value implicitly cast from global handle (Thanks Jason Goepel)
  • Fixed assert failure in compiler when using opAssign that returns a value instead of a reference (Thanks simong)
  • Fixed memory leak with registered cast behaviours on template types (Thanks Jason Goepel)
  • Fixed bug with missing implicit ref cast when passing object to parameter as inout reference (Thanks Jason Goepel)
  • Fixed bug when passing 'null' or 'void' to var type argument
• Library
  • It's now possible to use repeat_same in list pattern to tell compiler that all lines must be of the same length
  • The compiler will warn if JIT compiler is used and script is built without JIT entry points (Thanks gjl)
  • Compiler no longer warns on sign change for bitwise operator with negative enum value (Thanks _Vicious_)
  • Reduced size of saved bytecode
  • Changed GarbageCollect so that it can now be executed for a full cycle in a parallel thread
  • Implemented C++11 move operators for the internal asCString type (Thanks iraxef)
  • Compiler now casts to common base class when comparing two handles (Thanks Aaron Baker)
  • When unsafe references is turned on the compiler allows passing literal constants to const references (Thanks Jason Goepel)
  • Improved implicit cast of object to primitive in math expressions (Thanks Jason Goepel)
  • Optimization to use the copy constructor instead of the assignment when preparing temp object for func argument
  • Optimization to avoid copy when passing ref type to const &in parameter (Thanks Jason Goepel)
• Script language
  • Anonymous objects can now be initialized in expressions with lists
  • The opIndex operator overload now supports multiple arguments
  • Functor objects can now be implemented by implementing opCall methods in the class (Thanks gjl)
• Add-ons
  • Implemented closeTo() in the math add-on (Thanks haegarr)
  • GetTypeTraits() no longer incorrectly identifies C++ arrays as asOBJ_APP_CLASS (Thanks eezstreet)
  • The script array now supports user defined memory routines (Thanks FDsagizi)
  • The script array should be allocated with factory functions instead of directly with new (Thanks iraxef)
  • Added GetTypeId to the dictionary to retrieve the type id of the stored value (Thanks iraxef)
  • The dictionary now has an iterator on the C++ side that supports C++ range-for loops (Thanks iraxef)
  • Implemented the grid template add-on

Version 2.28.1 - 2014/01/31

• Bug fixes
  • Fixed improper warning of used types when releasing engine and having circular references between registered types (Thanks Jason Goepel)
  • Fixed memory leak on registering opAssign twice for the same object type (Thanks Jason Goepel)
  • Compiler will not used enum values from registered enum types if the module doesn't have access to it
  • Fixed assert failure in Execute when forgetting to set the object on a class method call (Thanks simps)
  • Compiler now uses the default args declared in derived methods instead of the default args in base method (Thanks Aaron Baker)
  • Fixed the position reported for errors while compiling global variables
  • Compiler wasn't searching parent namespaces when resolving the symbol for class inheritance (Thanks Agnis)
  • Fixed linker error on Windows RT with ARM due to misaligned code in as_callfunc_arm_msvc.asm (Thanks NiteLordz)
  • Fixed crash with THISCALL_ASGLOBAL and virtual methods (Thanks Macobyte)
  • Implicit cast didn't work in initialization of global vars (Thanks Jason Goepel)
  • Incorrect bytecode sequence when compiling initialization list for dictionary containing values from global string variables (Thanks Jordi Oliveras Rovira)
  • Compiler was incorrectly converting both results to const in ?: if one of the expressions was null (Thanks FDsagizi)
  • Fixed memory leak on iOS when passing complex object by value to registered function (Thanks FDsagizi)
  • Fixed intermittent crash with registered object properties of template instance types (Thanks aliascc)
  • Fixed crash when attempting to assign a script object to another of another type (Thanks Philip Bennefall)
  • Fixed crash when registering two or more methods for an object type uses template instance types in parameters or return value (Thanks iraxef)
• Library
  • Defined default arg for asSFuncPtr constructor to allow trivial instanciation (Thanks _Vicious_)
  • Added verification to avoid use of context from a different engine to call functions (Thanks GGLucas)
  • Removed some more unused code in AS_NO_COMPILER mode
  • Optimized compiler performance with faster lookups (Thanks GGLucas)
  • Added check against attempts to register multiple list factories (Thanks Jason Goepel)
  • Compiler is able to resolve ambiguous enum values if it can determine the enum type from the destination (Thanks Jason Goepel)
  • Slightly reduced memory consumption as virtual functions no longer store the default args
  • Linux with ARM now supports native calling conventions for both soft-float ABI and hard-float ABI
  • Compiler is capable of using constructors with default args as default constructor (Thanks Sir Ementaler)
  • An error will now be returned when building an empty script
  • Saving bytecode for an empty module will now return an error
  • The overhead for calling interface methods is reduced by adding the methods in the virtual function table (Thanks GGLucas)
  • asIScriptEngine::GetObjectTypeByName can now return template types too
  • POD value types are now allocated inline when members of script classes (Thanks GGLucas)
  • Ternary condition operator now converts either case to const @ if the other is const @ (Thanks _Vicious_)
  • Multithreading is now supported on Windows Store Apps too
  • Slightly reduced size of saved bytecode
  • Improved error messages when loading invalid bytecode
• Script language
  • Added the operators ** and **= for exponent math operations (Thanks Jason Goepel)
  • The methods opPow and opPow_r can be used to overload the exponent math operator (Thanks Jason Goepel)
• Virtual machine
  • Added the instructions POWi, POWu, POWf, POWd, POWdi, POWi64, POWu64 (Thanks Jason Goepel)
• Add-ons & samples
  • WriteConfigToFile now writes the engine properties too
  • asbuild sample updated to set the engine properties as informed in config file
  • Added GetTypeId to the script handle to make it easier to work with function pointers (Thanks Ava Skoog)
  • Implemented FindByRef in the script array (Thanks Marcus L)
  • CDebugger now has a RegisterToStringCallback to allow custom conversion of types to strings for the debug output
  • Fixed assert failure in CScriptWeakRef (Thanks Squared'D)
  • WriteConfigToFile escapes quote characters in default arg expressions (Thanks alraz.exe)
  • asbuild sample updated to treat the escaped quote characters properly (Thanks alraz.exe)
  • CScriptHandle will hold a reference to engine to avoid crash if engine is released before the contained reference (Thanks Samuel Villarreal)

Version 2.28.0 - 2013/11/02

• Bug fixes
  • The GET_WEAKREF_FLAG behaviour is now registered for the script types in AS_MAX_PORTABILITY too (Thanks orimoto)
  • Fixed stack alignment problem with native calling convention for Linux and ARM (Thanks loboWu)
  • Fixed null pointer access during compilation if JIT compiler is used (Thanks Andrew Ackermann)
  • Fixed null pointer access when calling GetMethodByDecl on template instance type (Thanks Jason Goepel)
  • Fixed memory leak with default args and shared functions (Thanks thd.MM)
  • Fixed crash on registering function with autohandles for unknown type (Thanks Jason Goepel)
  • Fixed crash on registering template specialization twice (Thanks Jason Goepel)
  • Fixed bug with passing handle to ?& arg with unsafe references (Thanks FDsagizi)
  • opEquals with funcdef works again (Thanks Violet CLM)
  • Fixed bug with implicit casts of large integer constants and uint64 (Thanks Apmyp)
  • Fixed bug in IsNested when called with parameter (Thanks Jordi Oliveras Rovira)
  • Fixed crash in compiler when resolving function pointers with namespace (Thanks Violet CLM)
  • Conditional operator ?: implicitly converts 0 to the type of the other expression again (Thanks FDsagizi)
  • Reusing existing module without discarding it no longer accumulates memory in engine (Thanks Scott Bean)
  • The object type for script classes that formed circular reference with base class wasn't resolved by gc (Thanks Scott Bean)
  • FindNextLineWithCode() works properly for class constructors where class has non-primitive members too (Thanks Scott Bean)
  • GetTypeDeclaration now work correctly for registered template specializations (Thanks zexee)
  • Fixed crash with chained handle assignments (Thanks FDsagizi)
  • Fixed compiler errors with Borland (Thanks Viacheslav Polyakov)
  • Fixed assert failure in compiler on explicit ref cast of void expression (Thanks AgentC)
• Library
  • The list factory behaviour now receives a pointer to a buffer with all values instead of just the expected length
  • Engine now properly supports use of autohandles in template factories
  • Assembler code for Linux + ARM is now unified to support both normal and thumb mode (Thanks loboWu)
  • The engine uses the registered list pattern to dynamically determine the elements in the list buffer
  • Optimized tokenizer with the use of jump tables (Thanks GGLucas)
  • Added compiler warning on implicit conversion from float to integer (Thanks FDsagizi)
  • FindNextLineWithCode() is able to find the first line with code from where the function has been declared
  • Added code to detect and warn instead of crashing if application attempts to resurrect script object during its destruction (Thanks Tuukka Pensala)
  • The function declaration for constructors and destructors now show the object type name instead of _beh_x_ (Thanks Jason Goepel)
  • Added support for atomics and posix threads with Android 2.3+ (Thanks Jordi Oliveras Rovira)
  • The engine no longer writes parser errors to message callback in the GetByDecl methods (Thanks kaveldun)
  • Updated config to correctly identify iOS with 64bit arm (Thanks taliska)
• Library interface
  • Added GetModuleCount and GetModuleByIndex for enumerating existing modules (Thanks Vitaly Akimov)
  • asBEHAVE_LIST_FACTORY must declare the expected pattern for the initialization list
  • Added asBEHAVE_LIST_CONSTRUCT to allow value types to be initialized with lists too
  • GetVarDecl and GetPropertyDeclaration now take an optional includeNamespace argument (Thanks zexee)
• Virtual machine
  • Implemented the bytecodes asBC_AllocMem, asBC_SetListSize, asBC_SetListType and asBC_PshListElmnt for handling initialization lists
  • asBC_FREE has been enhanced to allow it to destroy the content of an initialization list
• Add-ons
  • The script array add-on uses the new form for the initialization list
  • The weakref add-on now works properly in AS_MAX_PORTABILITY too
  • Fixed bug in script array resize() method that could cause a crash if reserving too much memory (Thanks Philip Bennefall)
  • Fixed compiler error in CDebugger add-on when using the AngelScript namespace (Thanks Jordi Oliveras Rovira)
  • The dictionary add-on now supports initialization lists
  • The Complex math add-on now supports initialization lists

Version 2.27.1 - 2013/08/16

• Bug fixes
  • Engine no longer accepts registering template factory with autohandles
  • Implicit conversion to ASHANDLE type will not copy the value any longer
  • Fixed 64bit bug in asBC_SwapPtr (Thanks Colin Didier)
  • Fixed bug in the compiler when dealing with opAssign that returns anything else than a reference (Thanks neorej16)
  • Compiler was incorrectly reusing temporary variables in some expressions with ternary condition operator (Thanks neorej16)
  • Compiler was incorrectly making a copy of the object in some cases for explicit ref casts
• Library
  • Reduced memory footprint for applications with a lot of registered functions
• Script language
  • For consistency @null is now a valid expression
  • Default arguments can be used with anonymous parameters (Thanks Sir Ementaler)
  • void is a legal expression and can be used to ignore output parameters
• Add-ons & samples
  • Fixed bug in CScriptBuilder with loading an empty file (Thanks Piotr Kosek)
  • Implemented a different ExecuteString that can return a value of variable type

Version 2.27.0 - 2013/07/28

• Bug fixes
  • Compiler would call a script class' opAssign method as if it was a system function in a specific situation causing a crash (Thanks Polyák István)
  • A compound assignment to a class member could be compiled incorrectly if the lvalue had deferred parameters in expression (Thanks Polyák István)
  • GetExceptionLineNumber would crash if the exception had been raised in a generated function (Thanks Polyák István)
  • Fixed compiler error on FreeBSD (Thanks Veniamin Gvozdikov)
  • Compiler didn't detect ambigious enum values when compiling initialization of global variables
  • Nested calls in context could overwrite value in register (Thanks Philip Bennefall)
  • Fixed bug with max portability and delegates (Thanks Andris Jaunzeikars)
  • Fixed memory leak in compiler with shared classes and virtual properties (Thanks Xifos)
  • Function pointers for global functions in namespaces wasn't resolving properly (Thanks Violet CLM)
  • Registered value types that didn't have size evenly divisable of 4 weren't allocated with enough space (Thanks Hermann Noll)
  • Class methods with default args using parenthesis failed to parse (Thanks Aaron Baker)
  • Template arguments declared as const T@ will keep the handle-to-const attribute in template instances
• Library interface
  • Removed previously deprecated methods
  • Added GetModule method to the asIScriptFunction and asIObjectType interfaces
  • Added Discard to the asIScriptModule interface, that does the same as asIScriptEngine::DiscardModule
  • Added GetDelegateObject and GetDelegateFunction to asIScriptFunction
  • Added CreateDelegate to asIScriptEngine
  • RegisterObjectBehaviour and RegisterStringFactory now accepts asCALL_THISCALL_ASGLOBAL
  • Added type modifier asTM_CONST to indicate parameters and return types that are const references (Thanks Polyák István)
  • GetArgTypeId and GetReturnTypeId now have optional parameter to retrieve the type modifier flags
  • Added GetFuncDefFromTypeId to allow getting the asIScriptFunction for a function definition (Thanks Polyák István)
  • NotifyGarbageCollectorOfNewObject will return the sequence number attributed to the object
  • Added GetObjectInGC to allow inspecting objects that are currently known by the GC
  • The new behaviour asBEHAVE_GET_WEAKREF_FLAG was added to support weak references (Thanks vroad)
  • Added the interface asILockableSharedBool for the weak ref flag
  • Global asCreateLockableSharedBool can be used by application classes to create instances of shared booleans
  • CreateScriptObject, CreateScriptObjectCopy and CreateUnitializedScriptObject now takes an asIObjectType instead of type id
  • AssignScriptObject also takes an asIObjectType instead of type id
  • Deprecated AddRefScriptObject and ReleaseScriptObject that takes type id
• Library
  • Improved performance of thread manager and with that reduced the overhead of script calls (Thanks Andrew Ackermann)
  • GC now gives an id for each object from a sequence and reports this when it cannot destroy an object
  • GC will call script class destructor before breaking circular references (Thanks hupsilardee)
  • Engine no longer silently accepts modifications to built-in types by the application (Thanks Violet CLM)
  • Added support for weak references (Thanks vroad)
• Script language
  • Literal float and double constants accept the format 1e5 (Thanks Jason Goepel)
  • Template subtypes can no longer be declared as read-only
  • Derived classes can no longer override base methods with different return types (Thanks Philip Bennefall)
• Add-ons & samples
  • Script array add-on can now sort arrays of handles by calling the opCmp on the objects (Thanks Polyák István)
  • Script array does a better search for matching opCmp and opEquals (Thanks Polyák István)
  • Fixed compilation error with has_trivial_destructor on g++ 4.8 in GetTypeTraits (Thanks Craig Soutar)
  • Added the weakref add-on (Thanks vroad)
  • The game sample uses the weakref add-on

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 instantiated 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 constants (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 unnecessary 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 independent 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.