As the title implys, I have an idea where we can use AngelScript; an Open Source coding script into a new emulator for better functionality, etc.
It wil be worth it looking at the features and improved speed displayed bellow.
This may or may improve the emulator's functions and certain systems within the emulator, improve stability and improve speed within the emulator on start up, etc.
Post any comments, ideas, criticism regarding my thread.
AngelScript Website:
AngelCode.com - scripting library
Here's some information regarding "AngelCode";
Features
Script language
Familiar syntax - The script syntax is similar to that of C or C++, with only a few differences.
Statically typed - Unlike most scripting languages that are dynamically typed this one uses the same static types as C++, and applications can register additional types.
Object oriented - The script language allows for declaration of classes, with support for single inheritance and polymorphism through interfaces.
Object handles - Pointers are not safe in a scripted environment, so AngelScript uses object handles instead. Object handles are almost like smart pointers, that control the life time of the object they hold.
Sandboxing -
The library provides a secure environment for the scripts, i.e. the scripts can only access what the application explicitly exposes, and any built-in script objects are completely secure.
International support - The script files can be encoded in ASCII or UTF-8. String constants can include UTF-8 encoded characters directly or can use escape sequences to add specific unicode code points. UTF-16 encoded string literals is also supported.
Engine
Run-time compiled - The library compiles the scripts into byte code and executes the byte code through a virtual machine.
Step by step execution - The scripts may be executed line by line, for controlled execution and debugging.
Detailed exceptions - When an exception occurs information about why and where can easily be obtained.
Line interpretation - The engine can interpret separate script lines using the currently compiled script. Useful for Quake like consoles.
Saving/loading byte code - The compiled bytecode can be saved and reloaded at a later time.
Modular - Scripts can be compiled into modules that can be dynamically linked with each other.
Concurrent scripts - Several scripts can be executed in parallel, by suspending and resuming them one by one. This allows for easy implementation of multi-tasking schemes, or even co-routines.
Debugging support - The application can examine the call stack and the value of local variables while running the scripts. The line callback feature allows the application to use breakpoints, do profiling, etc.
Integration
Direct access - The script engine can directly access and use registered functions, objects, and object members without the need to write proxy functions (where native calling conventions are supported).
C and C++ interface - There is a flat C interface that can be used by languages that don't interact well with C++ interfaces. It has also successfully been used in Delphi projects.
Multithreading - The library can be used in a multithreaded environment.
Memory management - Objects are reference counted for easy management of objects that pass between script and application. An iterative garbage collector is used where circular references can occur. The application can also completely control the library's memory usage.
Portability
Cross platform - It has been confirmed to work on Win32, Linux, MacOS X, XBox, XBox 360, PS2, PSP, PS3, Dreamcast, Nintendo DS, Windows Mobile, iPhone, and Android.
CPU independent - Both 32bit and 64bit platforms are supported. Both big endian and little endian CPUs are supported. Confirmed CPUs: x86, amd64, sh4, mips, ppc, ppc64, arm.
Compiler support - It works with MSVC++, GNUC, MinGW, DJGPP, Borland C++ Builder. Other compilers haven't been formally tested.
Native calling conventions - The library support native functions, i.e. without the need for wrappers on the following configurations and other compatible ones:
Win32 - MSVC - x86
Win32 - MinGW - x86
Win32 CE - MSVC - arm
Win64 - MSVC - x86/64
Linux - GNUC - x86
Linux - GNUC - x86/64
MacOS X - GNUC - x86
MacOS X - GNUC - ppc
IPhone - GNUC - arm
FreeBSD - GNUC - x86
Dreamcast - GNUC - sh4
PSP - GNUC - mips
PS2 - GNUC - mips
PS3 - GNUC - ppc/64
XBox - MSVC - x86
XBox 360 - MSVC - ppc/64
Android - GNUC - arm
Maximum portability mode - When the library is compiled in this mode it should work on just about any compiler/platform that can compile standard compliant C++ code. Some features like native calling conventions are not available in this mode.
Cross language - With the flat C interface, other languages, such as Delphi, are also able to use the library.
Other
No costs - The scripting library is completely free for all use, though donations are appreciated.
Well documented - Both the script language and library is documented.