AngelScript Change Log
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 Colin Vella, a.k.a 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 Colin Vella, a.k.a 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.