StringSplit(std::string str, std::string delim);
@@ -39,6 +45,7 @@ cPluginManager::cPluginManager()
cPluginManager::~cPluginManager()
{
UnloadPluginsNow();
+
delete m_LuaCommandBinder;
delete m_pState;
}
@@ -54,6 +61,16 @@ void cPluginManager::ReloadPluginsNow()
m_bReloadPlugins = false;
UnloadPluginsNow();
+
+
+#if USE_SQUIRREL
+ if( !SquirrelBindings::IsBound ) // Can only do this once apparently, or we're making ambiguous calls in the script
+ {
+ SquirrelVM::Init();
+ SquirrelBindings::Bind( SquirrelVM::GetVMPtr() );
+ }
+#endif
+
cIniFile IniFile("settings.ini");
if( IniFile.ReadFile() )
{
@@ -64,10 +81,10 @@ void cPluginManager::ReloadPluginsNow()
for(unsigned int i = 0; i < NumPlugins; i++)
{
std::string ValueName = IniFile.GetValueName(KeyNum, i );
- if( ValueName.compare("Plugin") == 0 )
- { // It's a plugin
+ if( ValueName.compare("Plugin") == 0 ) // It's a Lua plugin
+ {
std::string PluginFile = IniFile.GetValue(KeyNum, i );
- if( PluginFile.compare("") != 0 )
+ if( !PluginFile.empty() )
{
// allow for comma separated plugin list
// degrades and works fine for the plugin
@@ -82,6 +99,32 @@ void cPluginManager::ReloadPluginsNow()
}
}
}
+#if USE_SQUIRREL
+ else if( ValueName.compare("Squirrel") == 0 ) // Squirrel plugin
+ {
+ std::string PluginFile = IniFile.GetValue(KeyNum, i );
+ if( !PluginFile.empty() )
+ {
+ LOGINFO("Loading Squirrel plugin: %s", PluginFile.c_str() );
+ try
+ {
+ SquirrelObject SquirrelScript = SquirrelVM::CompileScript( (std::string("Plugins/") + PluginFile + ".nut").c_str() );
+ try
+ {
+ SquirrelVM::RunScript( SquirrelScript );
+ }
+ catch (SquirrelError & e)
+ {
+ LOGERROR("Error: %s, %s\n", e.desc, "SquirrelVM::RunScript");
+ }
+ }
+ catch (SquirrelError & e)
+ {
+ LOGERROR("Error: %s, %s\n", e.desc, "SquirrelVM::CompileScript");
+ }
+ }
+ }
+#endif
}
}
@@ -98,6 +141,8 @@ void cPluginManager::ReloadPluginsNow()
{
LOG("WARNING: Can't find settings.ini, so can't load any plugins.");
}
+
+
LOG("--Done loading plugins--");
}
@@ -291,11 +336,11 @@ bool cPluginManager::CallHook( PluginHook a_Hook, unsigned int a_NumArgs, ... )
return false;
}
-cPlugin* cPluginManager::GetPlugin( std::string a_Plugin )
+cPlugin* cPluginManager::GetPlugin( const char* a_Plugin )
{
for( PluginList::iterator itr = m_pState->Plugins.begin(); itr != m_pState->Plugins.end(); ++itr )
{
- if( (*itr)->GetName().compare( a_Plugin ) == 0 )
+ if( std::string( (*itr)->GetName() ).compare( a_Plugin ) == 0 )
{
return *itr;
}
@@ -328,6 +373,25 @@ void cPluginManager::UnloadPluginsNow()
{
RemovePlugin( *m_pState->Plugins.begin(), true );
}
+
+ //SquirrelVM::Shutdown(); // This breaks shit
+}
+
+void cPluginManager::RemoveHooks( cPlugin* a_Plugin )
+{
+ m_pState->Hooks[ E_PLUGIN_TICK ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_CHAT ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_COLLECT_ITEM ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_BLOCK_DIG ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_BLOCK_PLACE ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_DISCONNECT ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_HANDSHAKE ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_LOGIN ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_PLAYER_SPAWN ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_PLAYER_JOIN ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_PLAYER_MOVE ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_TAKE_DAMAGE ].remove( a_Plugin );
+ m_pState->Hooks[ E_PLUGIN_KILLED ].remove( a_Plugin );
}
void cPluginManager::RemovePlugin( cPlugin* a_Plugin, bool a_bDelete /* = false */ )
@@ -336,8 +400,10 @@ void cPluginManager::RemovePlugin( cPlugin* a_Plugin, bool a_bDelete /* = false
{
m_LuaCommandBinder->RemoveBindingsForPlugin( a_Plugin );
m_pState->Plugins.remove( a_Plugin );
+ RemoveHooks( a_Plugin );
a_Plugin->OnDisable();
- delete a_Plugin;
+ if( a_Plugin->GetLanguage() != cPlugin::E_SQUIRREL ) // Squirrel needs to clean it up himself!
+ delete a_Plugin;
}
else
{
@@ -356,11 +422,14 @@ bool cPluginManager::AddPlugin( cPlugin* a_Plugin )
m_pState->Plugins.push_back( a_Plugin );
return true;
}
+
+ RemoveHooks( a_Plugin ); // Undo any damage the Initialize() might have done
return false;
}
bool cPluginManager::AddPlugin( lua_State* a_LuaState, cPlugin* a_Plugin )
{
+ a_Plugin->SetLanguage( cPlugin::E_LUA );
cPlugin_Lua* LuaPlugin = GetLuaPlugin( a_LuaState );
if( LuaPlugin && a_Plugin->Initialize() )
{
@@ -391,8 +460,8 @@ void cPluginManager::RemoveLuaPlugin( std::string a_FileName )
if( (*itr)->GetFileName() == a_FileName )
{
cPlugin_Lua* Plugin = *itr;
- delete Plugin;
m_pState->LuaPlugins.remove( Plugin );
+ delete Plugin;
return;
}
}
diff --git a/source/cPluginManager.h b/source/cPluginManager.h
index 6a94060e0..ebe974b11 100644
--- a/source/cPluginManager.h
+++ b/source/cPluginManager.h
@@ -34,7 +34,7 @@ public: //tolua_export
static cPluginManager * GetPluginManager(); //tolua_export
typedef std::list< cPlugin* > PluginList;
- cPlugin* GetPlugin( std::string a_Plugin ); //tolua_export
+ cPlugin* GetPlugin( const char* a_Plugin ); //tolua_export
const PluginList & GetAllPlugins(); // >> EXPORTED IN MANUALBINDINGS <<
void ReloadPlugins(); //tolua_export
@@ -47,6 +47,7 @@ public: //tolua_export
bool CallHook( PluginHook a_Hook, unsigned int a_NumArgs, ... );
+ void RemoveHooks( cPlugin* a_Plugin );
void RemovePlugin( cPlugin* a_Plugin, bool a_bDelete = false ); //tolua_export
void RemoveLuaPlugin( std::string a_FileName ); //tolua_export
cPlugin_Lua* GetLuaPlugin( lua_State* a_State ); //tolua_export
diff --git a/source/cWebAdmin.cpp b/source/cWebAdmin.cpp
index 03775ee3f..bc22a4681 100644
--- a/source/cWebAdmin.cpp
+++ b/source/cWebAdmin.cpp
@@ -109,7 +109,7 @@ void cWebAdmin::Request_Handler(webserver::http_request* r)
const cPluginManager::PluginList & List = PM->GetAllPlugins();
for( cPluginManager::PluginList::const_iterator itr = List.begin(); itr != List.end(); ++itr )
{
- Content += (*itr)->GetName() + "
";
+ Content += std::string( (*itr)->GetName() ) + "
";
}
Content += "";
Content += "Players:
";
diff --git a/source/main.cpp b/source/main.cpp
index 1868e30ca..cbe499281 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -9,6 +9,13 @@
#include //std::signal
#include //exit()
+#include "SquirrelBindings.h"
+#if USE_SQUIRREL
+#pragma warning(disable:4100;disable:4127;disable:4510;disable:4610;disable:4244;disable:4512) // Getting A LOT of these warnings from SqPlus
+#include
+#pragma warning(default:4100;default:4127;default:4510;default:4610;default:4244;default:4512)
+#endif
+
void ShowCrashReport(int)
{
std::signal(SIGSEGV, SIG_DFL);
@@ -43,6 +50,11 @@ int main( int argc, char **argv )
{
LOGERROR("Unknown exception!");
}
+
+#if USE_SQUIRREL
+ SquirrelVM::Shutdown();
+#endif
+
#ifdef _DEBUG
_CrtDumpMemoryLeaks();
#endif
diff --git a/squirrel_3_0_1_stable/COMPILE b/squirrel_3_0_1_stable/COMPILE
new file mode 100644
index 000000000..d032a2f4e
--- /dev/null
+++ b/squirrel_3_0_1_stable/COMPILE
@@ -0,0 +1,41 @@
+Squirrel 3.0 stable
+--------------------------------------------------------
+What is in this distribution?
+
+squirrel
+ static library implementing the compiler and interpreter of the language
+
+sqstdlib
+ the standard utility libraries
+
+sq
+ stand alone interpreter
+
+doc
+ The manual
+
+etc
+ a minimalistic embedding sample
+
+samples
+ samples programs
+
+
+HOW TO COMPILE
+---------------------------------------------------------
+GCC USERS
+.........................................................
+There is a very simple makefile that compiles all libraries and exes
+from the root of the project run 'make'
+
+for 32 bits systems
+
+ $ make
+
+for 64 bits systems
+
+ $ make sq64
+
+VISUAL C++ USERS
+.........................................................
+Open squirrel.dsw from the root project directory and build(dho!)
\ No newline at end of file
diff --git a/squirrel_3_0_1_stable/COPYRIGHT b/squirrel_3_0_1_stable/COPYRIGHT
new file mode 100644
index 000000000..40bea1615
--- /dev/null
+++ b/squirrel_3_0_1_stable/COPYRIGHT
@@ -0,0 +1,21 @@
+Copyright (c) 2003-2011 Alberto Demichelis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------
+END OF COPYRIGHT
diff --git a/squirrel_3_0_1_stable/HISTORY b/squirrel_3_0_1_stable/HISTORY
new file mode 100644
index 000000000..d16ae44cc
--- /dev/null
+++ b/squirrel_3_0_1_stable/HISTORY
@@ -0,0 +1,422 @@
+***version 3.0.1 stable***
+-added # as alternative symbol for "line comment"(mostly useful for shell scripts)
+-added sq_throwobject() to throw an arbitrary object from the C API
+-added alignement flag for userdata types, SQ_ALIGNMENT (thx Shigemasa)
+-added rawset() and rawget() to class and instance default delegate
+-changed bytecode format now ensures matching integer size and float size
+-now inherited classes also inherit userdatasize
+-added SQUIRREL_VERSION_NUMBER in squirrel.h and _versionnumber_ global symbol
+-fixed sq_getmemberhandle
+-fixed sq_getrefcount
+-refactored some sqstdio code
+-refactored some clone code
+-refactored some stuff in the string lib
+-added -s and -fno-exceptions in GCC makefile(better performance when using GCC)
+
+***2011-03-13 ***
+***version 3.0 stable***
+-added sq_getcallee()
+-sq_getfreevariable() also works for native closures
+-minior optimizations
+-removed several warning when compiling with GCC 4.x
+-fixed some errors in the documentation
+-fixed bug when using SQUSEDOUBLE and 32bits intengers
+-fixed bug when invoking generators with closure.call() (thx huntercool)
+
+***2010-12-19 ***
+***version 3.0 release candidate 1(RC 1)***
+-improved metamethods error handling
+-added parameter 'isstatic' to _newmember metamethod(thx G.Meyer)
+-added sq_getrefcount() to return number of refences from C++(thx G.Meyer)
+
+***2010-11-07 ***
+***version 3.0 beta 3***
+-license changed to "MIT license"
+-added sq_resurrectunreachable() and resurrectunreachable()
+-added callee() built in function, returns the current running closure
+-added thread.getstackinfos()
+-added sq_objtouserpointer()
+-added sq_newtableex()
+-various refactoring and optimizations
+-fixed several 64bits issues regarding integer to string conversions
+-fixed some bugs when SQUSEDOUBLE is used in 32bits systems
+
+***2010-08-18 ***
+***version 3.0 beta 2.1***
+-fixed bug in class constructor
+-fixed bug in compound arith
+
+***2010-08-12 ***
+***version 3.0 beta 2***
+-class methods can be added or replaced after the class as been instantiated
+-JSON compliant table syntax, this is currently an experimental feature (thx atai)
+-sq_getsize() now returns userdatasize for classes and instances
+-now setroottable() and setconsttable() return the previous value of the respective table
+-fixed bug in compound arith operators when used on a free variable (thx ellon)
+-fixed some x64 minor bugs
+-fixed minor bug in the compiler
+-refactored some VM internals
+-documented sq_getmemberhandle, sq_getbyhandle, sq_setbyhandle to set and get value from classes
+
+***2009-11-15 ***
+***version 3.0 beta 1***
+-various refactoring and optimizations
+-fixed bug in free variables (thx mokehehe)
+-fixed bug in functions with default parameters (thx ara & Yexo)
+-fixed bug in exception handling
+-improved error propagation in _set and _get metamethods ( and 'throw null' for clean failure)
+-added sq_getmemberhandle, sq_getbyhandle, sq_setbyhandle to set and get value from classes
+
+***2009-06-30 ***
+***version 3.0 alpha 2***
+-added real free variables(thx Paul Ruizendaal)
+-added refactored function call implementation and compiler(thx Paul Ruizendaal)
+-added sq_getfunctioninfo
+-added compile time flag SQUSEDOUBLE to use double precision floats
+-added global slot _floatsize_ int the base lib to recognize single precision and double precision builds
+-sq_wakeupvm can now resume the vm with an exception
+-added sqstd_format
+-now blobs can be cloned
+-generators can now be instantiated by calling sq_call() or closure.call()
+-fixed debughook bug
+-fixed cooroutine error propagation
+
+***2008-07-23 ***
+***version 3.0 alpha 1***
+-first branch from 2.x source tree
+-added 'base' keyword
+-removed 'delegate' keyword
+-now compiled scripts are vararg functions
+-added setdelegate() and getdelegate() table builtin methods
+-added <=> 3 ways compare operator
+-added lambda expression @(a,b) a + b
+-added local function statement
+-added array built-in map(),reduce(),apply(),filter() and find()
+-generators hold only a weak reference of the enviroment object
+-removed 'vargv' and 'vargc' keywords
+-now var args are passed as an array called vargv(as a paramter)
+-removed 'parent' keyword
+-added class getbase() built in method
+-instanceof doesn't throw an exception if the left expression is not a class
+-lexical scoping for free variables(free variables are no longer in the second parameter list)
+-sq_setprintfunc accept error func
+-sq_geterrorfunc()
+-added sq_arrayremove() and sq_arrayinsert()
+-error() built in function(works like print but prints using the errorfunc)
+-added native debug hook
+
+***2008-02-17 ***
+***version 2.2 stable***
+-added _newslot metamethod in classes
+-added enums added constants
+-added sq_pushconsttable, sq_setconsttable
+-added default param
+-added octal literals(thx Dinosaur)
+-fixed debug hook, 'calls' and 'returns' are properly notified in the same number.
+-fixed a coroutine bug
+
+***2007-07-29 ***
+***version 2.1.2 stable***
+-new behaviour for generators iteration using foreach
+now when a generator is iterated by foreach the value returned by a 'return val' statement
+will terminate the iteration but will not be returned as foreach iteration
+-added sq_setclassudsize()
+-added sq_clear()
+-added table.clear(), array.clear()
+-fixed sq_cmp() (thx jyuill)
+-fixed minor bugs
+
+***2006-08-21 ***
+***version 2.1.1 stable***
+-vm refactoring
+-optimized internal function memory layout
+-new global symbol _version_ (is the version string)
+-code size optimization for float literals(on 32bits float builts)
+-now the raw ref API(sq_addref etc...) is fully reentrant.
+-fixed a bug in sq_getdelegate() now pushes null if the object doesn't have a delegate(thx MatzeB)
+-improved C reference performances in NO_GARBAGE_COLLECTOR builds
+-sq_getlocal() now enumerates also outer values.
+-fixed regexp library for GCC users.
+
+***2006-03-19 ***
+***version 2.1 stable***
+-added static class fields, new keyword static
+-added 64bits architecture support
+-added global slot _intsize_ int the base lib to recognize 32bits and 64bits builds
+-added functions with fixed environment, closure.bindenv() built-in function
+-all types except userdata and null implement the tostring() method
+-string concatenation now invokes metamethod _tostring
+-new metamethods for class objects _newmember and _inherited
+-sq_call() sq_resume() sq_wakeupvm() have a new signature
+-new C referencing implementation(scales more with the amount of references)
+-refactored hash table
+-new api functions sq_newslot(),sq_tobool(),sq_getbase(), sq_instanceof(), sq_bindenv()
+-the api func sq_createslot was deprecated but still supported in form of C macro on top of sq_newslot
+-sq_setreleasehook() now also works for classes
+-stream.readstr() and stream.writestr() have been deprecated(this affects file and blob)
+-fixed squirrel.h undeclared api calls
+-fixed few minor bugs
+-SQChar is now defined as wchar_t
+-removed warning when building with -Wall -pedantic for GCC users
+-added new std io function writeclosuretofile()
+-added new std string functions strip(),rstrip(),lstrip() and split()
+-regular expressions operators (+,*) now have more POSIX greedyness behaviour
+-class constructors are now invoked as normal functions
+
+***2005-10-02 ***
+***version 2.0.5 stable***
+-fixed some 64bits incompatibilities (thx sarge)
+-fixed minor bug in the stdlib format() function (thx Rick)
+-fixed a bug in dofile() that was preventing to compile empty files
+-added new API sq_poptop() & sq_getfreevariable()
+-some performance improvements
+
+***2005-08-14 ***
+***version 2.0.4 stable***
+-weak references and related API calls
+-added sq_objtobool()
+-class instances memory policies improved(1 mem allocation for the whole instance)
+-typetags are now declared as SQUserPointer instead of unsigned int
+-first pass for 64bits compatibility
+-fixed minor bug in the stdio stream
+-fixed a bug in format()
+-fixed bug in string.tointeger() and string.tofloat()
+
+***2005-06-24 ***
+***version 2.0.3 stable***
+-dofile() and loadfile() in the iolib now can decode ASCII, UTF8 files UCS2 big-endian and little-endian
+-sq_setparamscheck() : now typemesk can check for null
+-added string escape sequence \xhhhh
+-fixed some C++ standard incompatibilities
+
+***2005-05-15 ***
+***version 2.0.2 stable***
+-performances improvements (expecially for GCC users)
+-removed all dependencies from C++ exception handling
+-various bugfixes
+
+***2005-04-12 ***
+***version 2.0.1 stable***
+-various bugfixes
+-sq_setparamscheck() now allows spaces in the typemask
+
+***2005-04-03 ***
+***version 2.0 stable***
+-added API sq_gettypetag()
+-added built-in function to the bool type(tointeger, tostring etc...)
+
+***2005-02-27 ***
+***version 2.0 release candidate 1(RC 1)***
+-added API sq_reseterror()
+-modified sq_release()
+-now class instances can be cloned
+-various bufixes
+
+***2005-01-26 ***
+***version 2.0 beta 1***
+-added bool type
+-class properties can be redefined in a derived class
+-added ops *= /= and %=
+-new syntax for class attributes declaration instead of ( and )
+-increased the max number of literals per function from 65535 to 16777215
+-now free variables have proper lexical scoping
+-added API sq_createinstance(), sq_pushbool(), sq_getbool()
+-added built-in function type()
+-added built-in function obj.rawin(key) in table,class and instance
+-sq_rawget() and sq_rawset() now work also on classes and instances
+-the VM no longer uses C++ exception handling (more suitable for embedded devices)
+-various bufixes
+
+***2004-12-21 ***
+***version 2.0 alpha 2***
+-globals scoping changed, now if :: is omitted the VM automatically falls back on the root table
+-various bufixes
+-added class level attributes
+
+***2004-12-12 ***
+***version 2.0 alpha 1***
+-codebase branch from version 1.x
+-added classes
+-added functions with variable number of parameters(vargc & vargv and the ...)
+-0 and 0.0 are now considered 'false' by all conditional statements(if,while,for,?,do-while)
+-added new api functions sq_newclass() sq_setinstanceup() sq_getinstanceup() sq_getattributes() sq_setattributes()
+-modified api sq_settypetag()
+
+***2004-11-01 ***
+***version 1.0 stable***
+-fixed some minor bug
+-improved operator 'delete' performances
+-added scientific notation for float numbers( eg. 2.e16 or 2.e-2)
+
+***2004-08-30 ***
+***version 1.0 release candidate 2(RC 2)***
+-fixed bug in the vm(thx Pierre Renaux)
+-fixed bug in the optimizer(thx Pierre Renaux)
+-fixed some bug in the documentation(thx JD)
+-added new api functions for raw object handling
+-removed nested multiline comments
+-reduced memory footprint in C references
+
+***2004-08-23 ***
+***version 1.0 release candidate 1(RC 1)***
+-fixed division by zero
+-the 'in' operator and obj.rawget() do not query the default delegate anymore
+-added function sq_getprintfunc()
+-added new standard library 'auxlib'(implements default error handlers)
+
+***2004-07-12 ***
+***version 1.0 beta 4***
+-fixed a bug in the integer.tochar() built-in method
+-fixed unary minus operator
+-fixed bug in dofile()
+-fixed inconsistency between != and == operators(on float/integer comparison)
+-added javascript style unsigned right shift operator '>>>'
+-added array(size) constructor built-in function
+-array.resize(size,[fill]) built-in function accepts an optional 'fill' value
+-improved debug API, added sq_getclosureinfo() and sq_setnativeclosurename()
+
+***2004-05-23 ***
+***version 1.0 beta 3***
+-minor vm bug fixes
+-string allocation is now faster
+-tables and array memory usage is now less conservative(they shrink)
+-added regular expression routines in the standard library
+-The 'c' expression now accepts only 1 character(thx irbrian)
+-multiline strings <[ ]> have been substituted with C# style verbatim strings (eg. @"string")
+-added new keyword 'parent' for accessing the delegate of tables and unserdata
+-The metamethod '_clone' has been renamed '_cloned'
+-the _delslot metamethod's behaviour and prototype have been changed
+-new default function in the integer and float object 'tochar()'
+-the built-in function chcode2string has been removed
+-the default method [table].getdelegate() has been removed
+-new api sq_rawdeleteslot()
+-new table built-in method rawdelete(key)
+-the dynamic mudule loading has been removed from the standard distribution
+-some optimizations in the VM
+
+***2004-04-21 ***
+***version 1.0 beta 2***
+-minor compiler/parser bug fixes
+-sq_newclosure has a different prototype, the "paramscheck" of paramter has been moved to the new function sq_setparamscheck()
+-sq_setparamscheck allows to add automatic parameters type checking in native closures
+-sq_compile() lost the lineinfo parameter
+-new api sq_enabledebuginfo() globally sets compiler's debug info generation
+-added consistency check on bytecode serialization
+-fixed += operator, now works on strings like +
+-added global slot in the base lib _charsize_ to recognize unicode builds from ascii builds runtime
+-added registry table
+-new api call sq_pushregistrytable()
+-added type tag to the userdata type sq_settypetag()
+-sq_getuserdata now queries the userdata typetag
+-the built in function collect_garbage() as been renamed collectgarbage() for consistency reasons
+-new standard libraries(sqlibs are now obsolete)
+
+***2004-02-20 ***
+***version 1.0 beta 1***
+-fixed a bug in the compiler (thanks Martin Kofler)
+-fixed bug in the switch case statement
+-fixed the _unm metamethod
+-fixed minor bugs in the API
+-fixed automatic stack resizing
+-first beta version
+ first pass code clean up in the VM and base lib
+ first pass code coverege test has been done on VM and built-in lib
+-new VM creation API sq_open() sq_close() (sq_newvm and sq_releasevm are now obsolete)
+-new api allows to specifiy a "print" function to output text(sq_printfunc)
+-added some small optimizations
+-new cooperative multi-threading capabilities in the base library(coroutines), VMs are now a built in type("thread")
+-new built in functions have been added for manipulating the new "thread" type
+-friend virtual machines share the same root table, error handler and debug hook by default
+-new compile time options
+
+***2004-01-19 ***
+***version 0.9 alpha***
+-fixed a garbage collection bug
+-fixed some API bugs(thanks to Joshua Jensen)
+-fixed tail calls (in the version 0.8 the tail call optimization was erroneously disabled)
+-new function parameters semantic, now passing a wrong number of parameters generates an exception
+-native closures have now a built in parameter number checking
+-sq_rawget and sq_rawset now work also on arrays
+-sq_getsize now woks also on userdata
+-the userdata release hook prototype is changed(now passes the size of the userdata)
+-the lexer reader function now returns an integer instead of a char that allows better error checking on the input(thx Joshua Jensen)
+-faster compiler
+-try/catch blocks do not cause any runtime memory allocation anymore
+
+***2003-12-06 ***
+***version 0.8 alpha***
+-fixed a bug that was preventing to have callable userdata throught the metamethod _call
+-fixed a garbage collection bug
+-fixed == operator now can compare correctly different types
+-new built in method getstackinfos(level)
+-improved line informations precision for the debug hook
+-new api call sq_compilebuffer()
+-new built-in api function compilestring()
+-new syntactic sugar for function declarations inside tables
+-the debug API has been finalized
+
+***2003-11-17 ***
+***version 0.7 alpha***
+-fixed critical bug SQInteger the tail call system
+-fixed bug in the continue statement code generation
+-fixed func call param issue(thanks to Rewoonenco Andrew)
+-added _delslot metamethod(thanks to Rewoonenco Andrew)
+-new multiline string expression ( delimited by <[ and ]> )
+-normal strings ("") do not allow embedded new line anymore
+-reduced vm memory footprint(C refs are shared between friend VMs)
+-new api method sq_deleteslot()
+-new debug hook event 'r' is triggered when a function returns
+
+***2003-11-04 ***
+***version 0.6 alpha***
+-fixed switch statement(was executing the default case after a break)
+-sq_call() doesn't pop the closure (just the params)
+-the vm execution can be suspended from the C API anytime (micro-threads)
+-new api calls sq_suspendvm() sq_wakeupvm() sq_getvmstate() and sq_reservestack()
+
+***2003-10-13 ***
+***version 0.5 alpha***
+-fixed some minor bug
+-tested with non ASCII identifiers in unicode mode(I've tried chinese chars)
+-added built-in function string.find()
+-the built-in function array.sort() optionally accepts a cmp(a,b) function
+-the debug hook function now has a new prototype debug_hook(event_type,sourcefile,line,functionname)
+-fixed some debug info imprecision
+
+***2003-10-01 ***
+***version 0.4 alpha***
+-faster VM
+-sq_call will pop arguments and closure also in case of failure
+-fixed a bug in sq_remove
+-now the VM detects delegation cycles(and throws an exception)
+-new operators ++ and --
+-new operator ',' comma operator
+-fixed some expression precedence issue
+-fixed bug in sq_arraypop
+
+***2003-09-15 ***
+***version 0.3 alpha***
+-fixed a bug in array::insert()
+-optional Unicode core(define SQUNICODE or _UNICODE on Win32)
+-sq_compiler uses a new reader function SQLEXREADFUNC
+-the debug hook passes 'l' instead of 'line' for line callbacks
+ and 'c' instead of 'call' for call callbacks
+-new array.extend() bulit-in function
+-new API sq_clone()
+
+***2003-09-10 ***
+***version 0.2 pre-alpha***
+-new completely reentrant VM (sq_open and sq_close are now obsolete)
+-sq_newvm() has a new prototype
+-allocators are now global and linked in the VM
+-_newslot meta method added
+-rawset creates a slot if doesn't exists
+-the compiler error callback pass the vm handle(thanks Pierre Renaux)
+-sq_setforeignptr() sq_getforeingptr() are now public
+-sq_resume() now is possible to resume generators from C
+-sq_getlasterror() retrieve the last thrown error
+-improved docs
+
+***2003-09-06 ***
+***version 0.1 pre-alpha***
+first release
diff --git a/squirrel_3_0_1_stable/Makefile b/squirrel_3_0_1_stable/Makefile
new file mode 100644
index 000000000..8218f5bfa
--- /dev/null
+++ b/squirrel_3_0_1_stable/Makefile
@@ -0,0 +1,18 @@
+
+SQUIRREL=.
+MAKE=make
+
+sq32:
+ cd squirrel; $(MAKE)
+ cd sqstdlib; $(MAKE)
+ cd sq; $(MAKE)
+
+sqprof:
+ cd squirrel; $(MAKE) sqprof
+ cd sqstdlib; $(MAKE) sqprof
+ cd sq; $(MAKE) sqprof
+
+sq64:
+ cd squirrel; $(MAKE) sq64
+ cd sqstdlib; $(MAKE) sq64
+ cd sq; $(MAKE) sq64
diff --git a/squirrel_3_0_1_stable/README b/squirrel_3_0_1_stable/README
new file mode 100644
index 000000000..803b26aa1
--- /dev/null
+++ b/squirrel_3_0_1_stable/README
@@ -0,0 +1,23 @@
+The programming language SQUIRREL 3.0 stable
+
+--------------------------------------------------
+The project has been compiled and run on Windows(x86 and x64) and
+Linux(x86 and x64) and Solaris(x86 and x64).
+
+Has been tested with the following compilers:
+ MS Visual C++ 6.0,7.0,7.1,8.0,9.0,10.0 (32 and 64bits)
+ MinGW gcc 3.2 (mingw special 20020817-1)
+ Cygnus gcc 3.2
+ Linux gcc 3.2.3
+ Linux gcc 4.0.0 (x86 & 64bits)
+ Solaris gcc 4.0.0 (x86 & 64bits)
+
+
+Feedback and suggestions are appreciated
+project page - http://www.squirrel-lang.org
+community forums - http://forum.squirrel-lang.org
+wiki - http://wiki.squirrel-lang.org
+author - alberto@demichelis.net
+
+END OF README
+
diff --git a/squirrel_3_0_1_stable/include/sqstdaux.h b/squirrel_3_0_1_stable/include/sqstdaux.h
new file mode 100644
index 000000000..b90034823
--- /dev/null
+++ b/squirrel_3_0_1_stable/include/sqstdaux.h
@@ -0,0 +1,16 @@
+/* see copyright notice in squirrel.h */
+#ifndef _SQSTD_AUXLIB_H_
+#define _SQSTD_AUXLIB_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SQUIRREL_API void sqstd_seterrorhandlers(HSQUIRRELVM v);
+SQUIRREL_API void sqstd_printcallstack(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* _SQSTD_AUXLIB_H_ */
diff --git a/squirrel_3_0_1_stable/include/sqstdblob.h b/squirrel_3_0_1_stable/include/sqstdblob.h
new file mode 100644
index 000000000..eda4cc9c5
--- /dev/null
+++ b/squirrel_3_0_1_stable/include/sqstdblob.h
@@ -0,0 +1,20 @@
+/* see copyright notice in squirrel.h */
+#ifndef _SQSTDBLOB_H_
+#define _SQSTDBLOB_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SQUIRREL_API SQUserPointer sqstd_createblob(HSQUIRRELVM v, SQInteger size);
+SQUIRREL_API SQRESULT sqstd_getblob(HSQUIRRELVM v,SQInteger idx,SQUserPointer *ptr);
+SQUIRREL_API SQInteger sqstd_getblobsize(HSQUIRRELVM v,SQInteger idx);
+
+SQUIRREL_API SQRESULT sqstd_register_bloblib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQSTDBLOB_H_*/
+
diff --git a/squirrel_3_0_1_stable/include/sqstdio.h b/squirrel_3_0_1_stable/include/sqstdio.h
new file mode 100644
index 000000000..1174201a9
--- /dev/null
+++ b/squirrel_3_0_1_stable/include/sqstdio.h
@@ -0,0 +1,53 @@
+/* see copyright notice in squirrel.h */
+#ifndef _SQSTDIO_H_
+#define _SQSTDIO_H_
+
+#ifdef __cplusplus
+
+#define SQSTD_STREAM_TYPE_TAG 0x80000000
+
+struct SQStream {
+ virtual SQInteger Read(void *buffer, SQInteger size) = 0;
+ virtual SQInteger Write(void *buffer, SQInteger size) = 0;
+ virtual SQInteger Flush() = 0;
+ virtual SQInteger Tell() = 0;
+ virtual SQInteger Len() = 0;
+ virtual SQInteger Seek(SQInteger offset, SQInteger origin) = 0;
+ virtual bool IsValid() = 0;
+ virtual bool EOS() = 0;
+};
+
+extern "C" {
+#endif
+
+#define SQ_SEEK_CUR 0
+#define SQ_SEEK_END 1
+#define SQ_SEEK_SET 2
+
+typedef void* SQFILE;
+
+SQUIRREL_API SQFILE sqstd_fopen(const SQChar *,const SQChar *);
+SQUIRREL_API SQInteger sqstd_fread(SQUserPointer, SQInteger, SQInteger, SQFILE);
+SQUIRREL_API SQInteger sqstd_fwrite(const SQUserPointer, SQInteger, SQInteger, SQFILE);
+SQUIRREL_API SQInteger sqstd_fseek(SQFILE , SQInteger , SQInteger);
+SQUIRREL_API SQInteger sqstd_ftell(SQFILE);
+SQUIRREL_API SQInteger sqstd_fflush(SQFILE);
+SQUIRREL_API SQInteger sqstd_fclose(SQFILE);
+SQUIRREL_API SQInteger sqstd_feof(SQFILE);
+
+SQUIRREL_API SQRESULT sqstd_createfile(HSQUIRRELVM v, SQFILE file,SQBool own);
+SQUIRREL_API SQRESULT sqstd_getfile(HSQUIRRELVM v, SQInteger idx, SQFILE *file);
+
+//compiler helpers
+SQUIRREL_API SQRESULT sqstd_loadfile(HSQUIRRELVM v,const SQChar *filename,SQBool printerror);
+SQUIRREL_API SQRESULT sqstd_dofile(HSQUIRRELVM v,const SQChar *filename,SQBool retval,SQBool printerror);
+SQUIRREL_API SQRESULT sqstd_writeclosuretofile(HSQUIRRELVM v,const SQChar *filename);
+
+SQUIRREL_API SQRESULT sqstd_register_iolib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQSTDIO_H_*/
+
diff --git a/squirrel_3_0_1_stable/include/sqstdmath.h b/squirrel_3_0_1_stable/include/sqstdmath.h
new file mode 100644
index 000000000..420f2ce67
--- /dev/null
+++ b/squirrel_3_0_1_stable/include/sqstdmath.h
@@ -0,0 +1,15 @@
+/* see copyright notice in squirrel.h */
+#ifndef _SQSTD_MATH_H_
+#define _SQSTD_MATH_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SQUIRREL_API SQRESULT sqstd_register_mathlib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQSTD_MATH_H_*/
diff --git a/squirrel_3_0_1_stable/include/sqstdstring.h b/squirrel_3_0_1_stable/include/sqstdstring.h
new file mode 100644
index 000000000..771c2f658
--- /dev/null
+++ b/squirrel_3_0_1_stable/include/sqstdstring.h
@@ -0,0 +1,33 @@
+/* see copyright notice in squirrel.h */
+#ifndef _SQSTD_STRING_H_
+#define _SQSTD_STRING_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef unsigned int SQRexBool;
+typedef struct SQRex SQRex;
+
+typedef struct {
+ const SQChar *begin;
+ SQInteger len;
+} SQRexMatch;
+
+SQUIRREL_API SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error);
+SQUIRREL_API void sqstd_rex_free(SQRex *exp);
+SQUIRREL_API SQBool sqstd_rex_match(SQRex* exp,const SQChar* text);
+SQUIRREL_API SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end);
+SQUIRREL_API SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end);
+SQUIRREL_API SQInteger sqstd_rex_getsubexpcount(SQRex* exp);
+SQUIRREL_API SQBool sqstd_rex_getsubexp(SQRex* exp, SQInteger n, SQRexMatch *subexp);
+
+SQUIRREL_API SQRESULT sqstd_format(HSQUIRRELVM v,SQInteger nformatstringidx,SQInteger *outlen,SQChar **output);
+
+SQUIRREL_API SQRESULT sqstd_register_stringlib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQSTD_STRING_H_*/
diff --git a/squirrel_3_0_1_stable/include/sqstdsystem.h b/squirrel_3_0_1_stable/include/sqstdsystem.h
new file mode 100644
index 000000000..daefa0fd5
--- /dev/null
+++ b/squirrel_3_0_1_stable/include/sqstdsystem.h
@@ -0,0 +1,15 @@
+/* see copyright notice in squirrel.h */
+#ifndef _SQSTD_SYSTEMLIB_H_
+#define _SQSTD_SYSTEMLIB_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SQUIRREL_API SQInteger sqstd_register_systemlib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* _SQSTD_SYSTEMLIB_H_ */
diff --git a/squirrel_3_0_1_stable/include/squirrel.h b/squirrel_3_0_1_stable/include/squirrel.h
new file mode 100644
index 000000000..baaaf39c5
--- /dev/null
+++ b/squirrel_3_0_1_stable/include/squirrel.h
@@ -0,0 +1,500 @@
+/*
+Copyright (c) 2003-2011 Alberto Demichelis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+#ifndef _SQUIRREL_H_
+#define _SQUIRREL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef SQUIRREL_API
+#define SQUIRREL_API extern
+#endif
+
+#if (defined(_WIN64) || defined(_LP64))
+#ifndef _SQ64
+#define _SQ64
+#endif
+#endif
+
+#ifdef _SQ64
+
+#ifdef _MSC_VER
+typedef __int64 SQInteger;
+typedef unsigned __int64 SQUnsignedInteger;
+typedef unsigned __int64 SQHash; /*should be the same size of a pointer*/
+#else
+typedef long long SQInteger;
+typedef unsigned long long SQUnsignedInteger;
+typedef unsigned long long SQHash; /*should be the same size of a pointer*/
+#endif
+typedef int SQInt32;
+typedef unsigned int SQUnsignedInteger32;
+#else
+typedef int SQInteger;
+typedef int SQInt32; /*must be 32 bits(also on 64bits processors)*/
+typedef unsigned int SQUnsignedInteger32; /*must be 32 bits(also on 64bits processors)*/
+typedef unsigned int SQUnsignedInteger;
+typedef unsigned int SQHash; /*should be the same size of a pointer*/
+#endif
+
+
+#ifdef SQUSEDOUBLE
+typedef double SQFloat;
+#else
+typedef float SQFloat;
+#endif
+
+#if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64)
+#ifdef _MSC_VER
+typedef __int64 SQRawObjectVal; //must be 64bits
+#else
+typedef long long SQRawObjectVal; //must be 64bits
+#endif
+#define SQ_OBJECT_RAWINIT() { _unVal.raw = 0; }
+#else
+typedef SQUnsignedInteger SQRawObjectVal; //is 32 bits on 32 bits builds and 64 bits otherwise
+#define SQ_OBJECT_RAWINIT()
+#endif
+
+#ifndef SQ_ALIGNMENT // SQ_ALIGNMENT shall be less than or equal to SQ_MALLOC alignments, and its value shall be power of 2.
+#if defined(SQUSEDOUBLE) || defined(_SQ64)
+#define SQ_ALIGNMENT 8
+#else
+#define SQ_ALIGNMENT 4
+#endif
+#endif
+
+typedef void* SQUserPointer;
+typedef SQUnsignedInteger SQBool;
+typedef SQInteger SQRESULT;
+
+#define SQTrue (1)
+#define SQFalse (0)
+
+struct SQVM;
+struct SQTable;
+struct SQArray;
+struct SQString;
+struct SQClosure;
+struct SQGenerator;
+struct SQNativeClosure;
+struct SQUserData;
+struct SQFunctionProto;
+struct SQRefCounted;
+struct SQClass;
+struct SQInstance;
+struct SQDelegable;
+struct SQOuter;
+
+#ifdef _UNICODE
+#define SQUNICODE
+#endif
+
+#ifdef SQUNICODE
+#if (defined(_MSC_VER) && _MSC_VER >= 1400) // 1400 = VS8
+
+#if !defined(_NATIVE_WCHAR_T_DEFINED) //this is if the compiler considers wchar_t as native type
+#define wchar_t unsigned short
+#endif
+
+#else
+typedef unsigned short wchar_t;
+#endif
+
+typedef wchar_t SQChar;
+#define _SC(a) L##a
+#define scstrcmp wcscmp
+#define scsprintf swprintf
+#define scstrlen wcslen
+#define scstrtod wcstod
+#ifdef _SQ64
+#define scstrtol _wcstoi64
+#else
+#define scstrtol wcstol
+#endif
+#define scatoi _wtoi
+#define scstrtoul wcstoul
+#define scvsprintf vswprintf
+#define scstrstr wcsstr
+#define scisspace iswspace
+#define scisdigit iswdigit
+#define scisxdigit iswxdigit
+#define scisalpha iswalpha
+#define sciscntrl iswcntrl
+#define scisalnum iswalnum
+#define scprintf wprintf
+#define MAX_CHAR 0xFFFF
+#else
+typedef char SQChar;
+#define _SC(a) a
+#define scstrcmp strcmp
+#define scsprintf sprintf
+#define scstrlen strlen
+#define scstrtod strtod
+#ifdef _SQ64
+#ifdef _MSC_VER
+#define scstrtol _strtoi64
+#else
+#define scstrtol strtoll
+#endif
+#else
+#define scstrtol strtol
+#endif
+#define scatoi atoi
+#define scstrtoul strtoul
+#define scvsprintf vsprintf
+#define scstrstr strstr
+#define scisspace isspace
+#define scisdigit isdigit
+#define scisxdigit isxdigit
+#define sciscntrl iscntrl
+#define scisalpha isalpha
+#define scisalnum isalnum
+#define scprintf printf
+#define MAX_CHAR 0xFF
+#endif
+
+#ifdef _SQ64
+#define _PRINT_INT_PREC _SC("ll")
+#define _PRINT_INT_FMT _SC("%lld")
+#else
+#define _PRINT_INT_FMT _SC("%d")
+#endif
+
+#define SQUIRREL_VERSION _SC("Squirrel 3.0.1 stable")
+#define SQUIRREL_COPYRIGHT _SC("Copyright (C) 2003-2011 Alberto Demichelis")
+#define SQUIRREL_AUTHOR _SC("Alberto Demichelis")
+#define SQUIRREL_VERSION_NUMBER 301
+
+#define SQ_VMSTATE_IDLE 0
+#define SQ_VMSTATE_RUNNING 1
+#define SQ_VMSTATE_SUSPENDED 2
+
+#define SQUIRREL_EOB 0
+#define SQ_BYTECODE_STREAM_TAG 0xFAFA
+
+#define SQOBJECT_REF_COUNTED 0x08000000
+#define SQOBJECT_NUMERIC 0x04000000
+#define SQOBJECT_DELEGABLE 0x02000000
+#define SQOBJECT_CANBEFALSE 0x01000000
+
+#define SQ_MATCHTYPEMASKSTRING (-99999)
+
+#define _RT_MASK 0x00FFFFFF
+#define _RAW_TYPE(type) (type&_RT_MASK)
+
+#define _RT_NULL 0x00000001
+#define _RT_INTEGER 0x00000002
+#define _RT_FLOAT 0x00000004
+#define _RT_BOOL 0x00000008
+#define _RT_STRING 0x00000010
+#define _RT_TABLE 0x00000020
+#define _RT_ARRAY 0x00000040
+#define _RT_USERDATA 0x00000080
+#define _RT_CLOSURE 0x00000100
+#define _RT_NATIVECLOSURE 0x00000200
+#define _RT_GENERATOR 0x00000400
+#define _RT_USERPOINTER 0x00000800
+#define _RT_THREAD 0x00001000
+#define _RT_FUNCPROTO 0x00002000
+#define _RT_CLASS 0x00004000
+#define _RT_INSTANCE 0x00008000
+#define _RT_WEAKREF 0x00010000
+#define _RT_OUTER 0x00020000
+
+typedef enum tagSQObjectType{
+ OT_NULL = (_RT_NULL|SQOBJECT_CANBEFALSE),
+ OT_INTEGER = (_RT_INTEGER|SQOBJECT_NUMERIC|SQOBJECT_CANBEFALSE),
+ OT_FLOAT = (_RT_FLOAT|SQOBJECT_NUMERIC|SQOBJECT_CANBEFALSE),
+ OT_BOOL = (_RT_BOOL|SQOBJECT_CANBEFALSE),
+ OT_STRING = (_RT_STRING|SQOBJECT_REF_COUNTED),
+ OT_TABLE = (_RT_TABLE|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE),
+ OT_ARRAY = (_RT_ARRAY|SQOBJECT_REF_COUNTED),
+ OT_USERDATA = (_RT_USERDATA|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE),
+ OT_CLOSURE = (_RT_CLOSURE|SQOBJECT_REF_COUNTED),
+ OT_NATIVECLOSURE = (_RT_NATIVECLOSURE|SQOBJECT_REF_COUNTED),
+ OT_GENERATOR = (_RT_GENERATOR|SQOBJECT_REF_COUNTED),
+ OT_USERPOINTER = _RT_USERPOINTER,
+ OT_THREAD = (_RT_THREAD|SQOBJECT_REF_COUNTED) ,
+ OT_FUNCPROTO = (_RT_FUNCPROTO|SQOBJECT_REF_COUNTED), //internal usage only
+ OT_CLASS = (_RT_CLASS|SQOBJECT_REF_COUNTED),
+ OT_INSTANCE = (_RT_INSTANCE|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE),
+ OT_WEAKREF = (_RT_WEAKREF|SQOBJECT_REF_COUNTED),
+ OT_OUTER = (_RT_OUTER|SQOBJECT_REF_COUNTED) //internal usage only
+}SQObjectType;
+
+#define ISREFCOUNTED(t) (t&SQOBJECT_REF_COUNTED)
+
+
+typedef union tagSQObjectValue
+{
+ struct SQTable *pTable;
+ struct SQArray *pArray;
+ struct SQClosure *pClosure;
+ struct SQOuter *pOuter;
+ struct SQGenerator *pGenerator;
+ struct SQNativeClosure *pNativeClosure;
+ struct SQString *pString;
+ struct SQUserData *pUserData;
+ SQInteger nInteger;
+ SQFloat fFloat;
+ SQUserPointer pUserPointer;
+ struct SQFunctionProto *pFunctionProto;
+ struct SQRefCounted *pRefCounted;
+ struct SQDelegable *pDelegable;
+ struct SQVM *pThread;
+ struct SQClass *pClass;
+ struct SQInstance *pInstance;
+ struct SQWeakRef *pWeakRef;
+ SQRawObjectVal raw;
+}SQObjectValue;
+
+
+typedef struct tagSQObject
+{
+ SQObjectType _type;
+ SQObjectValue _unVal;
+}SQObject;
+
+typedef struct tagSQMemberHandle{
+ SQBool _static;
+ SQInteger _index;
+}SQMemberHandle;
+
+typedef struct tagSQStackInfos{
+ const SQChar* funcname;
+ const SQChar* source;
+ SQInteger line;
+}SQStackInfos;
+
+typedef struct SQVM* HSQUIRRELVM;
+typedef SQObject HSQOBJECT;
+typedef SQMemberHandle HSQMEMBERHANDLE;
+typedef SQInteger (*SQFUNCTION)(HSQUIRRELVM);
+typedef SQInteger (*SQRELEASEHOOK)(SQUserPointer,SQInteger size);
+typedef void (*SQCOMPILERERROR)(HSQUIRRELVM,const SQChar * /*desc*/,const SQChar * /*source*/,SQInteger /*line*/,SQInteger /*column*/);
+typedef void (*SQPRINTFUNCTION)(HSQUIRRELVM,const SQChar * ,...);
+typedef void (*SQDEBUGHOOK)(HSQUIRRELVM /*v*/, SQInteger /*type*/, const SQChar * /*sourcename*/, SQInteger /*line*/, const SQChar * /*funcname*/);
+typedef SQInteger (*SQWRITEFUNC)(SQUserPointer,SQUserPointer,SQInteger);
+typedef SQInteger (*SQREADFUNC)(SQUserPointer,SQUserPointer,SQInteger);
+
+typedef SQInteger (*SQLEXREADFUNC)(SQUserPointer);
+
+typedef struct tagSQRegFunction{
+ const SQChar *name;
+ SQFUNCTION f;
+ SQInteger nparamscheck;
+ const SQChar *typemask;
+}SQRegFunction;
+
+typedef struct tagSQFunctionInfo {
+ SQUserPointer funcid;
+ const SQChar *name;
+ const SQChar *source;
+}SQFunctionInfo;
+
+/*vm*/
+SQUIRREL_API HSQUIRRELVM sq_open(SQInteger initialstacksize);
+SQUIRREL_API HSQUIRRELVM sq_newthread(HSQUIRRELVM friendvm, SQInteger initialstacksize);
+SQUIRREL_API void sq_seterrorhandler(HSQUIRRELVM v);
+SQUIRREL_API void sq_close(HSQUIRRELVM v);
+SQUIRREL_API void sq_setforeignptr(HSQUIRRELVM v,SQUserPointer p);
+SQUIRREL_API SQUserPointer sq_getforeignptr(HSQUIRRELVM v);
+SQUIRREL_API void sq_setprintfunc(HSQUIRRELVM v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc);
+SQUIRREL_API SQPRINTFUNCTION sq_getprintfunc(HSQUIRRELVM v);
+SQUIRREL_API SQPRINTFUNCTION sq_geterrorfunc(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_suspendvm(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_wakeupvm(HSQUIRRELVM v,SQBool resumedret,SQBool retval,SQBool raiseerror,SQBool throwerror);
+SQUIRREL_API SQInteger sq_getvmstate(HSQUIRRELVM v);
+
+/*compiler*/
+SQUIRREL_API SQRESULT sq_compile(HSQUIRRELVM v,SQLEXREADFUNC read,SQUserPointer p,const SQChar *sourcename,SQBool raiseerror);
+SQUIRREL_API SQRESULT sq_compilebuffer(HSQUIRRELVM v,const SQChar *s,SQInteger size,const SQChar *sourcename,SQBool raiseerror);
+SQUIRREL_API void sq_enabledebuginfo(HSQUIRRELVM v, SQBool enable);
+SQUIRREL_API void sq_notifyallexceptions(HSQUIRRELVM v, SQBool enable);
+SQUIRREL_API void sq_setcompilererrorhandler(HSQUIRRELVM v,SQCOMPILERERROR f);
+
+/*stack operations*/
+SQUIRREL_API void sq_push(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API void sq_pop(HSQUIRRELVM v,SQInteger nelemstopop);
+SQUIRREL_API void sq_poptop(HSQUIRRELVM v);
+SQUIRREL_API void sq_remove(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQInteger sq_gettop(HSQUIRRELVM v);
+SQUIRREL_API void sq_settop(HSQUIRRELVM v,SQInteger newtop);
+SQUIRREL_API SQRESULT sq_reservestack(HSQUIRRELVM v,SQInteger nsize);
+SQUIRREL_API SQInteger sq_cmp(HSQUIRRELVM v);
+SQUIRREL_API void sq_move(HSQUIRRELVM dest,HSQUIRRELVM src,SQInteger idx);
+
+/*object creation handling*/
+SQUIRREL_API SQUserPointer sq_newuserdata(HSQUIRRELVM v,SQUnsignedInteger size);
+SQUIRREL_API void sq_newtable(HSQUIRRELVM v);
+SQUIRREL_API void sq_newtableex(HSQUIRRELVM v,SQInteger initialcapacity);
+SQUIRREL_API void sq_newarray(HSQUIRRELVM v,SQInteger size);
+SQUIRREL_API void sq_newclosure(HSQUIRRELVM v,SQFUNCTION func,SQUnsignedInteger nfreevars);
+SQUIRREL_API SQRESULT sq_setparamscheck(HSQUIRRELVM v,SQInteger nparamscheck,const SQChar *typemask);
+SQUIRREL_API SQRESULT sq_bindenv(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API void sq_pushstring(HSQUIRRELVM v,const SQChar *s,SQInteger len);
+SQUIRREL_API void sq_pushfloat(HSQUIRRELVM v,SQFloat f);
+SQUIRREL_API void sq_pushinteger(HSQUIRRELVM v,SQInteger n);
+SQUIRREL_API void sq_pushbool(HSQUIRRELVM v,SQBool b);
+SQUIRREL_API void sq_pushuserpointer(HSQUIRRELVM v,SQUserPointer p);
+SQUIRREL_API void sq_pushnull(HSQUIRRELVM v);
+SQUIRREL_API SQObjectType sq_gettype(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQInteger sq_getsize(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getbase(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQBool sq_instanceof(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_tostring(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API void sq_tobool(HSQUIRRELVM v, SQInteger idx, SQBool *b);
+SQUIRREL_API SQRESULT sq_getstring(HSQUIRRELVM v,SQInteger idx,const SQChar **c);
+SQUIRREL_API SQRESULT sq_getinteger(HSQUIRRELVM v,SQInteger idx,SQInteger *i);
+SQUIRREL_API SQRESULT sq_getfloat(HSQUIRRELVM v,SQInteger idx,SQFloat *f);
+SQUIRREL_API SQRESULT sq_getbool(HSQUIRRELVM v,SQInteger idx,SQBool *b);
+SQUIRREL_API SQRESULT sq_getthread(HSQUIRRELVM v,SQInteger idx,HSQUIRRELVM *thread);
+SQUIRREL_API SQRESULT sq_getuserpointer(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p);
+SQUIRREL_API SQRESULT sq_getuserdata(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag);
+SQUIRREL_API SQRESULT sq_settypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer typetag);
+SQUIRREL_API SQRESULT sq_gettypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer *typetag);
+SQUIRREL_API void sq_setreleasehook(HSQUIRRELVM v,SQInteger idx,SQRELEASEHOOK hook);
+SQUIRREL_API SQChar *sq_getscratchpad(HSQUIRRELVM v,SQInteger minsize);
+SQUIRREL_API SQRESULT sq_getfunctioninfo(HSQUIRRELVM v,SQInteger idx,SQFunctionInfo *fi);
+SQUIRREL_API SQRESULT sq_getclosureinfo(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars);
+SQUIRREL_API SQRESULT sq_setnativeclosurename(HSQUIRRELVM v,SQInteger idx,const SQChar *name);
+SQUIRREL_API SQRESULT sq_setinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer p);
+SQUIRREL_API SQRESULT sq_getinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p,SQUserPointer typetag);
+SQUIRREL_API SQRESULT sq_setclassudsize(HSQUIRRELVM v, SQInteger idx, SQInteger udsize);
+SQUIRREL_API SQRESULT sq_newclass(HSQUIRRELVM v,SQBool hasbase);
+SQUIRREL_API SQRESULT sq_createinstance(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_setattributes(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getattributes(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getclass(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API void sq_weakref(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getdefaultdelegate(HSQUIRRELVM v,SQObjectType t);
+SQUIRREL_API SQRESULT sq_getmemberhandle(HSQUIRRELVM v,SQInteger idx,HSQMEMBERHANDLE *handle);
+SQUIRREL_API SQRESULT sq_getbyhandle(HSQUIRRELVM v,SQInteger idx,HSQMEMBERHANDLE *handle);
+SQUIRREL_API SQRESULT sq_setbyhandle(HSQUIRRELVM v,SQInteger idx,HSQMEMBERHANDLE *handle);
+
+/*object manipulation*/
+SQUIRREL_API void sq_pushroottable(HSQUIRRELVM v);
+SQUIRREL_API void sq_pushregistrytable(HSQUIRRELVM v);
+SQUIRREL_API void sq_pushconsttable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_setroottable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_setconsttable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_newslot(HSQUIRRELVM v, SQInteger idx, SQBool bstatic);
+SQUIRREL_API SQRESULT sq_deleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval);
+SQUIRREL_API SQRESULT sq_set(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_get(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_rawget(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_rawset(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval);
+SQUIRREL_API SQRESULT sq_arrayappend(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_arraypop(HSQUIRRELVM v,SQInteger idx,SQBool pushval);
+SQUIRREL_API SQRESULT sq_arrayresize(HSQUIRRELVM v,SQInteger idx,SQInteger newsize);
+SQUIRREL_API SQRESULT sq_arrayreverse(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_arrayremove(HSQUIRRELVM v,SQInteger idx,SQInteger itemidx);
+SQUIRREL_API SQRESULT sq_arrayinsert(HSQUIRRELVM v,SQInteger idx,SQInteger destpos);
+SQUIRREL_API SQRESULT sq_setdelegate(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getdelegate(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_clone(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_setfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval);
+SQUIRREL_API SQRESULT sq_next(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getweakrefval(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_clear(HSQUIRRELVM v,SQInteger idx);
+
+/*calls*/
+SQUIRREL_API SQRESULT sq_call(HSQUIRRELVM v,SQInteger params,SQBool retval,SQBool raiseerror);
+SQUIRREL_API SQRESULT sq_resume(HSQUIRRELVM v,SQBool retval,SQBool raiseerror);
+SQUIRREL_API const SQChar *sq_getlocal(HSQUIRRELVM v,SQUnsignedInteger level,SQUnsignedInteger idx);
+SQUIRREL_API SQRESULT sq_getcallee(HSQUIRRELVM v);
+SQUIRREL_API const SQChar *sq_getfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval);
+SQUIRREL_API SQRESULT sq_throwerror(HSQUIRRELVM v,const SQChar *err);
+SQUIRREL_API SQRESULT sq_throwobject(HSQUIRRELVM v);
+SQUIRREL_API void sq_reseterror(HSQUIRRELVM v);
+SQUIRREL_API void sq_getlasterror(HSQUIRRELVM v);
+
+/*raw object handling*/
+SQUIRREL_API SQRESULT sq_getstackobj(HSQUIRRELVM v,SQInteger idx,HSQOBJECT *po);
+SQUIRREL_API void sq_pushobject(HSQUIRRELVM v,HSQOBJECT obj);
+SQUIRREL_API void sq_addref(HSQUIRRELVM v,HSQOBJECT *po);
+SQUIRREL_API SQBool sq_release(HSQUIRRELVM v,HSQOBJECT *po);
+SQUIRREL_API SQUnsignedInteger sq_getrefcount(HSQUIRRELVM v,HSQOBJECT *po);
+SQUIRREL_API void sq_resetobject(HSQOBJECT *po);
+SQUIRREL_API const SQChar *sq_objtostring(const HSQOBJECT *o);
+SQUIRREL_API SQBool sq_objtobool(const HSQOBJECT *o);
+SQUIRREL_API SQInteger sq_objtointeger(const HSQOBJECT *o);
+SQUIRREL_API SQFloat sq_objtofloat(const HSQOBJECT *o);
+SQUIRREL_API SQUserPointer sq_objtouserpointer(const HSQOBJECT *o);
+SQUIRREL_API SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag);
+
+/*GC*/
+SQUIRREL_API SQInteger sq_collectgarbage(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_resurrectunreachable(HSQUIRRELVM v);
+
+/*serialization*/
+SQUIRREL_API SQRESULT sq_writeclosure(HSQUIRRELVM vm,SQWRITEFUNC writef,SQUserPointer up);
+SQUIRREL_API SQRESULT sq_readclosure(HSQUIRRELVM vm,SQREADFUNC readf,SQUserPointer up);
+
+/*mem allocation*/
+SQUIRREL_API void *sq_malloc(SQUnsignedInteger size);
+SQUIRREL_API void *sq_realloc(void* p,SQUnsignedInteger oldsize,SQUnsignedInteger newsize);
+SQUIRREL_API void sq_free(void *p,SQUnsignedInteger size);
+
+/*debug*/
+SQUIRREL_API SQRESULT sq_stackinfos(HSQUIRRELVM v,SQInteger level,SQStackInfos *si);
+SQUIRREL_API void sq_setdebughook(HSQUIRRELVM v);
+SQUIRREL_API void sq_setnativedebughook(HSQUIRRELVM v,SQDEBUGHOOK hook);
+
+/*UTILITY MACRO*/
+#define sq_isnumeric(o) ((o)._type&SQOBJECT_NUMERIC)
+#define sq_istable(o) ((o)._type==OT_TABLE)
+#define sq_isarray(o) ((o)._type==OT_ARRAY)
+#define sq_isfunction(o) ((o)._type==OT_FUNCPROTO)
+#define sq_isclosure(o) ((o)._type==OT_CLOSURE)
+#define sq_isgenerator(o) ((o)._type==OT_GENERATOR)
+#define sq_isnativeclosure(o) ((o)._type==OT_NATIVECLOSURE)
+#define sq_isstring(o) ((o)._type==OT_STRING)
+#define sq_isinteger(o) ((o)._type==OT_INTEGER)
+#define sq_isfloat(o) ((o)._type==OT_FLOAT)
+#define sq_isuserpointer(o) ((o)._type==OT_USERPOINTER)
+#define sq_isuserdata(o) ((o)._type==OT_USERDATA)
+#define sq_isthread(o) ((o)._type==OT_THREAD)
+#define sq_isnull(o) ((o)._type==OT_NULL)
+#define sq_isclass(o) ((o)._type==OT_CLASS)
+#define sq_isinstance(o) ((o)._type==OT_INSTANCE)
+#define sq_isbool(o) ((o)._type==OT_BOOL)
+#define sq_isweakref(o) ((o)._type==OT_WEAKREF)
+#define sq_type(o) ((o)._type)
+
+/* deprecated */
+#define sq_createslot(v,n) sq_newslot(v,n,SQFalse)
+
+#define SQ_OK (0)
+#define SQ_ERROR (-1)
+
+#define SQ_FAILED(res) (res<0)
+#define SQ_SUCCEEDED(res) (res>=0)
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQUIRREL_H_*/
diff --git a/squirrel_3_0_1_stable/sqplus/Makefile b/squirrel_3_0_1_stable/sqplus/Makefile
new file mode 100644
index 000000000..1bef39832
--- /dev/null
+++ b/squirrel_3_0_1_stable/sqplus/Makefile
@@ -0,0 +1,18 @@
+SQUIRREL= ..
+
+OUT= $(SQUIRREL)/lib/libsqplus.a
+INCDIRS= -I$(SQUIRREL)/include -I. -Iinclude
+
+ALLSRCS = $(wildcard *.cpp)
+WIN32SRCS = $(wildcard *Win32*)
+SRCS = $(filter-out $(WIN32SRCS),$(ALLSRCS))
+
+sqplus:
+# g++ -fno-rtti -c $(SRCS) $(INCDIRS)
+ g++ -O3 -fno-rtti -Os -c $(SRCS) $(INCDIRS)
+ ar rc $(OUT) *.o
+ rm *.o
+
+
+#g++ -O3 -fno-rtti -Os -c $(SRCS) $(INCDIRS)
+#g++ -ggdb -fno-rtti -c $(SRCS) $(INCDIRS)
diff --git a/squirrel_3_0_1_stable/sqplus/SqPlus.cpp b/squirrel_3_0_1_stable/sqplus/SqPlus.cpp
new file mode 100644
index 000000000..a2eaacb72
--- /dev/null
+++ b/squirrel_3_0_1_stable/sqplus/SqPlus.cpp
@@ -0,0 +1,382 @@
+#include "sqplus.h"
+#include
+
+#ifdef SQPLUS_SMARTPOINTER_OPT
+#define SQPLUS_SMARTPOINTER_CPP_DECLARATION
+#include "SqPlusSmartPointer.h"
+#endif
+
+namespace SqPlus {
+
+static int getVarInfo(StackHandler & sa,VarRefPtr & vr) {
+ HSQOBJECT htable = sa.GetObjectHandle(1);
+ SquirrelObject table(htable);
+ const SQChar * el = sa.GetString(2);
+ ScriptStringVar256 varNameTag;
+ getVarNameTag(varNameTag,sizeof(varNameTag),el);
+ SQUserPointer data=0;
+ if (!table.RawGetUserData(varNameTag,&data)) {
+ return sa.ThrowError(_SC("getVarInfo: Could not retrieve UserData")); // Results in variable not being found error.
+ }
+ vr = (VarRefPtr)data;
+ return SQ_OK;
+} // getVarInfo
+
+static int getInstanceVarInfo(StackHandler & sa,VarRefPtr & vr,SQUserPointer & data) {
+ HSQOBJECT ho = sa.GetObjectHandle(1);
+ SquirrelObject instance(ho);
+ const SQChar * el = sa.GetString(2);
+ ScriptStringVar256 varNameTag;
+ getVarNameTag(varNameTag,sizeof(varNameTag),el);
+ SQUserPointer ivrData=0;
+ if (!instance.RawGetUserData(varNameTag,&ivrData)) {
+ return sa.ThrowError(_SC("getInstanceVarInfo: Could not retrieve UserData")); // Results in variable not being found error.
+ }
+ vr = (VarRefPtr)ivrData;
+
+ char * up;
+ if (!(vr->m_access & (VAR_ACCESS_STATIC|VAR_ACCESS_CONSTANT))) {
+ SQUserPointer typetag;
+ instance.GetTypeTag(&typetag);
+
+#if defined(SQ_USE_CLASS_INHERITANCE)
+ if (typetag != vr->instanceType) {
+ SquirrelObject typeTable = instance.GetValue(SQ_CLASS_OBJECT_TABLE_NAME);
+ up = (char *)typeTable.GetUserPointer(INT((size_t)vr->instanceType)); // 64-bit compatible version.
+ if (!up) {
+ throw SquirrelError(_SC("Invalid Instance Type"));
+ }
+ } else {
+ up = (char *)instance.GetInstanceUP(0);
+ } // if
+
+#elif defined(SQ_USE_CLASS_INHERITANCE_SIMPLE)
+ ClassTypeBase *ctb = (ClassTypeBase*)vr->instanceType;
+ up = (char *)instance.GetInstanceUP(0);
+ // Walk base classes until type tag match, adjust for inheritence offset
+ while(ctb && typetag!=ctb) {
+ up = (char*)up - ctb->m_offset;
+ ctb = ctb->m_pbase;
+ }
+ if (!ctb) {
+ throw SquirrelError(_SC("Invalid Instance Type"));
+ }
+#else
+ up = (char *)instance.GetInstanceUP(0);
+#endif
+
+#ifdef SQPLUS_SMARTPOINTER_OPT
+#define SQPLUS_SMARTPOINTER_INSTANCE_VARINFO
+#include "SqPlusSmartPointer.h"
+#endif
+
+ up += (size_t)vr->offsetOrAddrOrConst; // Offset
+ } else {
+ up = (char *)vr->offsetOrAddrOrConst; // Address
+ } // if
+ data = up;
+ return SQ_OK;
+} // getInstanceVarInfo
+
+
+// If not static/global, message can (and will) disappear before arriving at catch (G++)
+static ScriptStringVar256 g_msg_throw;
+
+static int setVar(StackHandler & sa,VarRef * vr,void * data) {
+ if (vr->m_access & (VAR_ACCESS_READ_ONLY|VAR_ACCESS_CONSTANT)) {
+ const SQChar * el = sa.GetString(2);
+ SCSNPRINTF(g_msg_throw.s,sizeof(g_msg_throw),_SC("setVar(): Cannot write to constant: %s"),el);
+ throw SquirrelError(g_msg_throw.s);
+ } // if
+ switch (vr->m_type) {
+ case TypeInfo::TypeID: {
+ INT * val = (INT *)data; // Address
+ if (val) {
+ INT v = sa.GetInt(3);
+ // Support for different int sizes
+ switch( vr->m_size ) {
+ case 1: v = (*(char*)val = (char)v); break;
+ case 2: v = (*(short*)val = (short)v); break;
+#ifdef _SQ64
+ case 4: v = (*(int*)val = (int)v); break;
+#endif
+ default: *val = v;
+ }
+ return sa.Return(v);
+ } // if
+ break;
+ } // case
+ case TypeInfo::TypeID: {
+ unsigned * val = (unsigned *)data; // Address
+ if (val) {
+ *val = sa.GetInt(3);
+ return sa.Return(static_cast(*val));
+ } // if
+ break;
+ } // case
+ case TypeInfo::TypeID: {
+ FLOAT * val = (FLOAT *)data; // Address
+ if (val) {
+ *val = sa.GetFloat(3);
+ return sa.Return(*val);
+ } // if
+ break;
+ } // case
+ case TypeInfo::TypeID: {
+ bool * val = (bool *)data; // Address
+ if (val) {
+ *val = sa.GetBool(3) ? true : false;
+ return sa.Return(*val);
+ } // if
+ break;
+ } // case
+ case VAR_TYPE_INSTANCE: {
+ HSQUIRRELVM v = sa.GetVMPtr();
+ SQUserPointer src = sa.GetInstanceUp(3,(SQUserPointer)vr->varType); // Effectively performs: ClassType<>::type() == ClassType<>().
+ if (!src) {
+ throw SquirrelError(_SC("INSTANCE type assignment mismatch"));
+ }
+ vr->varType->vgetCopyFunc()(data,src);
+ return 0;
+ }
+ case TypeInfo::TypeID: {
+ const SQChar * el = sa.GetString(2);
+ SCSNPRINTF(g_msg_throw.s,sizeof(g_msg_throw),_SC("setVar(): Cannot write to an SQUserPointer: %s"),el);
+ throw SquirrelError(g_msg_throw.s);
+ } // case
+ case TypeInfo::TypeID: {
+ ScriptStringVarBase * val = (ScriptStringVarBase *)data; // Address
+ if (val) {
+ const SQChar * strVal = sa.GetString(3);
+ if (strVal) {
+ *val = strVal;
+ return sa.Return(val->s);
+ } // if
+ } // if
+ break;
+ } // case
+#if defined(SQPLUS_SUPPORT_STD_STRING) && !defined(SQUNICODE)
+ case TypeInfo::TypeID: {
+ std::string *val = (std::string*)data; // Address
+ if (val) {
+ const SQChar *strVal = sa.GetString(3);
+ if (strVal) {
+ *val = strVal;
+ return sa.Return(val->c_str());
+ } // if
+ } // if
+ break;
+ } // case
+#endif
+ } // switch
+ return SQ_ERROR;
+} // setVar
+
+static int getVar(StackHandler & sa,VarRef * vr,void * data) {
+ switch (vr->m_type) {
+ case TypeInfo::TypeID: {
+ if (!(vr->m_access & VAR_ACCESS_CONSTANT)) {
+ if (data) {
+ INT v;
+ // Support for different int sizes
+ switch( vr->m_size ){
+ case 1: v = *(char*)data; break;
+ case 2: v = *(short*)data; break;
+#ifdef _SQ64
+ case 4: v = *(int*)data; break;
+#endif
+ default: v = *(INT*)data;
+ }
+ return sa.Return(v);
+ } // if
+ } else {
+ INT * val = (INT *)&data; // Constant value
+ return sa.Return(*val);
+ } // if
+ break;
+ } // case
+ case TypeInfo::TypeID: {
+ if (!(vr->m_access & VAR_ACCESS_CONSTANT)) {
+ unsigned * val = (unsigned *)data; // Address
+ if (val){
+ return sa.Return(static_cast(*val));
+ }
+ } else {
+ unsigned * val = (unsigned *)&data; // Constant value
+ return sa.Return(static_cast(*val));
+ } // if
+ break;
+ } // case
+ case TypeInfo::TypeID: {
+ if (!(vr->m_access & VAR_ACCESS_CONSTANT)) {
+ FLOAT * val = (FLOAT *)data; // Address
+ if (val) {
+ return sa.Return(*val);
+ } // if
+ } else {
+ FLOAT * val = (FLOAT *)&data; // Constant value
+ return sa.Return(*val);
+ } // if
+ break;
+ } // case
+ case TypeInfo::TypeID: {
+ if (!(vr->m_access & VAR_ACCESS_CONSTANT)) {
+ bool * val = (bool *)data; // Address
+ if (val) {
+ return sa.Return(*val);
+ } // if
+ } else {
+ bool * val = (bool *)&data; // Constant value
+ return sa.Return(*val);
+ } // if
+ break;
+ } // case
+ case VAR_TYPE_INSTANCE:
+ if (!CreateNativeClassInstance(sa.GetVMPtr(),vr->varType->GetTypeName(),data,0)) { // data = address. Allocates memory.
+ SCSNPRINTF(g_msg_throw.s,sizeof(g_msg_throw),_SC("getVar(): Could not create instance: %s"),vr->varType->GetTypeName());
+ throw SquirrelError(g_msg_throw.s);
+ } // if
+ return 1;
+ case TypeInfo::TypeID:
+ return sa.Return(data); // The address of member variable, not the variable itself.
+ case TypeInfo::TypeID: {
+ if (!(vr->m_access & VAR_ACCESS_CONSTANT)) {
+ ScriptStringVarBase * val = (ScriptStringVarBase *)data; // Address
+ if (val) {
+ return sa.Return(val->s);
+ } // if
+ } else {
+ throw SquirrelError(_SC("getVar(): Invalid type+access: 'ScriptStringVarBase' with VAR_ACCESS_CONSTANT (use VAR_ACCESS_READ_ONLY instead)"));
+ }
+ break;
+ } // case
+ case TypeInfo::TypeID: {
+ if (!(vr->m_access & VAR_ACCESS_CONSTANT)) {
+ if( vr->m_access==VAR_ACCESS_READ_WRITE )
+ throw SquirrelError(_SC("getVar(): Invalid type+access: 'const SQChar *' without VAR_ACCESS_CONSTANT"));
+ // It is OK to read from a SQChar* if requested
+ return sa.Return(*(const SQChar **)data); // Address
+ } else {
+ return sa.Return((const SQChar *)data); // Address
+ }
+ break;
+ } // case
+#ifdef SQPLUS_SUPPORT_STD_STRING
+ case TypeInfo::TypeID: {
+ if (!(vr->m_access & VAR_ACCESS_CONSTANT)) {
+ std::string *val = (std::string *)data; // Address
+ if (val) {
+ return sa.Return(val->c_str());
+ }
+ } else {
+ throw SquirrelError(_SC("getVar(): Invalid type+access: 'std::string' with VAR_ACCESS_CONSTANT (use VAR_ACCESS_READ_ONLY instead)"));
+ }
+ break;
+ } // case
+#endif
+ } // switch
+ return SQ_ERROR;
+} // getVar
+
+// === Global Vars ===
+
+int setVarFunc(HSQUIRRELVM v) {
+ SquirrelVM::Init(v); // For handling multi-VM setting right
+ StackHandler sa(v);
+ if (sa.GetType(1) == OT_TABLE) {
+ VarRefPtr vr;
+ int res = getVarInfo(sa,vr);
+ if (res != SQ_OK) return res;
+ return setVar(sa,vr,vr->offsetOrAddrOrConst);
+ } // if
+ return SQ_ERROR;
+} // setVarFunc
+
+int getVarFunc(HSQUIRRELVM v) {
+ SquirrelVM::Init(v); // For handling multi-VM setting right
+ StackHandler sa(v);
+ if (sa.GetType(1) == OT_TABLE) {
+ VarRefPtr vr;
+ int res = getVarInfo(sa,vr);
+ if (res != SQ_OK) return res;
+ return getVar(sa,vr,vr->offsetOrAddrOrConst);
+ } // if
+ return SQ_ERROR;
+} // getVarFunc
+
+// === Instance Vars ===
+
+int setInstanceVarFunc(HSQUIRRELVM v) {
+ SquirrelVM::Init(v); // For handling multi-VM setting right
+ StackHandler sa(v);
+ if (sa.GetType(1) == OT_INSTANCE) {
+ VarRefPtr vr;
+ void * data;
+ int res = getInstanceVarInfo(sa,vr,data);
+ if (res != SQ_OK) return res;
+ return setVar(sa,vr,data);
+ } // if
+ return SQ_ERROR;
+} // setInstanceVarFunc
+
+int getInstanceVarFunc(HSQUIRRELVM v) {
+ SquirrelVM::Init(v); // For handling multi-VM setting right
+ StackHandler sa(v);
+ if (sa.GetType(1) == OT_INSTANCE) {
+ VarRefPtr vr;
+ void * data;
+ int res = getInstanceVarInfo(sa,vr,data);
+ if (res != SQ_OK) return res;
+ return getVar(sa,vr,data);
+ } // if
+ return SQ_ERROR;
+} // getInstanceVarFunc
+
+// === Classes ===
+
+BOOL CreateClass(HSQUIRRELVM v,SquirrelObject & newClass,SQUserPointer classType,const SQChar * name,const SQChar * baseName) {
+ int n = 0;
+ int oldtop = sq_gettop(v);
+ sq_pushroottable(v);
+ sq_pushstring(v,name,-1);
+ if (baseName) {
+ sq_pushstring(v,baseName,-1);
+ if (SQ_FAILED(sq_get(v,-3))) { // Make sure the base exists if specified by baseName.
+ sq_settop(v,oldtop);
+ return FALSE;
+ } // if
+ } // if
+ if (SQ_FAILED(sq_newclass(v,baseName ? 1 : 0))) { // Will inherit from base class on stack from sq_get() above.
+ sq_settop(v,oldtop);
+ return FALSE;
+ } // if
+ newClass.AttachToStackObject(-1);
+ sq_settypetag(v,-1,classType);
+ sq_createslot(v,-3);
+ sq_pop(v,1);
+ return TRUE;
+} // CreateClass
+
+SquirrelObject RegisterClassType(HSQUIRRELVM v,const SQChar * scriptClassName,SQUserPointer classType,SQFUNCTION constructor) {
+ SquirrelVM::Init(v); // For handling multi-VM setting right
+ int top = sq_gettop(v);
+ SquirrelObject newClass;
+ if (CreateClass(v,newClass,classType,scriptClassName)) {
+ SquirrelVM::CreateFunction(newClass,constructor,_SC("constructor"));
+ } // if
+ sq_settop(v,top);
+ return newClass;
+} // RegisterClassType
+
+
+///////////////////////////////////////////////////////////////////////////
+// GCC sometimes has problems with finding inline functions at link time
+// (that also have a template definition). To solve the problem,
+// non-inlines goes here.
+#ifdef GCC_INLINE_WORKAROUND
+# include "SqPlusFunctionCallImpl.h"
+#endif // GCC_INLINE_WORKAROUND
+///////////////////////////////////////////////////////////////////////////
+
+} // namespace SqPlus
+
diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusCallTemplates.h b/squirrel_3_0_1_stable/sqplus/SqPlusCallTemplates.h
new file mode 100644
index 000000000..75e4887c5
--- /dev/null
+++ b/squirrel_3_0_1_stable/sqplus/SqPlusCallTemplates.h
@@ -0,0 +1,337 @@
+
+// This file is included multiple times, with varying options - No header guard.
+
+// Include this file to generate Call templates with or without these options:
+// - SQPLUS_APPLY_CONST - const qualifier after functions signature (const func / member func)
+// - SQPLUS_APPLY_CDECL - qualifier before class name (MSVC specific calling convention)
+
+#undef CONST_QUAL
+#undef CALL_QUAL
+
+#ifdef SQPLUS_APPLY_CONST
+ #define CONST_QUAL const
+#else
+ #define CONST_QUAL
+#endif
+
+#ifdef SQPLUS_APPLY_CDECL
+ #define CALL_QUAL __cdecl
+#else
+ #define CALL_QUAL
+#endif
+
+
+#ifdef SQPLUS_CALL_MFUNC_RET0
+
+ // Include this file again, with __cdecl also (Visual C++ specific)
+ #if defined(SQPLUS_ENABLE_CDECL_MEMBER_FUNCTIONS) && !defined(SQPLUS_APPLY_CDECL)
+ #define SQPLUS_APPLY_CDECL
+ #include "SqPlusCallTemplates.h"
+ #undef CALL_QUAL
+ #define CALL_QUAL
+ #endif
+
+ template
+ static int Call(Callee & callee,RT (CALL_QUAL Callee::*func)() CONST_QUAL,HSQUIRRELVM v,int /*index*/) {
+ RT ret = (callee.*func)();
+ Push(v,ret);
+ return 1;
+ }
+
+ template
+ static int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1) CONST_QUAL,HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ RT ret = (callee.*func)(
+ Get(TypeWrapper(),v,index + 0)
+ );
+ Push(v,ret);
+ return 1;
+ }
+
+ template
+ static int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2) CONST_QUAL,HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ RT ret = (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1)
+ );
+ Push(v,ret);
+ return 1;
+ }
+
+ template
+ static int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3) CONST_QUAL,HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ RT ret = (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2)
+ );
+ Push(v,ret);
+ return 1;
+ }
+
+ template
+ static int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4) CONST_QUAL,HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ sq_argassert(4,index + 3);
+ RT ret = (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2),
+ Get(TypeWrapper(),v,index + 3)
+ );
+ Push(v,ret);
+ return 1;
+ }
+
+ template
+ static int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5) CONST_QUAL,HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ sq_argassert(4,index + 3);
+ sq_argassert(5,index + 4);
+ RT ret = (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2),
+ Get(TypeWrapper(),v,index + 3),
+ Get(TypeWrapper(),v,index + 4)
+ );
+ Push(v,ret);
+ return 1;
+ }
+
+ template
+ static int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5,P6) CONST_QUAL,HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ sq_argassert(4,index + 3);
+ sq_argassert(5,index + 4);
+ sq_argassert(6,index + 5);
+ RT ret = (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2),
+ Get(TypeWrapper(),v,index + 3),
+ Get(TypeWrapper(),v,index + 4),
+ Get(TypeWrapper(),v,index + 5)
+ );
+ Push(v,ret);
+ return 1;
+ }
+
+ template
+ static int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5,P6,P7) CONST_QUAL,HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ sq_argassert(4,index + 3);
+ sq_argassert(5,index + 4);
+ sq_argassert(6,index + 5);
+ sq_argassert(7,index + 6);
+ RT ret = (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2),
+ Get(TypeWrapper(),v,index + 3),
+ Get(TypeWrapper(),v,index + 4),
+ Get(TypeWrapper(),v,index + 5),
+ Get(TypeWrapper(),v,index + 6)
+ );
+ Push(v,ret);
+ return 1;
+ }
+#undef SQPLUS_CALL_MFUNC_RET0
+#endif // SQPLUS_CALL_MFUNC_RET0
+
+
+#ifdef SQPLUS_CALL_MFUNC_NORET
+
+ // Include this very same thing with __cdecl also
+ #if defined(SQPLUS_ENABLE_CDECL_MEMBER_FUNCTIONS) && !defined(SQPLUS_APPLY_CDECL)
+ #define SQPLUS_APPLY_CDECL
+ #include "SqPlusCallTemplates.h"
+ #undef CALL_QUAL
+ #define CALL_QUAL
+ #endif
+
+ // === Member function calls ===
+
+ template
+ static int Call(Callee & callee,void (CALL_QUAL Callee::*func)() CONST_QUAL, HSQUIRRELVM,int /*index*/) {
+ (callee.*func)();
+ return 0;
+ }
+
+ template
+ static int Call(Callee & callee,void (CALL_QUAL Callee::*func)(P1) CONST_QUAL, HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ (callee.*func)(
+ Get(TypeWrapper(),v,index + 0)
+ );
+ return 0;
+ }
+
+ template
+ static int Call(Callee & callee,void (CALL_QUAL Callee::*func)(P1,P2) CONST_QUAL, HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1)
+ );
+ return 0;
+ }
+
+ template
+ static int Call(Callee & callee,void (CALL_QUAL Callee::*func)(P1,P2,P3) CONST_QUAL, HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2)
+ );
+ return 0;
+ }
+
+ template
+ static int Call(Callee & callee,void (CALL_QUAL Callee::*func)(P1,P2,P3,P4) CONST_QUAL, HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ sq_argassert(4,index + 3);
+ (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2),
+ Get(TypeWrapper(),v,index + 3)
+ );
+ return 0;
+ }
+
+ template
+ static int Call(Callee & callee,void (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5) CONST_QUAL, HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ sq_argassert(4,index + 3);
+ sq_argassert(5,index + 4);
+ (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2),
+ Get(TypeWrapper(),v,index + 3),
+ Get(TypeWrapper(),v,index + 4)
+ );
+ return 0;
+ }
+
+ template
+ static int Call(Callee & callee,void (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5,P6) CONST_QUAL, HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ sq_argassert(4,index + 3);
+ sq_argassert(5,index + 4);
+ sq_argassert(6,index + 5);
+ (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2),
+ Get(TypeWrapper(),v,index + 3),
+ Get(TypeWrapper(),v,index + 4),
+ Get(TypeWrapper(),v,index + 5)
+ );
+ return 0;
+ }
+
+ template
+ static int Call(Callee & callee,void (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5,P6,P7) CONST_QUAL, HSQUIRRELVM v,int index) {
+ sq_argassert(1,index + 0);
+ sq_argassert(2,index + 1);
+ sq_argassert(3,index + 2);
+ sq_argassert(4,index + 3);
+ sq_argassert(5,index + 4);
+ sq_argassert(6,index + 5);
+ sq_argassert(7,index + 6);
+ (callee.*func)(
+ Get(TypeWrapper(),v,index + 0),
+ Get(TypeWrapper(),v,index + 1),
+ Get(TypeWrapper(),v,index + 2),
+ Get(TypeWrapper(),v,index + 3),
+ Get(TypeWrapper(),v,index + 4),
+ Get(TypeWrapper(),v,index + 5),
+ Get(TypeWrapper(),v,index + 6)
+ );
+ return 0;
+ }
+#undef SQPLUS_CALL_MFUNC_NORET
+#endif // SQPLUS_CALL_MFUNC_NORET
+
+
+#ifdef SQPLUS_CALL_MFUNC_RET1
+
+ // Include this very same thing with __cdecl also
+ #if defined(SQPLUS_ENABLE_CDECL_MEMBER_FUNCTIONS) && !defined(SQPLUS_APPLY_CDECL)
+ #define SQPLUS_APPLY_CDECL
+ #include "SqPlusCallTemplates.h"
+ #undef CALL_QUAL
+ #define CALL_QUAL
+ #endif
+
+ template
+ int Call(Callee & callee, RT (CALL_QUAL Callee::*func)() CONST_QUAL, HSQUIRRELVM v,int index) {
+ return ReturnSpecialization