30 files changed, 6927 insertions, 6927 deletions

diff --git a/squirrel_3_0_1_stable/sqplus/Makefile b/squirrel_3_0_1_stable/_OLD_sqplus/Makefile
index 1bef39832..1bef39832 100644
--- a/squirrel_3_0_1_stable/sqplus/Makefile
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/Makefile
diff --git a/squirrel_3_0_1_stable/sqplus/SqPlus.cpp b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlus.cpp
index a2eaacb72..3fdf99735 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlus.cpp
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlus.cpp
@@ -1,382 +1,382 @@
-#include "sqplus.h"
-#include <stdio.h>
-
-#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)); // <TODO> 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<INT>::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<unsigned>::TypeID: {
-	  unsigned * val = (unsigned *)data; // Address
-	  if (val) {
-		  *val = sa.GetInt(3);
-		  return sa.Return(static_cast<INT>(*val));
-	  } // if
-	  break;
-  } // case
-  case TypeInfo<FLOAT>::TypeID: {
-    FLOAT * val = (FLOAT *)data; // Address
-    if (val) {
-      *val = sa.GetFloat(3);
-      return sa.Return(*val);
-    } // if
-    break;
-  } // case
-  case TypeInfo<bool>::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<SQUserPointer>::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<ScriptStringVarBase>::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<std::string>::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<INT>::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<unsigned>::TypeID: {
-	  if (!(vr->m_access & VAR_ACCESS_CONSTANT)) {
-		  unsigned * val = (unsigned *)data; // Address
-		  if (val){
-            return sa.Return(static_cast<INT>(*val));
-          }
-	  } else {
-		  unsigned * val = (unsigned *)&data; // Constant value
-		  return sa.Return(static_cast<INT>(*val));
-	  } // if
-	  break;
-  } // case
-  case TypeInfo<FLOAT>::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<bool>::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<SQUserPointer>::TypeID: 
-    return sa.Return(data); // The address of member variable, not the variable itself.
-  case TypeInfo<ScriptStringVarBase>::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<const SQChar *>::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<std::string>::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
-
+#include "sqplus.h"

+#include <stdio.h>

+

+#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)); // <TODO> 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<INT>::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<unsigned>::TypeID: {

+	  unsigned * val = (unsigned *)data; // Address

+	  if (val) {

+		  *val = sa.GetInt(3);

+		  return sa.Return(static_cast<INT>(*val));

+	  } // if

+	  break;

+  } // case

+  case TypeInfo<FLOAT>::TypeID: {

+    FLOAT * val = (FLOAT *)data; // Address

+    if (val) {

+      *val = sa.GetFloat(3);

+      return sa.Return(*val);

+    } // if

+    break;

+  } // case

+  case TypeInfo<bool>::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<SQUserPointer>::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<ScriptStringVarBase>::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<std::string>::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<INT>::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<unsigned>::TypeID: {

+	  if (!(vr->m_access & VAR_ACCESS_CONSTANT)) {

+		  unsigned * val = (unsigned *)data; // Address

+		  if (val){

+            return sa.Return(static_cast<INT>(*val));

+          }

+	  } else {

+		  unsigned * val = (unsigned *)&data; // Constant value

+		  return sa.Return(static_cast<INT>(*val));

+	  } // if

+	  break;

+  } // case

+  case TypeInfo<FLOAT>::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<bool>::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<SQUserPointer>::TypeID: 

+    return sa.Return(data); // The address of member variable, not the variable itself.

+  case TypeInfo<ScriptStringVarBase>::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<const SQChar *>::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<std::string>::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/_OLD_sqplus/SqPlusCallTemplates.h
index 75e4887c5..4ebded1d3 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusCallTemplates.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusCallTemplates.h
@@ -1,337 +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 <typename Callee>
-  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 <typename Callee,typename P1>
-  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<P1>(),v,index + 0)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename Callee,typename P1,typename P2>
-  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<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename Callee,typename P1,typename P2,typename P3>
-  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<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename Callee,typename P1,typename P2,typename P3,typename P4>
-  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<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5>
-  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<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
-  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<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4),
-      Get(TypeWrapper<P6>(),v,index + 5)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
-  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<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4),
-      Get(TypeWrapper<P6>(),v,index + 5),
-      Get(TypeWrapper<P7>(),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<typename Callee>
-	static int Call(Callee & callee,void (CALL_QUAL Callee::*func)() CONST_QUAL, HSQUIRRELVM,int /*index*/) {
-		(callee.*func)();
-		return 0;
-	}
-
-	template<typename Callee,typename P1>
-	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<P1>(),v,index + 0)
-		);
-		return 0;
-	}
-
-	template<typename Callee,typename P1,typename P2>
-	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<P1>(),v,index + 0),
-			Get(TypeWrapper<P2>(),v,index + 1)
-		);
-		return 0;
-	}
-
-	template<typename Callee,typename P1,typename P2,typename P3>
-	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<P1>(),v,index + 0),
-			Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2)
-		);
-		return 0;
-	}
-
-	template<typename Callee,typename P1,typename P2,typename P3,typename P4>
-	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<P1>(),v,index + 0),
-			Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3)
-		);
-		return 0;
-	}
-
-	template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5>
-	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<P1>(),v,index + 0),
-			Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4)
-		);
-		return 0;
-	}
-
-	template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
-	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<P1>(),v,index + 0),
-			Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4),
-      Get(TypeWrapper<P6>(),v,index + 5)
-		);
-		return 0;
-	}
-
-	template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
-	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<P1>(),v,index + 0),
-			Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4),
-      Get(TypeWrapper<P6>(),v,index + 5),
-      Get(TypeWrapper<P7>(),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<typename Callee,typename RT>
-	int Call(Callee & callee, RT (CALL_QUAL Callee::*func)() CONST_QUAL, HSQUIRRELVM v,int index) {
-	  return ReturnSpecialization<RT>::Call(callee,func,v,index);
-	}
-
-	template<typename Callee,typename RT,typename P1>
-	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1) CONST_QUAL, HSQUIRRELVM v,int index) {
-	  return ReturnSpecialization<RT>::Call(callee,func,v,index);
-	}
-
-	template<typename Callee,typename RT,typename P1,typename P2>
-	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2) CONST_QUAL, HSQUIRRELVM v,int index) {
-	  return ReturnSpecialization<RT>::Call(callee,func,v,index);
-	}
-
-	template<typename Callee,typename RT,typename P1,typename P2,typename P3>
-	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3) CONST_QUAL, HSQUIRRELVM v,int index) {
-	  return ReturnSpecialization<RT>::Call(callee,func,v,index);
-	}
-
-	template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4>
-	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4) CONST_QUAL, HSQUIRRELVM v,int index) {
-	  return ReturnSpecialization<RT>::Call(callee,func,v,index);
-	}
-
-	template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4,typename P5>
-	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5) CONST_QUAL, HSQUIRRELVM v,int index) {
-	  return ReturnSpecialization<RT>::Call(callee,func,v,index);
-	}
-
-	template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
-	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5,P6) CONST_QUAL, HSQUIRRELVM v,int index) {
-	  return ReturnSpecialization<RT>::Call(callee,func,v,index);
-	}
-
-	template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
-	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5,P6,P7) CONST_QUAL, HSQUIRRELVM v,int index) {
-	  return ReturnSpecialization<RT>::Call(callee,func,v,index);
-	}
-
-#undef SQPLUS_CALL_MFUNC_RET1
-#endif // SQPLUS_CALL_MFUNC_RET1
-
-// We will be reusing these symbols later
-#undef SQPLUS_APPLY_CDECL
-#undef SQPLUS_APPLY_CONST 
+

+// 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 <typename Callee>

+  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 <typename Callee,typename P1>

+  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<P1>(),v,index + 0)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename Callee,typename P1,typename P2>

+  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<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename Callee,typename P1,typename P2,typename P3>

+  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<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename Callee,typename P1,typename P2,typename P3,typename P4>

+  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<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5>

+  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<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>

+  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<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4),

+      Get(TypeWrapper<P6>(),v,index + 5)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>

+  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<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4),

+      Get(TypeWrapper<P6>(),v,index + 5),

+      Get(TypeWrapper<P7>(),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<typename Callee>

+	static int Call(Callee & callee,void (CALL_QUAL Callee::*func)() CONST_QUAL, HSQUIRRELVM,int /*index*/) {

+		(callee.*func)();

+		return 0;

+	}

+

+	template<typename Callee,typename P1>

+	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<P1>(),v,index + 0)

+		);

+		return 0;

+	}

+

+	template<typename Callee,typename P1,typename P2>

+	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<P1>(),v,index + 0),

+			Get(TypeWrapper<P2>(),v,index + 1)

+		);

+		return 0;

+	}

+

+	template<typename Callee,typename P1,typename P2,typename P3>

+	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<P1>(),v,index + 0),

+			Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2)

+		);

+		return 0;

+	}

+

+	template<typename Callee,typename P1,typename P2,typename P3,typename P4>

+	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<P1>(),v,index + 0),

+			Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3)

+		);

+		return 0;

+	}

+

+	template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5>

+	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<P1>(),v,index + 0),

+			Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4)

+		);

+		return 0;

+	}

+

+	template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>

+	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<P1>(),v,index + 0),

+			Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4),

+      Get(TypeWrapper<P6>(),v,index + 5)

+		);

+		return 0;

+	}

+

+	template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>

+	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<P1>(),v,index + 0),

+			Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4),

+      Get(TypeWrapper<P6>(),v,index + 5),

+      Get(TypeWrapper<P7>(),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<typename Callee,typename RT>

+	int Call(Callee & callee, RT (CALL_QUAL Callee::*func)() CONST_QUAL, HSQUIRRELVM v,int index) {

+	  return ReturnSpecialization<RT>::Call(callee,func,v,index);

+	}

+

+	template<typename Callee,typename RT,typename P1>

+	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1) CONST_QUAL, HSQUIRRELVM v,int index) {

+	  return ReturnSpecialization<RT>::Call(callee,func,v,index);

+	}

+

+	template<typename Callee,typename RT,typename P1,typename P2>

+	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2) CONST_QUAL, HSQUIRRELVM v,int index) {

+	  return ReturnSpecialization<RT>::Call(callee,func,v,index);

+	}

+

+	template<typename Callee,typename RT,typename P1,typename P2,typename P3>

+	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3) CONST_QUAL, HSQUIRRELVM v,int index) {

+	  return ReturnSpecialization<RT>::Call(callee,func,v,index);

+	}

+

+	template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4>

+	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4) CONST_QUAL, HSQUIRRELVM v,int index) {

+	  return ReturnSpecialization<RT>::Call(callee,func,v,index);

+	}

+

+	template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4,typename P5>

+	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5) CONST_QUAL, HSQUIRRELVM v,int index) {

+	  return ReturnSpecialization<RT>::Call(callee,func,v,index);

+	}

+

+	template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>

+	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5,P6) CONST_QUAL, HSQUIRRELVM v,int index) {

+	  return ReturnSpecialization<RT>::Call(callee,func,v,index);

+	}

+

+	template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>

+	int Call(Callee & callee,RT (CALL_QUAL Callee::*func)(P1,P2,P3,P4,P5,P6,P7) CONST_QUAL, HSQUIRRELVM v,int index) {

+	  return ReturnSpecialization<RT>::Call(callee,func,v,index);

+	}

+

+#undef SQPLUS_CALL_MFUNC_RET1

+#endif // SQPLUS_CALL_MFUNC_RET1

+

+// We will be reusing these symbols later

+#undef SQPLUS_APPLY_CDECL

+#undef SQPLUS_APPLY_CONST 

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusConst.h b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusConst.h
index 0fd6b72ae..50fafc220 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusConst.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusConst.h
@@ -1,74 +1,74 @@
-// SqPlusConst.h
-// SqPlus constant type and constant member function support created by Simon Michelmore.
-// Modular integration 11/14/05 jcs.
-
-#ifdef SQPLUS_DECLARE_INSTANCE_TYPE_CONST
-#undef SQPLUS_DECLARE_INSTANCE_TYPE_CONST
-
-// Kamaitati's NULL_INSTANCE support. 5/28/06 jcs
-
-#ifdef SQPLUS_SUPPORT_NULL_INSTANCES
-
-#define DECLARE_INSTANCE_TYPE_NAME_CONST_BASE(TYPE,NAME) \
-inline bool Match(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,false>(v,idx) != NULL; } \
-inline const TYPE & Get(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE,true>(v,idx); } 
-
-// Ordinary case
-#define DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME) \
-  DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) \
-  namespace SqPlus { \
-  DECLARE_INSTANCE_TYPE_NAME_CONST_BASE(TYPE,NAME) \
-  template<> inline void Push(HSQUIRRELVM v,const TYPE * value) { \
-    if (!value) sq_pushnull(v); \
-    else if (!CreateNativeClassInstance(v,GetTypeName(*value),(TYPE*)value,0)) \
-      throw SquirrelError(_SC("Push(): could not create INSTANCE (check registration name)")); } \
-  template<> inline void Push(HSQUIRRELVM v,const TYPE & value) { if (!CreateCopyInstance(v,GetTypeName(value),value)) throw SquirrelError(_SC("Push(): could not create INSTANCE copy (check registration name)")); } \
-  } // nameSpace SqPlus
-
-// Case for custom Push implementation (covariant return type)
-#define DECLARE_INSTANCE_TYPE_NAME_CONST_CUSTOM(TYPE,NAME) \
-  DECLARE_INSTANCE_TYPE_NAME_CUSTOM_(TYPE,NAME) \
-  namespace SqPlus { \
-  DECLARE_INSTANCE_TYPE_NAME_CONST_BASE(TYPE,NAME) \
-  template<> void Push(HSQUIRRELVM v,const TYPE * value); \
-  template<> void Push(HSQUIRRELVM v,const TYPE & value); \
-  } // nameSpace SqPlus
-
-
-#else
-
-#define DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME) \
-  DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) \
-  namespace SqPlus { \
-  template<> inline void Push(HSQUIRRELVM v,const TYPE * value) { if (!CreateNativeClassInstance(v,GetTypeName(*value),(TYPE*)value,0)) throw SquirrelError(_SC("Push(): could not create INSTANCE (check registration name)")); } \
-  template<> inline void Push(HSQUIRRELVM v,const TYPE & value) { if (!CreateCopyInstance(v,GetTypeName(value),value)) throw SquirrelError(_SC("Push(): could not create INSTANCE copy (check registration name)")); } \
-  template<> inline bool	Match(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return GetInstance<TYPE,false>(v,idx) != NULL; } \
-  template<> inline const TYPE & Get(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE,true>(v,idx); } \
-  } // nameSpace SqPlus
-
-#endif
-
-#define DECLARE_INSTANCE_TYPE(TYPE)           DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,TYPE)
-#define DECLARE_INSTANCE_TYPE_NAME(TYPE,NAME) DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME)
-#define DECLARE_INSTANCE_TYPE_CUSTOM(TYPE)           DECLARE_INSTANCE_TYPE_NAME_CONST_CUSTOM(TYPE,TYPE)
-#define DECLARE_INSTANCE_TYPE_NAME_CUSTOM(TYPE,NAME) DECLARE_INSTANCE_TYPE_NAME_CONST_CUSTOM(TYPE,NAME)
-#endif
-
-#define SQPLUS_APPLY_CONST
-#include "SqPlusCallTemplates.h"
-
-
-#ifdef SQ_REG_CONST_STATIC_VAR
-#undef SQ_REG_CONST_STATIC_VAR
-template<typename VarType>
-SQClassDefBase & staticVar(const VarType * pvar,const SQChar * name,VarAccessType access=VAR_ACCESS_READ_ONLY) {
-  struct CV {
-    const VarType * var;
-  } cv; // Cast Variable helper.
-  cv.var = pvar;
-  RegisterInstanceVariable(newClass,ClassType<TClassType>::type(),*(VarType **)&cv,name,VarAccessType(access|VAR_ACCESS_STATIC));
-  return *this;
-} // staticVar
-#endif
-
-// SqPlusConst.h
+// SqPlusConst.h

+// SqPlus constant type and constant member function support created by Simon Michelmore.

+// Modular integration 11/14/05 jcs.

+

+#ifdef SQPLUS_DECLARE_INSTANCE_TYPE_CONST

+#undef SQPLUS_DECLARE_INSTANCE_TYPE_CONST

+

+// Kamaitati's NULL_INSTANCE support. 5/28/06 jcs

+

+#ifdef SQPLUS_SUPPORT_NULL_INSTANCES

+

+#define DECLARE_INSTANCE_TYPE_NAME_CONST_BASE(TYPE,NAME) \

+inline bool Match(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,false>(v,idx) != NULL; } \

+inline const TYPE & Get(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE,true>(v,idx); } 

+

+// Ordinary case

+#define DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME) \

+  DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) \

+  namespace SqPlus { \

+  DECLARE_INSTANCE_TYPE_NAME_CONST_BASE(TYPE,NAME) \

+  template<> inline void Push(HSQUIRRELVM v,const TYPE * value) { \

+    if (!value) sq_pushnull(v); \

+    else if (!CreateNativeClassInstance(v,GetTypeName(*value),(TYPE*)value,0)) \

+      throw SquirrelError(_SC("Push(): could not create INSTANCE (check registration name)")); } \

+  template<> inline void Push(HSQUIRRELVM v,const TYPE & value) { if (!CreateCopyInstance(v,GetTypeName(value),value)) throw SquirrelError(_SC("Push(): could not create INSTANCE copy (check registration name)")); } \

+  } // nameSpace SqPlus

+

+// Case for custom Push implementation (covariant return type)

+#define DECLARE_INSTANCE_TYPE_NAME_CONST_CUSTOM(TYPE,NAME) \

+  DECLARE_INSTANCE_TYPE_NAME_CUSTOM_(TYPE,NAME) \

+  namespace SqPlus { \

+  DECLARE_INSTANCE_TYPE_NAME_CONST_BASE(TYPE,NAME) \

+  template<> void Push(HSQUIRRELVM v,const TYPE * value); \

+  template<> void Push(HSQUIRRELVM v,const TYPE & value); \

+  } // nameSpace SqPlus

+

+

+#else

+

+#define DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME) \

+  DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) \

+  namespace SqPlus { \

+  template<> inline void Push(HSQUIRRELVM v,const TYPE * value) { if (!CreateNativeClassInstance(v,GetTypeName(*value),(TYPE*)value,0)) throw SquirrelError(_SC("Push(): could not create INSTANCE (check registration name)")); } \

+  template<> inline void Push(HSQUIRRELVM v,const TYPE & value) { if (!CreateCopyInstance(v,GetTypeName(value),value)) throw SquirrelError(_SC("Push(): could not create INSTANCE copy (check registration name)")); } \

+  template<> inline bool	Match(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return GetInstance<TYPE,false>(v,idx) != NULL; } \

+  template<> inline const TYPE & Get(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE,true>(v,idx); } \

+  } // nameSpace SqPlus

+

+#endif

+

+#define DECLARE_INSTANCE_TYPE(TYPE)           DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,TYPE)

+#define DECLARE_INSTANCE_TYPE_NAME(TYPE,NAME) DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME)

+#define DECLARE_INSTANCE_TYPE_CUSTOM(TYPE)           DECLARE_INSTANCE_TYPE_NAME_CONST_CUSTOM(TYPE,TYPE)

+#define DECLARE_INSTANCE_TYPE_NAME_CUSTOM(TYPE,NAME) DECLARE_INSTANCE_TYPE_NAME_CONST_CUSTOM(TYPE,NAME)

+#endif

+

+#define SQPLUS_APPLY_CONST

+#include "SqPlusCallTemplates.h"

+

+

+#ifdef SQ_REG_CONST_STATIC_VAR

+#undef SQ_REG_CONST_STATIC_VAR

+template<typename VarType>

+SQClassDefBase & staticVar(const VarType * pvar,const SQChar * name,VarAccessType access=VAR_ACCESS_READ_ONLY) {

+  struct CV {

+    const VarType * var;

+  } cv; // Cast Variable helper.

+  cv.var = pvar;

+  RegisterInstanceVariable(newClass,ClassType<TClassType>::type(),*(VarType **)&cv,name,VarAccessType(access|VAR_ACCESS_STATIC));

+  return *this;

+} // staticVar

+#endif

+

+// SqPlusConst.h

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusFunctionCallImpl.h b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusFunctionCallImpl.h
index c0752a7f3..8b54308d8 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusFunctionCallImpl.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusFunctionCallImpl.h
@@ -1,114 +1,114 @@
-#ifndef _SQPLUS_FUNCTION_CALL_IMPL_H_
-#define _SQPLUS_FUNCTION_CALL_IMPL_H_
-
-#ifdef GCC_INLINE_WORKAROUND
-# define SQINLINE
-#else
-# define SQINLINE inline
-#endif
-
-SQINLINE void Push(HSQUIRRELVM v,char value)           { sq_pushinteger(v,value); }
-SQINLINE void Push(HSQUIRRELVM v,unsigned char value)  { sq_pushinteger(v,value); }
-SQINLINE void Push(HSQUIRRELVM v,short value)          { sq_pushinteger(v,value); }
-SQINLINE void Push(HSQUIRRELVM v,unsigned short value) { sq_pushinteger(v,value); }
-SQINLINE void Push(HSQUIRRELVM v,int value)            { sq_pushinteger(v,value); }
-SQINLINE void Push(HSQUIRRELVM v,unsigned int value)   { sq_pushinteger(v,value); }
-SQINLINE void Push(HSQUIRRELVM v,long value)           { sq_pushinteger(v,value); }
-SQINLINE void Push(HSQUIRRELVM v,unsigned long value)  { sq_pushinteger(v,value); }
-SQINLINE void Push(HSQUIRRELVM v,double value)         { sq_pushfloat(v,(FLOAT)value); }
-SQINLINE void Push(HSQUIRRELVM v,float value)          { sq_pushfloat(v,(FLOAT)value); }
-SQINLINE void Push(HSQUIRRELVM v,const SQChar * value) { sq_pushstring(v,value,-1); }
-SQINLINE void Push(HSQUIRRELVM v,SQChar * value) { sq_pushstring(v,value,-1); }
-SQINLINE void Push(HSQUIRRELVM v,const SquirrelNull &) { sq_pushnull(v); }
-SQINLINE void Push(HSQUIRRELVM v,SQFUNCTION value)     { sq_pushuserpointer(v,(void*)value); }
-SQINLINE void Push(HSQUIRRELVM v,SQAnythingPtr value)  { sq_pushuserpointer(v,(void*)value); } // Cast to SQAnythingPtr instead of void * if USE_ARGUMENT_DEPENDANT_OVERLOADS can't be used by your compiler.
-SQINLINE void Push(HSQUIRRELVM v,SquirrelObject & so)  { sq_pushobject(v,so.GetObjectHandle()); }
-
-#ifdef USE_ARGUMENT_DEPENDANT_OVERLOADS
-#ifdef _MSC_VER
-#pragma warning (disable:4675) // Disable warning: "resolved overload was found by argument-dependent lookup" when class/struct pointers are used as function arguments.
-#endif
-// === BEGIN Argument Dependent Overloads ===
-SQINLINE void Push(HSQUIRRELVM v,bool value)                  { sq_pushbool(v,value); }               // Pass bool as int if USE_ARGUMENT_DEPENDANT_OVERLOADS can't be used by your compiler.
-SQINLINE void Push(HSQUIRRELVM v,const void * value)          { sq_pushuserpointer(v,(void*)value); } // Pass SQAnythingPtr instead of void * "                                             "
-SQINLINE void Push(HSQUIRRELVM v,const SQUserPointer & value) { sq_pushuserpointer(v,(void*)value); }
-// === END Argument Dependent Overloads ===
-#endif
-
-#define SQPLUS_CHECK_GET(res) if (!SQ_SUCCEEDED(res)) throw SquirrelError(_SC("sq_get*() failed (type error)"))
-
-//SQINLINE bool	Match(TypeWrapper<bool>,HSQUIRRELVM v,int idx)           { return sq_gettype(v,idx) == OT_BOOL; }
-SQINLINE bool	Match(TypeWrapper<bool>,HSQUIRRELVM v,int idx)           { return true; } // All types can be cast to bool
-SQINLINE bool	Match(TypeWrapper<char>,HSQUIRRELVM v,int idx)           { return sq_gettype(v,idx) == OT_INTEGER; }
-SQINLINE bool	Match(TypeWrapper<unsigned char>,HSQUIRRELVM v, int idx) { return sq_gettype(v,idx) == OT_INTEGER; }
-SQINLINE bool	Match(TypeWrapper<short>,HSQUIRRELVM v,int idx)          { return sq_gettype(v,idx) == OT_INTEGER; }
-SQINLINE bool	Match(TypeWrapper<unsigned short>,HSQUIRRELVM v,int idx) { return sq_gettype(v,idx) == OT_INTEGER; }
-SQINLINE bool	Match(TypeWrapper<int>,HSQUIRRELVM v,int idx)            { return sq_gettype(v,idx) == OT_INTEGER; }
-SQINLINE bool	Match(TypeWrapper<unsigned int>,HSQUIRRELVM v,int idx)   { return sq_gettype(v,idx) == OT_INTEGER; }
-SQINLINE bool	Match(TypeWrapper<long>,HSQUIRRELVM v,int idx)           { return sq_gettype(v,idx) == OT_INTEGER; }
-SQINLINE bool	Match(TypeWrapper<unsigned long>,HSQUIRRELVM v,int idx)  { return sq_gettype(v,idx) == OT_INTEGER; }
-SQINLINE bool	Match(TypeWrapper<float>,HSQUIRRELVM v,int idx)          { int type = sq_gettype(v,idx); return type == OT_FLOAT; }
-SQINLINE bool	Match(TypeWrapper<double>,HSQUIRRELVM v,int idx)         { int type = sq_gettype(v,idx); return type == OT_FLOAT; }
-SQINLINE bool	Match(TypeWrapper<const SQChar *>,HSQUIRRELVM v,int idx) { return sq_gettype(v,idx) == OT_STRING; }
-SQINLINE bool	Match(TypeWrapper<SQChar *>,HSQUIRRELVM v,int idx)       { return sq_gettype(v,idx) == OT_STRING; }
-SQINLINE bool	Match(TypeWrapper<HSQUIRRELVM>,HSQUIRRELVM v,int idx)    { return true; } // See Get() for HSQUIRRELVM below (v is always present).
-SQINLINE bool	Match(TypeWrapper<void*>,HSQUIRRELVM v,int idx)          { return sq_gettype(v,idx) == OT_USERPOINTER; }
-SQINLINE bool	Match(TypeWrapper<SquirrelObject>,HSQUIRRELVM v,int idx) { return true; } // See sq_getstackobj(): always returns true.
-
-SQINLINE void           Get(TypeWrapper<void>,HSQUIRRELVM v,int)                {}
-//SQINLINE bool           Get(TypeWrapper<bool>,HSQUIRRELVM v,int idx)            { SQBool b; SQPLUS_CHECK_GET(sq_getbool(v,idx,&b)); return b != 0; }
-SQINLINE char           Get(TypeWrapper<char>,HSQUIRRELVM v,int idx)            { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<char>(i); }
-SQINLINE unsigned char  Get(TypeWrapper<unsigned char>,HSQUIRRELVM v,int idx)   { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<unsigned char>(i); }
-SQINLINE short          Get(TypeWrapper<short>,HSQUIRRELVM v,int idx)           { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<short>(i); }
-SQINLINE unsigned short	Get(TypeWrapper<unsigned short>,HSQUIRRELVM v,int idx)  { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<unsigned short>(i); }
-SQINLINE int            Get(TypeWrapper<int>,HSQUIRRELVM v,int idx)             { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return i; }
-SQINLINE unsigned int   Get(TypeWrapper<unsigned int>,HSQUIRRELVM v,int idx)    { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<unsigned int>(i); }
-SQINLINE long           Get(TypeWrapper<long>,HSQUIRRELVM v,int idx)            { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<long>(i); }
-SQINLINE unsigned long  Get(TypeWrapper<unsigned long>,HSQUIRRELVM v,int idx)   { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<unsigned long>(i); }
-SQINLINE float          Get(TypeWrapper<float>,HSQUIRRELVM v,int idx)           { FLOAT f; SQPLUS_CHECK_GET(sq_getfloat(v,idx,&f)); return f; }
-SQINLINE double         Get(TypeWrapper<double>,HSQUIRRELVM v,int idx)          { FLOAT f; SQPLUS_CHECK_GET(sq_getfloat(v,idx,&f)); return static_cast<double>(f); }
-SQINLINE const SQChar * Get(TypeWrapper<const SQChar *>,HSQUIRRELVM v,int idx)  { const SQChar * s; SQPLUS_CHECK_GET(sq_getstring(v,idx,&s)); return s; }
-SQINLINE SquirrelNull   Get(TypeWrapper<SquirrelNull>,HSQUIRRELVM v,int idx)    { (void)v, (void)idx; return SquirrelNull();  }
-SQINLINE void *         Get(TypeWrapper<void *>,HSQUIRRELVM v,int idx)          { SQUserPointer p; SQPLUS_CHECK_GET(sq_getuserpointer(v,idx,&p)); return p; }
-SQINLINE HSQUIRRELVM    Get(TypeWrapper<HSQUIRRELVM>,HSQUIRRELVM v,int /*idx*/) { sq_poptop(v); return v; } // sq_poptop(v): remove UserData from stack so GetParamCount() matches normal behavior.
-SQINLINE SquirrelObject Get(TypeWrapper<SquirrelObject>,HSQUIRRELVM v,int idx)  { HSQOBJECT o; SQPLUS_CHECK_GET(sq_getstackobj(v,idx,&o)); return SquirrelObject(o); }
-
-SQINLINE bool Get(TypeWrapper<bool>,HSQUIRRELVM v,int idx){
-    switch( sq_gettype(v,idx) ){
-        case OT_NULL:{ return false; }
-        case OT_BOOL:{ SQBool b; SQPLUS_CHECK_GET(sq_getbool(v,idx,&b)); return b != 0; }
-        case OT_INTEGER:{ INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return i != 0; }
-        case OT_FLOAT:{ FLOAT f; SQPLUS_CHECK_GET(sq_getfloat(v,idx,&f)); return f != (FLOAT)0.0; }
-        default: return true; } }
-
-#ifdef SQPLUS_AUTOCONVERT_OTHER_CHAR
-SQINLINE void Push(HSQUIRRELVM v, const SQOtherChar *value){ SQDefCharBuf cb(value); sq_pushstring(v,(const SQChar*)cb,-1); }
-SQINLINE void Push(HSQUIRRELVM v, SQOtherChar *value){ SQDefCharBuf cb(value); sq_pushstring(v,(const SQChar*)cb,-1); }
-SQINLINE bool	Match(TypeWrapper<const SQOtherChar *>,HSQUIRRELVM v,int idx) { return sq_gettype(v,idx) == OT_STRING; }
-SQINLINE bool	Match(TypeWrapper<SQOtherChar *>,HSQUIRRELVM v,int idx)       { return sq_gettype(v,idx) == OT_STRING; }
-/*SQINLINE SQOtherChar* Get(TypeWrapper<const SQOtherChar *>,HSQUIRRELVM v,int idx)  { 
-	const SQChar *s;  SQPLUS_CHECK_GET(sq_getstring(v,idx,&s));  
-	static SQOthCharBuf ocb[SQPLUS_AUTOCONVERT_MAX_INSTANCES]; static int st_buf_cnt; 
-	return ocb[st_buf_cnt++%SQPLUS_AUTOCONVERT_MAX_INSTANCES].Set(s); }*/
-SQINLINE SQOthCharBuf Get(TypeWrapper<const SQOtherChar *>,HSQUIRRELVM v,int idx)  { const SQChar * s;  SQPLUS_CHECK_GET(sq_getstring(v,idx,&s));  return SQOthCharBuf(s); }
-#endif // SQPLUS_AUTOCONVERT_OTHER_CHAR
-
-#if defined(SQPLUS_SUPPORT_STD_STRING) && !defined(SQUNICODE)
-SQINLINE void Push(HSQUIRRELVM v,const std::string& value) { sq_pushstring(v,value.c_str(),-1); }
-SQINLINE bool Match(TypeWrapper<const std::string&>, HSQUIRRELVM v, int idx) { return sq_gettype(v,idx) == OT_STRING; }
-SQINLINE std::string Get(TypeWrapper<const std::string&>,HSQUIRRELVM v,int idx) { const SQChar * s; SQPLUS_CHECK_GET(sq_getstring(v,idx,&s)); return std::string(s); } 
-#endif // defined(SQPLUS_SUPPORT_STD_STRING) && !defined(SQUNICODE)
-
-// Added jflanglois suggestion, 8/20/06. jcs
-#ifdef SQPLUS_SUPPORT_SQ_STD_STRING
-typedef std::basic_string<SQChar> sq_std_string;
-SQINLINE void Push(HSQUIRRELVM v,const sq_std_string & value) { sq_pushstring(v,value.c_str(),-1); }
-SQINLINE bool Match(TypeWrapper<const sq_std_string &>, HSQUIRRELVM v, int idx) { return sq_gettype(v,idx) == OT_STRING; }
-SQINLINE sq_std_string Get(TypeWrapper<const sq_std_string &>,HSQUIRRELVM v,int idx) { const SQChar * s; SQPLUS_CHECK_GET(sq_getstring(v,idx,&s)); return sq_std_string(s); } 
-#endif
-
-// Specialization to support void return type.
-SQINLINE void GetRet(TypeWrapper<void>,HSQUIRRELVM v,int idx) { sq_pop(v,2); }
-
-#endif // _SQPLUS_FUNCTION_CALL_IMPL_H_
-
+#ifndef _SQPLUS_FUNCTION_CALL_IMPL_H_

+#define _SQPLUS_FUNCTION_CALL_IMPL_H_

+

+#ifdef GCC_INLINE_WORKAROUND

+# define SQINLINE

+#else

+# define SQINLINE inline

+#endif

+

+SQINLINE void Push(HSQUIRRELVM v,char value)           { sq_pushinteger(v,value); }

+SQINLINE void Push(HSQUIRRELVM v,unsigned char value)  { sq_pushinteger(v,value); }

+SQINLINE void Push(HSQUIRRELVM v,short value)          { sq_pushinteger(v,value); }

+SQINLINE void Push(HSQUIRRELVM v,unsigned short value) { sq_pushinteger(v,value); }

+SQINLINE void Push(HSQUIRRELVM v,int value)            { sq_pushinteger(v,value); }

+SQINLINE void Push(HSQUIRRELVM v,unsigned int value)   { sq_pushinteger(v,value); }

+SQINLINE void Push(HSQUIRRELVM v,long value)           { sq_pushinteger(v,value); }

+SQINLINE void Push(HSQUIRRELVM v,unsigned long value)  { sq_pushinteger(v,value); }

+SQINLINE void Push(HSQUIRRELVM v,double value)         { sq_pushfloat(v,(FLOAT)value); }

+SQINLINE void Push(HSQUIRRELVM v,float value)          { sq_pushfloat(v,(FLOAT)value); }

+SQINLINE void Push(HSQUIRRELVM v,const SQChar * value) { sq_pushstring(v,value,-1); }

+SQINLINE void Push(HSQUIRRELVM v,SQChar * value) { sq_pushstring(v,value,-1); }

+SQINLINE void Push(HSQUIRRELVM v,const SquirrelNull &) { sq_pushnull(v); }

+SQINLINE void Push(HSQUIRRELVM v,SQFUNCTION value)     { sq_pushuserpointer(v,(void*)value); }

+SQINLINE void Push(HSQUIRRELVM v,SQAnythingPtr value)  { sq_pushuserpointer(v,(void*)value); } // Cast to SQAnythingPtr instead of void * if USE_ARGUMENT_DEPENDANT_OVERLOADS can't be used by your compiler.

+SQINLINE void Push(HSQUIRRELVM v,SquirrelObject & so)  { sq_pushobject(v,so.GetObjectHandle()); }

+

+#ifdef USE_ARGUMENT_DEPENDANT_OVERLOADS

+#ifdef _MSC_VER

+#pragma warning (disable:4675) // Disable warning: "resolved overload was found by argument-dependent lookup" when class/struct pointers are used as function arguments.

+#endif

+// === BEGIN Argument Dependent Overloads ===

+SQINLINE void Push(HSQUIRRELVM v,bool value)                  { sq_pushbool(v,value); }               // Pass bool as int if USE_ARGUMENT_DEPENDANT_OVERLOADS can't be used by your compiler.

+SQINLINE void Push(HSQUIRRELVM v,const void * value)          { sq_pushuserpointer(v,(void*)value); } // Pass SQAnythingPtr instead of void * "                                             "

+SQINLINE void Push(HSQUIRRELVM v,const SQUserPointer & value) { sq_pushuserpointer(v,(void*)value); }

+// === END Argument Dependent Overloads ===

+#endif

+

+#define SQPLUS_CHECK_GET(res) if (!SQ_SUCCEEDED(res)) throw SquirrelError(_SC("sq_get*() failed (type error)"))

+

+//SQINLINE bool	Match(TypeWrapper<bool>,HSQUIRRELVM v,int idx)           { return sq_gettype(v,idx) == OT_BOOL; }

+SQINLINE bool	Match(TypeWrapper<bool>,HSQUIRRELVM v,int idx)           { return true; } // All types can be cast to bool

+SQINLINE bool	Match(TypeWrapper<char>,HSQUIRRELVM v,int idx)           { return sq_gettype(v,idx) == OT_INTEGER; }

+SQINLINE bool	Match(TypeWrapper<unsigned char>,HSQUIRRELVM v, int idx) { return sq_gettype(v,idx) == OT_INTEGER; }

+SQINLINE bool	Match(TypeWrapper<short>,HSQUIRRELVM v,int idx)          { return sq_gettype(v,idx) == OT_INTEGER; }

+SQINLINE bool	Match(TypeWrapper<unsigned short>,HSQUIRRELVM v,int idx) { return sq_gettype(v,idx) == OT_INTEGER; }

+SQINLINE bool	Match(TypeWrapper<int>,HSQUIRRELVM v,int idx)            { return sq_gettype(v,idx) == OT_INTEGER; }

+SQINLINE bool	Match(TypeWrapper<unsigned int>,HSQUIRRELVM v,int idx)   { return sq_gettype(v,idx) == OT_INTEGER; }

+SQINLINE bool	Match(TypeWrapper<long>,HSQUIRRELVM v,int idx)           { return sq_gettype(v,idx) == OT_INTEGER; }

+SQINLINE bool	Match(TypeWrapper<unsigned long>,HSQUIRRELVM v,int idx)  { return sq_gettype(v,idx) == OT_INTEGER; }

+SQINLINE bool	Match(TypeWrapper<float>,HSQUIRRELVM v,int idx)          { int type = sq_gettype(v,idx); return type == OT_FLOAT; }

+SQINLINE bool	Match(TypeWrapper<double>,HSQUIRRELVM v,int idx)         { int type = sq_gettype(v,idx); return type == OT_FLOAT; }

+SQINLINE bool	Match(TypeWrapper<const SQChar *>,HSQUIRRELVM v,int idx) { return sq_gettype(v,idx) == OT_STRING; }

+SQINLINE bool	Match(TypeWrapper<SQChar *>,HSQUIRRELVM v,int idx)       { return sq_gettype(v,idx) == OT_STRING; }

+SQINLINE bool	Match(TypeWrapper<HSQUIRRELVM>,HSQUIRRELVM v,int idx)    { return true; } // See Get() for HSQUIRRELVM below (v is always present).

+SQINLINE bool	Match(TypeWrapper<void*>,HSQUIRRELVM v,int idx)          { return sq_gettype(v,idx) == OT_USERPOINTER; }

+SQINLINE bool	Match(TypeWrapper<SquirrelObject>,HSQUIRRELVM v,int idx) { return true; } // See sq_getstackobj(): always returns true.

+

+SQINLINE void           Get(TypeWrapper<void>,HSQUIRRELVM v,int)                {}

+//SQINLINE bool           Get(TypeWrapper<bool>,HSQUIRRELVM v,int idx)            { SQBool b; SQPLUS_CHECK_GET(sq_getbool(v,idx,&b)); return b != 0; }

+SQINLINE char           Get(TypeWrapper<char>,HSQUIRRELVM v,int idx)            { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<char>(i); }

+SQINLINE unsigned char  Get(TypeWrapper<unsigned char>,HSQUIRRELVM v,int idx)   { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<unsigned char>(i); }

+SQINLINE short          Get(TypeWrapper<short>,HSQUIRRELVM v,int idx)           { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<short>(i); }

+SQINLINE unsigned short	Get(TypeWrapper<unsigned short>,HSQUIRRELVM v,int idx)  { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<unsigned short>(i); }

+SQINLINE int            Get(TypeWrapper<int>,HSQUIRRELVM v,int idx)             { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return i; }

+SQINLINE unsigned int   Get(TypeWrapper<unsigned int>,HSQUIRRELVM v,int idx)    { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<unsigned int>(i); }

+SQINLINE long           Get(TypeWrapper<long>,HSQUIRRELVM v,int idx)            { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<long>(i); }

+SQINLINE unsigned long  Get(TypeWrapper<unsigned long>,HSQUIRRELVM v,int idx)   { INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return static_cast<unsigned long>(i); }

+SQINLINE float          Get(TypeWrapper<float>,HSQUIRRELVM v,int idx)           { FLOAT f; SQPLUS_CHECK_GET(sq_getfloat(v,idx,&f)); return f; }

+SQINLINE double         Get(TypeWrapper<double>,HSQUIRRELVM v,int idx)          { FLOAT f; SQPLUS_CHECK_GET(sq_getfloat(v,idx,&f)); return static_cast<double>(f); }

+SQINLINE const SQChar * Get(TypeWrapper<const SQChar *>,HSQUIRRELVM v,int idx)  { const SQChar * s; SQPLUS_CHECK_GET(sq_getstring(v,idx,&s)); return s; }

+SQINLINE SquirrelNull   Get(TypeWrapper<SquirrelNull>,HSQUIRRELVM v,int idx)    { (void)v, (void)idx; return SquirrelNull();  }

+SQINLINE void *         Get(TypeWrapper<void *>,HSQUIRRELVM v,int idx)          { SQUserPointer p; SQPLUS_CHECK_GET(sq_getuserpointer(v,idx,&p)); return p; }

+SQINLINE HSQUIRRELVM    Get(TypeWrapper<HSQUIRRELVM>,HSQUIRRELVM v,int /*idx*/) { sq_poptop(v); return v; } // sq_poptop(v): remove UserData from stack so GetParamCount() matches normal behavior.

+SQINLINE SquirrelObject Get(TypeWrapper<SquirrelObject>,HSQUIRRELVM v,int idx)  { HSQOBJECT o; SQPLUS_CHECK_GET(sq_getstackobj(v,idx,&o)); return SquirrelObject(o); }

+

+SQINLINE bool Get(TypeWrapper<bool>,HSQUIRRELVM v,int idx){

+    switch( sq_gettype(v,idx) ){

+        case OT_NULL:{ return false; }

+        case OT_BOOL:{ SQBool b; SQPLUS_CHECK_GET(sq_getbool(v,idx,&b)); return b != 0; }

+        case OT_INTEGER:{ INT i; SQPLUS_CHECK_GET(sq_getinteger(v,idx,&i)); return i != 0; }

+        case OT_FLOAT:{ FLOAT f; SQPLUS_CHECK_GET(sq_getfloat(v,idx,&f)); return f != (FLOAT)0.0; }

+        default: return true; } }

+

+#ifdef SQPLUS_AUTOCONVERT_OTHER_CHAR

+SQINLINE void Push(HSQUIRRELVM v, const SQOtherChar *value){ SQDefCharBuf cb(value); sq_pushstring(v,(const SQChar*)cb,-1); }

+SQINLINE void Push(HSQUIRRELVM v, SQOtherChar *value){ SQDefCharBuf cb(value); sq_pushstring(v,(const SQChar*)cb,-1); }

+SQINLINE bool	Match(TypeWrapper<const SQOtherChar *>,HSQUIRRELVM v,int idx) { return sq_gettype(v,idx) == OT_STRING; }

+SQINLINE bool	Match(TypeWrapper<SQOtherChar *>,HSQUIRRELVM v,int idx)       { return sq_gettype(v,idx) == OT_STRING; }

+/*SQINLINE SQOtherChar* Get(TypeWrapper<const SQOtherChar *>,HSQUIRRELVM v,int idx)  { 

+	const SQChar *s;  SQPLUS_CHECK_GET(sq_getstring(v,idx,&s));  

+	static SQOthCharBuf ocb[SQPLUS_AUTOCONVERT_MAX_INSTANCES]; static int st_buf_cnt; 

+	return ocb[st_buf_cnt++%SQPLUS_AUTOCONVERT_MAX_INSTANCES].Set(s); }*/

+SQINLINE SQOthCharBuf Get(TypeWrapper<const SQOtherChar *>,HSQUIRRELVM v,int idx)  { const SQChar * s;  SQPLUS_CHECK_GET(sq_getstring(v,idx,&s));  return SQOthCharBuf(s); }

+#endif // SQPLUS_AUTOCONVERT_OTHER_CHAR

+

+#if defined(SQPLUS_SUPPORT_STD_STRING) && !defined(SQUNICODE)

+SQINLINE void Push(HSQUIRRELVM v,const std::string& value) { sq_pushstring(v,value.c_str(),-1); }

+SQINLINE bool Match(TypeWrapper<const std::string&>, HSQUIRRELVM v, int idx) { return sq_gettype(v,idx) == OT_STRING; }

+SQINLINE std::string Get(TypeWrapper<const std::string&>,HSQUIRRELVM v,int idx) { const SQChar * s; SQPLUS_CHECK_GET(sq_getstring(v,idx,&s)); return std::string(s); } 

+#endif // defined(SQPLUS_SUPPORT_STD_STRING) && !defined(SQUNICODE)

+

+// Added jflanglois suggestion, 8/20/06. jcs

+#ifdef SQPLUS_SUPPORT_SQ_STD_STRING

+typedef std::basic_string<SQChar> sq_std_string;

+SQINLINE void Push(HSQUIRRELVM v,const sq_std_string & value) { sq_pushstring(v,value.c_str(),-1); }

+SQINLINE bool Match(TypeWrapper<const sq_std_string &>, HSQUIRRELVM v, int idx) { return sq_gettype(v,idx) == OT_STRING; }

+SQINLINE sq_std_string Get(TypeWrapper<const sq_std_string &>,HSQUIRRELVM v,int idx) { const SQChar * s; SQPLUS_CHECK_GET(sq_getstring(v,idx,&s)); return sq_std_string(s); } 

+#endif

+

+// Specialization to support void return type.

+SQINLINE void GetRet(TypeWrapper<void>,HSQUIRRELVM v,int idx) { sq_pop(v,2); }

+

+#endif // _SQPLUS_FUNCTION_CALL_IMPL_H_

+

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusOCharBuf.cpp b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusOCharBuf.cpp
index 4a0bd2a9b..7c49c33db 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusOCharBuf.cpp
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusOCharBuf.cpp
@@ -1,61 +1,61 @@
-
-#include "sqplus.h"
-#include "SqPlusOCharBuf.h" 
-
-#include <wchar.h>
-
-// Conversion functions, between char* string and wchar_t* strings.
-
-int ol_strlen(const wchar_t* pwc){ return (int)wcslen(pwc); }
-int ol_buflen(const wchar_t* pwc){ return (int)wcslen(pwc); }
-int ol_charlen(const wchar_t* pwc){ return 1; }
-//int ol_charlen(const wchar_t pwc){ return 1; }
-int ol_char(const wchar_t* pwc){ return (int)*pwc; }
-bool ol_writechar(wchar_t*& pwc, int ch){ *pwc=(wchar_t)ch; pwc++; return true; }
-
-int ol_buflen(const char* pc){ return (int)strlen(pc); }
-
-#if SQPLUS_USE_LATIN1==1
-  // Convert to 8-bit LATIN1 char set. The only thing to do is convert chars out of range to '?'
-  int ol_strlen(const char* pc){ return (int)strlen(pc); }
-  int ol_charlen(const char* pc){ return 1; }
-  //int ol_charlen(int pc){ return 1; }
-  int ol_char(const char* pc){ return (int)*(unsigned char*)pc; }
-  bool ol_writechar(char*& pc, int ch){ *pc=(char)(ch>255?'?':ch); pc++; return true; }
-#else
-  #include "SqPlusUtf8.h" 
-  // Convert to 8-Bit UTF8 encoding. Some more work here. 
-  int ol_strlen(const char* pc){ return sqplus_utf8_strlen(pc); }
-  int ol_charlen(const char* pc){ return sqplus_utf8_len_first(pc); }
-  //int ol_charlen(int ch){ char buf[8]; return sqplus_wchar_to_utf8(buf,ch,8); }  
-  int ol_char(const char* pc){ int chr=-1; sqplus_utf8_to_wchar(&chr,pc); return chr; }
-  bool ol_writechar(char*& pc, int ch) { 
-	  int l=sqplus_wchar_to_utf8(pc,ch,8); 
-	  if(l>0){ 
-		  pc += l; 
-		  return true;  
-	  }
-	  else return false;
-  }
-#endif
-
-
-#ifdef SQUNICODE
-  // SQChar is wchar_t, convert to/from to either Latin1 or UTF8
-  SQDefCharBuf CH2SQ( const char* ps ){
-    return SQDefCharBuf(ps);
-  }
-  SQOthCharBuf SQ2CH( const wchar_t* pws ){
-    return SQOthCharBuf(pws);
-  }
-#else
-  // SQChar is char, convert to/from wchar_t
-  SQDefCharBuf WC2SQ( const wchar_t* pws ){
-    return SQDefCharBuf(pws);
-  }
-  SQOthCharBuf SQ2WC( const char* ps ){
-    return SQOthCharBuf(ps);
-  }
-#endif
-
-
+

+#include "sqplus.h"

+#include "SqPlusOCharBuf.h" 

+

+#include <wchar.h>

+

+// Conversion functions, between char* string and wchar_t* strings.

+

+int ol_strlen(const wchar_t* pwc){ return (int)wcslen(pwc); }

+int ol_buflen(const wchar_t* pwc){ return (int)wcslen(pwc); }

+int ol_charlen(const wchar_t* pwc){ return 1; }

+//int ol_charlen(const wchar_t pwc){ return 1; }

+int ol_char(const wchar_t* pwc){ return (int)*pwc; }

+bool ol_writechar(wchar_t*& pwc, int ch){ *pwc=(wchar_t)ch; pwc++; return true; }

+

+int ol_buflen(const char* pc){ return (int)strlen(pc); }

+

+#if SQPLUS_USE_LATIN1==1

+  // Convert to 8-bit LATIN1 char set. The only thing to do is convert chars out of range to '?'

+  int ol_strlen(const char* pc){ return (int)strlen(pc); }

+  int ol_charlen(const char* pc){ return 1; }

+  //int ol_charlen(int pc){ return 1; }

+  int ol_char(const char* pc){ return (int)*(unsigned char*)pc; }

+  bool ol_writechar(char*& pc, int ch){ *pc=(char)(ch>255?'?':ch); pc++; return true; }

+#else

+  #include "SqPlusUtf8.h" 

+  // Convert to 8-Bit UTF8 encoding. Some more work here. 

+  int ol_strlen(const char* pc){ return sqplus_utf8_strlen(pc); }

+  int ol_charlen(const char* pc){ return sqplus_utf8_len_first(pc); }

+  //int ol_charlen(int ch){ char buf[8]; return sqplus_wchar_to_utf8(buf,ch,8); }  

+  int ol_char(const char* pc){ int chr=-1; sqplus_utf8_to_wchar(&chr,pc); return chr; }

+  bool ol_writechar(char*& pc, int ch) { 

+	  int l=sqplus_wchar_to_utf8(pc,ch,8); 

+	  if(l>0){ 

+		  pc += l; 

+		  return true;  

+	  }

+	  else return false;

+  }

+#endif

+

+

+#ifdef SQUNICODE

+  // SQChar is wchar_t, convert to/from to either Latin1 or UTF8

+  SQDefCharBuf CH2SQ( const char* ps ){

+    return SQDefCharBuf(ps);

+  }

+  SQOthCharBuf SQ2CH( const wchar_t* pws ){

+    return SQOthCharBuf(pws);

+  }

+#else

+  // SQChar is char, convert to/from wchar_t

+  SQDefCharBuf WC2SQ( const wchar_t* pws ){

+    return SQDefCharBuf(pws);

+  }

+  SQOthCharBuf SQ2WC( const char* ps ){

+    return SQOthCharBuf(ps);

+  }

+#endif

+

+

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusOCharBuf.h b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusOCharBuf.h
index c27e7c803..24fe16b16 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusOCharBuf.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusOCharBuf.h
@@ -1,193 +1,193 @@
-
-#ifndef SQPLUS_OCHARBUF_H
-#define SQPLUS_OCHARBUF_H
-
-// Conversion routines between different character encodings, to be used in
-// Push/Get/Match handlers of SqPlus. It enables using both of char* and 
-// wchar_t* as function arguments.
-//
-// When converting from wchar_t to char, the choice is between using a Latin1 
-// or a UTF8 representation in 8-bit mode. This is probably most useful if 
-// Squirrel is compiled in ANSI mode and the app uses some wchar_t strings 
-// (UNICODE mode on Win32). 
-//
-
-// A char is either
-//  - A Latin1 character (first code page, coincides with Unicode points 0..255)
-//  - Part of an UTF8 character
-//
-// Note: SQUTF8 requires Squirrel sources that have been patched for UTF8 strings 
-// internally (when converting function arguments). 
-
-#ifndef SQUTF8
-  // Default to Latin1 conversion 
-  //#undef SQPLUS_USE_LATIN1
-  #ifndef SQPLUS_USE_LATIN1
-    #define SQPLUS_USE_LATIN1 1
-  #endif
-#else
-  // Using Squirrel with internal UTF8 string encoding 
-  //#undef SQPLUS_USE_LATIN1
-  #ifndef SQPLUS_USE_LATIN1
-    #define SQPLUS_USE_LATIN1 0
-  #endif
-#endif 
- 
-
-// The various ol_... functions sets up for a conversion scheme 
-// that can be used in both wchar_t => char and  char => wchar_t.
-int ol_strlen(const wchar_t* pwc);
-int ol_buflen(const wchar_t* pwc);
-int ol_charlen(const wchar_t* pwc);
-int ol_char(const wchar_t* pwc);
-bool ol_writechar(wchar_t*& pwc, int ch);
-
-int ol_strlen(const char* pc);
-int ol_buflen(const char* pc);
-int ol_charlen(const char* pc);
-int ol_char(const char* pc);
-bool ol_writechar(char*& pc, int ch);
-
-#ifdef SQUNICODE
-  // SQChar is wchar_t, convert to/from either Latin1 or UTF8
-  typedef char SQOtherChar;
-#else
-  // SQChar is char, convert to/from wchar_t
-  typedef wchar_t SQOtherChar;
-#endif
-
-
-// Buffer to hold a string and release it in destructor. 
-// SQT is input character type 
-// SQOT is the opposite type of SQChar
-// If 'try_borrow' is set, it will not allocate a new buffer when no 
-// conversion is done, it will just keep the input pointer (beware).
-template<class SQT, class SQOT, bool use_latin1>
-struct SQCharBufImpl {
-
-	// Allocate a buffer from string of same type
-	SQCharBufImpl(const SQT *poc=NULL, bool try_borrow=true ) : m_poc(0), m_own(false) { 
-		Init( poc, try_borrow );
-	}
-
-	// This does conversion from other char type
-	SQCharBufImpl(const SQOT *ps, bool try_borrow=false ) : m_poc(0), m_own(false) { 
-		Init( ps ); // Cannot borrow pointer when doing conversion
-	}
-
-	void Init( const SQT *poc, bool try_borrow ){
-		m_own = !try_borrow;
-		if( try_borrow ){ 
-			m_poc = (SQT*)poc;
-		}
-		else {
-			int sl = poc ? ol_buflen(poc) : 0;
-			if( poc ){
-				m_poc = poc ? new SQT[sl+1] : NULL; 
-				if( m_poc ) memcpy( m_poc, poc, (sl+1)*sizeof(SQT) );
-			}
-			else
-				m_poc = NULL;
-		}
-    }
-
-	void Init( const SQOT *ps ){
-		m_own = true;
-        if( ps ){
-            int sl = ps ? ol_strlen(ps) : 0;	// Length of string in characters (not bytes)
-		    int scl = 0;                        // Length of converted string in char/wchar_t count
-			// How much storage needed? 
-			if( !use_latin1 && sizeof(SQT)<sizeof(SQOT) ){
-				// Converting wchar_t => UTF8 
-				const SQOT *ps1 = ps;   // It is wchar_t* here
-				SQT tmp_buf[8];
-				SQT *ptmp;
-				while( *ps1 ){
-				    ptmp = tmp_buf;
-                    if( ol_writechar(ptmp,*ps1++) )
-                        scl += ol_charlen(tmp_buf);
-                    else
-                        scl++;
-				}
-			}
-			else scl = sl;  // Converting to wchar_t or Latin1, keep length 
-
-            m_poc = new SQT[scl+1]; 
-			if( !m_poc ) return;
-
-			// Convert 
-			SQT *poc = m_poc;
-			while( *ps ){
-				ol_writechar( poc, ol_char(ps) );
-				ps += ol_charlen(ps);
-			}
-			*poc = 0;	// Terminating zero
-        }
-        else
-            m_poc = NULL;
-    }
-    
-    ~SQCharBufImpl(){ Release(); }
-    
-	void Release( ){
-		if(m_poc && m_own ) 
-			delete [] m_poc; 
-		m_poc = NULL;
-	}
-
-	SQT* Set( const SQOT *ps ){
-		Release( );
-		Init( ps );
-		return m_poc;
-	}
-
-    operator SQT*() const { return m_poc; }
-    
-	SQCharBufImpl<SQT,SQOT,use_latin1>& operator = (const SQT *ps){
-		Release();
-		Init( ps, false );
-		return *this;
-	}
-
-	SQCharBufImpl<SQT,SQOT,use_latin1>& operator = (const SQOT *ps){
-		Release();
-		Init( ps );
-		return *this;
-	}
-
-	// Move string from other here - Note: Empties the input argument (other)
-	SQCharBufImpl<SQT,SQOT,use_latin1>& operator = (const SQCharBufImpl<SQT,SQOT,use_latin1>& other){
-		Release();
-		m_poc = other.m_poc;
-		m_own = other.m_own;
-		SQT **psqt = (SQT**)&other.m_poc;
-		*psqt = NULL;
-		return *this;
-	}
-
-protected:
-    SQT *m_poc;
-	bool m_own;
-};
-
-typedef SQCharBufImpl<SQOtherChar, SQChar, bool(SQPLUS_USE_LATIN1)> SQOthCharBuf;
-typedef SQCharBufImpl<SQChar, SQOtherChar, bool(SQPLUS_USE_LATIN1)> SQDefCharBuf;
-typedef SQCharBufImpl<wchar_t, char, bool(SQPLUS_USE_LATIN1)>       SQWCharBuf;
-typedef SQCharBufImpl<char, wchar_t, bool(SQPLUS_USE_LATIN1)>       SQACharBuf;
-
-#ifdef SQUNICODE
-  // SQChar is wchar_t, convert to/from to either Latin1 or UTF8
-  #define WC2SQ(s) s
-  #define SQ2WC(s) s
-  SQDefCharBuf CH2SQ( const char* ps );
-  SQOthCharBuf SQ2CH( const wchar_t* pws );
-#else
-  // SQChar is char, convert to/from wchar_t
-  SQDefCharBuf WC2SQ( const wchar_t* pws );
-  SQOthCharBuf SQ2WC( const char* pws );
-  #define CH2SQ(s) s
-  #define SQ2CH(s) s
-#endif
-
-#endif // SQPLUS_CHARBUF_H
-
+

+#ifndef SQPLUS_OCHARBUF_H

+#define SQPLUS_OCHARBUF_H

+

+// Conversion routines between different character encodings, to be used in

+// Push/Get/Match handlers of SqPlus. It enables using both of char* and 

+// wchar_t* as function arguments.

+//

+// When converting from wchar_t to char, the choice is between using a Latin1 

+// or a UTF8 representation in 8-bit mode. This is probably most useful if 

+// Squirrel is compiled in ANSI mode and the app uses some wchar_t strings 

+// (UNICODE mode on Win32). 

+//

+

+// A char is either

+//  - A Latin1 character (first code page, coincides with Unicode points 0..255)

+//  - Part of an UTF8 character

+//

+// Note: SQUTF8 requires Squirrel sources that have been patched for UTF8 strings 

+// internally (when converting function arguments). 

+

+#ifndef SQUTF8

+  // Default to Latin1 conversion 

+  //#undef SQPLUS_USE_LATIN1

+  #ifndef SQPLUS_USE_LATIN1

+    #define SQPLUS_USE_LATIN1 1

+  #endif

+#else

+  // Using Squirrel with internal UTF8 string encoding 

+  //#undef SQPLUS_USE_LATIN1

+  #ifndef SQPLUS_USE_LATIN1

+    #define SQPLUS_USE_LATIN1 0

+  #endif

+#endif 

+ 

+

+// The various ol_... functions sets up for a conversion scheme 

+// that can be used in both wchar_t => char and  char => wchar_t.

+int ol_strlen(const wchar_t* pwc);

+int ol_buflen(const wchar_t* pwc);

+int ol_charlen(const wchar_t* pwc);

+int ol_char(const wchar_t* pwc);

+bool ol_writechar(wchar_t*& pwc, int ch);

+

+int ol_strlen(const char* pc);

+int ol_buflen(const char* pc);

+int ol_charlen(const char* pc);

+int ol_char(const char* pc);

+bool ol_writechar(char*& pc, int ch);

+

+#ifdef SQUNICODE

+  // SQChar is wchar_t, convert to/from either Latin1 or UTF8

+  typedef char SQOtherChar;

+#else

+  // SQChar is char, convert to/from wchar_t

+  typedef wchar_t SQOtherChar;

+#endif

+

+

+// Buffer to hold a string and release it in destructor. 

+// SQT is input character type 

+// SQOT is the opposite type of SQChar

+// If 'try_borrow' is set, it will not allocate a new buffer when no 

+// conversion is done, it will just keep the input pointer (beware).

+template<class SQT, class SQOT, bool use_latin1>

+struct SQCharBufImpl {

+

+	// Allocate a buffer from string of same type

+	SQCharBufImpl(const SQT *poc=NULL, bool try_borrow=true ) : m_poc(0), m_own(false) { 

+		Init( poc, try_borrow );

+	}

+

+	// This does conversion from other char type

+	SQCharBufImpl(const SQOT *ps, bool try_borrow=false ) : m_poc(0), m_own(false) { 

+		Init( ps ); // Cannot borrow pointer when doing conversion

+	}

+

+	void Init( const SQT *poc, bool try_borrow ){

+		m_own = !try_borrow;

+		if( try_borrow ){ 

+			m_poc = (SQT*)poc;

+		}

+		else {

+			int sl = poc ? ol_buflen(poc) : 0;

+			if( poc ){

+				m_poc = poc ? new SQT[sl+1] : NULL; 

+				if( m_poc ) memcpy( m_poc, poc, (sl+1)*sizeof(SQT) );

+			}

+			else

+				m_poc = NULL;

+		}

+    }

+

+	void Init( const SQOT *ps ){

+		m_own = true;

+        if( ps ){

+            int sl = ps ? ol_strlen(ps) : 0;	// Length of string in characters (not bytes)

+		    int scl = 0;                        // Length of converted string in char/wchar_t count

+			// How much storage needed? 

+			if( !use_latin1 && sizeof(SQT)<sizeof(SQOT) ){

+				// Converting wchar_t => UTF8 

+				const SQOT *ps1 = ps;   // It is wchar_t* here

+				SQT tmp_buf[8];

+				SQT *ptmp;

+				while( *ps1 ){

+				    ptmp = tmp_buf;

+                    if( ol_writechar(ptmp,*ps1++) )

+                        scl += ol_charlen(tmp_buf);

+                    else

+                        scl++;

+				}

+			}

+			else scl = sl;  // Converting to wchar_t or Latin1, keep length 

+

+            m_poc = new SQT[scl+1]; 

+			if( !m_poc ) return;

+

+			// Convert 

+			SQT *poc = m_poc;

+			while( *ps ){

+				ol_writechar( poc, ol_char(ps) );

+				ps += ol_charlen(ps);

+			}

+			*poc = 0;	// Terminating zero

+        }

+        else

+            m_poc = NULL;

+    }

+    

+    ~SQCharBufImpl(){ Release(); }

+    

+	void Release( ){

+		if(m_poc && m_own ) 

+			delete [] m_poc; 

+		m_poc = NULL;

+	}

+

+	SQT* Set( const SQOT *ps ){

+		Release( );

+		Init( ps );

+		return m_poc;

+	}

+

+    operator SQT*() const { return m_poc; }

+    

+	SQCharBufImpl<SQT,SQOT,use_latin1>& operator = (const SQT *ps){

+		Release();

+		Init( ps, false );

+		return *this;

+	}

+

+	SQCharBufImpl<SQT,SQOT,use_latin1>& operator = (const SQOT *ps){

+		Release();

+		Init( ps );

+		return *this;

+	}

+

+	// Move string from other here - Note: Empties the input argument (other)

+	SQCharBufImpl<SQT,SQOT,use_latin1>& operator = (const SQCharBufImpl<SQT,SQOT,use_latin1>& other){

+		Release();

+		m_poc = other.m_poc;

+		m_own = other.m_own;

+		SQT **psqt = (SQT**)&other.m_poc;

+		*psqt = NULL;

+		return *this;

+	}

+

+protected:

+    SQT *m_poc;

+	bool m_own;

+};

+

+typedef SQCharBufImpl<SQOtherChar, SQChar, bool(SQPLUS_USE_LATIN1)> SQOthCharBuf;

+typedef SQCharBufImpl<SQChar, SQOtherChar, bool(SQPLUS_USE_LATIN1)> SQDefCharBuf;

+typedef SQCharBufImpl<wchar_t, char, bool(SQPLUS_USE_LATIN1)>       SQWCharBuf;

+typedef SQCharBufImpl<char, wchar_t, bool(SQPLUS_USE_LATIN1)>       SQACharBuf;

+

+#ifdef SQUNICODE

+  // SQChar is wchar_t, convert to/from to either Latin1 or UTF8

+  #define WC2SQ(s) s

+  #define SQ2WC(s) s

+  SQDefCharBuf CH2SQ( const char* ps );

+  SQOthCharBuf SQ2CH( const wchar_t* pws );

+#else

+  // SQChar is char, convert to/from wchar_t

+  SQDefCharBuf WC2SQ( const wchar_t* pws );

+  SQOthCharBuf SQ2WC( const char* pws );

+  #define CH2SQ(s) s

+  #define SQ2CH(s) s

+#endif

+

+#endif // SQPLUS_CHARBUF_H

+

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusOverload.h b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusOverload.h
index e205de366..9668469ad 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusOverload.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusOverload.h
@@ -1,819 +1,819 @@
-// SqPlusOverload.h
-// SqPlus function overloading support created by Katsuaki Kawachi.
-//
-// Const member function fixed Tegan
-//   from http://squirrel-lang.org/forums/thread/2160.aspx
-
-#ifdef SQPLUS_OVERLOAD_RELEASE_HOOK
-#undef SQPLUS_OVERLOAD_RELEASE_HOOK
-
-    // These end up int ClassType<T> now
-    static inline int destruct(SQUserPointer up, SQInteger size) {
-        if (up) {
-            static_cast<T*>(up)->~T();
-            sq_free(up, size);
-        }
-        return 0;
-    }
-
-    static inline SQRELEASEHOOK &release(void) {
-        static SQRELEASEHOOK hook = ClassType<T>::destruct;
-        return hook;
-    }
-
-    void releaseHook(SQRELEASEHOOK releaseHook) {
-        release() = releaseHook;
-        //return *this;
-    }
-    
-    static inline SQRELEASEHOOK &getReleaseHook(void) {
-        return release();
-    }
-
-#endif // SQPLUS_OVERLOAD_RELEASE_HOOK
-
-
-#ifdef SQPLUS_OVERLOAD_DECLARATION
-#undef SQPLUS_OVERLOAD_DECLARATION
-
-template<typename Func> struct Arg;
-
-#endif // SQPLUS_OVERLOAD_DECLARATION
-
-
-#ifdef SQPLUS_OVERLOAD_IMPLEMENTATION
-#undef SQPLUS_OVERLOAD_IMPLEMENTATION
-private:
-    class SQFuncHolder {
-    private:
-        template<typename T>
-        class FlexArray {
-        protected:
-            SquirrelObject array;
-        public:
-            FlexArray(int size = 0) {
-                this->resize(size);
-            }
-            int size(void) const {
-                return array.Len();
-            }
-            void resize(int newSize) {
-                if (this->size() == 0) {
-                    array = SquirrelVM::CreateArray(newSize);
-                } else {
-                    array.ArrayResize(newSize);
-                }
-            }
-            void push_back(const T &t) {
-                this->set(this->size(), t);
-            }
-            void set(int index, const T &t) {
-                get(index) = t;
-            }
-            T &get(int index) {
-                if (index >= array.Len()) {
-                    resize(index + 1);
-                }
-                SQUserPointer up = array.GetUserPointer(index);
-                if (!up) {
-                    up = sq_newuserdata(SquirrelVM::GetVMPtr(), sizeof(T));
-                    new(static_cast<T*>(up)) T;
-                    array.SetUserPointer(index, up);
-                }
-                return *static_cast<T*>(up);
-            }
-        };
-        /*
-          storage of wrapped C++ functions
-         */
-        typedef SQInteger(*WrappedFunction)(HSQUIRRELVM, bool, int);
-        typedef FlexArray<WrappedFunction> SQWrappedFuncArray;
-        typedef FlexArray<SQWrappedFuncArray> SQWrappedFuncArray2 ;
-        typedef FlexArray<SQWrappedFuncArray2> SQWrappedFuncArray3 ;
-
-        struct MemberHolder {
-            static SQWrappedFuncArray &funcs(int functionIndex,
-                                             int paramCount) {
-                static SQWrappedFuncArray3 funcs;
-                return funcs.get(paramCount).get(functionIndex);
-            }
-        };
-        struct StaticHolder {
-            static SQWrappedFuncArray &funcs(int functionIndex,
-                                             int paramCount) {
-                static SQWrappedFuncArray3 funcs;
-                return funcs.get(paramCount).get(functionIndex);
-            }
-        };
-        struct ConstructorHolder {
-            static SQWrappedFuncArray &funcs(int paramCount) {
-                static SQWrappedFuncArray2 funcs;
-                return funcs.get(paramCount);
-            }
-        };
-            
-        /*
-          wrapper for C++ functions
-         */
-        template<typename Mfunc> struct MemberDispatcher {
-            static inline FlexArray<Mfunc> &mfunc(void) {
-                static FlexArray<Mfunc> mfunc;
-                return mfunc;
-            }
-            static inline SQInteger
-            dispatch(HSQUIRRELVM v, bool execute, int functionIndex) {
-                return execute ?
-                    Call(*GetInstance<TClassType, true>(v, 1),
-                         mfunc().get(functionIndex), v, 2) :
-                    Arg<Mfunc>::argTypeDistance(v);
-            }
-        };
-        template<typename Sfunc> struct StaticDispatcher {
-            static inline FlexArray<Sfunc> &sfunc(void) {
-                static FlexArray<Sfunc> sfunc;
-                return sfunc;
-            }
-            static inline SQInteger
-            dispatch(HSQUIRRELVM v, bool execute, int functionIndex) {
-                return execute ?
-                    Call(sfunc().get(functionIndex), v, 2) :
-                    Arg<Sfunc>::argTypeDistance(v);
-            }
-        };
-        template<typename Cfunc> struct Constructor {
-            static inline Cfunc &cfunc(void) {
-                static Cfunc cfunc = 0;
-                return cfunc;
-            }
-            static inline SQInteger
-            construct(HSQUIRRELVM v, bool execute, int) {
-                return execute ?
-                    Call(cfunc(), v, 2) :
-                    Arg<Cfunc>::argTypeDistance(v);
-            }
-        };
-
-        // search and call an overloaded function on runtime
-        static inline SQInteger
-        call(SQWrappedFuncArray &funcs, HSQUIRRELVM v, int functionIndex = 0) {
-            bool ambiguous = false;
-            int imin = -1;
-            int dmin = INT_MAX;
-            for (int i = 0, size = funcs.size(); i < size; ++i) {
-                // FIXME: to be refactored
-                const int d = (**funcs.get(i))(v, false, functionIndex);
-                if (d == 0) { // complete match
-                    imin = i;
-                    ambiguous = false;
-                    goto SQPLUS_OVERLOAD_CALL_IMMEDIATE_EXECUTION;
-                } else if (0 < d && d < dmin) {
-                    dmin = d;
-                    imin = i;
-                    ambiguous = false;
-                } else if (d == dmin) {
-                    ambiguous = true;
-                }
-            }
-
-            if (ambiguous) {
-                return sq_throwerror(
-                    v, _SC("Call of overloaded function is ambiguous")
-                    );
-            } else if (imin == -1) {
-                return sq_throwerror(
-                    v, _SC("No match for given arguments")
-                    );
-            }
-
-          SQPLUS_OVERLOAD_CALL_IMMEDIATE_EXECUTION:
-            // FIXME: to be refactored
-            return (**funcs.get(imin))(v, true, functionIndex);
-        }
-        
-    public:
-        template<typename Mfunc> static inline void
-        addMemberFunc(int functionIndex, Mfunc mfunc) {
-            MemberHolder::funcs(functionIndex, Arg<Mfunc>::num()).push_back(
-                &MemberDispatcher<Mfunc>::dispatch
-                );
-            MemberDispatcher<Mfunc>::mfunc().set(functionIndex, mfunc);
-        }
-        template<typename Sfunc> static inline void
-        addStaticFunc(int functionIndex, Sfunc sfunc) {
-            StaticHolder::funcs(functionIndex, Arg<Sfunc>::num()).push_back(
-                &StaticDispatcher<Sfunc>::dispatch
-                );
-            StaticDispatcher<Sfunc>::sfunc().set(functionIndex, sfunc);
-        }
-        template<typename Cfunc> static inline void
-        addConstructor(Cfunc cfunc) {
-            ConstructorHolder::funcs(Arg<Cfunc>::num()).push_back(
-                &Constructor<Cfunc>::construct
-                );
-            Constructor<Cfunc>::cfunc() = cfunc;
-        }
-            
-        static inline SQInteger
-        memberCall(int paramCount, HSQUIRRELVM v, int functionIndex) {
-            return call(MemberHolder::funcs(functionIndex, paramCount),
-                        v, functionIndex);
-        }
-        static inline SQInteger
-        staticCall(int paramCount, HSQUIRRELVM v, int functionIndex) {
-            return call(StaticHolder::funcs(functionIndex, paramCount),
-                        v, functionIndex);
-        }
-        static inline SQInteger
-        constructorCall(int paramCount, HSQUIRRELVM v, int) {
-            return call(ConstructorHolder::funcs(paramCount), v);
-        }
-    }; // class SQFuncHolder
-
-
-    struct FunctionNameEnumerator {
-        SquirrelObject names;
-        FunctionNameEnumerator(void) : names(SquirrelVM::CreateTable()) {}
-        int index(const SQChar *n) {
-            int i;
-            SquirrelObject v = names.GetValue(n);
-            if (v.IsNull()) {
-                i = names.Len();
-                names.SetValue(n, i);
-            } else {
-                i = v.ToInteger();
-            }
-            return i;
-        }
-    };
-
-    FunctionNameEnumerator overloadedMemberNames;
-    FunctionNameEnumerator overloadedStaticMemberNames;
-
-    static SquirrelObject &
-    functionIndexHolders(HSQUIRRELVM v) {
-        static SquirrelObject indexHolders;
-        if (indexHolders.IsNull()) {
-            sq_newtable(v);
-            indexHolders.AttachToStackObject(-1);
-            sq_pop(v, 1);
-        }    
-        return indexHolders;
-    }
-
-    template<int N>
-    static SquirrelObject &
-    indexHolder(HSQUIRRELVM v) {
-        static SquirrelObject holder;
-        if (holder.IsNull()) {
-            sq_pushobject(v, functionIndexHolders(v).GetObjectHandle());
-            sq_pushinteger(v, N);
-            if (SQ_OK == sq_rawget(v, -2)) {
-                holder.AttachToStackObject(-1);
-                sq_pop(v, 3);
-            } else {
-                sq_pushinteger(v, N);
-                sq_newtable(v);
-                holder.AttachToStackObject(-1);
-                sq_rawset(v, -3);
-                sq_pop(v, 1);
-            }
-        }
-        return holder;
-    }
-
-    template<typename Func>
-    class SQOverloader {
-    private:
-        static inline SQInteger switcher(HSQUIRRELVM v,
-                                         int(*caller)(int, HSQUIRRELVM, int),
-                                         int fidx) {
-            return (*caller)(StackHandler(v).GetParamCount() - 1,
-                             v,
-                             fidx);
-        }
-        
-        static inline SQInteger memberSwitcher(HSQUIRRELVM v) {
-            SQInteger fidx;
-            sq_pushobject(v, indexHolder<0>(v).GetObjectHandle());
-            sq_push(v, 0);      // native closure
-            sq_rawget(v, -2);
-            sq_getinteger(v, -1, &fidx);
-            sq_pop(v, 2);
-            return switcher(v, SQFuncHolder::memberCall, fidx);
-        }
-        static inline SQInteger staticSwitcher(HSQUIRRELVM v) {
-            SQInteger fidx;
-            sq_pushobject(v, indexHolder<1>(v).GetObjectHandle());
-            sq_push(v, 0);      // native closure
-            sq_rawget(v, -2);
-            sq_getinteger(v, -1, &fidx);
-            sq_pop(v, 2);
-            return switcher(v, SQFuncHolder::staticCall, fidx);
-        }
-        static inline SQInteger constructorSwitcher(HSQUIRRELVM v) {
-            return switcher(v, SQFuncHolder::constructorCall, 0);
-        }
-        
-    public:
-        static inline void addMemberFunc(SQClassDefBase<TClassType,TClassBase> *def,
-                                         Func mfunc,
-                                         const SQChar *name) {
-            const int fidx = def->overloadedMemberNames.index(name);
-            SQFuncHolder::addMemberFunc(fidx, mfunc);
-            def->staticFuncVarArgs(memberSwitcher, name);
-
-            HSQUIRRELVM v = def->v;
-            // get closure
-            sq_pushobject(v, def->newClass.GetObjectHandle());
-            sq_pushstring(v, name, -1);
-            sq_rawget(v, -2);
-            // holder[closure] = fidx
-            sq_pushobject(v, indexHolder<0>(v).GetObjectHandle());
-            sq_push(v, -2);
-            sq_pushinteger(v, fidx);
-            sq_rawset(v, -3);
-            //
-            sq_pop(v, 3);
-        }
-
-        static inline void addOperatorFunc(SQClassDefBase<TClassType,TClassBase> *def,
-                                           Func ofunc,
-                                           const SQChar *name) {
-            if (Arg<Func>::num() != 1) {
-                //assert(false &&
-                //       "Cannot add this function as operator (argc != 1)");
-				abort();
-			}
-            SQChar proxy[256];
-            scsprintf(proxy, _SC("overloaded%s"), name);
-            
-            addMemberFunc(def, ofunc, proxy);
-
-            SQChar script[512];
-            scsprintf(script, _SC("%s.%s<-function(o){return %s.%s(o);}"),
-                      def->name, name, def->name, proxy);
-            SquirrelVM::RunScript(SquirrelVM::CompileBuffer(script));
-        }
-            
-        static inline void addStaticFunc(SQClassDefBase<TClassType,TClassBase> *def,
-                                         Func sfunc,
-                                         const SQChar *name) {
-            const int fidx = def->overloadedStaticMemberNames.index(name);
-            SQFuncHolder::addStaticFunc(fidx, sfunc);
-            def->staticFuncVarArgs(staticSwitcher, name);
-
-            HSQUIRRELVM v = def->v;
-            // get closure
-            sq_pushobject(v, def->newClass.GetObjectHandle());
-            sq_pushstring(v, name, -1);
-            sq_rawget(v, -2);
-
-            // holder[closure] = fidx
-            sq_pushobject(v, indexHolder<1>(v).GetObjectHandle());
-            sq_push(v, -2);
-            sq_pushinteger(v, fidx);
-            sq_rawset(v, -3);
-            //
-            sq_pop(v, 3);
-        }
-        template<typename Cfunc>
-        static inline void addConstructor(SQClassDefBase<TClassType,TClassBase> *def,
-                                          Cfunc cfunc) {
-            SQFuncHolder::addConstructor(cfunc);
-            def->staticFuncVarArgs(constructorSwitcher, _SC("constructor"));
-        }
-        static inline void addGlobalFunc(SQClassDefBase<TClassType,TClassBase> *def,
-                                         Func gfunc,
-                                         const SQChar *name) {
-            const int fidx = def->overloadedStaticMemberNames.index(name);
-            SQFuncHolder::addStaticFunc(fidx, gfunc);
-            SquirrelVM::CreateFunctionGlobal(staticSwitcher, name, _SC("*"));
-
-            HSQUIRRELVM v = def->v;
-            // get closure
-            sq_pushroottable(v);
-            sq_pushstring(v, name, -1);
-            sq_rawget(v, -2);
-
-            // holder[closure] = fidx
-            sq_pushobject(v, indexHolder<1>(v).GetObjectHandle());
-            sq_push(v, -2);
-            sq_pushinteger(v, fidx);
-            sq_rawset(v, -3);
-            //
-            sq_pop(v, 3);
-        }
-    };
-
-public:
-    template<typename Mfunc>
-    SQClassDefBase<TClassType,TClassBase> &overloadFunc(Mfunc mfunc, const SQChar *n) {
-        SQOverloader<Mfunc>::addMemberFunc(this, mfunc, n);
-        return *this;
-    }
-    template<typename Ofunc>
-    SQClassDefBase<TClassType,TClassBase> &overloadOperator(Ofunc ofunc, const SQChar *n){
-        SQOverloader<Ofunc>::addOperatorFunc(this, ofunc, n);
-        return *this;
-    }
-    template<typename Sfunc>
-    SQClassDefBase<TClassType,TClassBase> &overloadStaticFunc(Sfunc sfunc,
-                                                   const SQChar *n) {
-        SQOverloader<Sfunc>::addStaticFunc(this, sfunc, n);
-        return *this;
-    }
-    template<typename Cmetafunc>
-    SQClassDefBase<TClassType,TClassBase> &overloadConstructor(void) {
-        SQOverloader<Cmetafunc>::addConstructor(this, &Arg<Cmetafunc>::create);
-        return *this;
-    }
-    template<typename Cfunc>
-    SQClassDefBase<TClassType,TClassBase> &overloadConstructor(Cfunc cfunc) {
-        SQOverloader<Cfunc>::addConstructor(this, cfunc);
-        return *this;
-    }
-    template<typename Gfunc>
-    SQClassDefBase<TClassType,TClassBase> &overloadGlobalFunc(Gfunc gfunc,
-                                                   const SQChar *n) {
-        SQOverloader<Gfunc>::addGlobalFunc(this, gfunc, n);
-        return *this;
-    }
-
-
-#endif // SQPLUS_OVERLOAD_IMPLEMENTATION
-
-
-
-#ifdef SQPLUS_OVERLOAD_FUNCTIONS
-#undef SQPLUS_OVERLOAD_FUNCTIONS
-
-struct GlobalFuncOverloader {};
-static inline SQClassDefBase<GlobalFuncOverloader,SQNoBaseClass> &globalFuncOverloader(void)
-{
-    static SQClassDefBase<GlobalFuncOverloader,SQNoBaseClass> fo(_SC("GlobalFuncOverloader"));
-    return fo;
-}
-
-template<typename Gfunc> void
-OverloadGlobal(Gfunc gfunc, const SQChar *n)
-{
-    globalFuncOverloader().overloadGlobalFunc(gfunc, n);
-}
-
-template<typename TYPE> struct CheckInstance {
-    template<typename T> struct unref {typedef T type;};
-    template<typename T> struct unref<T&> {typedef T type;};
-    template<typename T> struct unref<T*> {typedef T type;};
-    template<typename T> struct unref<const T&> {typedef T type;};
-    template<typename T> struct unref<const T*> {typedef T type;};
-    
-    /*
-      d = -1 : not in hierarchy
-      d = 0  : same
-      d > 0  : similar (o is d-th subclass of TYPE)
-    */
-    static inline int distance(HSQUIRRELVM v, int index) {
-        HSQOBJECT o;
-        sq_resetobject(&o);
-        sq_getstackobj(v, index, &o);
-    
-        const int top = sq_gettop(v);
-        sq_pushroottable(v);
-
-        // Check plain object type
-        int d = -1;
-        if (Match(TypeWrapper<TYPE>(), v, index)) {
-            d = 0;
-            
-            // Check instance type hierarchy
-            if (sq_type(o) == OT_INSTANCE) {
-                SQUserPointer dsttype =
-                    ClassType<typename unref<TYPE>::type>::type();
-            
-                SQUserPointer argtype;
-                for (sq_getclass(v, index);
-                     sq_gettypetag(v, -1, &argtype) == SQ_OK;
-                     sq_getbase(v, -1)) {
-                    if (argtype == dsttype) {
-                        goto SQPLUS_OVERLOAD_DISTANCE_IMMEDIATE_RETURN;
-                    }
-                    ++d;
-                }
-                d = -1;         // no matching type found
-            }
-        }
-      SQPLUS_OVERLOAD_DISTANCE_IMMEDIATE_RETURN:
-        sq_settop(v, top);
-        return d;
-    }
-};
-
-
-template<typename T, typename R>
-struct Arg<R(T::*)(void)> {
-    static inline int num(void) {return 0;}
-    static inline int argTypeDistance(HSQUIRRELVM) {
-        return 0;
-    }
-};
-
-template<typename T, typename R, typename A1>
-struct Arg<R(T::*)(A1)> {
-    static inline int num(void) {return 1;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        return Arg<R(*)(A1)>::argTypeDistance(v);
-    }
-};
-
-template<typename T, typename R, typename A1, typename A2>
-struct Arg<R(T::*)(A1, A2)> {
-    static inline int num(void) {return 2;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        return Arg<R(*)(A1, A2)>::argTypeDistance(v);
-    }
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3>
-struct Arg<R(T::*)(A1, A2, A3)> {
-    static inline int num(void) {return 3;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        return Arg<R(*)(A1, A2, A3)>::argTypeDistance(v);
-    }
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3, typename A4>
-struct Arg<R(T::*)(A1, A2, A3, A4)> {
-    static inline int num(void) {return 4;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        return Arg<R(*)(A1, A2, A3, A4)>::argTypeDistance(v);
-    }
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5>
-struct Arg<R(T::*)(A1, A2, A3, A4, A5)> {
-    static inline int num(void) {return 5;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        return Arg<R(*)(A1, A2, A3, A4, A5)>::argTypeDistance(v);
-    }
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-struct Arg<R(T::*)(A1, A2, A3, A4, A5, A6)> {
-    static inline int num(void) {return 6;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        return Arg<R(*)(A1, A2, A3, A4, A5, A6)>::argTypeDistance(v);
-    }
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-struct Arg<R(T::*)(A1, A2, A3, A4, A5, A6, A7)> {
-    static inline int num(void) {return 7;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        return Arg<R(*)(A1, A2, A3, A4, A5, A6, A7)>::argTypeDistance(v);
-    }
-};
-
-#ifdef SQPLUS_CONST_OPT
-template<typename T, typename R>
-struct Arg<R(T::*)(void) const> {
-	static inline int num(void) {return 0;}
-	static inline int argTypeDistance(HSQUIRRELVM) {
-		return 0;
-	}
-};
-
-template<typename T, typename R, typename A1>
-struct Arg<R(T::*)(A1) const> {
-	static inline int num(void) {return 1;}
-	static inline int argTypeDistance(HSQUIRRELVM v) {
-		return Arg<R(*)(A1)>::argTypeDistance(v);
-	}
-};
-
-template<typename T, typename R, typename A1, typename A2>
-struct Arg<R(T::*)(A1, A2) const> {
-	static inline int num(void) {return 2;}
-	static inline int argTypeDistance(HSQUIRRELVM v) {
-		return Arg<R(*)(A1, A2)>::argTypeDistance(v);
-	}
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3>
-struct Arg<R(T::*)(A1, A2, A3) const> {
-	static inline int num(void) {return 3;}
-	static inline int argTypeDistance(HSQUIRRELVM v) {
-		return Arg<R(*)(A1, A2, A3)>::argTypeDistance(v);
-	}
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3, typename A4>
-struct Arg<R(T::*)(A1, A2, A3, A4) const> {
-	static inline int num(void) {return 4;}
-	static inline int argTypeDistance(HSQUIRRELVM v) {
-		return Arg<R(*)(A1, A2, A3, A4)>::argTypeDistance(v);
-	}
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5>
-struct Arg<R(T::*)(A1, A2, A3, A4, A5) const> {
-	static inline int num(void) {return 5;}
-	static inline int argTypeDistance(HSQUIRRELVM v) {
-		return Arg<R(*)(A1, A2, A3, A4, A5)>::argTypeDistance(v);
-	}
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-struct Arg<R(T::*)(A1, A2, A3, A4, A5, A6) const> {
-	static inline int num(void) {return 6;}
-	static inline int argTypeDistance(HSQUIRRELVM v) {
-		return Arg<R(*)(A1, A2, A3, A4, A5, A6)>::argTypeDistance(v);
-	}
-};
-
-template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-struct Arg<R(T::*)(A1, A2, A3, A4, A5, A6, A7) const> {
-	static inline int num(void) {return 7;}
-	static inline int argTypeDistance(HSQUIRRELVM v) {
-		return Arg<R(*)(A1, A2, A3, A4, A5, A6, A7)>::argTypeDistance(v);
-	}
-};
-#endif
-
-static inline int classAllocationError(HSQUIRRELVM v) {
-    return sq_throwerror(v, _SC("Failed to allocate memory"));
-}
-
-template<typename R>
-struct Arg<R(*)(void)> {
-    static inline int num(void) {return 0;}
-    static inline int argTypeDistance(HSQUIRRELVM) {return 0;}
-    static inline int create(void) {
-        HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-        R *r = static_cast<R*>(sq_malloc(sizeof(R)));
-        return r ?
-            PostConstruct<R>(v, new(r) R,
-                             ClassType<R>::getReleaseHook()) :
-            classAllocationError(v);
-    }
-};
-
-template<typename R, typename A1>
-struct Arg<R(*)(A1)> {
-    static inline int num(void) {return 1;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        int s, r;
-        r = 0;
-        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;
-        return r;
-    }
-    static inline int create(A1 a1) {
-        HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-        R *r = static_cast<R*>(sq_malloc(sizeof(R)));
-        return r ?
-            PostConstruct<R>(v, new(r) R(a1),
-                             ClassType<R>::getReleaseHook()) :
-            classAllocationError(v);
-    }
-};
-
-template<typename R, typename A1, typename A2>
-struct Arg<R(*)(A1, A2)> {
-    static inline int num(void) {return 2;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        int s, r;
-        r = 0;
-        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;
-        return r;
-    }
-    static inline int create(A1 a1, A2 a2) {
-        HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-        R *r = static_cast<R*>(sq_malloc(sizeof(R)));
-        return r ?
-            PostConstruct<R>(v, new(r) R(a1, a2),
-                             ClassType<R>::getReleaseHook()) :
-            classAllocationError(v);
-    }
-};
-
-template<typename R, typename A1, typename A2, typename A3>
-struct Arg<R(*)(A1, A2, A3)> {
-    static inline int num(void) {return 3;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        int s, r;
-        r = 0;
-        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;
-        return r;
-    }
-    static inline int create(A1 a1, A2 a2, A3 a3) {
-        HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-        R *r = static_cast<R*>(sq_malloc(sizeof(R)));
-        return r ?
-            PostConstruct<R>(v, new(r) R(a1, a2, a3),
-                             ClassType<R>::getReleaseHook()) :
-            classAllocationError(v);
-    }
-};
-
-template<typename R, typename A1, typename A2, typename A3, typename A4>
-struct Arg<R(*)(A1, A2, A3, A4)> {
-    static inline int num(void) {return 4;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        int s, r;
-        r = 0;
-        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A4>::distance(v, 5); if (s < 0) {return -1;} r += s;
-        return r;
-    }
-    static inline int create(A1 a1, A2 a2, A3 a3, A4 a4) {
-        HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-        R *r = static_cast<R*>(sq_malloc(sizeof(R)));
-        return r ?
-            PostConstruct<R>(v, new(r) R(a1, a2, a3, a4),
-                             ClassType<R>::getReleaseHook()) :
-            classAllocationError(v);
-    }
-};
-
-template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5>
-struct Arg<R(*)(A1, A2, A3, A4, A5)> {
-    static inline int num(void) {return 5;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        int s, r;
-        r = 0;
-        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A4>::distance(v, 5); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A5>::distance(v, 6); if (s < 0) {return -1;} r += s;
-        return r;
-    }
-    static inline int create(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-        HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-        R *r = static_cast<R*>(sq_malloc(sizeof(R)));
-        return r ?
-            PostConstruct<R>(v, new(r) R(a1, a2, a3, a4, a5),
-                             ClassType<R>::getReleaseHook()) :
-            classAllocationError(v);
-    }
-};
-
-template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-struct Arg<R(*)(A1, A2, A3, A4, A5, A6)> {
-    static inline int num(void) {return 6;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        int s, r;
-        r = 0;
-        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A4>::distance(v, 5); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A5>::distance(v, 6); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A6>::distance(v, 7); if (s < 0) {return -1;} r += s;
-        return r;
-    }
-    static inline int create(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
-        HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-        R *r = static_cast<R*>(sq_malloc(sizeof(R)));
-        return r ?
-            PostConstruct<R>(v, new(r) R(a1, a2, a3, a4, a5, a6),
-                             ClassType<R>::getReleaseHook()) :
-            classAllocationError(v);
-    }
-};
-
-template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-struct Arg<R(*)(A1, A2, A3, A4, A5, A6, A7)> {
-    static inline int num(void) {return 7;}
-    static inline int argTypeDistance(HSQUIRRELVM v) {
-        int s, r;
-        r = 0;
-        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A4>::distance(v, 5); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A5>::distance(v, 6); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A6>::distance(v, 7); if (s < 0) {return -1;} r += s;
-        s = CheckInstance<A7>::distance(v, 8); if (s < 0) {return -1;} r += s;
-        return r;
-    }
-    static inline int create(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
-        HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-        R *r = static_cast<R*>(sq_malloc(sizeof(R)));
-        return r ?
-            PostConstruct<R>(v, new(r) R(a1, a2, a3, a4, a5, a6, a7),
-                             ClassType<R>::getReleaseHook()) :
-            classAllocationError(v);
-    }
-};
-#endif // SQPLUS_OVERLOAD_FUNCTIONS
-
-// SqPlusOverload.h
-
-// Local Variables: 
-// mode: c++
-// End:
+// SqPlusOverload.h

+// SqPlus function overloading support created by Katsuaki Kawachi.

+//

+// Const member function fixed Tegan

+//   from http://squirrel-lang.org/forums/thread/2160.aspx

+

+#ifdef SQPLUS_OVERLOAD_RELEASE_HOOK

+#undef SQPLUS_OVERLOAD_RELEASE_HOOK

+

+    // These end up int ClassType<T> now

+    static inline int destruct(SQUserPointer up, SQInteger size) {

+        if (up) {

+            static_cast<T*>(up)->~T();

+            sq_free(up, size);

+        }

+        return 0;

+    }

+

+    static inline SQRELEASEHOOK &release(void) {

+        static SQRELEASEHOOK hook = ClassType<T>::destruct;

+        return hook;

+    }

+

+    void releaseHook(SQRELEASEHOOK releaseHook) {

+        release() = releaseHook;

+        //return *this;

+    }

+    

+    static inline SQRELEASEHOOK &getReleaseHook(void) {

+        return release();

+    }

+

+#endif // SQPLUS_OVERLOAD_RELEASE_HOOK

+

+

+#ifdef SQPLUS_OVERLOAD_DECLARATION

+#undef SQPLUS_OVERLOAD_DECLARATION

+

+template<typename Func> struct Arg;

+

+#endif // SQPLUS_OVERLOAD_DECLARATION

+

+

+#ifdef SQPLUS_OVERLOAD_IMPLEMENTATION

+#undef SQPLUS_OVERLOAD_IMPLEMENTATION

+private:

+    class SQFuncHolder {

+    private:

+        template<typename T>

+        class FlexArray {

+        protected:

+            SquirrelObject array;

+        public:

+            FlexArray(int size = 0) {

+                this->resize(size);

+            }

+            int size(void) const {

+                return array.Len();

+            }

+            void resize(int newSize) {

+                if (this->size() == 0) {

+                    array = SquirrelVM::CreateArray(newSize);

+                } else {

+                    array.ArrayResize(newSize);

+                }

+            }

+            void push_back(const T &t) {

+                this->set(this->size(), t);

+            }

+            void set(int index, const T &t) {

+                get(index) = t;

+            }

+            T &get(int index) {

+                if (index >= array.Len()) {

+                    resize(index + 1);

+                }

+                SQUserPointer up = array.GetUserPointer(index);

+                if (!up) {

+                    up = sq_newuserdata(SquirrelVM::GetVMPtr(), sizeof(T));

+                    new(static_cast<T*>(up)) T;

+                    array.SetUserPointer(index, up);

+                }

+                return *static_cast<T*>(up);

+            }

+        };

+        /*

+          storage of wrapped C++ functions

+         */

+        typedef SQInteger(*WrappedFunction)(HSQUIRRELVM, bool, int);

+        typedef FlexArray<WrappedFunction> SQWrappedFuncArray;

+        typedef FlexArray<SQWrappedFuncArray> SQWrappedFuncArray2 ;

+        typedef FlexArray<SQWrappedFuncArray2> SQWrappedFuncArray3 ;

+

+        struct MemberHolder {

+            static SQWrappedFuncArray &funcs(int functionIndex,

+                                             int paramCount) {

+                static SQWrappedFuncArray3 funcs;

+                return funcs.get(paramCount).get(functionIndex);

+            }

+        };

+        struct StaticHolder {

+            static SQWrappedFuncArray &funcs(int functionIndex,

+                                             int paramCount) {

+                static SQWrappedFuncArray3 funcs;

+                return funcs.get(paramCount).get(functionIndex);

+            }

+        };

+        struct ConstructorHolder {

+            static SQWrappedFuncArray &funcs(int paramCount) {

+                static SQWrappedFuncArray2 funcs;

+                return funcs.get(paramCount);

+            }

+        };

+            

+        /*

+          wrapper for C++ functions

+         */

+        template<typename Mfunc> struct MemberDispatcher {

+            static inline FlexArray<Mfunc> &mfunc(void) {

+                static FlexArray<Mfunc> mfunc;

+                return mfunc;

+            }

+            static inline SQInteger

+            dispatch(HSQUIRRELVM v, bool execute, int functionIndex) {

+                return execute ?

+                    Call(*GetInstance<TClassType, true>(v, 1),

+                         mfunc().get(functionIndex), v, 2) :

+                    Arg<Mfunc>::argTypeDistance(v);

+            }

+        };

+        template<typename Sfunc> struct StaticDispatcher {

+            static inline FlexArray<Sfunc> &sfunc(void) {

+                static FlexArray<Sfunc> sfunc;

+                return sfunc;

+            }

+            static inline SQInteger

+            dispatch(HSQUIRRELVM v, bool execute, int functionIndex) {

+                return execute ?

+                    Call(sfunc().get(functionIndex), v, 2) :

+                    Arg<Sfunc>::argTypeDistance(v);

+            }

+        };

+        template<typename Cfunc> struct Constructor {

+            static inline Cfunc &cfunc(void) {

+                static Cfunc cfunc = 0;

+                return cfunc;

+            }

+            static inline SQInteger

+            construct(HSQUIRRELVM v, bool execute, int) {

+                return execute ?

+                    Call(cfunc(), v, 2) :

+                    Arg<Cfunc>::argTypeDistance(v);

+            }

+        };

+

+        // search and call an overloaded function on runtime

+        static inline SQInteger

+        call(SQWrappedFuncArray &funcs, HSQUIRRELVM v, int functionIndex = 0) {

+            bool ambiguous = false;

+            int imin = -1;

+            int dmin = INT_MAX;

+            for (int i = 0, size = funcs.size(); i < size; ++i) {

+                // FIXME: to be refactored

+                const int d = (**funcs.get(i))(v, false, functionIndex);

+                if (d == 0) { // complete match

+                    imin = i;

+                    ambiguous = false;

+                    goto SQPLUS_OVERLOAD_CALL_IMMEDIATE_EXECUTION;

+                } else if (0 < d && d < dmin) {

+                    dmin = d;

+                    imin = i;

+                    ambiguous = false;

+                } else if (d == dmin) {

+                    ambiguous = true;

+                }

+            }

+

+            if (ambiguous) {

+                return sq_throwerror(

+                    v, _SC("Call of overloaded function is ambiguous")

+                    );

+            } else if (imin == -1) {

+                return sq_throwerror(

+                    v, _SC("No match for given arguments")

+                    );

+            }

+

+          SQPLUS_OVERLOAD_CALL_IMMEDIATE_EXECUTION:

+            // FIXME: to be refactored

+            return (**funcs.get(imin))(v, true, functionIndex);

+        }

+        

+    public:

+        template<typename Mfunc> static inline void

+        addMemberFunc(int functionIndex, Mfunc mfunc) {

+            MemberHolder::funcs(functionIndex, Arg<Mfunc>::num()).push_back(

+                &MemberDispatcher<Mfunc>::dispatch

+                );

+            MemberDispatcher<Mfunc>::mfunc().set(functionIndex, mfunc);

+        }

+        template<typename Sfunc> static inline void

+        addStaticFunc(int functionIndex, Sfunc sfunc) {

+            StaticHolder::funcs(functionIndex, Arg<Sfunc>::num()).push_back(

+                &StaticDispatcher<Sfunc>::dispatch

+                );

+            StaticDispatcher<Sfunc>::sfunc().set(functionIndex, sfunc);

+        }

+        template<typename Cfunc> static inline void

+        addConstructor(Cfunc cfunc) {

+            ConstructorHolder::funcs(Arg<Cfunc>::num()).push_back(

+                &Constructor<Cfunc>::construct

+                );

+            Constructor<Cfunc>::cfunc() = cfunc;

+        }

+            

+        static inline SQInteger

+        memberCall(int paramCount, HSQUIRRELVM v, int functionIndex) {

+            return call(MemberHolder::funcs(functionIndex, paramCount),

+                        v, functionIndex);

+        }

+        static inline SQInteger

+        staticCall(int paramCount, HSQUIRRELVM v, int functionIndex) {

+            return call(StaticHolder::funcs(functionIndex, paramCount),

+                        v, functionIndex);

+        }

+        static inline SQInteger

+        constructorCall(int paramCount, HSQUIRRELVM v, int) {

+            return call(ConstructorHolder::funcs(paramCount), v);

+        }

+    }; // class SQFuncHolder

+

+

+    struct FunctionNameEnumerator {

+        SquirrelObject names;

+        FunctionNameEnumerator(void) : names(SquirrelVM::CreateTable()) {}

+        int index(const SQChar *n) {

+            int i;

+            SquirrelObject v = names.GetValue(n);

+            if (v.IsNull()) {

+                i = names.Len();

+                names.SetValue(n, i);

+            } else {

+                i = v.ToInteger();

+            }

+            return i;

+        }

+    };

+

+    FunctionNameEnumerator overloadedMemberNames;

+    FunctionNameEnumerator overloadedStaticMemberNames;

+

+    static SquirrelObject &

+    functionIndexHolders(HSQUIRRELVM v) {

+        static SquirrelObject indexHolders;

+        if (indexHolders.IsNull()) {

+            sq_newtable(v);

+            indexHolders.AttachToStackObject(-1);

+            sq_pop(v, 1);

+        }    

+        return indexHolders;

+    }

+

+    template<int N>

+    static SquirrelObject &

+    indexHolder(HSQUIRRELVM v) {

+        static SquirrelObject holder;

+        if (holder.IsNull()) {

+            sq_pushobject(v, functionIndexHolders(v).GetObjectHandle());

+            sq_pushinteger(v, N);

+            if (SQ_OK == sq_rawget(v, -2)) {

+                holder.AttachToStackObject(-1);

+                sq_pop(v, 3);

+            } else {

+                sq_pushinteger(v, N);

+                sq_newtable(v);

+                holder.AttachToStackObject(-1);

+                sq_rawset(v, -3);

+                sq_pop(v, 1);

+            }

+        }

+        return holder;

+    }

+

+    template<typename Func>

+    class SQOverloader {

+    private:

+        static inline SQInteger switcher(HSQUIRRELVM v,

+                                         int(*caller)(int, HSQUIRRELVM, int),

+                                         int fidx) {

+            return (*caller)(StackHandler(v).GetParamCount() - 1,

+                             v,

+                             fidx);

+        }

+        

+        static inline SQInteger memberSwitcher(HSQUIRRELVM v) {

+            SQInteger fidx;

+            sq_pushobject(v, indexHolder<0>(v).GetObjectHandle());

+            sq_push(v, 0);      // native closure

+            sq_rawget(v, -2);

+            sq_getinteger(v, -1, &fidx);

+            sq_pop(v, 2);

+            return switcher(v, SQFuncHolder::memberCall, fidx);

+        }

+        static inline SQInteger staticSwitcher(HSQUIRRELVM v) {

+            SQInteger fidx;

+            sq_pushobject(v, indexHolder<1>(v).GetObjectHandle());

+            sq_push(v, 0);      // native closure

+            sq_rawget(v, -2);

+            sq_getinteger(v, -1, &fidx);

+            sq_pop(v, 2);

+            return switcher(v, SQFuncHolder::staticCall, fidx);

+        }

+        static inline SQInteger constructorSwitcher(HSQUIRRELVM v) {

+            return switcher(v, SQFuncHolder::constructorCall, 0);

+        }

+        

+    public:

+        static inline void addMemberFunc(SQClassDefBase<TClassType,TClassBase> *def,

+                                         Func mfunc,

+                                         const SQChar *name) {

+            const int fidx = def->overloadedMemberNames.index(name);

+            SQFuncHolder::addMemberFunc(fidx, mfunc);

+            def->staticFuncVarArgs(memberSwitcher, name);

+

+            HSQUIRRELVM v = def->v;

+            // get closure

+            sq_pushobject(v, def->newClass.GetObjectHandle());

+            sq_pushstring(v, name, -1);

+            sq_rawget(v, -2);

+            // holder[closure] = fidx

+            sq_pushobject(v, indexHolder<0>(v).GetObjectHandle());

+            sq_push(v, -2);

+            sq_pushinteger(v, fidx);

+            sq_rawset(v, -3);

+            //

+            sq_pop(v, 3);

+        }

+

+        static inline void addOperatorFunc(SQClassDefBase<TClassType,TClassBase> *def,

+                                           Func ofunc,

+                                           const SQChar *name) {

+            if (Arg<Func>::num() != 1) {

+                //assert(false &&

+                //       "Cannot add this function as operator (argc != 1)");

+				abort();

+			}

+            SQChar proxy[256];

+            scsprintf(proxy, _SC("overloaded%s"), name);

+            

+            addMemberFunc(def, ofunc, proxy);

+

+            SQChar script[512];

+            scsprintf(script, _SC("%s.%s<-function(o){return %s.%s(o);}"),

+                      def->name, name, def->name, proxy);

+            SquirrelVM::RunScript(SquirrelVM::CompileBuffer(script));

+        }

+            

+        static inline void addStaticFunc(SQClassDefBase<TClassType,TClassBase> *def,

+                                         Func sfunc,

+                                         const SQChar *name) {

+            const int fidx = def->overloadedStaticMemberNames.index(name);

+            SQFuncHolder::addStaticFunc(fidx, sfunc);

+            def->staticFuncVarArgs(staticSwitcher, name);

+

+            HSQUIRRELVM v = def->v;

+            // get closure

+            sq_pushobject(v, def->newClass.GetObjectHandle());

+            sq_pushstring(v, name, -1);

+            sq_rawget(v, -2);

+

+            // holder[closure] = fidx

+            sq_pushobject(v, indexHolder<1>(v).GetObjectHandle());

+            sq_push(v, -2);

+            sq_pushinteger(v, fidx);

+            sq_rawset(v, -3);

+            //

+            sq_pop(v, 3);

+        }

+        template<typename Cfunc>

+        static inline void addConstructor(SQClassDefBase<TClassType,TClassBase> *def,

+                                          Cfunc cfunc) {

+            SQFuncHolder::addConstructor(cfunc);

+            def->staticFuncVarArgs(constructorSwitcher, _SC("constructor"));

+        }

+        static inline void addGlobalFunc(SQClassDefBase<TClassType,TClassBase> *def,

+                                         Func gfunc,

+                                         const SQChar *name) {

+            const int fidx = def->overloadedStaticMemberNames.index(name);

+            SQFuncHolder::addStaticFunc(fidx, gfunc);

+            SquirrelVM::CreateFunctionGlobal(staticSwitcher, name, _SC("*"));

+

+            HSQUIRRELVM v = def->v;

+            // get closure

+            sq_pushroottable(v);

+            sq_pushstring(v, name, -1);

+            sq_rawget(v, -2);

+

+            // holder[closure] = fidx

+            sq_pushobject(v, indexHolder<1>(v).GetObjectHandle());

+            sq_push(v, -2);

+            sq_pushinteger(v, fidx);

+            sq_rawset(v, -3);

+            //

+            sq_pop(v, 3);

+        }

+    };

+

+public:

+    template<typename Mfunc>

+    SQClassDefBase<TClassType,TClassBase> &overloadFunc(Mfunc mfunc, const SQChar *n) {

+        SQOverloader<Mfunc>::addMemberFunc(this, mfunc, n);

+        return *this;

+    }

+    template<typename Ofunc>

+    SQClassDefBase<TClassType,TClassBase> &overloadOperator(Ofunc ofunc, const SQChar *n){

+        SQOverloader<Ofunc>::addOperatorFunc(this, ofunc, n);

+        return *this;

+    }

+    template<typename Sfunc>

+    SQClassDefBase<TClassType,TClassBase> &overloadStaticFunc(Sfunc sfunc,

+                                                   const SQChar *n) {

+        SQOverloader<Sfunc>::addStaticFunc(this, sfunc, n);

+        return *this;

+    }

+    template<typename Cmetafunc>

+    SQClassDefBase<TClassType,TClassBase> &overloadConstructor(void) {

+        SQOverloader<Cmetafunc>::addConstructor(this, &Arg<Cmetafunc>::create);

+        return *this;

+    }

+    template<typename Cfunc>

+    SQClassDefBase<TClassType,TClassBase> &overloadConstructor(Cfunc cfunc) {

+        SQOverloader<Cfunc>::addConstructor(this, cfunc);

+        return *this;

+    }

+    template<typename Gfunc>

+    SQClassDefBase<TClassType,TClassBase> &overloadGlobalFunc(Gfunc gfunc,

+                                                   const SQChar *n) {

+        SQOverloader<Gfunc>::addGlobalFunc(this, gfunc, n);

+        return *this;

+    }

+

+

+#endif // SQPLUS_OVERLOAD_IMPLEMENTATION

+

+

+

+#ifdef SQPLUS_OVERLOAD_FUNCTIONS

+#undef SQPLUS_OVERLOAD_FUNCTIONS

+

+struct GlobalFuncOverloader {};

+static inline SQClassDefBase<GlobalFuncOverloader,SQNoBaseClass> &globalFuncOverloader(void)

+{

+    static SQClassDefBase<GlobalFuncOverloader,SQNoBaseClass> fo(_SC("GlobalFuncOverloader"));

+    return fo;

+}

+

+template<typename Gfunc> void

+OverloadGlobal(Gfunc gfunc, const SQChar *n)

+{

+    globalFuncOverloader().overloadGlobalFunc(gfunc, n);

+}

+

+template<typename TYPE> struct CheckInstance {

+    template<typename T> struct unref {typedef T type;};

+    template<typename T> struct unref<T&> {typedef T type;};

+    template<typename T> struct unref<T*> {typedef T type;};

+    template<typename T> struct unref<const T&> {typedef T type;};

+    template<typename T> struct unref<const T*> {typedef T type;};

+    

+    /*

+      d = -1 : not in hierarchy

+      d = 0  : same

+      d > 0  : similar (o is d-th subclass of TYPE)

+    */

+    static inline int distance(HSQUIRRELVM v, int index) {

+        HSQOBJECT o;

+        sq_resetobject(&o);

+        sq_getstackobj(v, index, &o);

+    

+        const int top = sq_gettop(v);

+        sq_pushroottable(v);

+

+        // Check plain object type

+        int d = -1;

+        if (Match(TypeWrapper<TYPE>(), v, index)) {

+            d = 0;

+            

+            // Check instance type hierarchy

+            if (sq_type(o) == OT_INSTANCE) {

+                SQUserPointer dsttype =

+                    ClassType<typename unref<TYPE>::type>::type();

+            

+                SQUserPointer argtype;

+                for (sq_getclass(v, index);

+                     sq_gettypetag(v, -1, &argtype) == SQ_OK;

+                     sq_getbase(v, -1)) {

+                    if (argtype == dsttype) {

+                        goto SQPLUS_OVERLOAD_DISTANCE_IMMEDIATE_RETURN;

+                    }

+                    ++d;

+                }

+                d = -1;         // no matching type found

+            }

+        }

+      SQPLUS_OVERLOAD_DISTANCE_IMMEDIATE_RETURN:

+        sq_settop(v, top);

+        return d;

+    }

+};

+

+

+template<typename T, typename R>

+struct Arg<R(T::*)(void)> {

+    static inline int num(void) {return 0;}

+    static inline int argTypeDistance(HSQUIRRELVM) {

+        return 0;

+    }

+};

+

+template<typename T, typename R, typename A1>

+struct Arg<R(T::*)(A1)> {

+    static inline int num(void) {return 1;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        return Arg<R(*)(A1)>::argTypeDistance(v);

+    }

+};

+

+template<typename T, typename R, typename A1, typename A2>

+struct Arg<R(T::*)(A1, A2)> {

+    static inline int num(void) {return 2;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        return Arg<R(*)(A1, A2)>::argTypeDistance(v);

+    }

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3>

+struct Arg<R(T::*)(A1, A2, A3)> {

+    static inline int num(void) {return 3;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        return Arg<R(*)(A1, A2, A3)>::argTypeDistance(v);

+    }

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3, typename A4>

+struct Arg<R(T::*)(A1, A2, A3, A4)> {

+    static inline int num(void) {return 4;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        return Arg<R(*)(A1, A2, A3, A4)>::argTypeDistance(v);

+    }

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5>

+struct Arg<R(T::*)(A1, A2, A3, A4, A5)> {

+    static inline int num(void) {return 5;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        return Arg<R(*)(A1, A2, A3, A4, A5)>::argTypeDistance(v);

+    }

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>

+struct Arg<R(T::*)(A1, A2, A3, A4, A5, A6)> {

+    static inline int num(void) {return 6;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        return Arg<R(*)(A1, A2, A3, A4, A5, A6)>::argTypeDistance(v);

+    }

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>

+struct Arg<R(T::*)(A1, A2, A3, A4, A5, A6, A7)> {

+    static inline int num(void) {return 7;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        return Arg<R(*)(A1, A2, A3, A4, A5, A6, A7)>::argTypeDistance(v);

+    }

+};

+

+#ifdef SQPLUS_CONST_OPT

+template<typename T, typename R>

+struct Arg<R(T::*)(void) const> {

+	static inline int num(void) {return 0;}

+	static inline int argTypeDistance(HSQUIRRELVM) {

+		return 0;

+	}

+};

+

+template<typename T, typename R, typename A1>

+struct Arg<R(T::*)(A1) const> {

+	static inline int num(void) {return 1;}

+	static inline int argTypeDistance(HSQUIRRELVM v) {

+		return Arg<R(*)(A1)>::argTypeDistance(v);

+	}

+};

+

+template<typename T, typename R, typename A1, typename A2>

+struct Arg<R(T::*)(A1, A2) const> {

+	static inline int num(void) {return 2;}

+	static inline int argTypeDistance(HSQUIRRELVM v) {

+		return Arg<R(*)(A1, A2)>::argTypeDistance(v);

+	}

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3>

+struct Arg<R(T::*)(A1, A2, A3) const> {

+	static inline int num(void) {return 3;}

+	static inline int argTypeDistance(HSQUIRRELVM v) {

+		return Arg<R(*)(A1, A2, A3)>::argTypeDistance(v);

+	}

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3, typename A4>

+struct Arg<R(T::*)(A1, A2, A3, A4) const> {

+	static inline int num(void) {return 4;}

+	static inline int argTypeDistance(HSQUIRRELVM v) {

+		return Arg<R(*)(A1, A2, A3, A4)>::argTypeDistance(v);

+	}

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5>

+struct Arg<R(T::*)(A1, A2, A3, A4, A5) const> {

+	static inline int num(void) {return 5;}

+	static inline int argTypeDistance(HSQUIRRELVM v) {

+		return Arg<R(*)(A1, A2, A3, A4, A5)>::argTypeDistance(v);

+	}

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>

+struct Arg<R(T::*)(A1, A2, A3, A4, A5, A6) const> {

+	static inline int num(void) {return 6;}

+	static inline int argTypeDistance(HSQUIRRELVM v) {

+		return Arg<R(*)(A1, A2, A3, A4, A5, A6)>::argTypeDistance(v);

+	}

+};

+

+template<typename T, typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>

+struct Arg<R(T::*)(A1, A2, A3, A4, A5, A6, A7) const> {

+	static inline int num(void) {return 7;}

+	static inline int argTypeDistance(HSQUIRRELVM v) {

+		return Arg<R(*)(A1, A2, A3, A4, A5, A6, A7)>::argTypeDistance(v);

+	}

+};

+#endif

+

+static inline int classAllocationError(HSQUIRRELVM v) {

+    return sq_throwerror(v, _SC("Failed to allocate memory"));

+}

+

+template<typename R>

+struct Arg<R(*)(void)> {

+    static inline int num(void) {return 0;}

+    static inline int argTypeDistance(HSQUIRRELVM) {return 0;}

+    static inline int create(void) {

+        HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+        R *r = static_cast<R*>(sq_malloc(sizeof(R)));

+        return r ?

+            PostConstruct<R>(v, new(r) R,

+                             ClassType<R>::getReleaseHook()) :

+            classAllocationError(v);

+    }

+};

+

+template<typename R, typename A1>

+struct Arg<R(*)(A1)> {

+    static inline int num(void) {return 1;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        int s, r;

+        r = 0;

+        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;

+        return r;

+    }

+    static inline int create(A1 a1) {

+        HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+        R *r = static_cast<R*>(sq_malloc(sizeof(R)));

+        return r ?

+            PostConstruct<R>(v, new(r) R(a1),

+                             ClassType<R>::getReleaseHook()) :

+            classAllocationError(v);

+    }

+};

+

+template<typename R, typename A1, typename A2>

+struct Arg<R(*)(A1, A2)> {

+    static inline int num(void) {return 2;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        int s, r;

+        r = 0;

+        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;

+        return r;

+    }

+    static inline int create(A1 a1, A2 a2) {

+        HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+        R *r = static_cast<R*>(sq_malloc(sizeof(R)));

+        return r ?

+            PostConstruct<R>(v, new(r) R(a1, a2),

+                             ClassType<R>::getReleaseHook()) :

+            classAllocationError(v);

+    }

+};

+

+template<typename R, typename A1, typename A2, typename A3>

+struct Arg<R(*)(A1, A2, A3)> {

+    static inline int num(void) {return 3;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        int s, r;

+        r = 0;

+        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;

+        return r;

+    }

+    static inline int create(A1 a1, A2 a2, A3 a3) {

+        HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+        R *r = static_cast<R*>(sq_malloc(sizeof(R)));

+        return r ?

+            PostConstruct<R>(v, new(r) R(a1, a2, a3),

+                             ClassType<R>::getReleaseHook()) :

+            classAllocationError(v);

+    }

+};

+

+template<typename R, typename A1, typename A2, typename A3, typename A4>

+struct Arg<R(*)(A1, A2, A3, A4)> {

+    static inline int num(void) {return 4;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        int s, r;

+        r = 0;

+        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A4>::distance(v, 5); if (s < 0) {return -1;} r += s;

+        return r;

+    }

+    static inline int create(A1 a1, A2 a2, A3 a3, A4 a4) {

+        HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+        R *r = static_cast<R*>(sq_malloc(sizeof(R)));

+        return r ?

+            PostConstruct<R>(v, new(r) R(a1, a2, a3, a4),

+                             ClassType<R>::getReleaseHook()) :

+            classAllocationError(v);

+    }

+};

+

+template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5>

+struct Arg<R(*)(A1, A2, A3, A4, A5)> {

+    static inline int num(void) {return 5;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        int s, r;

+        r = 0;

+        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A4>::distance(v, 5); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A5>::distance(v, 6); if (s < 0) {return -1;} r += s;

+        return r;

+    }

+    static inline int create(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {

+        HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+        R *r = static_cast<R*>(sq_malloc(sizeof(R)));

+        return r ?

+            PostConstruct<R>(v, new(r) R(a1, a2, a3, a4, a5),

+                             ClassType<R>::getReleaseHook()) :

+            classAllocationError(v);

+    }

+};

+

+template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>

+struct Arg<R(*)(A1, A2, A3, A4, A5, A6)> {

+    static inline int num(void) {return 6;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        int s, r;

+        r = 0;

+        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A4>::distance(v, 5); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A5>::distance(v, 6); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A6>::distance(v, 7); if (s < 0) {return -1;} r += s;

+        return r;

+    }

+    static inline int create(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {

+        HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+        R *r = static_cast<R*>(sq_malloc(sizeof(R)));

+        return r ?

+            PostConstruct<R>(v, new(r) R(a1, a2, a3, a4, a5, a6),

+                             ClassType<R>::getReleaseHook()) :

+            classAllocationError(v);

+    }

+};

+

+template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>

+struct Arg<R(*)(A1, A2, A3, A4, A5, A6, A7)> {

+    static inline int num(void) {return 7;}

+    static inline int argTypeDistance(HSQUIRRELVM v) {

+        int s, r;

+        r = 0;

+        s = CheckInstance<A1>::distance(v, 2); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A2>::distance(v, 3); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A3>::distance(v, 4); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A4>::distance(v, 5); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A5>::distance(v, 6); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A6>::distance(v, 7); if (s < 0) {return -1;} r += s;

+        s = CheckInstance<A7>::distance(v, 8); if (s < 0) {return -1;} r += s;

+        return r;

+    }

+    static inline int create(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {

+        HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+        R *r = static_cast<R*>(sq_malloc(sizeof(R)));

+        return r ?

+            PostConstruct<R>(v, new(r) R(a1, a2, a3, a4, a5, a6, a7),

+                             ClassType<R>::getReleaseHook()) :

+            classAllocationError(v);

+    }

+};

+#endif // SQPLUS_OVERLOAD_FUNCTIONS

+

+// SqPlusOverload.h

+

+// Local Variables: 

+// mode: c++

+// End:

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusSetup.h b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusSetup.h
index 372e63f69..ca191459e 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusSetup.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusSetup.h
@@ -1,129 +1,129 @@
-#ifndef SQPLUSSETUP_H
-#define SQPLUSSETUP_H
-
-// Setup file for SqPlus. 
-// Comment / uncomment / define options below.
-
-
-// Inheritance in Squirrel allows one class to inherit a base class's
-// functions and variables.
-//
-// Variables are merged: if Derived has a var name 'val' and Base has
-// a var of the same name, the resulting var 'val' will take Derived's
-// initialization value.
-//
-// Functions are not merged, and can be called via Squirrel scoping rules.
-//
-// Define SQ_USE_CLASS_INHERITANCE to enable class inheritance support
-// (requires slightly more memory and adds some CPU overhead).
-//
-// Can also be useful for debugging, as class type information is
-// checked before dispatching instance function calls and before
-// accessing instance member variables.
-#define SQ_USE_CLASS_INHERITANCE
-
-
-// This is a new C++ template based inheritence scheme that uses no
-// additional memory per instance. To support offset between "this"
-// pointer in base and derived class, use a second class in:
-//    SQClassDef< MyClass, MyBaseClass >.
-// NOTE: For new code SQ_USE_CLASS_INHERITANCE_SIMPLE is more
-// efficient than above method.
-//#define SQ_USE_CLASS_INHERITANCE_SIMPLE
-
-// === Instance type info support ===
-#define SQ_SUPPORT_INSTANCE_TYPE_INFO
-
-// === Constant argument and constant member function support ===
-// Define SQPLUS_CONST_OPT before including SqPlus.h for constant
-// argument + constant member function support.
-#define SQPLUS_CONST_OPT
-
-
-// === Uncomment to support smart pointer ===
-// Define SQPLUS_SMARTPOINTER_OPT before including SqPlus.h for
-// smartpointer member function + variable support
-//#define SQPLUS_SMARTPOINTER_OPT
-
-
-// === Function overloading support ===
-#define SQPLUS_OVERLOAD_OPT
-
-// === Uncomment to support std::string ===
-// Requires that Squirrel is compiled with SQChar == char
-//#define SQPLUS_SUPPORT_STD_STRING
-
-// === Uncomment to support typedef std::basic_string<SQChar> sq_std_string ===
-#define SQPLUS_SUPPORT_SQ_STD_STRING
-
-// === Uncomment to support NULL INSTANCE arguments ===
-#define SQPLUS_SUPPORT_NULL_INSTANCES
-
-// === Uncomment to disable copying of class instances ===
-// If classes being exposed have private or protected constructors 
-// one cannot do assign (=) in template functions.
-//#define SQPLUS_DISABLE_COPY_INSTANCES
-
-
-// === Auto generating typemasks for registered functions  ===
-// This is useful when using Squirrel interactively
-//#define SQPLUS_ENABLE_AUTO_TYPEMASK
-
-// === Uncomment to generate a typeof function for each class  ===
-// This is mostly for displaying function help from inside a Squirrel prompt
-//#define SQPLUS_ENABLE_TYPEOF
-
-// === Uncomment to skip sq_argassert() ===
-//#define SQ_SKIP_ARG_ASSERT
-
-// === GCC Inline template fix ===
-// Can solve problems when linking if GCC has problems with inline functions
-//#define GCC_INLINE_WORKAROUND
-
-
-// === MSVC cdecl member functions ===
-// Enable binding member functions with __cdecl calling convention under MSVC. 
-// Mostly useful when linking with binaries from other compilers. 
-#ifdef _MSC_VER
-//#define SQPLUS_ENABLE_CDECL_MEMBER_FUNCTIONS
-#endif 
-
-
-// === Generic Push/Pop/Match handlers ===
-// This enables using a 'fallback' set of Push/Get/Match that operates
-// on class level (not on template level). This opens for handling all
-// members of a certain class hierarchy using the same function
-// GenPush/GenGet/GenMatch overrides (provided the hierarchy has some
-// run-time type mechanism to use). They are used whenever an exact
-// template match is not found.
-//#define SQPLUS_USE_GENERIC_HANDLERS
-
-
-// === Sandbox VM ===
-// This enables giving one VM the role of 'sandbox' VM where scripts
-// of unknown origin may execute and not have access to any SqPlus
-// registered functions.  All normal VMs have full access to script
-// functions, but the one given in SetSandboxVm() can only use std
-// Squirrel functions.
-//#define SQPLUS_USE_SANDBOX_VM
-
-
-#if defined(SQPLUS_SUPPORT_STD_STRING) || defined(SQPLUS_SUPPORT_SQ_STD_STRING)
-# include <string>
-#endif
-
-
-// === Conversion of arguments from opposite char type ( char <=> wchar_t ) === 
-// Converts strings to opposite encoding in Push/Get handlers (UTF8 / Latin1)
-#define SQPLUS_AUTOCONVERT_OTHER_CHAR
-
-// === Whether 8 bit chars are treated as Latin1(1) or UTF8(0) ===
-// (leave undefined for undefined for automatic handling)
-#define SQPLUS_USE_LATIN1 1
-
-// === Include system library bindings when creating VM:s in SquirrelVM::Init() ===
-// Define to bind to system lib when VM:s are created automatically in 
-// SquirrelVM::Init()
-//#define SQPLUS_SQUIRRELVM_WITH_SYSTEMLIB
-
-#endif // SQPLUSSETUP_H
+#ifndef SQPLUSSETUP_H

+#define SQPLUSSETUP_H

+

+// Setup file for SqPlus. 

+// Comment / uncomment / define options below.

+

+

+// Inheritance in Squirrel allows one class to inherit a base class's

+// functions and variables.

+//

+// Variables are merged: if Derived has a var name 'val' and Base has

+// a var of the same name, the resulting var 'val' will take Derived's

+// initialization value.

+//

+// Functions are not merged, and can be called via Squirrel scoping rules.

+//

+// Define SQ_USE_CLASS_INHERITANCE to enable class inheritance support

+// (requires slightly more memory and adds some CPU overhead).

+//

+// Can also be useful for debugging, as class type information is

+// checked before dispatching instance function calls and before

+// accessing instance member variables.

+#define SQ_USE_CLASS_INHERITANCE

+

+

+// This is a new C++ template based inheritence scheme that uses no

+// additional memory per instance. To support offset between "this"

+// pointer in base and derived class, use a second class in:

+//    SQClassDef< MyClass, MyBaseClass >.

+// NOTE: For new code SQ_USE_CLASS_INHERITANCE_SIMPLE is more

+// efficient than above method.

+//#define SQ_USE_CLASS_INHERITANCE_SIMPLE

+

+// === Instance type info support ===

+#define SQ_SUPPORT_INSTANCE_TYPE_INFO

+

+// === Constant argument and constant member function support ===

+// Define SQPLUS_CONST_OPT before including SqPlus.h for constant

+// argument + constant member function support.

+#define SQPLUS_CONST_OPT

+

+

+// === Uncomment to support smart pointer ===

+// Define SQPLUS_SMARTPOINTER_OPT before including SqPlus.h for

+// smartpointer member function + variable support

+//#define SQPLUS_SMARTPOINTER_OPT

+

+

+// === Function overloading support ===

+#define SQPLUS_OVERLOAD_OPT

+

+// === Uncomment to support std::string ===

+// Requires that Squirrel is compiled with SQChar == char

+//#define SQPLUS_SUPPORT_STD_STRING

+

+// === Uncomment to support typedef std::basic_string<SQChar> sq_std_string ===

+#define SQPLUS_SUPPORT_SQ_STD_STRING

+

+// === Uncomment to support NULL INSTANCE arguments ===

+#define SQPLUS_SUPPORT_NULL_INSTANCES

+

+// === Uncomment to disable copying of class instances ===

+// If classes being exposed have private or protected constructors 

+// one cannot do assign (=) in template functions.

+//#define SQPLUS_DISABLE_COPY_INSTANCES

+

+

+// === Auto generating typemasks for registered functions  ===

+// This is useful when using Squirrel interactively

+//#define SQPLUS_ENABLE_AUTO_TYPEMASK

+

+// === Uncomment to generate a typeof function for each class  ===

+// This is mostly for displaying function help from inside a Squirrel prompt

+//#define SQPLUS_ENABLE_TYPEOF

+

+// === Uncomment to skip sq_argassert() ===

+//#define SQ_SKIP_ARG_ASSERT

+

+// === GCC Inline template fix ===

+// Can solve problems when linking if GCC has problems with inline functions

+//#define GCC_INLINE_WORKAROUND

+

+

+// === MSVC cdecl member functions ===

+// Enable binding member functions with __cdecl calling convention under MSVC. 

+// Mostly useful when linking with binaries from other compilers. 

+#ifdef _MSC_VER

+//#define SQPLUS_ENABLE_CDECL_MEMBER_FUNCTIONS

+#endif 

+

+

+// === Generic Push/Pop/Match handlers ===

+// This enables using a 'fallback' set of Push/Get/Match that operates

+// on class level (not on template level). This opens for handling all

+// members of a certain class hierarchy using the same function

+// GenPush/GenGet/GenMatch overrides (provided the hierarchy has some

+// run-time type mechanism to use). They are used whenever an exact

+// template match is not found.

+//#define SQPLUS_USE_GENERIC_HANDLERS

+

+

+// === Sandbox VM ===

+// This enables giving one VM the role of 'sandbox' VM where scripts

+// of unknown origin may execute and not have access to any SqPlus

+// registered functions.  All normal VMs have full access to script

+// functions, but the one given in SetSandboxVm() can only use std

+// Squirrel functions.

+//#define SQPLUS_USE_SANDBOX_VM

+

+

+#if defined(SQPLUS_SUPPORT_STD_STRING) || defined(SQPLUS_SUPPORT_SQ_STD_STRING)

+# include <string>

+#endif

+

+

+// === Conversion of arguments from opposite char type ( char <=> wchar_t ) === 

+// Converts strings to opposite encoding in Push/Get handlers (UTF8 / Latin1)

+#define SQPLUS_AUTOCONVERT_OTHER_CHAR

+

+// === Whether 8 bit chars are treated as Latin1(1) or UTF8(0) ===

+// (leave undefined for undefined for automatic handling)

+#define SQPLUS_USE_LATIN1 1

+

+// === Include system library bindings when creating VM:s in SquirrelVM::Init() ===

+// Define to bind to system lib when VM:s are created automatically in 

+// SquirrelVM::Init()

+//#define SQPLUS_SQUIRRELVM_WITH_SYSTEMLIB

+

+#endif // SQPLUSSETUP_H

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusSmartPointer.h b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusSmartPointer.h
index 34996ffd8..5a6bacbf5 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusSmartPointer.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusSmartPointer.h
@@ -1,141 +1,141 @@
-// SqPlusSmartPointer.h
-// SqPlus smart pointer member function support created by James Whitworth.
-// Modular integration 07/11/07 James Whitworth.
-// you must define the function:
-// unsigned char* getSmartPointerPointee(unsigned char*) {
-// 		return &(MySmartPointer->pointee);
-// }
-// somewhere in your program so it can correctly lookup member variables on the class pointed to
-// by your smart pointer.
-
-#ifdef SQPLUS_SMARTPOINTER_ACCESSTYPE
-#undef SQPLUS_SMARTPOINTER_ACCESSTYPE
-enum VarAccessType {VAR_ACCESS_READ_WRITE=0,VAR_ACCESS_READ_ONLY=1<<0,VAR_ACCESS_CONSTANT=1<<1,VAR_ACCESS_STATIC=1<<2,VAR_ACCESS_SMARTPOINTER=1<<3};
-#endif // #ifdef SQPLUS_SMARTPOINTER_ACCESSTYPE
-
-#ifdef SQPLUS_SMARTPOINTER_REGISTER_VARIABLE
-#undef SQPLUS_SMARTPOINTER_REGISTER_VARIABLE
-// classType is the type of the member variable's containing class.
-template<typename T>
-void
-RegisterSmartInstanceVariable(SquirrelObject & so,
-                              ClassTypeBase *classType,
-                              T *var,
-                              const SQChar *scriptVarName,
-                              VarAccessType access = VAR_ACCESS_READ_WRITE)
-{
-	VarRef *pvr = createVarRef(so,scriptVarName);
-    
-    // var must be passed in as &obj->var, where obj = 0 
-    // (the address is the offset), or as static/global address.
-	void *offsetOrAddrOrConst = static_cast<void*>(var);
-	*pvr = VarRef(offsetOrAddrOrConst,
-                  TypeInfo<T>(),
-                  classType,
-                  ClassType<T>::type(),
-                  sizeof(*var),
-                  access);
-	pvr->m_access |= VAR_ACCESS_SMARTPOINTER;
-	createInstanceSetGetHandlers(so);
-}
-#endif // #ifdef SQPLUS_SMARTPOINTER_REGISTER_VARIABLE
-
-#ifdef SQPLUS_SMARTPOINTER_DISPATCH
-#undef SQPLUS_SMARTPOINTER_DISPATCH
-template<typename Callee,typename Pointee,typename Func>
-class DirectCallSmartInstanceMemberFunction {
-public:
-  static inline int Dispatch(HSQUIRRELVM v) {
-    DirectCallInstanceFuncPicker<Callee, Func> p(v);
-    if (!p.instance || !p.func) {
-      sq_throwerror(v, _SC("Invalid Instance Type"));
-    }
-	Pointee *pointeeInstance = static_cast<Pointee*>(p.instance->get());
-    return
-        !pointeeInstance ? sq_throwerror(v, _SC("SmartPointer Pointee NULL")) :
-        Call(*pointeeInstance, *(p.func), v, 2);
-  }
-};
-#endif // #ifdef SQPLUS_SMARTPOINTER_DISPATCH
-
-#ifdef SQPLUS_SMARTPOINTER_DIRECT_CLOSURE
-#undef SQPLUS_SMARTPOINTER_DIRECT_CLOSURE
-
-template<typename Callee,typename Pointee,typename Func>
-inline void sq_pushdirectsmartinstanceclosure(HSQUIRRELVM v,const Callee & callee,const Pointee & pointee,Func func,SQUnsignedInteger nupvalues) {
-  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func));  // Also pushed on stack.
-  memcpy(up,&func,sizeof(func));
-  sq_newclosure(v,DirectCallSmartInstanceMemberFunction<Callee,Pointee,Func>::Dispatch,nupvalues+1);
-} // sq_pushdirectinstanceclosure
-
-#endif // #ifdef SQPLUS_SMARTPOINTER_DIRECT_CLOSURE
-
-#ifdef SQPLUS_SMARTPOINTER_REGISTER_INSTANCE
-#undef SQPLUS_SMARTPOINTER_REGISTER_INSTANCE
-
-template<typename Callee, typename Pointee, typename Func>
-inline void RegisterSmartInstance(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,Pointee & pointee,Func func,const SQChar * name) {
-  sq_pushobject(v,hclass);
-  sq_pushstring(v,name,-1);
-  sq_pushdirectsmartinstanceclosure(v,callee,pointee,func,0);
-  sq_createslot(v,-3);
-  sq_poptop(v); // Remove hclass.
-} // RegisterInstance
-
-#endif // #ifdef SQPLUS_SMARTPOINTER_REGISTER_INSTANCE
-
-#ifdef SQPLUS_SMARTPOINTER_CLASS_DEF_FUNC
-#undef SQPLUS_SMARTPOINTER_CLASS_DEF_FUNC
-
-  // Register a smartpointer member function.
-  template<typename Pointee, typename Func>
-  SQClassDefBase & smartFunc(Func pfunc,const SQChar * name) {
-    RegisterSmartInstance(v,newClass.GetObjectHandle(),*(TClassType *)0,*(Pointee *)0,pfunc,name);
-    return *this;
-  } // func
-
-#endif // #ifdef SQPLUS_SMARTPOINTER_CLASS_DEF_FUNC
-
-#ifdef SQPLUS_SMARTPOINTER_CLASS_DEF_VAR
-#undef SQPLUS_SMARTPOINTER_CLASS_DEF_VAR
-
-  // Register a member variable.
-  template<typename Pointee, typename VarType>
-  SQClassDefBase & smartVar(VarType Pointee::* pvar,const SQChar * name,VarAccessType access=VAR_ACCESS_READ_WRITE) {
-	  struct CV {
-		  VarType Pointee::* var;
-	  } cv; // Cast Variable helper.
-	  cv.var = pvar;
-	  RegisterSmartInstanceVariable(newClass,ClassType<TClassType>::type(),*(VarType **)&cv,name,access);
-	  return *this;
-  } // var
-
-  // Register a member variable as a UserPointer (read only).
-  template<typename Pointee, typename VarType>
-  SQClassDefBase & smartVarAsUserPointer(VarType Pointee::* pvar,const SQChar * name) {
-	  struct CV {
-		  VarType Pointee::* var;
-	  } cv; // Cast Variable helper.
-	  cv.var = pvar;
-	  RegisterSmartInstanceVariable(newClass,ClassType<TClassType>::type(),*(SQAnything **)&cv,name,VAR_ACCESS_READ_ONLY);
-	  return *this;
-  } // varAsUserPointer
-
-#endif // #ifdef SQPLUS_SMARTPOINTER_CLASS_DEF_VAR
-
-
-#ifdef SQPLUS_SMARTPOINTER_CPP_DECLARATION
-#undef SQPLUS_SMARTPOINTER_CPP_DECLARATION
-extern unsigned char* getSmartPointerPointee(unsigned char*);
-#endif
-
-#ifdef SQPLUS_SMARTPOINTER_INSTANCE_VARINFO
-#undef SQPLUS_SMARTPOINTER_INSTANCE_VARINFO
-	if(vr->m_access & VAR_ACCESS_SMARTPOINTER) {
-		up = reinterpret_cast<char*>(
-            getSmartPointerPointee(reinterpret_cast<unsigned char*>(up))
-            );
-	}
-#endif // #ifdef SQPLUS_SMARTPOINTER_CPP_DECLARATION
-
-// SqPlusSmartPointer.h
+// SqPlusSmartPointer.h

+// SqPlus smart pointer member function support created by James Whitworth.

+// Modular integration 07/11/07 James Whitworth.

+// you must define the function:

+// unsigned char* getSmartPointerPointee(unsigned char*) {

+// 		return &(MySmartPointer->pointee);

+// }

+// somewhere in your program so it can correctly lookup member variables on the class pointed to

+// by your smart pointer.

+

+#ifdef SQPLUS_SMARTPOINTER_ACCESSTYPE

+#undef SQPLUS_SMARTPOINTER_ACCESSTYPE

+enum VarAccessType {VAR_ACCESS_READ_WRITE=0,VAR_ACCESS_READ_ONLY=1<<0,VAR_ACCESS_CONSTANT=1<<1,VAR_ACCESS_STATIC=1<<2,VAR_ACCESS_SMARTPOINTER=1<<3};

+#endif // #ifdef SQPLUS_SMARTPOINTER_ACCESSTYPE

+

+#ifdef SQPLUS_SMARTPOINTER_REGISTER_VARIABLE

+#undef SQPLUS_SMARTPOINTER_REGISTER_VARIABLE

+// classType is the type of the member variable's containing class.

+template<typename T>

+void

+RegisterSmartInstanceVariable(SquirrelObject & so,

+                              ClassTypeBase *classType,

+                              T *var,

+                              const SQChar *scriptVarName,

+                              VarAccessType access = VAR_ACCESS_READ_WRITE)

+{

+	VarRef *pvr = createVarRef(so,scriptVarName);

+    

+    // var must be passed in as &obj->var, where obj = 0 

+    // (the address is the offset), or as static/global address.

+	void *offsetOrAddrOrConst = static_cast<void*>(var);

+	*pvr = VarRef(offsetOrAddrOrConst,

+                  TypeInfo<T>(),

+                  classType,

+                  ClassType<T>::type(),

+                  sizeof(*var),

+                  access);

+	pvr->m_access |= VAR_ACCESS_SMARTPOINTER;

+	createInstanceSetGetHandlers(so);

+}

+#endif // #ifdef SQPLUS_SMARTPOINTER_REGISTER_VARIABLE

+

+#ifdef SQPLUS_SMARTPOINTER_DISPATCH

+#undef SQPLUS_SMARTPOINTER_DISPATCH

+template<typename Callee,typename Pointee,typename Func>

+class DirectCallSmartInstanceMemberFunction {

+public:

+  static inline int Dispatch(HSQUIRRELVM v) {

+    DirectCallInstanceFuncPicker<Callee, Func> p(v);

+    if (!p.instance || !p.func) {

+      sq_throwerror(v, _SC("Invalid Instance Type"));

+    }

+	Pointee *pointeeInstance = static_cast<Pointee*>(p.instance->get());

+    return

+        !pointeeInstance ? sq_throwerror(v, _SC("SmartPointer Pointee NULL")) :

+        Call(*pointeeInstance, *(p.func), v, 2);

+  }

+};

+#endif // #ifdef SQPLUS_SMARTPOINTER_DISPATCH

+

+#ifdef SQPLUS_SMARTPOINTER_DIRECT_CLOSURE

+#undef SQPLUS_SMARTPOINTER_DIRECT_CLOSURE

+

+template<typename Callee,typename Pointee,typename Func>

+inline void sq_pushdirectsmartinstanceclosure(HSQUIRRELVM v,const Callee & callee,const Pointee & pointee,Func func,SQUnsignedInteger nupvalues) {

+  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func));  // Also pushed on stack.

+  memcpy(up,&func,sizeof(func));

+  sq_newclosure(v,DirectCallSmartInstanceMemberFunction<Callee,Pointee,Func>::Dispatch,nupvalues+1);

+} // sq_pushdirectinstanceclosure

+

+#endif // #ifdef SQPLUS_SMARTPOINTER_DIRECT_CLOSURE

+

+#ifdef SQPLUS_SMARTPOINTER_REGISTER_INSTANCE

+#undef SQPLUS_SMARTPOINTER_REGISTER_INSTANCE

+

+template<typename Callee, typename Pointee, typename Func>

+inline void RegisterSmartInstance(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,Pointee & pointee,Func func,const SQChar * name) {

+  sq_pushobject(v,hclass);

+  sq_pushstring(v,name,-1);

+  sq_pushdirectsmartinstanceclosure(v,callee,pointee,func,0);

+  sq_createslot(v,-3);

+  sq_poptop(v); // Remove hclass.

+} // RegisterInstance

+

+#endif // #ifdef SQPLUS_SMARTPOINTER_REGISTER_INSTANCE

+

+#ifdef SQPLUS_SMARTPOINTER_CLASS_DEF_FUNC

+#undef SQPLUS_SMARTPOINTER_CLASS_DEF_FUNC

+

+  // Register a smartpointer member function.

+  template<typename Pointee, typename Func>

+  SQClassDefBase & smartFunc(Func pfunc,const SQChar * name) {

+    RegisterSmartInstance(v,newClass.GetObjectHandle(),*(TClassType *)0,*(Pointee *)0,pfunc,name);

+    return *this;

+  } // func

+

+#endif // #ifdef SQPLUS_SMARTPOINTER_CLASS_DEF_FUNC

+

+#ifdef SQPLUS_SMARTPOINTER_CLASS_DEF_VAR

+#undef SQPLUS_SMARTPOINTER_CLASS_DEF_VAR

+

+  // Register a member variable.

+  template<typename Pointee, typename VarType>

+  SQClassDefBase & smartVar(VarType Pointee::* pvar,const SQChar * name,VarAccessType access=VAR_ACCESS_READ_WRITE) {

+	  struct CV {

+		  VarType Pointee::* var;

+	  } cv; // Cast Variable helper.

+	  cv.var = pvar;

+	  RegisterSmartInstanceVariable(newClass,ClassType<TClassType>::type(),*(VarType **)&cv,name,access);

+	  return *this;

+  } // var

+

+  // Register a member variable as a UserPointer (read only).

+  template<typename Pointee, typename VarType>

+  SQClassDefBase & smartVarAsUserPointer(VarType Pointee::* pvar,const SQChar * name) {

+	  struct CV {

+		  VarType Pointee::* var;

+	  } cv; // Cast Variable helper.

+	  cv.var = pvar;

+	  RegisterSmartInstanceVariable(newClass,ClassType<TClassType>::type(),*(SQAnything **)&cv,name,VAR_ACCESS_READ_ONLY);

+	  return *this;

+  } // varAsUserPointer

+

+#endif // #ifdef SQPLUS_SMARTPOINTER_CLASS_DEF_VAR

+

+

+#ifdef SQPLUS_SMARTPOINTER_CPP_DECLARATION

+#undef SQPLUS_SMARTPOINTER_CPP_DECLARATION

+extern unsigned char* getSmartPointerPointee(unsigned char*);

+#endif

+

+#ifdef SQPLUS_SMARTPOINTER_INSTANCE_VARINFO

+#undef SQPLUS_SMARTPOINTER_INSTANCE_VARINFO

+	if(vr->m_access & VAR_ACCESS_SMARTPOINTER) {

+		up = reinterpret_cast<char*>(

+            getSmartPointerPointee(reinterpret_cast<unsigned char*>(up))

+            );

+	}

+#endif // #ifdef SQPLUS_SMARTPOINTER_CPP_DECLARATION

+

+// SqPlusSmartPointer.h

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusTypeMask.h b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusTypeMask.h
index 975a51a1f..50dc0c066 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusTypeMask.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusTypeMask.h
@@ -1,169 +1,169 @@
-
-// File to automatically generate a typemask for a function 
-
-// Will generate type masks that accepts Instance pointer or null 
-#ifndef SQPLUS_ACCEPT_NULL_INSTANCE
-    #define SQPLUS_ACCEPT_NULL_INSTANCE
-#endif 
-
-// Macros to reduce typing: (P1), (P1,P2), (P1,P2,P3), ...
-#define P_0 
-#define P_1 P1
-#define P_2 P_1,P2
-#define P_3 P_2,P3
-#define P_4 P_3,P4
-#define P_5 P_4,P5
-#define P_6 P_5,P6
-#define P_7 P_6,P7
-
-// Macros to reduce typing: (typename P1), (typename P1,typename P2), ...
-#define PTN_0 
-#define PTN_1 typename P1
-#define PTN_2 PTN_1,typename P2
-#define PTN_3 PTN_2,typename P3
-#define PTN_4 PTN_3,typename P4
-#define PTN_5 PTN_4,typename P5
-#define PTN_6 PTN_5,typename P6
-#define PTN_7 PTN_6,typename P7
-
-// Include a comma first in list: ,typename P1,typename P2
-#define PTNC_0 
-#define PTNC_1 ,PTN_1
-#define PTNC_2 ,PTN_2
-#define PTNC_3 ,PTN_3
-#define PTNC_4 ,PTN_4
-#define PTNC_5 ,PTN_5
-#define PTNC_6 ,PTN_6
-#define PTNC_7 ,PTN_7
-
-#ifdef SQUNICODE
-#define scstrcpy wcscpy
-#else
-#define scstrcpy strcpy
-#endif
-
-inline const SQChar* strappchar(SQChar *buf, SQChar *in, SQChar ch){ 
-    int l=scstrlen(in); 
-    scstrcpy(buf,in);
-    buf[l] = ch;
-#ifdef SQPLUS_ACCEPT_NULL_INSTANCE
-    if( ch=='x' ){
-        buf[++l] = '|'; // Also accept NULL pointers
-        buf[++l] = 'o';
-    }
-#endif
-    buf[l+1] = 0;
-    return buf; 
-}
-
-template<class T>
-struct sqTypeMask { };
-
-
-// Return type not included in type mask, delegate to void case
-
-// Base case, no arguments
-template<typename RT> 
-struct sqTypeMask<RT(*)()> { 
-    static const SQChar *Get(){
-    	static SQChar buf[64];
-    	//buf[0] = _SC('t');
-    	//buf[1] = 0;
-        //strcpy(buf,"t|x");  // Accept both instance and table, we don't use param anyway
-    	buf[0] = _SC('.');  // Accept anything (not used)
-    	buf[1] = 0;
-    	return buf; 
-    }
-};
-
-// Recursive case, peel of one arg at each level
-#define DECLARE_RT_SQTYPEMASK(N,M) \
-template<typename RT PTNC_##N> \
-struct sqTypeMask<RT(*)(P_##N)> { \
-    static const SQChar *Get(){ \
-        static SQChar buf[10]; \
-        return strappchar(buf, (SQChar*)sqTypeMask<RT(*)(P_##M)>::Get(), \
-                               (SQChar)TypeInfo<P##N>::TypeMask); \
-    } \
-};
-
-DECLARE_RT_SQTYPEMASK(1,0)
-DECLARE_RT_SQTYPEMASK(2,1)
-DECLARE_RT_SQTYPEMASK(3,2)
-DECLARE_RT_SQTYPEMASK(4,3)
-DECLARE_RT_SQTYPEMASK(5,4)
-DECLARE_RT_SQTYPEMASK(6,5)
-DECLARE_RT_SQTYPEMASK(7,6)
-
-
-// Difference to above is that 1st param is instance instead of table
-
-#define DECLARE_RT_MEMBER_SQTYPEMASK(N,QUAL) \
-template<typename Callee, typename RT PTNC_##N> \
-struct sqTypeMask<RT(Callee::*)(P_##N) QUAL> { \
-    static const SQChar *Get(){ \
-        SQChar *buf = (SQChar*)sqTypeMask<RT(*)(P_##N)>::Get(); \
-        buf[0] = _SC('x'); \
-        return buf; \
-    } \
-};
-
-//    	buf[1] = 0; \ 
-
-DECLARE_RT_MEMBER_SQTYPEMASK(0,)
-DECLARE_RT_MEMBER_SQTYPEMASK(1,)
-DECLARE_RT_MEMBER_SQTYPEMASK(2,)
-DECLARE_RT_MEMBER_SQTYPEMASK(3,)
-DECLARE_RT_MEMBER_SQTYPEMASK(4,)
-DECLARE_RT_MEMBER_SQTYPEMASK(5,)
-DECLARE_RT_MEMBER_SQTYPEMASK(6,)
-DECLARE_RT_MEMBER_SQTYPEMASK(7,)
-
-DECLARE_RT_MEMBER_SQTYPEMASK(0,const)
-DECLARE_RT_MEMBER_SQTYPEMASK(1,const)
-DECLARE_RT_MEMBER_SQTYPEMASK(2,const)
-DECLARE_RT_MEMBER_SQTYPEMASK(3,const)
-DECLARE_RT_MEMBER_SQTYPEMASK(4,const)
-DECLARE_RT_MEMBER_SQTYPEMASK(5,const)
-DECLARE_RT_MEMBER_SQTYPEMASK(6,const)
-DECLARE_RT_MEMBER_SQTYPEMASK(7,const)
-
-
-#ifdef _MSC_VER
-
-// Difference to above is we're using __cdecl calling convention here
-// Only makes sense for MSVC where member functions can have different 
-// calling conventions (__cdecl or __thiscall)
-
-#define DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(N,QUAL) \
-template<typename Callee, typename RT PTNC_##N> \
-struct sqTypeMask<RT(__cdecl Callee::*)(P_##N) QUAL> { \
-    static const SQChar *Get(){ \
-        SQChar *buf = (SQChar*)sqTypeMask<RT(*)(P_##N)>::Get(); \
-        buf[0] = _SC('x'); \
-        return buf; \
-    } \
-};
-
-//    	buf[1] = 0; \
-
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(0,)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(1,)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(2,)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(3,)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(4,)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(5,)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(6,)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(7,)
-
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(0,const)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(1,const)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(2,const)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(3,const)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(4,const)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(5,const)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(6,const)
-DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(7,const)
-
-#endif // _MSC_VER
-
+

+// File to automatically generate a typemask for a function 

+

+// Will generate type masks that accepts Instance pointer or null 

+#ifndef SQPLUS_ACCEPT_NULL_INSTANCE

+    #define SQPLUS_ACCEPT_NULL_INSTANCE

+#endif 

+

+// Macros to reduce typing: (P1), (P1,P2), (P1,P2,P3), ...

+#define P_0 

+#define P_1 P1

+#define P_2 P_1,P2

+#define P_3 P_2,P3

+#define P_4 P_3,P4

+#define P_5 P_4,P5

+#define P_6 P_5,P6

+#define P_7 P_6,P7

+

+// Macros to reduce typing: (typename P1), (typename P1,typename P2), ...

+#define PTN_0 

+#define PTN_1 typename P1

+#define PTN_2 PTN_1,typename P2

+#define PTN_3 PTN_2,typename P3

+#define PTN_4 PTN_3,typename P4

+#define PTN_5 PTN_4,typename P5

+#define PTN_6 PTN_5,typename P6

+#define PTN_7 PTN_6,typename P7

+

+// Include a comma first in list: ,typename P1,typename P2

+#define PTNC_0 

+#define PTNC_1 ,PTN_1

+#define PTNC_2 ,PTN_2

+#define PTNC_3 ,PTN_3

+#define PTNC_4 ,PTN_4

+#define PTNC_5 ,PTN_5

+#define PTNC_6 ,PTN_6

+#define PTNC_7 ,PTN_7

+

+#ifdef SQUNICODE

+#define scstrcpy wcscpy

+#else

+#define scstrcpy strcpy

+#endif

+

+inline const SQChar* strappchar(SQChar *buf, SQChar *in, SQChar ch){ 

+    int l=scstrlen(in); 

+    scstrcpy(buf,in);

+    buf[l] = ch;

+#ifdef SQPLUS_ACCEPT_NULL_INSTANCE

+    if( ch=='x' ){

+        buf[++l] = '|'; // Also accept NULL pointers

+        buf[++l] = 'o';

+    }

+#endif

+    buf[l+1] = 0;

+    return buf; 

+}

+

+template<class T>

+struct sqTypeMask { };

+

+

+// Return type not included in type mask, delegate to void case

+

+// Base case, no arguments

+template<typename RT> 

+struct sqTypeMask<RT(*)()> { 

+    static const SQChar *Get(){

+    	static SQChar buf[64];

+    	//buf[0] = _SC('t');

+    	//buf[1] = 0;

+        //strcpy(buf,"t|x");  // Accept both instance and table, we don't use param anyway

+    	buf[0] = _SC('.');  // Accept anything (not used)

+    	buf[1] = 0;

+    	return buf; 

+    }

+};

+

+// Recursive case, peel of one arg at each level

+#define DECLARE_RT_SQTYPEMASK(N,M) \

+template<typename RT PTNC_##N> \

+struct sqTypeMask<RT(*)(P_##N)> { \

+    static const SQChar *Get(){ \

+        static SQChar buf[10]; \

+        return strappchar(buf, (SQChar*)sqTypeMask<RT(*)(P_##M)>::Get(), \

+                               (SQChar)TypeInfo<P##N>::TypeMask); \

+    } \

+};

+

+DECLARE_RT_SQTYPEMASK(1,0)

+DECLARE_RT_SQTYPEMASK(2,1)

+DECLARE_RT_SQTYPEMASK(3,2)

+DECLARE_RT_SQTYPEMASK(4,3)

+DECLARE_RT_SQTYPEMASK(5,4)

+DECLARE_RT_SQTYPEMASK(6,5)

+DECLARE_RT_SQTYPEMASK(7,6)

+

+

+// Difference to above is that 1st param is instance instead of table

+

+#define DECLARE_RT_MEMBER_SQTYPEMASK(N,QUAL) \

+template<typename Callee, typename RT PTNC_##N> \

+struct sqTypeMask<RT(Callee::*)(P_##N) QUAL> { \

+    static const SQChar *Get(){ \

+        SQChar *buf = (SQChar*)sqTypeMask<RT(*)(P_##N)>::Get(); \

+        buf[0] = _SC('x'); \

+        return buf; \

+    } \

+};

+

+//    	buf[1] = 0; \ 

+

+DECLARE_RT_MEMBER_SQTYPEMASK(0,)

+DECLARE_RT_MEMBER_SQTYPEMASK(1,)

+DECLARE_RT_MEMBER_SQTYPEMASK(2,)

+DECLARE_RT_MEMBER_SQTYPEMASK(3,)

+DECLARE_RT_MEMBER_SQTYPEMASK(4,)

+DECLARE_RT_MEMBER_SQTYPEMASK(5,)

+DECLARE_RT_MEMBER_SQTYPEMASK(6,)

+DECLARE_RT_MEMBER_SQTYPEMASK(7,)

+

+DECLARE_RT_MEMBER_SQTYPEMASK(0,const)

+DECLARE_RT_MEMBER_SQTYPEMASK(1,const)

+DECLARE_RT_MEMBER_SQTYPEMASK(2,const)

+DECLARE_RT_MEMBER_SQTYPEMASK(3,const)

+DECLARE_RT_MEMBER_SQTYPEMASK(4,const)

+DECLARE_RT_MEMBER_SQTYPEMASK(5,const)

+DECLARE_RT_MEMBER_SQTYPEMASK(6,const)

+DECLARE_RT_MEMBER_SQTYPEMASK(7,const)

+

+

+#ifdef _MSC_VER

+

+// Difference to above is we're using __cdecl calling convention here

+// Only makes sense for MSVC where member functions can have different 

+// calling conventions (__cdecl or __thiscall)

+

+#define DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(N,QUAL) \

+template<typename Callee, typename RT PTNC_##N> \

+struct sqTypeMask<RT(__cdecl Callee::*)(P_##N) QUAL> { \

+    static const SQChar *Get(){ \

+        SQChar *buf = (SQChar*)sqTypeMask<RT(*)(P_##N)>::Get(); \

+        buf[0] = _SC('x'); \

+        return buf; \

+    } \

+};

+

+//    	buf[1] = 0; \

+

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(0,)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(1,)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(2,)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(3,)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(4,)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(5,)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(6,)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(7,)

+

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(0,const)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(1,const)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(2,const)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(3,const)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(4,const)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(5,const)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(6,const)

+DECLARE_RT_MEMBER_SQTYPEMASK_CDECL(7,const)

+

+#endif // _MSC_VER

+

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusUtf8.cpp b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusUtf8.cpp
index 7505e9928..f5ee39ae5 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusUtf8.cpp
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusUtf8.cpp
@@ -1,133 +1,133 @@
-
-///////////////////////////////////////////////////////////////////////
-// Simple conversion routines, to, from UTF8 and full Unicode character
-// (using int). 
-// 
-
-// Only when needed 
-#if !defined(SQPLUS_USE_LATIN1) || SQPLUS_USE_LATIN1==0
-
-static char g_utf8_length[256];
-static int g_did_init_length; 
-
-void sqplus_init_utf8_lengths() {
-    // Fill in lengths in array above
-    for( int lb=0; lb<256; lb++ ){
-        int l = -1;
-        if( !(lb&0x80) ) l=1;
-        else if( (lb&0xE0)==0xC0 ) l=2;
-        else if( (lb&0xF0)==0xE0 ) l=3;
-        else if( (lb&0xF8)==0xF0 ) l=4;
-        else if( (lb&0xFC)==0xF8 ) l=5;
-        else if( (lb&0xFE)==0xFC ) l=6;
-        g_utf8_length[lb] = l;
-    }
-    g_did_init_length = 1;
-}
-
-// Length of a UTF8 encoded Unicode character
-int sqplus_utf8_len(int lead_byte){
-    if( !(lead_byte&0x80) ) return 1;  // Special case, make faster
-    if( !g_did_init_length )
-        sqplus_init_utf8_lengths();
-        
-    return g_utf8_length[(unsigned char)lead_byte];
-}
-
-int sqplus_utf8_len_first(const char* pc){
-    int lb = *(unsigned char*)pc;
-    if( !(lb&0x80) ) return 1;  // Special case, make faster
-    if( !g_did_init_length )
-        sqplus_init_utf8_lengths();
-
-    int l = g_utf8_length[(unsigned char)lb];
-    if( l>0 ) return l;
-    
-    // Invalid UTF8 lead byte. Look for next valid character. 
-    const char *pc1 = pc+1;
-    while( ((*pc1)&0xC0)==0x80 ) 
-        pc1++;
-    return int(pc1 - pc);
-}
-
-
-// Length of a UTF8 encoded Unicode string (number of Unicode characters)
-int sqplus_utf8_strlen(const char *str) {
-    if( !str ) return 0;
-    int l, tl=0;
-    while( *str ){
-        l = sqplus_utf8_len_first(str);
-        str += l;
-        tl++;
-    }
-    return tl;
-}
-
-// Convert one UTF8 encoded character to Unicode point
-int sqplus_utf8_to_wchar(int *result, const char *string){
-    int res=-1;
-    
-    // Assume argument pointers to be OK
-    unsigned char ch = *string;
-    int l = sqplus_utf8_len(ch);
-    
-    if( l<1  ) return -1;
-    int wc = l>1 ? (ch&(0x7F>>l)) : ch;
-    while( l>1 ){
-        wc = (wc<<6) + (*++string & 0x3F);
-        l--;
-    }
-    *result = wc;
-    
-    return 0;
-}
-
-// Convert one Unicode point to UTF8 encoded version.
-// Checks if output fits in 1/4/6 bytes buffer.
-int sqplus_wchar_to_utf8(char *s, int wc, int size){
-    if( size<1 ) return -1;
-    if( (unsigned int)wc>=0x80000000 ) return -2;
-    
-    // Single byte case
-    if( wc<0x80 ){
-        *s = (char)wc;
-        //*s = (char)wc&0x7F;
-        return 1;
-    }
-    if( size<4 ) return -3;
-
-    // Two or more UTF8 bytes
-    int p = 1;  // Index of last UTF8 byte
-    if( wc>0x7FF ){ // 11 bits
-        // Three or more UTF8 bytes
-        p++; // p>=2
-        if( wc>0xFFFF ){    // 16 bits
-            // Four or more UTF8 bytes
-            p++; // p>=3
-            if( wc>0x1FFFFF ){  // 21 bits
-                // Five or more UTF8 bytes
-                if( size<6 ) return -3;
-                p++; // p>=4 UTF8 bytes
-                if( wc>0x3FFFFFF ){ // 26 bits
-                    // Six UTF8 bytes
-                    p++; // p>=5 
-                    if( (unsigned int)wc>(unsigned int)0x7FFFFFF ){  // 31 bits
-						// Would need 7 UTF8 bytes. Not supported.
-						return -10;
-                    }
-                    s[p-4] = 0x80 | ((wc>>24)&0x3F);    // Bit 24..29
-                }
-                s[p-3] = 0x80 | ((wc>>18)&0x3F);    // Bit 18..23
-            }
-            s[p-2] = 0x80 | ((wc>>12)&0x3F);    // Bit 12..17
-        }
-        s[p-1] = 0x80 | ((wc>>6)&0x3F);    // Bit 6..11
-    }
-    s[p] = 0x80 | (wc&0x3F);    // Bit 0..5
-    s[0] = (0xFC << (5-p)) | (wc>>(p*6));
-    
-    return p+1;
-}
-
-#endif // #if !defined(SQPLUS_USE_LATIN1) || SQPLUS_USE_LATIN1==0
-
+

+///////////////////////////////////////////////////////////////////////

+// Simple conversion routines, to, from UTF8 and full Unicode character

+// (using int). 

+// 

+

+// Only when needed 

+#if !defined(SQPLUS_USE_LATIN1) || SQPLUS_USE_LATIN1==0

+

+static char g_utf8_length[256];

+static int g_did_init_length; 

+

+void sqplus_init_utf8_lengths() {

+    // Fill in lengths in array above

+    for( int lb=0; lb<256; lb++ ){

+        int l = -1;

+        if( !(lb&0x80) ) l=1;

+        else if( (lb&0xE0)==0xC0 ) l=2;

+        else if( (lb&0xF0)==0xE0 ) l=3;

+        else if( (lb&0xF8)==0xF0 ) l=4;

+        else if( (lb&0xFC)==0xF8 ) l=5;

+        else if( (lb&0xFE)==0xFC ) l=6;

+        g_utf8_length[lb] = l;

+    }

+    g_did_init_length = 1;

+}

+

+// Length of a UTF8 encoded Unicode character

+int sqplus_utf8_len(int lead_byte){

+    if( !(lead_byte&0x80) ) return 1;  // Special case, make faster

+    if( !g_did_init_length )

+        sqplus_init_utf8_lengths();

+        

+    return g_utf8_length[(unsigned char)lead_byte];

+}

+

+int sqplus_utf8_len_first(const char* pc){

+    int lb = *(unsigned char*)pc;

+    if( !(lb&0x80) ) return 1;  // Special case, make faster

+    if( !g_did_init_length )

+        sqplus_init_utf8_lengths();

+

+    int l = g_utf8_length[(unsigned char)lb];

+    if( l>0 ) return l;

+    

+    // Invalid UTF8 lead byte. Look for next valid character. 

+    const char *pc1 = pc+1;

+    while( ((*pc1)&0xC0)==0x80 ) 

+        pc1++;

+    return int(pc1 - pc);

+}

+

+

+// Length of a UTF8 encoded Unicode string (number of Unicode characters)

+int sqplus_utf8_strlen(const char *str) {

+    if( !str ) return 0;

+    int l, tl=0;

+    while( *str ){

+        l = sqplus_utf8_len_first(str);

+        str += l;

+        tl++;

+    }

+    return tl;

+}

+

+// Convert one UTF8 encoded character to Unicode point

+int sqplus_utf8_to_wchar(int *result, const char *string){

+    int res=-1;

+    

+    // Assume argument pointers to be OK

+    unsigned char ch = *string;

+    int l = sqplus_utf8_len(ch);

+    

+    if( l<1  ) return -1;

+    int wc = l>1 ? (ch&(0x7F>>l)) : ch;

+    while( l>1 ){

+        wc = (wc<<6) + (*++string & 0x3F);

+        l--;

+    }

+    *result = wc;

+    

+    return 0;

+}

+

+// Convert one Unicode point to UTF8 encoded version.

+// Checks if output fits in 1/4/6 bytes buffer.

+int sqplus_wchar_to_utf8(char *s, int wc, int size){

+    if( size<1 ) return -1;

+    if( (unsigned int)wc>=0x80000000 ) return -2;

+    

+    // Single byte case

+    if( wc<0x80 ){

+        *s = (char)wc;

+        //*s = (char)wc&0x7F;

+        return 1;

+    }

+    if( size<4 ) return -3;

+

+    // Two or more UTF8 bytes

+    int p = 1;  // Index of last UTF8 byte

+    if( wc>0x7FF ){ // 11 bits

+        // Three or more UTF8 bytes

+        p++; // p>=2

+        if( wc>0xFFFF ){    // 16 bits

+            // Four or more UTF8 bytes

+            p++; // p>=3

+            if( wc>0x1FFFFF ){  // 21 bits

+                // Five or more UTF8 bytes

+                if( size<6 ) return -3;

+                p++; // p>=4 UTF8 bytes

+                if( wc>0x3FFFFFF ){ // 26 bits

+                    // Six UTF8 bytes

+                    p++; // p>=5 

+                    if( (unsigned int)wc>(unsigned int)0x7FFFFFF ){  // 31 bits

+						// Would need 7 UTF8 bytes. Not supported.

+						return -10;

+                    }

+                    s[p-4] = 0x80 | ((wc>>24)&0x3F);    // Bit 24..29

+                }

+                s[p-3] = 0x80 | ((wc>>18)&0x3F);    // Bit 18..23

+            }

+            s[p-2] = 0x80 | ((wc>>12)&0x3F);    // Bit 12..17

+        }

+        s[p-1] = 0x80 | ((wc>>6)&0x3F);    // Bit 6..11

+    }

+    s[p] = 0x80 | (wc&0x3F);    // Bit 0..5

+    s[0] = (0xFC << (5-p)) | (wc>>(p*6));

+    

+    return p+1;

+}

+

+#endif // #if !defined(SQPLUS_USE_LATIN1) || SQPLUS_USE_LATIN1==0

+

diff --git a/squirrel_3_0_1_stable/sqplus/SqPlusUtf8.h b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusUtf8.h
index b0c14aa36..faefcb6c8 100644
--- a/squirrel_3_0_1_stable/sqplus/SqPlusUtf8.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SqPlusUtf8.h
@@ -1,15 +1,15 @@
-#ifndef SQPLUSUTF8_H
-#define SQPLUSUTF8_H
-
-#if defined(SQUTF8) || SQPLUS_USE_LATIN1!=1 
-
-// Simple Unicode <-> UTF8 conversion routines
-//int sqplus_utf8_len(char lead_byte);
-int sqplus_utf8_len_first(const char *str);
-int sqplus_utf8_strlen(const char *str);
-int sqplus_utf8_to_wchar(int *result, const char *string);
-int sqplus_wchar_to_utf8(char *s, int wc, int size);
-
-#endif // defined(SQUTF8) || SQPLUS_USE_LATIN1!=1 
-
-#endif // SQPLUSUTF8_H
+#ifndef SQPLUSUTF8_H

+#define SQPLUSUTF8_H

+

+#if defined(SQUTF8) || SQPLUS_USE_LATIN1!=1 

+

+// Simple Unicode <-> UTF8 conversion routines

+//int sqplus_utf8_len(char lead_byte);

+int sqplus_utf8_len_first(const char *str);

+int sqplus_utf8_strlen(const char *str);

+int sqplus_utf8_to_wchar(int *result, const char *string);

+int sqplus_wchar_to_utf8(char *s, int wc, int size);

+

+#endif // defined(SQUTF8) || SQPLUS_USE_LATIN1!=1 

+

+#endif // SQPLUSUTF8_H

diff --git a/squirrel_3_0_1_stable/sqplus/SquirrelBindingsUtils.cpp b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelBindingsUtils.cpp
index cd337961c..81d1ef4fa 100644
--- a/squirrel_3_0_1_stable/sqplus/SquirrelBindingsUtils.cpp
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelBindingsUtils.cpp
@@ -1,161 +1,161 @@
-#include "sqplus.h"
-
-BOOL CreateStaticNamespace(HSQUIRRELVM v,ScriptNamespaceDecl *sn)
-{
-	int n = 0;
-	sq_pushroottable(v);
-	sq_pushstring(v,sn->name,-1);
-	sq_newtable(v);
-	const ScriptClassMemberDecl *members = sn->members;
-	const ScriptClassMemberDecl *m = NULL;
-	while(members[n].name) {
-		m = &members[n];
-		sq_pushstring(v,m->name,-1);
-		sq_newclosure(v,m->func,0);
-		sq_setparamscheck(v,m->params,m->typemask);
-		sq_setnativeclosurename(v,-1,m->name);
-		sq_createslot(v,-3);
-		n++;
-	}
-	const ScriptConstantDecl *consts = sn->constants;
-	const ScriptConstantDecl *c = NULL;
-	n = 0;
-	while(consts[n].name) {
-		c = &consts[n];
-		sq_pushstring(v,c->name,-1);
-		switch(c->type) {
-		case OT_STRING: sq_pushstring(v,c->val.s,-1);break;
-		case OT_INTEGER: sq_pushinteger(v,c->val.i);break;
-		case OT_FLOAT: sq_pushfloat(v,c->val.f);break;
-		}
-		sq_createslot(v,-3);
-		n++;
-	}
-	if(sn->delegate) {
-		const ScriptClassMemberDecl *members = sn->delegate;
-		const ScriptClassMemberDecl *m = NULL;
-		sq_newtable(v);
-		while(members[n].name) {
-			m = &members[n];
-			sq_pushstring(v,m->name,-1);
-			sq_newclosure(v,m->func,0);
-			sq_setparamscheck(v,m->params,m->typemask);
-			sq_setnativeclosurename(v,-1,m->name);
-			sq_createslot(v,-3);
-			n++;
-		}
-		sq_setdelegate(v,-2);
-	}
-	sq_createslot(v,-3);
-	sq_pop(v,1);
-	
-	return TRUE;
-}
-
-BOOL CreateClass(HSQUIRRELVM v,SquirrelClassDecl *cd)
-{
-	int n = 0;
-	int oldtop = sq_gettop(v);
-	sq_pushroottable(v);
-	sq_pushstring(v,cd->name,-1);
-	if(cd->base) {
-		sq_pushstring(v,cd->base,-1);
-		if(SQ_FAILED(sq_get(v,-3))) { // Make sure the base exists if specified by cd->base name.
-			sq_settop(v,oldtop);
-			return FALSE;
-		}
-	}
-	if(SQ_FAILED(sq_newclass(v,cd->base?1:0))) { // Will inherit from base class on stack from sq_get() above.
-		sq_settop(v,oldtop);
-		return FALSE;
-	}
-//  sq_settypetag(v,-1,(unsigned int)cd);
-#ifdef _WIN32
-#pragma warning(disable : 4311)
-#endif
-	sq_settypetag(v,-1,reinterpret_cast<SQUserPointer>(cd));
-	const ScriptClassMemberDecl *members = cd->members;
-	const ScriptClassMemberDecl *m = NULL;
-  if (members) {
-    while(members[n].name) {
-      m = &members[n];
-      sq_pushstring(v,m->name,-1);
-      sq_newclosure(v,m->func,0);
-      sq_setparamscheck(v,m->params,m->typemask);
-      sq_setnativeclosurename(v,-1,m->name);
-      sq_createslot(v,-3);
-      n++;
-    }
-  } // if
-	sq_createslot(v,-3);
-	sq_pop(v,1);
-	return TRUE;
-}
-
-BOOL CreateNativeClassInstance(HSQUIRRELVM v,
-                               const SQChar *classname,
-                               SQUserPointer ud,
-                               SQRELEASEHOOK hook)
-{
-  // If we don't do this, SquirrelVM keeps an old pointer around and this 
-  // will be used by SquirrelObject. That crashes when using several VMs.
-  SquirrelVM::Init( v );
-  
-  int oldtop = sq_gettop(v);
-  sq_pushroottable(v);
-  sq_pushstring(v,classname,-1);
-  if(SQ_FAILED(sq_rawget(v,-2))){ //Get the class (created with sq_newclass()).
-    sq_settop(v,oldtop);
-    return FALSE;
-  }
-  //sq_pushroottable(v);
-  if(SQ_FAILED(sq_createinstance(v,-1))) {
-    sq_settop(v,oldtop);
-    return FALSE;
-  }
-
-#ifdef SQ_USE_CLASS_INHERITANCE
-  HSQOBJECT ho;
-  sq_getstackobj(v, -1, &ho); // OT_INSTANCE
-  SquirrelObject instance(ho);
-  SqPlus::PopulateAncestry(v, instance, ud);
-#endif
-    
-  sq_remove(v,-3); //removes the root table
-  sq_remove(v,-2); //removes the class
-  if(SQ_FAILED(sq_setinstanceup(v,-1,ud))) {
-    sq_settop(v,oldtop);
-    return FALSE;
-  }
-  sq_setreleasehook(v,-1,hook);
-  return TRUE;
-}
-
-
-
-// Create native class instance and leave on stack.
-BOOL CreateConstructNativeClassInstance(HSQUIRRELVM v,const SQChar * className) {
-  int oldtop = sq_gettop(v);
-  sq_pushroottable(v);
-  sq_pushstring(v,className,-1);
-  if (SQ_FAILED(sq_rawget(v,-2))) { // Get the class (created with sq_newclass()).
-    sq_settop(v,oldtop);
-    return FALSE;
-  } // if
-#if 0
-  sq_remove(v,-3); // Remove the root table.
-  sq_push(v,1);    // Push the 'this'.
-#else // Kamaitati's change. 5/28/06 jcs.
-  sq_remove(v,-2); // Remove the root table.
-  sq_pushroottable(v); // Push the 'this'.
-#endif
-  if (SQ_FAILED(sq_call(v,1,SQTrue,SQ_CALL_RAISE_ERROR))) { // Call ClassName(): creates new instance and calls constructor (instead of sq_createinstance() where constructor is not called).
-    sq_settop(v,oldtop);
-    return FALSE;
-  } // if
-  sq_remove(v,-2); // Remove the class.
-  //  int newtop = sq_gettop(v);
-  return TRUE;
-} // CreateConstructNativeClassInstance
-
-
+#include "sqplus.h"

+

+BOOL CreateStaticNamespace(HSQUIRRELVM v,ScriptNamespaceDecl *sn)

+{

+	int n = 0;

+	sq_pushroottable(v);

+	sq_pushstring(v,sn->name,-1);

+	sq_newtable(v);

+	const ScriptClassMemberDecl *members = sn->members;

+	const ScriptClassMemberDecl *m = NULL;

+	while(members[n].name) {

+		m = &members[n];

+		sq_pushstring(v,m->name,-1);

+		sq_newclosure(v,m->func,0);

+		sq_setparamscheck(v,m->params,m->typemask);

+		sq_setnativeclosurename(v,-1,m->name);

+		sq_createslot(v,-3);

+		n++;

+	}

+	const ScriptConstantDecl *consts = sn->constants;

+	const ScriptConstantDecl *c = NULL;

+	n = 0;

+	while(consts[n].name) {

+		c = &consts[n];

+		sq_pushstring(v,c->name,-1);

+		switch(c->type) {

+		case OT_STRING: sq_pushstring(v,c->val.s,-1);break;

+		case OT_INTEGER: sq_pushinteger(v,c->val.i);break;

+		case OT_FLOAT: sq_pushfloat(v,c->val.f);break;

+		}

+		sq_createslot(v,-3);

+		n++;

+	}

+	if(sn->delegate) {

+		const ScriptClassMemberDecl *members = sn->delegate;

+		const ScriptClassMemberDecl *m = NULL;

+		sq_newtable(v);

+		while(members[n].name) {

+			m = &members[n];

+			sq_pushstring(v,m->name,-1);

+			sq_newclosure(v,m->func,0);

+			sq_setparamscheck(v,m->params,m->typemask);

+			sq_setnativeclosurename(v,-1,m->name);

+			sq_createslot(v,-3);

+			n++;

+		}

+		sq_setdelegate(v,-2);

+	}

+	sq_createslot(v,-3);

+	sq_pop(v,1);

+	

+	return TRUE;

+}

+

+BOOL CreateClass(HSQUIRRELVM v,SquirrelClassDecl *cd)

+{

+	int n = 0;

+	int oldtop = sq_gettop(v);

+	sq_pushroottable(v);

+	sq_pushstring(v,cd->name,-1);

+	if(cd->base) {

+		sq_pushstring(v,cd->base,-1);

+		if(SQ_FAILED(sq_get(v,-3))) { // Make sure the base exists if specified by cd->base name.

+			sq_settop(v,oldtop);

+			return FALSE;

+		}

+	}

+	if(SQ_FAILED(sq_newclass(v,cd->base?1:0))) { // Will inherit from base class on stack from sq_get() above.

+		sq_settop(v,oldtop);

+		return FALSE;

+	}

+//  sq_settypetag(v,-1,(unsigned int)cd);

+#ifdef _WIN32

+#pragma warning(disable : 4311)

+#endif

+	sq_settypetag(v,-1,reinterpret_cast<SQUserPointer>(cd));

+	const ScriptClassMemberDecl *members = cd->members;

+	const ScriptClassMemberDecl *m = NULL;

+  if (members) {

+    while(members[n].name) {

+      m = &members[n];

+      sq_pushstring(v,m->name,-1);

+      sq_newclosure(v,m->func,0);

+      sq_setparamscheck(v,m->params,m->typemask);

+      sq_setnativeclosurename(v,-1,m->name);

+      sq_createslot(v,-3);

+      n++;

+    }

+  } // if

+	sq_createslot(v,-3);

+	sq_pop(v,1);

+	return TRUE;

+}

+

+BOOL CreateNativeClassInstance(HSQUIRRELVM v,

+                               const SQChar *classname,

+                               SQUserPointer ud,

+                               SQRELEASEHOOK hook)

+{

+  // If we don't do this, SquirrelVM keeps an old pointer around and this 

+  // will be used by SquirrelObject. That crashes when using several VMs.

+  SquirrelVM::Init( v );

+  

+  int oldtop = sq_gettop(v);

+  sq_pushroottable(v);

+  sq_pushstring(v,classname,-1);

+  if(SQ_FAILED(sq_rawget(v,-2))){ //Get the class (created with sq_newclass()).

+    sq_settop(v,oldtop);

+    return FALSE;

+  }

+  //sq_pushroottable(v);

+  if(SQ_FAILED(sq_createinstance(v,-1))) {

+    sq_settop(v,oldtop);

+    return FALSE;

+  }

+

+#ifdef SQ_USE_CLASS_INHERITANCE

+  HSQOBJECT ho;

+  sq_getstackobj(v, -1, &ho); // OT_INSTANCE

+  SquirrelObject instance(ho);

+  SqPlus::PopulateAncestry(v, instance, ud);

+#endif

+    

+  sq_remove(v,-3); //removes the root table

+  sq_remove(v,-2); //removes the class

+  if(SQ_FAILED(sq_setinstanceup(v,-1,ud))) {

+    sq_settop(v,oldtop);

+    return FALSE;

+  }

+  sq_setreleasehook(v,-1,hook);

+  return TRUE;

+}

+

+

+

+// Create native class instance and leave on stack.

+BOOL CreateConstructNativeClassInstance(HSQUIRRELVM v,const SQChar * className) {

+  int oldtop = sq_gettop(v);

+  sq_pushroottable(v);

+  sq_pushstring(v,className,-1);

+  if (SQ_FAILED(sq_rawget(v,-2))) { // Get the class (created with sq_newclass()).

+    sq_settop(v,oldtop);

+    return FALSE;

+  } // if

+#if 0

+  sq_remove(v,-3); // Remove the root table.

+  sq_push(v,1);    // Push the 'this'.

+#else // Kamaitati's change. 5/28/06 jcs.

+  sq_remove(v,-2); // Remove the root table.

+  sq_pushroottable(v); // Push the 'this'.

+#endif

+  if (SQ_FAILED(sq_call(v,1,SQTrue,SQ_CALL_RAISE_ERROR))) { // Call ClassName(): creates new instance and calls constructor (instead of sq_createinstance() where constructor is not called).

+    sq_settop(v,oldtop);

+    return FALSE;

+  } // if

+  sq_remove(v,-2); // Remove the class.

+  //  int newtop = sq_gettop(v);

+  return TRUE;

+} // CreateConstructNativeClassInstance

+

+

diff --git a/squirrel_3_0_1_stable/sqplus/SquirrelBindingsUtils.h b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelBindingsUtils.h
index 11ab4be54..5f727c263 100644
--- a/squirrel_3_0_1_stable/sqplus/SquirrelBindingsUtils.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelBindingsUtils.h
@@ -1,152 +1,152 @@
-#ifndef SQUIRREL_BINDINGS_UTILS_H
-#define SQUIRREL_BINDINGS_UTILS_H
-
-struct ScriptClassMemberDecl  {
-	const SQChar *name;
-	SQFUNCTION func;
-	int params;
-	const SQChar *typemask;
-};
-
-struct SquirrelClassDecl  {
-	const SQChar *name;
-	const SQChar *base;
-	const ScriptClassMemberDecl *members;
-};
-
-struct ScriptConstantDecl  {
-	const SQChar *name;
-	SQObjectType type;
-	union value {
-		value(float v){ f = v; }
-		value(int v){ i = v; }
-		value(long int v){ li = v; }
-		value(const SQChar *v){ s = v; }
-		float f;
-		int i;
-		long int li;
-		const SQChar *s;
-	} val;
-};
-
-struct ScriptNamespaceDecl  {
-	const SQChar *name;
-	const ScriptClassMemberDecl *members;
-	const ScriptConstantDecl *constants;
-	const ScriptClassMemberDecl *delegate;
-};
-
-#define _BEGIN_CLASS(classname)  \
-		int __##classname##__typeof(HSQUIRRELVM v) \
-		{ \
-			sq_pushstring(v,_SC(#classname),-1); \
-			return 1; \
-		} \
-		struct ScriptClassMemberDecl __##classname##_members[] = { \
-		{_SC("_typeof"),__##classname##__typeof,1,NULL},
-
-#define _BEGIN_NAMESPACE(xnamespace) struct ScriptClassMemberDecl __##xnamespace##_members[] = {
-#define _BEGIN_NAMESPACE_CONSTANTS(xnamespace) {NULL,NULL,0,NULL}}; \
-	struct ScriptConstantDecl __##xnamespace##_constants[] = {
-
-#define _BEGIN_DELEGATE(xnamespace) struct ScriptClassMemberDecl __##xnamespace##_delegate[] = {
-#define _DELEGATE(xnamespace) __##xnamespace##_delegate
-#define _END_DELEGATE(classname) {NULL,NULL,NULL,NULL}};
-
-#define _CONSTANT(name,type,val) {_SC(#name),type,val},
-#define _CONSTANT_IMPL(name,type) {_SC(#name),type,name},
-
-#define _MEMBER_FUNCTION(classname,name,nparams,typemask) \
-	{_SC(#name),__##classname##_##name,nparams,typemask},
-
-#define _END_NAMESPACE(classname,delegate) {NULL,OT_NULL,0}}; \
-struct ScriptNamespaceDecl __##classname##_decl = {   \
-	_SC(#classname), __##classname##_members,__##classname##_constants,delegate };
-
-#define _END_CLASS(classname) {NULL,NULL,0,NULL}}; \
-struct SquirrelClassDecl __##classname##_decl = {  \
-	_SC(#classname), NULL, __##classname##_members };
-
-
-#define _END_CLASS_INHERITANCE(classname,base) {NULL,NULL,NULL,NULL}}; \
-struct SquirrelClassDecl __##classname##_decl = {  \
-	_SC(#classname), _SC(#base), __##classname##_members };
-
-#define _MEMBER_FUNCTION_IMPL(classname,name) \
-	int __##classname##_##name(HSQUIRRELVM v)
-
-#define _INIT_STATIC_NAMESPACE(classname) CreateStaticNamespace(SquirrelVM::GetVMPtr(),&__##classname##_decl);
-#define _INIT_CLASS(classname)CreateClass(SquirrelVM::GetVMPtr(),&__##classname##_decl);
-
-#define _DECL_STATIC_NAMESPACE(xnamespace) extern struct ScriptNamespaceDecl __##xnamespace##_decl;
-#define _DECL_CLASS(classname) extern struct SquirrelClassDecl __##classname##_decl;
-
-#define _CHECK_SELF(cppclass,scriptclass) \
-	cppclass *self = NULL; \
-	if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)&__##scriptclass##_decl))) { \
-		return sq_throwerror(v,_SC("invalid instance type"));\
-	}
-
-#define _CHECK_INST_PARAM(pname,idx,cppclass,scriptclass)  \
-	cppclass *pname = NULL; \
-	if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer*)&pname,(SQUserPointer)&__##scriptclass##_decl))) { \
-		return sq_throwerror(v,_SC("invalid instance type"));\
-	} \
-
-#define _CHECK_INST_PARAM_BREAK(pname,idx,cppclass,scriptclass)  \
-	cppclass *pname = NULL; \
-	if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer*)&pname,(SQUserPointer)&__##scriptclass##_decl))) { \
-		break; \
-	} \
-
-#define _CLASS_TAG(classname) ((unsigned int)&__##classname##_decl)
-
-
-#define _DECL_NATIVE_CONSTRUCTION(classname,cppclass) \
-	BOOL push_##classname(cppclass &quat); \
-	SquirrelObject new_##classname(cppclass &quat);
-
-#define _IMPL_NATIVE_CONSTRUCTION(classname,cppclass) \
-static int classname##_release_hook(SQUserPointer p, int size) \
-{ \
-	if(p) { \
-		cppclass *pv = (cppclass *)p; \
-		delete pv; \
-	} \
-	return 0; \
-} \
-BOOL push_##classname(cppclass &quat) \
-{ \
-	cppclass *newquat = new cppclass; \
-	*newquat = quat; \
-	if(!CreateNativeClassInstance(SquirrelVM::GetVMPtr(),_SC(#classname),newquat,classname##_release_hook)) { \
-		delete newquat; \
-		return FALSE; \
-	} \
-	return TRUE; \
-} \
-SquirrelObject new_##classname(cppclass &quat) \
-{ \
-	SquirrelObject ret; \
-	if(push_##classname(quat)) { \
-		ret.AttachToStackObject(-1); \
-		sq_pop(SquirrelVM::GetVMPtr(),1); \
-	} \
-	return ret; \
-} \
-int construct_##classname(cppclass *p) \
-{ \
-	sq_setinstanceup(SquirrelVM::GetVMPtr(),1,p); \
-	sq_setreleasehook(SquirrelVM::GetVMPtr(),1,classname##_release_hook); \
-	return 1; \
-}
-
-BOOL CreateStaticClass(HSQUIRRELVM v,SquirrelClassDecl *cd);
-BOOL CreateStaticNamespace(HSQUIRRELVM v,ScriptNamespaceDecl *sn);
-BOOL CreateClass(HSQUIRRELVM v,SquirrelClassDecl *cd);
-BOOL InitScriptClasses(HSQUIRRELVM v);
-BOOL CreateNativeClassInstance(HSQUIRRELVM v,const SQChar *classname,SQUserPointer ud,SQRELEASEHOOK hook);
-BOOL CreateConstructNativeClassInstance(HSQUIRRELVM v,const SQChar * className);
-
-#endif // SQUIRREL_BINDINGS_UTILS_H
-
+#ifndef SQUIRREL_BINDINGS_UTILS_H

+#define SQUIRREL_BINDINGS_UTILS_H

+

+struct ScriptClassMemberDecl  {

+	const SQChar *name;

+	SQFUNCTION func;

+	int params;

+	const SQChar *typemask;

+};

+

+struct SquirrelClassDecl  {

+	const SQChar *name;

+	const SQChar *base;

+	const ScriptClassMemberDecl *members;

+};

+

+struct ScriptConstantDecl  {

+	const SQChar *name;

+	SQObjectType type;

+	union value {

+		value(float v){ f = v; }

+		value(int v){ i = v; }

+		value(long int v){ li = v; }

+		value(const SQChar *v){ s = v; }

+		float f;

+		int i;

+		long int li;

+		const SQChar *s;

+	} val;

+};

+

+struct ScriptNamespaceDecl  {

+	const SQChar *name;

+	const ScriptClassMemberDecl *members;

+	const ScriptConstantDecl *constants;

+	const ScriptClassMemberDecl *delegate;

+};

+

+#define _BEGIN_CLASS(classname)  \

+		int __##classname##__typeof(HSQUIRRELVM v) \

+		{ \

+			sq_pushstring(v,_SC(#classname),-1); \

+			return 1; \

+		} \

+		struct ScriptClassMemberDecl __##classname##_members[] = { \

+		{_SC("_typeof"),__##classname##__typeof,1,NULL},

+

+#define _BEGIN_NAMESPACE(xnamespace) struct ScriptClassMemberDecl __##xnamespace##_members[] = {

+#define _BEGIN_NAMESPACE_CONSTANTS(xnamespace) {NULL,NULL,0,NULL}}; \

+	struct ScriptConstantDecl __##xnamespace##_constants[] = {

+

+#define _BEGIN_DELEGATE(xnamespace) struct ScriptClassMemberDecl __##xnamespace##_delegate[] = {

+#define _DELEGATE(xnamespace) __##xnamespace##_delegate

+#define _END_DELEGATE(classname) {NULL,NULL,NULL,NULL}};

+

+#define _CONSTANT(name,type,val) {_SC(#name),type,val},

+#define _CONSTANT_IMPL(name,type) {_SC(#name),type,name},

+

+#define _MEMBER_FUNCTION(classname,name,nparams,typemask) \

+	{_SC(#name),__##classname##_##name,nparams,typemask},

+

+#define _END_NAMESPACE(classname,delegate) {NULL,OT_NULL,0}}; \

+struct ScriptNamespaceDecl __##classname##_decl = {   \

+	_SC(#classname), __##classname##_members,__##classname##_constants,delegate };

+

+#define _END_CLASS(classname) {NULL,NULL,0,NULL}}; \

+struct SquirrelClassDecl __##classname##_decl = {  \

+	_SC(#classname), NULL, __##classname##_members };

+

+

+#define _END_CLASS_INHERITANCE(classname,base) {NULL,NULL,NULL,NULL}}; \

+struct SquirrelClassDecl __##classname##_decl = {  \

+	_SC(#classname), _SC(#base), __##classname##_members };

+

+#define _MEMBER_FUNCTION_IMPL(classname,name) \

+	int __##classname##_##name(HSQUIRRELVM v)

+

+#define _INIT_STATIC_NAMESPACE(classname) CreateStaticNamespace(SquirrelVM::GetVMPtr(),&__##classname##_decl);

+#define _INIT_CLASS(classname)CreateClass(SquirrelVM::GetVMPtr(),&__##classname##_decl);

+

+#define _DECL_STATIC_NAMESPACE(xnamespace) extern struct ScriptNamespaceDecl __##xnamespace##_decl;

+#define _DECL_CLASS(classname) extern struct SquirrelClassDecl __##classname##_decl;

+

+#define _CHECK_SELF(cppclass,scriptclass) \

+	cppclass *self = NULL; \

+	if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)&__##scriptclass##_decl))) { \

+		return sq_throwerror(v,_SC("invalid instance type"));\

+	}

+

+#define _CHECK_INST_PARAM(pname,idx,cppclass,scriptclass)  \

+	cppclass *pname = NULL; \

+	if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer*)&pname,(SQUserPointer)&__##scriptclass##_decl))) { \

+		return sq_throwerror(v,_SC("invalid instance type"));\

+	} \

+

+#define _CHECK_INST_PARAM_BREAK(pname,idx,cppclass,scriptclass)  \

+	cppclass *pname = NULL; \

+	if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer*)&pname,(SQUserPointer)&__##scriptclass##_decl))) { \

+		break; \

+	} \

+

+#define _CLASS_TAG(classname) ((unsigned int)&__##classname##_decl)

+

+

+#define _DECL_NATIVE_CONSTRUCTION(classname,cppclass) \

+	BOOL push_##classname(cppclass &quat); \

+	SquirrelObject new_##classname(cppclass &quat);

+

+#define _IMPL_NATIVE_CONSTRUCTION(classname,cppclass) \

+static int classname##_release_hook(SQUserPointer p, int size) \

+{ \

+	if(p) { \

+		cppclass *pv = (cppclass *)p; \

+		delete pv; \

+	} \

+	return 0; \

+} \

+BOOL push_##classname(cppclass &quat) \

+{ \

+	cppclass *newquat = new cppclass; \

+	*newquat = quat; \

+	if(!CreateNativeClassInstance(SquirrelVM::GetVMPtr(),_SC(#classname),newquat,classname##_release_hook)) { \

+		delete newquat; \

+		return FALSE; \

+	} \

+	return TRUE; \

+} \

+SquirrelObject new_##classname(cppclass &quat) \

+{ \

+	SquirrelObject ret; \

+	if(push_##classname(quat)) { \

+		ret.AttachToStackObject(-1); \

+		sq_pop(SquirrelVM::GetVMPtr(),1); \

+	} \

+	return ret; \

+} \

+int construct_##classname(cppclass *p) \

+{ \

+	sq_setinstanceup(SquirrelVM::GetVMPtr(),1,p); \

+	sq_setreleasehook(SquirrelVM::GetVMPtr(),1,classname##_release_hook); \

+	return 1; \

+}

+

+BOOL CreateStaticClass(HSQUIRRELVM v,SquirrelClassDecl *cd);

+BOOL CreateStaticNamespace(HSQUIRRELVM v,ScriptNamespaceDecl *sn);

+BOOL CreateClass(HSQUIRRELVM v,SquirrelClassDecl *cd);

+BOOL InitScriptClasses(HSQUIRRELVM v);

+BOOL CreateNativeClassInstance(HSQUIRRELVM v,const SQChar *classname,SQUserPointer ud,SQRELEASEHOOK hook);

+BOOL CreateConstructNativeClassInstance(HSQUIRRELVM v,const SQChar * className);

+

+#endif // SQUIRREL_BINDINGS_UTILS_H

+

diff --git a/squirrel_3_0_1_stable/sqplus/SquirrelBindingsUtilsWin32.cpp b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelBindingsUtilsWin32.cpp
index dd3f850ca..448c49f25 100644
--- a/squirrel_3_0_1_stable/sqplus/SquirrelBindingsUtilsWin32.cpp
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelBindingsUtilsWin32.cpp
@@ -1,31 +1,31 @@
-#include "sqplus.h"
-
-//#include "SquirrelObject.h"
-//#include "SquirrelVM.h"
-#include "SquirrelBindingsUtilsWin32.h"
-
-int refcounted_release_hook(SQUserPointer p, int size)
-{
-	IUnknown *pRC = (IUnknown*)p;
-	pRC->Release();
-	return 0;
-}
-
-static BOOL __CreateRefCountedInstance(HSQUIRRELVM v,const SQChar *classname,IUnknown *pRC,SQRELEASEHOOK hook)
-{
-	if(!CreateNativeClassInstance(v,classname,pRC,hook)) return FALSE;
-	return TRUE;
-}
-
-int construct_RefCounted(IUnknown *p)
-{
-	sq_setinstanceup(SquirrelVM::GetVMPtr(),1,p);
-	sq_setreleasehook(SquirrelVM::GetVMPtr(),1,refcounted_release_hook);
-	return 1;
-}
-
-
-BOOL CreateRefCountedInstance(HSQUIRRELVM v,const SQChar *classname,IUnknown *pRC)
-{
-	return __CreateRefCountedInstance(v,classname,pRC,refcounted_release_hook);
-}
+#include "sqplus.h"

+

+//#include "SquirrelObject.h"

+//#include "SquirrelVM.h"

+#include "SquirrelBindingsUtilsWin32.h"

+

+int refcounted_release_hook(SQUserPointer p, int size)

+{

+	IUnknown *pRC = (IUnknown*)p;

+	pRC->Release();

+	return 0;

+}

+

+static BOOL __CreateRefCountedInstance(HSQUIRRELVM v,const SQChar *classname,IUnknown *pRC,SQRELEASEHOOK hook)

+{

+	if(!CreateNativeClassInstance(v,classname,pRC,hook)) return FALSE;

+	return TRUE;

+}

+

+int construct_RefCounted(IUnknown *p)

+{

+	sq_setinstanceup(SquirrelVM::GetVMPtr(),1,p);

+	sq_setreleasehook(SquirrelVM::GetVMPtr(),1,refcounted_release_hook);

+	return 1;

+}

+

+

+BOOL CreateRefCountedInstance(HSQUIRRELVM v,const SQChar *classname,IUnknown *pRC)

+{

+	return __CreateRefCountedInstance(v,classname,pRC,refcounted_release_hook);

+}

diff --git a/squirrel_3_0_1_stable/sqplus/SquirrelBindingsUtilsWin32.h b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelBindingsUtilsWin32.h
index 3f3358422..0acd05147 100644
--- a/squirrel_3_0_1_stable/sqplus/SquirrelBindingsUtilsWin32.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelBindingsUtilsWin32.h
@@ -1,41 +1,41 @@
-#ifndef SQUIRREL_BINDINGS_UTILS_WIN32_H
-#define SQUIRREL_BINDINGS_UTILS_WIN32_H
-
-#ifndef _INC_WINDOWS
-#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
-// Windows Header Files:
-#include <windows.h>
-#endif
-#ifndef __IUnknown_INTERFACE_DEFINED__
-#include <unknwn.h>
-#endif
-
-#ifndef SQUIRREL_BINDINGS_UTILS_H
-#include "SquirrelBindingsUtils.h"
-#endif
-
-#define _DECLARE_REFCOUNTED_NEW(cppclass,classname) \
-	SquirrelObject new_##classname(cppclass *ptr) { \
-		if(CreateRefCountedInstance(SquirrelVM::GetVMPtr(),_SC(#classname),ptr)) { \
-			HSQOBJECT o; \
-			sq_getstackobj(SquirrelVM::GetVMPtr(),-1,&o); \
-			SquirrelObject tmp = o; \
-			sq_pop(SquirrelVM::GetVMPtr(),1); \
-			return tmp; \
-		} \
-		return SquirrelObject() ; \
-	}
-
-#define _RETURN_REFCOUNTED_INSTANCE(classname,ptr) \
-	if(!CreateRefCountedInstance(SquirrelVM::GetVMPtr(),_SC(#classname),ptr)) { \
-		return sa.ThrowError(_SC("cannot create the class instance")); \
-	} \
-	return 1;
-
-BOOL CreateRefCountedInstance(HSQUIRRELVM v,const SQChar *classname,IUnknown *pRC);
-BOOL CreateRefCountedInstanceChached(HSQUIRRELVM v,const SQChar *classname,IUnknown *pRC);
-int refcounted_release_hook(SQUserPointer p, int size);
-int construct_RefCounted(IUnknown *p);
-
-#endif // SQUIRREL_BINDINGS_UTILS_WIN32_H
-
+#ifndef SQUIRREL_BINDINGS_UTILS_WIN32_H

+#define SQUIRREL_BINDINGS_UTILS_WIN32_H

+

+#ifndef _INC_WINDOWS

+#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers

+// Windows Header Files:

+#include <windows.h>

+#endif

+#ifndef __IUnknown_INTERFACE_DEFINED__

+#include <unknwn.h>

+#endif

+

+#ifndef SQUIRREL_BINDINGS_UTILS_H

+#include "SquirrelBindingsUtils.h"

+#endif

+

+#define _DECLARE_REFCOUNTED_NEW(cppclass,classname) \

+	SquirrelObject new_##classname(cppclass *ptr) { \

+		if(CreateRefCountedInstance(SquirrelVM::GetVMPtr(),_SC(#classname),ptr)) { \

+			HSQOBJECT o; \

+			sq_getstackobj(SquirrelVM::GetVMPtr(),-1,&o); \

+			SquirrelObject tmp = o; \

+			sq_pop(SquirrelVM::GetVMPtr(),1); \

+			return tmp; \

+		} \

+		return SquirrelObject() ; \

+	}

+

+#define _RETURN_REFCOUNTED_INSTANCE(classname,ptr) \

+	if(!CreateRefCountedInstance(SquirrelVM::GetVMPtr(),_SC(#classname),ptr)) { \

+		return sa.ThrowError(_SC("cannot create the class instance")); \

+	} \

+	return 1;

+

+BOOL CreateRefCountedInstance(HSQUIRRELVM v,const SQChar *classname,IUnknown *pRC);

+BOOL CreateRefCountedInstanceChached(HSQUIRRELVM v,const SQChar *classname,IUnknown *pRC);

+int refcounted_release_hook(SQUserPointer p, int size);

+int construct_RefCounted(IUnknown *p);

+

+#endif // SQUIRREL_BINDINGS_UTILS_WIN32_H

+

diff --git a/squirrel_3_0_1_stable/sqplus/SquirrelObject.cpp b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelObject.cpp
index 58d43bbed..90ffead80 100644
--- a/squirrel_3_0_1_stable/sqplus/SquirrelObject.cpp
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelObject.cpp
@@ -1,702 +1,702 @@
-#include "sqplus.h"
-
-SquirrelObject::SquirrelObject(void)
-{
-	 sq_resetobject(&_o);
-}
-
-SquirrelObject::~SquirrelObject()
-{
-    Reset();
-}
-
-SquirrelObject::SquirrelObject(const SquirrelObject &o)
-{
-	_o = o._o;
-	sq_addref(SquirrelVM::_VM,&_o);
-}
-
-SquirrelObject::SquirrelObject(HSQOBJECT o)
-{
-	_o = o;
-	sq_addref(SquirrelVM::_VM,&_o);
-}
-
-void SquirrelObject::Reset(void) {
-  if(SquirrelVM::_VM)
-    sq_release(SquirrelVM::_VM,&_o);
-  else if( _o._type!=OT_NULL && _o._unVal.pRefCounted )
-    printf( "SquirrelObject::~SquirrelObject - Cannot release\n" ); 
-  sq_resetobject(&_o);
-} // SquirrelObject::Reset
-
-SquirrelObject SquirrelObject::Clone()
-{
-	SquirrelObject ret;
-	if(GetType() == OT_TABLE || GetType() == OT_ARRAY)
-	{
-		sq_pushobject(SquirrelVM::_VM,_o);
-		sq_clone(SquirrelVM::_VM,-1);
-		ret.AttachToStackObject(-1);
-		sq_pop(SquirrelVM::_VM,2);
-	}
-	return ret;
-
-}
-
-SquirrelObject & SquirrelObject::operator =(const SquirrelObject &o)
-{
-	//HSQOBJECT t;
-	//t = o._o;
-	//sq_addref(SquirrelVM::_VM,&t);
-	sq_addref(SquirrelVM::_VM, (HSQOBJECT*)&o._o);
-	sq_release(SquirrelVM::_VM,&_o);
-	//_o = t;
-	_o = o._o;
-	return *this;
-}
-
-SquirrelObject & SquirrelObject::operator =(HSQOBJECT ho)
-{
-	sq_addref(SquirrelVM::_VM,&ho);
-	sq_release(SquirrelVM::_VM,&_o);
-	_o = ho;
-	return *this;
-}
-
-SquirrelObject & SquirrelObject::operator =(int n)
-{
-	sq_pushinteger(SquirrelVM::_VM,n);
-	AttachToStackObject(-1);
-	sq_pop(SquirrelVM::_VM,1);
-	return *this;
-}
-
-#include <assert.h>
-#include "../squirrel/sqstate.h"
-#include "../squirrel/sqvm.h"
-
-SquirrelObject & SquirrelObject::operator =(HSQUIRRELVM v)
-{
-    if( v && SquirrelVM::_VM ){
-    	SquirrelVM::_VM->Push(v);
-        AttachToStackObject(-1);
-        sq_poptop(SquirrelVM::_VM);
-    }
-    else Reset();
-	return *this;
-}
-
-bool SquirrelObject::operator == (const SquirrelObject &o)
-{
-    bool cmp = false;
-    HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-    int oldtop = sq_gettop(v);
-    
-    sq_pushobject(v, GetObjectHandle());
-    sq_pushobject(v, o.GetObjectHandle());
-    if(sq_cmp(v) == 0)
-        cmp = true;
-   
-    sq_settop(v, oldtop);
-    return cmp;
-}
-
-bool SquirrelObject::CompareUserPointer( const SquirrelObject &o )
-{
-    if( _o._type == o.GetObjectHandle()._type )
-        if( _o._unVal.pUserPointer == o.GetObjectHandle()._unVal.pUserPointer )
-            return true;
-
-    return false;
-}
-
-void SquirrelObject::ArrayAppend(const SquirrelObject &o)
-{
-	if(sq_isarray(_o)) {
-		sq_pushobject(SquirrelVM::_VM,_o);
-		sq_pushobject(SquirrelVM::_VM,o._o);
-		sq_arrayappend(SquirrelVM::_VM,-2);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-}
-
-void SquirrelObject::AttachToStackObject(int idx)
-{
-	HSQOBJECT t;
-	sq_getstackobj(SquirrelVM::_VM,idx,&t);
-	sq_addref(SquirrelVM::_VM,&t);
-	sq_release(SquirrelVM::_VM,&_o);
-	_o = t;
-}
-
-BOOL SquirrelObject::SetDelegate(SquirrelObject &obj)
-{
-	if(obj.GetType() == OT_TABLE ||
-		obj.GetType() == OT_NULL) {
-			switch(_o._type) {
-				case OT_USERDATA:
-				case OT_TABLE:
-					sq_pushobject(SquirrelVM::_VM,_o);
-					sq_pushobject(SquirrelVM::_VM,obj._o);
-					if(SQ_SUCCEEDED(sq_setdelegate(SquirrelVM::_VM,-2))) {
-					  sq_pop(SquirrelVM::_VM,1);
-					  return TRUE;
-					}
-					sq_pop(SquirrelVM::_VM,1);
-					break;
-			}
-	}
-	return FALSE;
-}
-
-SquirrelObject SquirrelObject::GetDelegate()
-{
-	SquirrelObject ret;
-	if(_o._type == OT_TABLE || _o._type == OT_USERDATA)
-	{
-    int top = sq_gettop(SquirrelVM::_VM);
-		sq_pushobject(SquirrelVM::_VM,_o);
-		sq_getdelegate(SquirrelVM::_VM,-1);
-		ret.AttachToStackObject(-1);
-    sq_settop(SquirrelVM::_VM,top);
-//		sq_pop(SquirrelVM::_VM,2);
-	}
-	return ret;
-}
-
-BOOL SquirrelObject::IsNull() const
-{
-	return sq_isnull(_o);
-}
-
-BOOL SquirrelObject::IsNumeric() const
-{
-	return sq_isnumeric(_o);
-}
-
-int SquirrelObject::Len() const
-{
-	int ret = 0;
-	if(sq_isarray(_o) || sq_istable(_o) || sq_isstring(_o)) {
-		sq_pushobject(SquirrelVM::_VM,_o);
-		ret = sq_getsize(SquirrelVM::_VM,-1);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	return ret;
-}
-
-#define _SETVALUE_INT_BEGIN \
-	BOOL ret = FALSE; \
-	int top = sq_gettop(SquirrelVM::_VM); \
-	sq_pushobject(SquirrelVM::_VM,_o); \
-	sq_pushinteger(SquirrelVM::_VM,key);
-
-#define _SETVALUE_INT_END \
-	if(SQ_SUCCEEDED(sq_rawset(SquirrelVM::_VM,-3))) { \
-		ret = TRUE; \
-	} \
-	sq_settop(SquirrelVM::_VM,top); \
-	return ret;
-
-BOOL SquirrelObject::SetValue(INT key,const SquirrelObject &val)
-{
-	_SETVALUE_INT_BEGIN
-	sq_pushobject(SquirrelVM::_VM,val._o);
-	_SETVALUE_INT_END
-}
-
-BOOL SquirrelObject::SetValue(INT key,INT n)
-{
-	_SETVALUE_INT_BEGIN
-	sq_pushinteger(SquirrelVM::_VM,n);
-	_SETVALUE_INT_END
-}
-
-BOOL SquirrelObject::SetValue(INT key,FLOAT f)
-{
-	_SETVALUE_INT_BEGIN
-	sq_pushfloat(SquirrelVM::_VM,f);
-	_SETVALUE_INT_END
-}
-
-BOOL SquirrelObject::SetValue(INT key,const SQChar *s)
-{
-	_SETVALUE_INT_BEGIN
-	sq_pushstring(SquirrelVM::_VM,s,-1);
-	_SETVALUE_INT_END
-}
-
-BOOL SquirrelObject::SetValue(INT key,bool b)
-{
-	_SETVALUE_INT_BEGIN
-	sq_pushbool(SquirrelVM::_VM,b);
-	_SETVALUE_INT_END
-}
-
-BOOL SquirrelObject::SetValue(const SquirrelObject &key,const SquirrelObject &val)
-{
-	BOOL ret = FALSE;
-	int top = sq_gettop(SquirrelVM::_VM);
-	sq_pushobject(SquirrelVM::_VM,_o);
-	sq_pushobject(SquirrelVM::_VM,key._o);
-	sq_pushobject(SquirrelVM::_VM,val._o);
-	if(SQ_SUCCEEDED(sq_rawset(SquirrelVM::_VM,-3))) {
-		ret = TRUE;
-	}
-	sq_settop(SquirrelVM::_VM,top);
-	return ret;
-}
-
-#define _SETVALUE_STR_BEGIN \
-	BOOL ret = FALSE; \
-	int top = sq_gettop(SquirrelVM::_VM); \
-	sq_pushobject(SquirrelVM::_VM,_o); \
-	sq_pushstring(SquirrelVM::_VM,key,-1);
-
-#define _SETVALUE_STR_END \
-	if(SQ_SUCCEEDED(sq_rawset(SquirrelVM::_VM,-3))) { \
-		ret = TRUE; \
-	} \
-	sq_settop(SquirrelVM::_VM,top); \
-	return ret;
-
-BOOL SquirrelObject::SetValue(const SQChar *key,const SquirrelObject &val)
-{
-	_SETVALUE_STR_BEGIN
-	sq_pushobject(SquirrelVM::_VM,val._o);
-	_SETVALUE_STR_END
-}
-
-BOOL SquirrelObject::SetValue(const SQChar *key,INT n)
-{
-	_SETVALUE_STR_BEGIN
-	sq_pushinteger(SquirrelVM::_VM,n);
-	_SETVALUE_STR_END
-}
-
-BOOL SquirrelObject::SetValue(const SQChar *key,FLOAT f)
-{
-	_SETVALUE_STR_BEGIN
-	sq_pushfloat(SquirrelVM::_VM,f);
-	_SETVALUE_STR_END
-}
-
-BOOL SquirrelObject::SetValue(const SQChar *key,const SQChar *s)
-{
-	_SETVALUE_STR_BEGIN
-	sq_pushstring(SquirrelVM::_VM,s,-1);
-	_SETVALUE_STR_END
-}
-
-BOOL SquirrelObject::SetValue(const SQChar *key,bool b)
-{
-	_SETVALUE_STR_BEGIN
-	sq_pushbool(SquirrelVM::_VM,b);
-	_SETVALUE_STR_END
-}
-
-// === BEGIN User Pointer, User Data ===
-
-BOOL SquirrelObject::SetUserPointer(const SQChar * key,SQUserPointer up) {
-  _SETVALUE_STR_BEGIN
-  sq_pushuserpointer(SquirrelVM::_VM,up);
-  _SETVALUE_STR_END
-} // SquirrelObject::SetUserPointer
-
-SQUserPointer SquirrelObject::GetUserPointer(const SQChar * key) {
-  SQUserPointer ret = NULL;
-  if (GetSlot(key)) {
-    sq_getuserpointer(SquirrelVM::_VM,-1,&ret);
-    sq_pop(SquirrelVM::_VM,1);
-  } // if
-  sq_pop(SquirrelVM::_VM,1);
-  return ret;
-} // SquirrelObject::GetUserPointer
-
-BOOL SquirrelObject::SetUserPointer(INT key,SQUserPointer up) {
-  _SETVALUE_INT_BEGIN
-  sq_pushuserpointer(SquirrelVM::_VM,up);
-  _SETVALUE_INT_END
-} // SquirrelObject::SetUserPointer
-
-SQUserPointer SquirrelObject::GetUserPointer(INT key) {
-  SQUserPointer ret = NULL;
-  if (GetSlot(key)) {
-    sq_getuserpointer(SquirrelVM::_VM,-1,&ret);
-    sq_pop(SquirrelVM::_VM,1);
-  } // if
-  sq_pop(SquirrelVM::_VM,1);
-  return ret;
-} // SquirrelObject::GetUserPointer
-
-// === User Data ===
-
-BOOL SquirrelObject::NewUserData(const SQChar * key,INT size,SQUserPointer * typetag) {
-  _SETVALUE_STR_BEGIN
-  sq_newuserdata(SquirrelVM::_VM,size);
-  if (typetag) {
-    sq_settypetag(SquirrelVM::_VM,-1,typetag);
-  } // if
-  _SETVALUE_STR_END
-} // SquirrelObject::NewUserData
-
-BOOL SquirrelObject::GetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag) {
-  BOOL ret = false;
-  if (GetSlot(key)) {
-    sq_getuserdata(SquirrelVM::_VM,-1,data,typetag);
-    sq_pop(SquirrelVM::_VM,1);
-    ret = true;
-  } // if
-  sq_pop(SquirrelVM::_VM,1);
-  return ret;
-} // SquirrelObject::GetUserData
-
-BOOL SquirrelObject::RawGetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag) {
-  BOOL ret = false;
-  if (RawGetSlot(key)) {
-    sq_getuserdata(SquirrelVM::_VM,-1,data,typetag);
-    sq_pop(SquirrelVM::_VM,1);
-    ret = true;
-  } // if
-  sq_pop(SquirrelVM::_VM,1);
-  return ret;
-} // SquirrelObject::RawGetUserData
-
-// === END User Pointer ===
-
-// === BEGIN Arrays ===
-
-BOOL SquirrelObject::ArrayResize(INT newSize) {
-//  int top = sq_gettop(SquirrelVM::_VM);
-  sq_pushobject(SquirrelVM::_VM,GetObjectHandle());
-  BOOL res = sq_arrayresize(SquirrelVM::_VM,-1,newSize) == SQ_OK;
-  sq_pop(SquirrelVM::_VM,1);
-//  sq_settop(SquirrelVM::_VM,top);
-  return res;
-} // SquirrelObject::ArrayResize
-
-BOOL SquirrelObject::ArrayExtend(INT amount) {
-  int newLen = Len()+amount;
-  return ArrayResize(newLen);
-} // SquirrelObject::ArrayExtend
-
-BOOL SquirrelObject::ArrayReverse(void) {
-  sq_pushobject(SquirrelVM::_VM,GetObjectHandle());
-  BOOL res = sq_arrayreverse(SquirrelVM::_VM,-1) == SQ_OK;
-  sq_pop(SquirrelVM::_VM,1);
-  return res;
-} // SquirrelObject::ArrayReverse
-
-SquirrelObject SquirrelObject::ArrayPop(SQBool returnPoppedVal) {
-  SquirrelObject ret;
-  int top = sq_gettop(SquirrelVM::_VM);
-  sq_pushobject(SquirrelVM::_VM,GetObjectHandle());
-  if (sq_arraypop(SquirrelVM::_VM,-1,returnPoppedVal) == SQ_OK) {
-    if (returnPoppedVal) {
-      ret.AttachToStackObject(-1);
-    } // if
-  } // if
-  sq_settop(SquirrelVM::_VM,top);
-  return ret;
-} // SquirrelObject::ArrayPop
-
-// === END Arrays ===
-
-SQObjectType SquirrelObject::GetType()
-{
-	return _o._type;
-}
-
-BOOL SquirrelObject::GetSlot(INT key) const
-{
-	sq_pushobject(SquirrelVM::_VM,_o);
-	sq_pushinteger(SquirrelVM::_VM,key);
-	if(SQ_SUCCEEDED(sq_get(SquirrelVM::_VM,-2))) {
-		return TRUE;
-	}
-	
-	return FALSE;
-}
-
-
-SquirrelObject SquirrelObject::GetValue(INT key)const
-{
-	SquirrelObject ret;
-	if(GetSlot(key)) {
-		ret.AttachToStackObject(-1);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret;
-}
-
-FLOAT SquirrelObject::GetFloat(INT key) const
-{
-	FLOAT ret = 0.0f;
-	if(GetSlot(key)) {
-		sq_getfloat(SquirrelVM::_VM,-1,&ret);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret;
-}
-
-INT SquirrelObject::GetInt(INT key) const
-{
-	INT ret = 0;
-	if(GetSlot(key)) {
-		sq_getinteger(SquirrelVM::_VM,-1,&ret);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret;
-}
-
-const SQChar *SquirrelObject::GetString(INT key) const
-{
-	const SQChar *ret = NULL;
-	if(GetSlot(key)) {
-		sq_getstring(SquirrelVM::_VM,-1,&ret);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret;
-}
-
-bool SquirrelObject::GetBool(INT key) const
-{
-	SQBool ret = FALSE;
-	if(GetSlot(key)) {
-		sq_getbool(SquirrelVM::_VM,-1,&ret);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret?true:false;
-}
-
-BOOL SquirrelObject::Exists(const SQChar *key) const
-{
-	if(GetSlot(key)) {
-  	sq_pop(SquirrelVM::_VM,2);
-		return TRUE;
-	} else {
-  	sq_pop(SquirrelVM::_VM,1);
-		return FALSE;
-	}
-}
-////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-BOOL SquirrelObject::GetSlot(const SQChar *name) const
-{
-	sq_pushobject(SquirrelVM::_VM,_o);
-	sq_pushstring(SquirrelVM::_VM,name,-1);
-	if(SQ_SUCCEEDED(sq_get(SquirrelVM::_VM,-2))) {
-		return TRUE;
-	}
-	
-	return FALSE;
-}
-
-BOOL SquirrelObject::RawGetSlot(const SQChar *name) const {
-  sq_pushobject(SquirrelVM::_VM,_o);
-  sq_pushstring(SquirrelVM::_VM,name,-1);
-  if(SQ_SUCCEEDED(sq_rawget(SquirrelVM::_VM,-2))) {
-    return TRUE;
-  }
-  return FALSE;
-} // SquirrelObject::RawGetSlot
-
-SquirrelObject SquirrelObject::GetValue(const SQChar *key)const
-{
-	SquirrelObject ret;
-	if(GetSlot(key)) {
-		ret.AttachToStackObject(-1);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret;
-}
-
-FLOAT SquirrelObject::GetFloat(const SQChar *key) const
-{
-	FLOAT ret = 0.0f;
-	if(GetSlot(key)) {
-		sq_getfloat(SquirrelVM::_VM,-1,&ret);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret;
-}
-
-INT SquirrelObject::GetInt(const SQChar *key) const
-{
-	INT ret = 0;
-	if(GetSlot(key)) {
-		sq_getinteger(SquirrelVM::_VM,-1,&ret);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret;
-}
-
-const SQChar *SquirrelObject::GetString(const SQChar *key) const
-{
-	const SQChar *ret = NULL;
-	if(GetSlot(key)) {
-		sq_getstring(SquirrelVM::_VM,-1,&ret);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret;
-}
-
-bool SquirrelObject::GetBool(const SQChar *key) const
-{
-	SQBool ret = FALSE;
-	if(GetSlot(key)) {
-		sq_getbool(SquirrelVM::_VM,-1,&ret);
-		sq_pop(SquirrelVM::_VM,1);
-	}
-	sq_pop(SquirrelVM::_VM,1);
-	return ret?true:false;
-}
-
-SQUserPointer SquirrelObject::GetInstanceUP(SQUserPointer tag) const
-{
-    SQUserPointer up;
-    sq_pushobject(SquirrelVM::_VM,_o);
-    if (SQ_FAILED(sq_getinstanceup(SquirrelVM::_VM,-1,(SQUserPointer*)&up,tag))) {
-        sq_reseterror(SquirrelVM::_VM);
-        up = NULL;
-    } // if
-    sq_pop(SquirrelVM::_VM,1);
-    return up;
-}
-
-BOOL SquirrelObject::SetInstanceUP(SQUserPointer up)
-{
-	if(!sq_isinstance(_o)) return FALSE;
-	sq_pushobject(SquirrelVM::_VM,_o);
-	sq_setinstanceup(SquirrelVM::_VM,-1,up);
-	sq_pop(SquirrelVM::_VM,1);
-	return TRUE;
-}
-
-SquirrelObject SquirrelObject::GetAttributes(const SQChar *key)
-{
-	SquirrelObject ret;
-	int top = sq_gettop(SquirrelVM::_VM);
-	sq_pushobject(SquirrelVM::_VM,_o);
-	if(key)
-		sq_pushstring(SquirrelVM::_VM,key,-1);
-	else
-		sq_pushnull(SquirrelVM::_VM);
-	if(SQ_SUCCEEDED(sq_getattributes(SquirrelVM::_VM,-2))) {
-		ret.AttachToStackObject(-1);
-	}
-	sq_settop(SquirrelVM::_VM,top);
-	return ret;
-}
-
-BOOL SquirrelObject::BeginIteration()
-{
-	if(!sq_istable(_o) && !sq_isarray(_o) && !sq_isclass(_o))
-		return FALSE;
-	sq_pushobject(SquirrelVM::_VM,_o);
-	sq_pushnull(SquirrelVM::_VM);
-	return TRUE;
-}
-
-BOOL SquirrelObject::Next(SquirrelObject &key,SquirrelObject &val)
-{
-	if(SQ_SUCCEEDED(sq_next(SquirrelVM::_VM,-2))) {
-		key.AttachToStackObject(-2);
-		val.AttachToStackObject(-1);
-		sq_pop(SquirrelVM::_VM,2);
-		return TRUE;
-	}
-	return FALSE;
-}
-
-BOOL SquirrelObject::GetTypeTag(SQUserPointer * typeTag) {
-  if (SQ_SUCCEEDED(sq_getobjtypetag(&_o,typeTag))) {
-    return TRUE;
-  } // if
-  return FALSE;
-} // SquirrelObject::GetTypeTag
-
-const SQChar * SquirrelObject::GetTypeName(const SQChar * key) {
-#if 1
-  // This version will work even if SQ_SUPPORT_INSTANCE_TYPE_INFO is not enabled.
-  SqPlus::ScriptStringVar256 varNameTag;
-  SqPlus::getVarNameTag(varNameTag,sizeof(varNameTag),key);
-  SQUserPointer data=0;
-  if (!RawGetUserData(varNameTag,&data)) {
-    return NULL;
-  } // if
-  SqPlus::VarRefPtr vr = (SqPlus::VarRefPtr)data;
-  return vr->varType->GetTypeName();
-#else // This version will only work if SQ_SUPPORT_INSTANCE_TYPE_INFO is enabled.
-  SquirrelObject so = GetValue(key);
-  if (so.IsNull()) return NULL;
-  return so.GetTypeName();
-#endif
-} // SquirrelObject::GetTypeName
-
-const SQChar * SquirrelObject::GetTypeName(INT key) {
-  SquirrelObject so = GetValue(key);
-  if (so.IsNull()) return NULL;
-  return so.GetTypeName();
-} // SquirrelObject::GetTypeName
-
-const SQChar * SquirrelObject::GetTypeName(void) {
-  SQUserPointer typeTag=NULL;
-  if (SQ_SUCCEEDED(sq_getobjtypetag(&_o,&typeTag))) {
-    SquirrelObject typeTable = SquirrelVM::GetRootTable().GetValue(SQ_PLUS_TYPE_TABLE);
-    if (typeTable.IsNull()) {
-      return NULL; // Not compiled with SQ_SUPPORT_INSTANCE_TYPE_INFO enabled.
-    } // if
-    return typeTable.GetString(INT((size_t)typeTag));
-  } // if
-  return NULL;
-} // SquirrelObject::GetTypeName
-
-SquirrelObject SquirrelObject::GetBase(void)
-{
-   SquirrelObject ret;
-   sq_pushobject(SquirrelVM::_VM,_o);
-   sq_getbase(SquirrelVM::_VM,-1);
-   ret.AttachToStackObject(-1);
-   sq_pop(SquirrelVM::_VM,2);
-
-   return ret;
-}
-
-const SQChar* SquirrelObject::ToString()
-{
-	return sq_objtostring(&_o);
-}
-
-SQInteger SquirrelObject::ToInteger()
-{
-	return sq_objtointeger(&_o);
-}
-
-SQFloat SquirrelObject::ToFloat()
-{
-	return sq_objtofloat(&_o);
-}
-
-bool SquirrelObject::ToBool()
-{
-	//<<FIXME>>
-	return _o._unVal.nInteger?true:false;
-}
-
-void SquirrelObject::EndIteration()
-{
-	sq_pop(SquirrelVM::_VM,2);
-}
-
+#include "sqplus.h"

+

+SquirrelObject::SquirrelObject(void)

+{

+	 sq_resetobject(&_o);

+}

+

+SquirrelObject::~SquirrelObject()

+{

+    Reset();

+}

+

+SquirrelObject::SquirrelObject(const SquirrelObject &o)

+{

+	_o = o._o;

+	sq_addref(SquirrelVM::_VM,&_o);

+}

+

+SquirrelObject::SquirrelObject(HSQOBJECT o)

+{

+	_o = o;

+	sq_addref(SquirrelVM::_VM,&_o);

+}

+

+void SquirrelObject::Reset(void) {

+  if(SquirrelVM::_VM)

+    sq_release(SquirrelVM::_VM,&_o);

+  else if( _o._type!=OT_NULL && _o._unVal.pRefCounted )

+    printf( "SquirrelObject::~SquirrelObject - Cannot release\n" ); 

+  sq_resetobject(&_o);

+} // SquirrelObject::Reset

+

+SquirrelObject SquirrelObject::Clone()

+{

+	SquirrelObject ret;

+	if(GetType() == OT_TABLE || GetType() == OT_ARRAY)

+	{

+		sq_pushobject(SquirrelVM::_VM,_o);

+		sq_clone(SquirrelVM::_VM,-1);

+		ret.AttachToStackObject(-1);

+		sq_pop(SquirrelVM::_VM,2);

+	}

+	return ret;

+

+}

+

+SquirrelObject & SquirrelObject::operator =(const SquirrelObject &o)

+{

+	//HSQOBJECT t;

+	//t = o._o;

+	//sq_addref(SquirrelVM::_VM,&t);

+	sq_addref(SquirrelVM::_VM, (HSQOBJECT*)&o._o);

+	sq_release(SquirrelVM::_VM,&_o);

+	//_o = t;

+	_o = o._o;

+	return *this;

+}

+

+SquirrelObject & SquirrelObject::operator =(HSQOBJECT ho)

+{

+	sq_addref(SquirrelVM::_VM,&ho);

+	sq_release(SquirrelVM::_VM,&_o);

+	_o = ho;

+	return *this;

+}

+

+SquirrelObject & SquirrelObject::operator =(int n)

+{

+	sq_pushinteger(SquirrelVM::_VM,n);

+	AttachToStackObject(-1);

+	sq_pop(SquirrelVM::_VM,1);

+	return *this;

+}

+

+#include <assert.h>

+#include "../squirrel/sqstate.h"

+#include "../squirrel/sqvm.h"

+

+SquirrelObject & SquirrelObject::operator =(HSQUIRRELVM v)

+{

+    if( v && SquirrelVM::_VM ){

+    	SquirrelVM::_VM->Push(v);

+        AttachToStackObject(-1);

+        sq_poptop(SquirrelVM::_VM);

+    }

+    else Reset();

+	return *this;

+}

+

+bool SquirrelObject::operator == (const SquirrelObject &o)

+{

+    bool cmp = false;

+    HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+    int oldtop = sq_gettop(v);

+    

+    sq_pushobject(v, GetObjectHandle());

+    sq_pushobject(v, o.GetObjectHandle());

+    if(sq_cmp(v) == 0)

+        cmp = true;

+   

+    sq_settop(v, oldtop);

+    return cmp;

+}

+

+bool SquirrelObject::CompareUserPointer( const SquirrelObject &o )

+{

+    if( _o._type == o.GetObjectHandle()._type )

+        if( _o._unVal.pUserPointer == o.GetObjectHandle()._unVal.pUserPointer )

+            return true;

+

+    return false;

+}

+

+void SquirrelObject::ArrayAppend(const SquirrelObject &o)

+{

+	if(sq_isarray(_o)) {

+		sq_pushobject(SquirrelVM::_VM,_o);

+		sq_pushobject(SquirrelVM::_VM,o._o);

+		sq_arrayappend(SquirrelVM::_VM,-2);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+}

+

+void SquirrelObject::AttachToStackObject(int idx)

+{

+	HSQOBJECT t;

+	sq_getstackobj(SquirrelVM::_VM,idx,&t);

+	sq_addref(SquirrelVM::_VM,&t);

+	sq_release(SquirrelVM::_VM,&_o);

+	_o = t;

+}

+

+BOOL SquirrelObject::SetDelegate(SquirrelObject &obj)

+{

+	if(obj.GetType() == OT_TABLE ||

+		obj.GetType() == OT_NULL) {

+			switch(_o._type) {

+				case OT_USERDATA:

+				case OT_TABLE:

+					sq_pushobject(SquirrelVM::_VM,_o);

+					sq_pushobject(SquirrelVM::_VM,obj._o);

+					if(SQ_SUCCEEDED(sq_setdelegate(SquirrelVM::_VM,-2))) {

+					  sq_pop(SquirrelVM::_VM,1);

+					  return TRUE;

+					}

+					sq_pop(SquirrelVM::_VM,1);

+					break;

+			}

+	}

+	return FALSE;

+}

+

+SquirrelObject SquirrelObject::GetDelegate()

+{

+	SquirrelObject ret;

+	if(_o._type == OT_TABLE || _o._type == OT_USERDATA)

+	{

+    int top = sq_gettop(SquirrelVM::_VM);

+		sq_pushobject(SquirrelVM::_VM,_o);

+		sq_getdelegate(SquirrelVM::_VM,-1);

+		ret.AttachToStackObject(-1);

+    sq_settop(SquirrelVM::_VM,top);

+//		sq_pop(SquirrelVM::_VM,2);

+	}

+	return ret;

+}

+

+BOOL SquirrelObject::IsNull() const

+{

+	return sq_isnull(_o);

+}

+

+BOOL SquirrelObject::IsNumeric() const

+{

+	return sq_isnumeric(_o);

+}

+

+int SquirrelObject::Len() const

+{

+	int ret = 0;

+	if(sq_isarray(_o) || sq_istable(_o) || sq_isstring(_o)) {

+		sq_pushobject(SquirrelVM::_VM,_o);

+		ret = sq_getsize(SquirrelVM::_VM,-1);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	return ret;

+}

+

+#define _SETVALUE_INT_BEGIN \

+	BOOL ret = FALSE; \

+	int top = sq_gettop(SquirrelVM::_VM); \

+	sq_pushobject(SquirrelVM::_VM,_o); \

+	sq_pushinteger(SquirrelVM::_VM,key);

+

+#define _SETVALUE_INT_END \

+	if(SQ_SUCCEEDED(sq_rawset(SquirrelVM::_VM,-3))) { \

+		ret = TRUE; \

+	} \

+	sq_settop(SquirrelVM::_VM,top); \

+	return ret;

+

+BOOL SquirrelObject::SetValue(INT key,const SquirrelObject &val)

+{

+	_SETVALUE_INT_BEGIN

+	sq_pushobject(SquirrelVM::_VM,val._o);

+	_SETVALUE_INT_END

+}

+

+BOOL SquirrelObject::SetValue(INT key,INT n)

+{

+	_SETVALUE_INT_BEGIN

+	sq_pushinteger(SquirrelVM::_VM,n);

+	_SETVALUE_INT_END

+}

+

+BOOL SquirrelObject::SetValue(INT key,FLOAT f)

+{

+	_SETVALUE_INT_BEGIN

+	sq_pushfloat(SquirrelVM::_VM,f);

+	_SETVALUE_INT_END

+}

+

+BOOL SquirrelObject::SetValue(INT key,const SQChar *s)

+{

+	_SETVALUE_INT_BEGIN

+	sq_pushstring(SquirrelVM::_VM,s,-1);

+	_SETVALUE_INT_END

+}

+

+BOOL SquirrelObject::SetValue(INT key,bool b)

+{

+	_SETVALUE_INT_BEGIN

+	sq_pushbool(SquirrelVM::_VM,b);

+	_SETVALUE_INT_END

+}

+

+BOOL SquirrelObject::SetValue(const SquirrelObject &key,const SquirrelObject &val)

+{

+	BOOL ret = FALSE;

+	int top = sq_gettop(SquirrelVM::_VM);

+	sq_pushobject(SquirrelVM::_VM,_o);

+	sq_pushobject(SquirrelVM::_VM,key._o);

+	sq_pushobject(SquirrelVM::_VM,val._o);

+	if(SQ_SUCCEEDED(sq_rawset(SquirrelVM::_VM,-3))) {

+		ret = TRUE;

+	}

+	sq_settop(SquirrelVM::_VM,top);

+	return ret;

+}

+

+#define _SETVALUE_STR_BEGIN \

+	BOOL ret = FALSE; \

+	int top = sq_gettop(SquirrelVM::_VM); \

+	sq_pushobject(SquirrelVM::_VM,_o); \

+	sq_pushstring(SquirrelVM::_VM,key,-1);

+

+#define _SETVALUE_STR_END \

+	if(SQ_SUCCEEDED(sq_rawset(SquirrelVM::_VM,-3))) { \

+		ret = TRUE; \

+	} \

+	sq_settop(SquirrelVM::_VM,top); \

+	return ret;

+

+BOOL SquirrelObject::SetValue(const SQChar *key,const SquirrelObject &val)

+{

+	_SETVALUE_STR_BEGIN

+	sq_pushobject(SquirrelVM::_VM,val._o);

+	_SETVALUE_STR_END

+}

+

+BOOL SquirrelObject::SetValue(const SQChar *key,INT n)

+{

+	_SETVALUE_STR_BEGIN

+	sq_pushinteger(SquirrelVM::_VM,n);

+	_SETVALUE_STR_END

+}

+

+BOOL SquirrelObject::SetValue(const SQChar *key,FLOAT f)

+{

+	_SETVALUE_STR_BEGIN

+	sq_pushfloat(SquirrelVM::_VM,f);

+	_SETVALUE_STR_END

+}

+

+BOOL SquirrelObject::SetValue(const SQChar *key,const SQChar *s)

+{

+	_SETVALUE_STR_BEGIN

+	sq_pushstring(SquirrelVM::_VM,s,-1);

+	_SETVALUE_STR_END

+}

+

+BOOL SquirrelObject::SetValue(const SQChar *key,bool b)

+{

+	_SETVALUE_STR_BEGIN

+	sq_pushbool(SquirrelVM::_VM,b);

+	_SETVALUE_STR_END

+}

+

+// === BEGIN User Pointer, User Data ===

+

+BOOL SquirrelObject::SetUserPointer(const SQChar * key,SQUserPointer up) {

+  _SETVALUE_STR_BEGIN

+  sq_pushuserpointer(SquirrelVM::_VM,up);

+  _SETVALUE_STR_END

+} // SquirrelObject::SetUserPointer

+

+SQUserPointer SquirrelObject::GetUserPointer(const SQChar * key) {

+  SQUserPointer ret = NULL;

+  if (GetSlot(key)) {

+    sq_getuserpointer(SquirrelVM::_VM,-1,&ret);

+    sq_pop(SquirrelVM::_VM,1);

+  } // if

+  sq_pop(SquirrelVM::_VM,1);

+  return ret;

+} // SquirrelObject::GetUserPointer

+

+BOOL SquirrelObject::SetUserPointer(INT key,SQUserPointer up) {

+  _SETVALUE_INT_BEGIN

+  sq_pushuserpointer(SquirrelVM::_VM,up);

+  _SETVALUE_INT_END

+} // SquirrelObject::SetUserPointer

+

+SQUserPointer SquirrelObject::GetUserPointer(INT key) {

+  SQUserPointer ret = NULL;

+  if (GetSlot(key)) {

+    sq_getuserpointer(SquirrelVM::_VM,-1,&ret);

+    sq_pop(SquirrelVM::_VM,1);

+  } // if

+  sq_pop(SquirrelVM::_VM,1);

+  return ret;

+} // SquirrelObject::GetUserPointer

+

+// === User Data ===

+

+BOOL SquirrelObject::NewUserData(const SQChar * key,INT size,SQUserPointer * typetag) {

+  _SETVALUE_STR_BEGIN

+  sq_newuserdata(SquirrelVM::_VM,size);

+  if (typetag) {

+    sq_settypetag(SquirrelVM::_VM,-1,typetag);

+  } // if

+  _SETVALUE_STR_END

+} // SquirrelObject::NewUserData

+

+BOOL SquirrelObject::GetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag) {

+  BOOL ret = false;

+  if (GetSlot(key)) {

+    sq_getuserdata(SquirrelVM::_VM,-1,data,typetag);

+    sq_pop(SquirrelVM::_VM,1);

+    ret = true;

+  } // if

+  sq_pop(SquirrelVM::_VM,1);

+  return ret;

+} // SquirrelObject::GetUserData

+

+BOOL SquirrelObject::RawGetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag) {

+  BOOL ret = false;

+  if (RawGetSlot(key)) {

+    sq_getuserdata(SquirrelVM::_VM,-1,data,typetag);

+    sq_pop(SquirrelVM::_VM,1);

+    ret = true;

+  } // if

+  sq_pop(SquirrelVM::_VM,1);

+  return ret;

+} // SquirrelObject::RawGetUserData

+

+// === END User Pointer ===

+

+// === BEGIN Arrays ===

+

+BOOL SquirrelObject::ArrayResize(INT newSize) {

+//  int top = sq_gettop(SquirrelVM::_VM);

+  sq_pushobject(SquirrelVM::_VM,GetObjectHandle());

+  BOOL res = sq_arrayresize(SquirrelVM::_VM,-1,newSize) == SQ_OK;

+  sq_pop(SquirrelVM::_VM,1);

+//  sq_settop(SquirrelVM::_VM,top);

+  return res;

+} // SquirrelObject::ArrayResize

+

+BOOL SquirrelObject::ArrayExtend(INT amount) {

+  int newLen = Len()+amount;

+  return ArrayResize(newLen);

+} // SquirrelObject::ArrayExtend

+

+BOOL SquirrelObject::ArrayReverse(void) {

+  sq_pushobject(SquirrelVM::_VM,GetObjectHandle());

+  BOOL res = sq_arrayreverse(SquirrelVM::_VM,-1) == SQ_OK;

+  sq_pop(SquirrelVM::_VM,1);

+  return res;

+} // SquirrelObject::ArrayReverse

+

+SquirrelObject SquirrelObject::ArrayPop(SQBool returnPoppedVal) {

+  SquirrelObject ret;

+  int top = sq_gettop(SquirrelVM::_VM);

+  sq_pushobject(SquirrelVM::_VM,GetObjectHandle());

+  if (sq_arraypop(SquirrelVM::_VM,-1,returnPoppedVal) == SQ_OK) {

+    if (returnPoppedVal) {

+      ret.AttachToStackObject(-1);

+    } // if

+  } // if

+  sq_settop(SquirrelVM::_VM,top);

+  return ret;

+} // SquirrelObject::ArrayPop

+

+// === END Arrays ===

+

+SQObjectType SquirrelObject::GetType()

+{

+	return _o._type;

+}

+

+BOOL SquirrelObject::GetSlot(INT key) const

+{

+	sq_pushobject(SquirrelVM::_VM,_o);

+	sq_pushinteger(SquirrelVM::_VM,key);

+	if(SQ_SUCCEEDED(sq_get(SquirrelVM::_VM,-2))) {

+		return TRUE;

+	}

+	

+	return FALSE;

+}

+

+

+SquirrelObject SquirrelObject::GetValue(INT key)const

+{

+	SquirrelObject ret;

+	if(GetSlot(key)) {

+		ret.AttachToStackObject(-1);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret;

+}

+

+FLOAT SquirrelObject::GetFloat(INT key) const

+{

+	FLOAT ret = 0.0f;

+	if(GetSlot(key)) {

+		sq_getfloat(SquirrelVM::_VM,-1,&ret);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret;

+}

+

+INT SquirrelObject::GetInt(INT key) const

+{

+	INT ret = 0;

+	if(GetSlot(key)) {

+		sq_getinteger(SquirrelVM::_VM,-1,&ret);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret;

+}

+

+const SQChar *SquirrelObject::GetString(INT key) const

+{

+	const SQChar *ret = NULL;

+	if(GetSlot(key)) {

+		sq_getstring(SquirrelVM::_VM,-1,&ret);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret;

+}

+

+bool SquirrelObject::GetBool(INT key) const

+{

+	SQBool ret = FALSE;

+	if(GetSlot(key)) {

+		sq_getbool(SquirrelVM::_VM,-1,&ret);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret?true:false;

+}

+

+BOOL SquirrelObject::Exists(const SQChar *key) const

+{

+	if(GetSlot(key)) {

+  	sq_pop(SquirrelVM::_VM,2);

+		return TRUE;

+	} else {

+  	sq_pop(SquirrelVM::_VM,1);

+		return FALSE;

+	}

+}

+////////////////////////////////////////////////////////////////////////////////

+///////////////////////////////////////////////////////////////////////////////

+

+BOOL SquirrelObject::GetSlot(const SQChar *name) const

+{

+	sq_pushobject(SquirrelVM::_VM,_o);

+	sq_pushstring(SquirrelVM::_VM,name,-1);

+	if(SQ_SUCCEEDED(sq_get(SquirrelVM::_VM,-2))) {

+		return TRUE;

+	}

+	

+	return FALSE;

+}

+

+BOOL SquirrelObject::RawGetSlot(const SQChar *name) const {

+  sq_pushobject(SquirrelVM::_VM,_o);

+  sq_pushstring(SquirrelVM::_VM,name,-1);

+  if(SQ_SUCCEEDED(sq_rawget(SquirrelVM::_VM,-2))) {

+    return TRUE;

+  }

+  return FALSE;

+} // SquirrelObject::RawGetSlot

+

+SquirrelObject SquirrelObject::GetValue(const SQChar *key)const

+{

+	SquirrelObject ret;

+	if(GetSlot(key)) {

+		ret.AttachToStackObject(-1);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret;

+}

+

+FLOAT SquirrelObject::GetFloat(const SQChar *key) const

+{

+	FLOAT ret = 0.0f;

+	if(GetSlot(key)) {

+		sq_getfloat(SquirrelVM::_VM,-1,&ret);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret;

+}

+

+INT SquirrelObject::GetInt(const SQChar *key) const

+{

+	INT ret = 0;

+	if(GetSlot(key)) {

+		sq_getinteger(SquirrelVM::_VM,-1,&ret);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret;

+}

+

+const SQChar *SquirrelObject::GetString(const SQChar *key) const

+{

+	const SQChar *ret = NULL;

+	if(GetSlot(key)) {

+		sq_getstring(SquirrelVM::_VM,-1,&ret);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret;

+}

+

+bool SquirrelObject::GetBool(const SQChar *key) const

+{

+	SQBool ret = FALSE;

+	if(GetSlot(key)) {

+		sq_getbool(SquirrelVM::_VM,-1,&ret);

+		sq_pop(SquirrelVM::_VM,1);

+	}

+	sq_pop(SquirrelVM::_VM,1);

+	return ret?true:false;

+}

+

+SQUserPointer SquirrelObject::GetInstanceUP(SQUserPointer tag) const

+{

+    SQUserPointer up;

+    sq_pushobject(SquirrelVM::_VM,_o);

+    if (SQ_FAILED(sq_getinstanceup(SquirrelVM::_VM,-1,(SQUserPointer*)&up,tag))) {

+        sq_reseterror(SquirrelVM::_VM);

+        up = NULL;

+    } // if

+    sq_pop(SquirrelVM::_VM,1);

+    return up;

+}

+

+BOOL SquirrelObject::SetInstanceUP(SQUserPointer up)

+{

+	if(!sq_isinstance(_o)) return FALSE;

+	sq_pushobject(SquirrelVM::_VM,_o);

+	sq_setinstanceup(SquirrelVM::_VM,-1,up);

+	sq_pop(SquirrelVM::_VM,1);

+	return TRUE;

+}

+

+SquirrelObject SquirrelObject::GetAttributes(const SQChar *key)

+{

+	SquirrelObject ret;

+	int top = sq_gettop(SquirrelVM::_VM);

+	sq_pushobject(SquirrelVM::_VM,_o);

+	if(key)

+		sq_pushstring(SquirrelVM::_VM,key,-1);

+	else

+		sq_pushnull(SquirrelVM::_VM);

+	if(SQ_SUCCEEDED(sq_getattributes(SquirrelVM::_VM,-2))) {

+		ret.AttachToStackObject(-1);

+	}

+	sq_settop(SquirrelVM::_VM,top);

+	return ret;

+}

+

+BOOL SquirrelObject::BeginIteration()

+{

+	if(!sq_istable(_o) && !sq_isarray(_o) && !sq_isclass(_o))

+		return FALSE;

+	sq_pushobject(SquirrelVM::_VM,_o);

+	sq_pushnull(SquirrelVM::_VM);

+	return TRUE;

+}

+

+BOOL SquirrelObject::Next(SquirrelObject &key,SquirrelObject &val)

+{

+	if(SQ_SUCCEEDED(sq_next(SquirrelVM::_VM,-2))) {

+		key.AttachToStackObject(-2);

+		val.AttachToStackObject(-1);

+		sq_pop(SquirrelVM::_VM,2);

+		return TRUE;

+	}

+	return FALSE;

+}

+

+BOOL SquirrelObject::GetTypeTag(SQUserPointer * typeTag) {

+  if (SQ_SUCCEEDED(sq_getobjtypetag(&_o,typeTag))) {

+    return TRUE;

+  } // if

+  return FALSE;

+} // SquirrelObject::GetTypeTag

+

+const SQChar * SquirrelObject::GetTypeName(const SQChar * key) {

+#if 1

+  // This version will work even if SQ_SUPPORT_INSTANCE_TYPE_INFO is not enabled.

+  SqPlus::ScriptStringVar256 varNameTag;

+  SqPlus::getVarNameTag(varNameTag,sizeof(varNameTag),key);

+  SQUserPointer data=0;

+  if (!RawGetUserData(varNameTag,&data)) {

+    return NULL;

+  } // if

+  SqPlus::VarRefPtr vr = (SqPlus::VarRefPtr)data;

+  return vr->varType->GetTypeName();

+#else // This version will only work if SQ_SUPPORT_INSTANCE_TYPE_INFO is enabled.

+  SquirrelObject so = GetValue(key);

+  if (so.IsNull()) return NULL;

+  return so.GetTypeName();

+#endif

+} // SquirrelObject::GetTypeName

+

+const SQChar * SquirrelObject::GetTypeName(INT key) {

+  SquirrelObject so = GetValue(key);

+  if (so.IsNull()) return NULL;

+  return so.GetTypeName();

+} // SquirrelObject::GetTypeName

+

+const SQChar * SquirrelObject::GetTypeName(void) {

+  SQUserPointer typeTag=NULL;

+  if (SQ_SUCCEEDED(sq_getobjtypetag(&_o,&typeTag))) {

+    SquirrelObject typeTable = SquirrelVM::GetRootTable().GetValue(SQ_PLUS_TYPE_TABLE);

+    if (typeTable.IsNull()) {

+      return NULL; // Not compiled with SQ_SUPPORT_INSTANCE_TYPE_INFO enabled.

+    } // if

+    return typeTable.GetString(INT((size_t)typeTag));

+  } // if

+  return NULL;

+} // SquirrelObject::GetTypeName

+

+SquirrelObject SquirrelObject::GetBase(void)

+{

+   SquirrelObject ret;

+   sq_pushobject(SquirrelVM::_VM,_o);

+   sq_getbase(SquirrelVM::_VM,-1);

+   ret.AttachToStackObject(-1);

+   sq_pop(SquirrelVM::_VM,2);

+

+   return ret;

+}

+

+const SQChar* SquirrelObject::ToString()

+{

+	return sq_objtostring(&_o);

+}

+

+SQInteger SquirrelObject::ToInteger()

+{

+	return sq_objtointeger(&_o);

+}

+

+SQFloat SquirrelObject::ToFloat()

+{

+	return sq_objtofloat(&_o);

+}

+

+bool SquirrelObject::ToBool()

+{

+	//<<FIXME>>

+	return _o._unVal.nInteger?true:false;

+}

+

+void SquirrelObject::EndIteration()

+{

+	sq_pop(SquirrelVM::_VM,2);

+}

+

diff --git a/squirrel_3_0_1_stable/sqplus/SquirrelObject.h b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelObject.h
index 647410a74..8824c3dea 100644
--- a/squirrel_3_0_1_stable/sqplus/SquirrelObject.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelObject.h
@@ -1,256 +1,256 @@
-#ifndef _SQUIRREL_OBJECT_H_
-#define _SQUIRREL_OBJECT_H_
-
-class SquirrelObject
-{
-  friend class SquirrelVM;
-  
-public:
-  SquirrelObject();
-  virtual ~SquirrelObject();
-  SquirrelObject(const SquirrelObject & o);
-  SquirrelObject(HSQOBJECT o);
-  
-#if 1
-  template <typename _ty>
-  SquirrelObject(const _ty & val) { sq_resetobject(&_o); Set((_ty &)val); } // Cast away const to avoid compiler SqPlus::Push() match issue.
-  template <typename _ty>
-  SquirrelObject(_ty & val) { sq_resetobject(&_o); Set(val); }
-  template <typename _ty>
-  SquirrelObject(_ty * val) { sq_resetobject(&_o); SetByValue(val); } // Set() would also be OK here. SetByValue() to save potential compiler overhead.
-#endif
-
-  SquirrelObject & operator = (HSQOBJECT ho);
-  SquirrelObject & operator = (const SquirrelObject &o);
-  SquirrelObject & operator = (int n);
-  SquirrelObject & operator = (HSQUIRRELVM v);
-  
-  operator HSQOBJECT& (){ return _o; } 
-  bool operator ==(const SquirrelObject& o);
-  bool CompareUserPointer(const SquirrelObject& o);
-  
-  void AttachToStackObject(int idx);
-  void Reset(void); // Release (any) reference and reset _o.
-  SquirrelObject Clone();
-  BOOL SetValue(const SquirrelObject &key,const SquirrelObject &val);
-  
-  BOOL SetValue(SQInteger key,const SquirrelObject &val);
-  BOOL SetValue(INT key,bool b); // Compiler treats SQBool as INT.
-  BOOL SetValue(INT key,INT n);
-  BOOL SetValue(INT key,FLOAT f);
-  BOOL SetValue(INT key,const SQChar *s);
-
-  BOOL SetValue(const SQChar *key,const SquirrelObject &val);
-  BOOL SetValue(const SQChar *key,bool b);
-  BOOL SetValue(const SQChar *key,INT n);
-  BOOL SetValue(const SQChar *key,FLOAT f);
-  BOOL SetValue(const SQChar *key,const SQChar *s);
-
-  BOOL SetUserPointer(const SQChar * key,SQUserPointer up);
-  SQUserPointer GetUserPointer(const SQChar * key);
-  BOOL SetUserPointer(INT key,SQUserPointer up);
-  SQUserPointer GetUserPointer(INT key);
-
-  BOOL NewUserData(const SQChar * key,INT size,SQUserPointer * typetag=0);
-  BOOL GetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag=0);
-  BOOL RawGetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag=0);
-
-  // === BEGIN Arrays ===
-
-  BOOL ArrayResize(INT newSize);
-  BOOL ArrayExtend(INT amount);
-  BOOL ArrayReverse(void);
-  SquirrelObject ArrayPop(SQBool returnPoppedVal=SQTrue);
-
-  void ArrayAppend(const SquirrelObject &o);
-
-  template<typename T>
-  BOOL ArrayAppend(T item);
-
-  // === END Arrays ===
-
-  BOOL SetInstanceUP(SQUserPointer up);
-  BOOL IsNull() const;
-  int IsNumeric() const;
-  int Len() const;
-  BOOL SetDelegate(SquirrelObject &obj);
-  SquirrelObject GetDelegate();
-  const SQChar* ToString();
-  bool ToBool();
-  SQInteger ToInteger();
-  SQFloat ToFloat();
-  SQUserPointer GetInstanceUP(SQUserPointer tag) const;
-  SquirrelObject GetValue(const SQChar *key) const;
-  BOOL Exists(const SQChar *key) const;
-  FLOAT GetFloat(const SQChar *key) const;
-  INT GetInt(const SQChar *key) const;
-  const SQChar *GetString(const SQChar *key) const;
-  bool GetBool(const SQChar *key) const;
-  SquirrelObject GetValue(INT key) const;
-  FLOAT GetFloat(INT key) const;
-  INT GetInt(INT key) const;
-  const SQChar *GetString(INT key) const;
-  bool GetBool(INT key) const;
-  SquirrelObject GetAttributes(const SQChar *key = NULL);
-  SQObjectType GetType();
-  HSQOBJECT & GetObjectHandle() const {return *(HSQOBJECT*)&_o;}
-  BOOL BeginIteration();
-  BOOL Next(SquirrelObject &key,SquirrelObject &value);
-  void EndIteration();
-
-  BOOL GetTypeTag(SQUserPointer * typeTag);
-
-  // === Get the type name of item/object through string key in a table or class. Returns NULL if the type name is not set (not an SqPlus registered type).
-  const SQChar * GetTypeName(const SQChar * key);
-  // === Get the type name of item/object through INT key in a table or class. Returns NULL if the type name is not set (not an SqPlus registered type).
-  const SQChar * GetTypeName(INT key);
-  // === Get the type name of this object, else return NULL if not an SqPlus registered type.
-  const SQChar * GetTypeName(void);
-
-  // === Return base class of object using sq_getbase() === 
-  SquirrelObject GetBase();
-  
-  // === BEGIN code suggestion from the Wiki ===
-  // Get any bound type from this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.
-  template<typename _ty>
-  _ty Get(void);
-
-  // Set any bound type to this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.
-  template<typename _ty>
-  SquirrelObject SetByValue(_ty val); // classes/structs should be passed by ref (below) to avoid an extra copy.
-
-  // Set any bound type to this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.
-  template<typename _ty>
-  SquirrelObject &Set(_ty & val);
-
-  // === END code suggestion from the Wiki ===
-
-private:
-  BOOL GetSlot(const SQChar *name) const;
-  BOOL RawGetSlot(const SQChar *name) const;
-  BOOL GetSlot(INT key) const;
-  HSQOBJECT _o;
-};
-
-struct StackHandler {
-  StackHandler(HSQUIRRELVM v) {
-    _top = sq_gettop(v);
-    this->v = v;
-  }
-  SQFloat GetFloat(int idx) {
-    SQFloat x = 0.0f;
-    if(idx > 0 && idx <= _top) {
-      sq_getfloat(v,idx,&x);
-    }
-    return x;
-  }
-  SQInteger GetInt(int idx) {
-    SQInteger x = 0;
-    if(idx > 0 && idx <= _top) {
-      sq_getinteger(v,idx,&x);
-    }
-    return x;
-  }
-  HSQOBJECT GetObjectHandle(int idx) {
-    HSQOBJECT x;
-    if(idx > 0 && idx <= _top) {
-      sq_resetobject(&x);
-      sq_getstackobj(v,idx,&x);
-    }
-    return x;
-  }
-  const SQChar *GetString(int idx)
-  {
-    const SQChar *x = NULL;
-    if(idx > 0 && idx <= _top) {
-      sq_getstring(v,idx,&x);
-    }
-    return x;
-  }
-  SQUserPointer GetUserPointer(int idx)
-  {
-    SQUserPointer x = 0;
-    if(idx > 0 && idx <= _top) {
-      sq_getuserpointer(v,idx,&x);
-    }
-    return x;
-  }
-  SQUserPointer GetInstanceUp(int idx,SQUserPointer tag)
-  {
-    SQUserPointer self;
-    if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer*)&self,tag)))
-      return NULL;
-    return self;
-  }
-  SQUserPointer GetUserData(int idx,SQUserPointer tag=0)
-  {
-    SQUserPointer otag;
-    SQUserPointer up;
-    if(idx > 0 && idx <= _top) {
-      if(SQ_SUCCEEDED(sq_getuserdata(v,idx,&up,&otag))) {
-        if(tag == otag)
-          return up;
-      }
-    }
-    return NULL;
-  }
-  BOOL GetBool(int idx)
-  {
-    SQBool ret;
-    if(idx > 0 && idx <= _top) {
-      if(SQ_SUCCEEDED(sq_getbool(v,idx,&ret)))
-        return ret;
-    }
-    return FALSE;
-  }
-  int GetType(int idx)
-  {
-    if(idx > 0 && idx <= _top) {
-      return sq_gettype(v,idx);
-    }
-    return -1;
-  }
-  
-  int GetParamCount() {
-    return _top;
-  }
-  int Return(const SQChar *s)
-  {
-    sq_pushstring(v,s,-1);
-    return 1;
-  }
-  int Return(FLOAT f)
-  {
-    sq_pushfloat(v,f);
-    return 1;
-  }
-  int Return(INT i)
-  {
-    sq_pushinteger(v,i);
-    return 1;
-	}
-	int Return(bool b)
-	{
-		sq_pushbool(v,b);
-		return 1;
-	}
-  int Return(SQUserPointer p) {
-    sq_pushuserpointer(v,p);
-    return 1;
-  }
-	int Return(SquirrelObject &o)
-	{
-		sq_pushobject(v,o.GetObjectHandle());
-		return 1;
-	}
-	int Return() { return 0; }
-	int ThrowError(const SQChar *error) {
-		return sq_throwerror(v,error);
-	}
-  HSQUIRRELVM GetVMPtr() { return v; }
-private:
-	int _top;
-	HSQUIRRELVM v;
-};
-
-#endif //_SQUIRREL_OBJECT_H_
+#ifndef _SQUIRREL_OBJECT_H_

+#define _SQUIRREL_OBJECT_H_

+

+class SquirrelObject

+{

+  friend class SquirrelVM;

+  

+public:

+  SquirrelObject();

+  virtual ~SquirrelObject();

+  SquirrelObject(const SquirrelObject & o);

+  SquirrelObject(HSQOBJECT o);

+  

+#if 1

+  template <typename _ty>

+  SquirrelObject(const _ty & val) { sq_resetobject(&_o); Set((_ty &)val); } // Cast away const to avoid compiler SqPlus::Push() match issue.

+  template <typename _ty>

+  SquirrelObject(_ty & val) { sq_resetobject(&_o); Set(val); }

+  template <typename _ty>

+  SquirrelObject(_ty * val) { sq_resetobject(&_o); SetByValue(val); } // Set() would also be OK here. SetByValue() to save potential compiler overhead.

+#endif

+

+  SquirrelObject & operator = (HSQOBJECT ho);

+  SquirrelObject & operator = (const SquirrelObject &o);

+  SquirrelObject & operator = (int n);

+  SquirrelObject & operator = (HSQUIRRELVM v);

+  

+  operator HSQOBJECT& (){ return _o; } 

+  bool operator ==(const SquirrelObject& o);

+  bool CompareUserPointer(const SquirrelObject& o);

+  

+  void AttachToStackObject(int idx);

+  void Reset(void); // Release (any) reference and reset _o.

+  SquirrelObject Clone();

+  BOOL SetValue(const SquirrelObject &key,const SquirrelObject &val);

+  

+  BOOL SetValue(SQInteger key,const SquirrelObject &val);

+  BOOL SetValue(INT key,bool b); // Compiler treats SQBool as INT.

+  BOOL SetValue(INT key,INT n);

+  BOOL SetValue(INT key,FLOAT f);

+  BOOL SetValue(INT key,const SQChar *s);

+

+  BOOL SetValue(const SQChar *key,const SquirrelObject &val);

+  BOOL SetValue(const SQChar *key,bool b);

+  BOOL SetValue(const SQChar *key,INT n);

+  BOOL SetValue(const SQChar *key,FLOAT f);

+  BOOL SetValue(const SQChar *key,const SQChar *s);

+

+  BOOL SetUserPointer(const SQChar * key,SQUserPointer up);

+  SQUserPointer GetUserPointer(const SQChar * key);

+  BOOL SetUserPointer(INT key,SQUserPointer up);

+  SQUserPointer GetUserPointer(INT key);

+

+  BOOL NewUserData(const SQChar * key,INT size,SQUserPointer * typetag=0);

+  BOOL GetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag=0);

+  BOOL RawGetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag=0);

+

+  // === BEGIN Arrays ===

+

+  BOOL ArrayResize(INT newSize);

+  BOOL ArrayExtend(INT amount);

+  BOOL ArrayReverse(void);

+  SquirrelObject ArrayPop(SQBool returnPoppedVal=SQTrue);

+

+  void ArrayAppend(const SquirrelObject &o);

+

+  template<typename T>

+  BOOL ArrayAppend(T item);

+

+  // === END Arrays ===

+

+  BOOL SetInstanceUP(SQUserPointer up);

+  BOOL IsNull() const;

+  int IsNumeric() const;

+  int Len() const;

+  BOOL SetDelegate(SquirrelObject &obj);

+  SquirrelObject GetDelegate();

+  const SQChar* ToString();

+  bool ToBool();

+  SQInteger ToInteger();

+  SQFloat ToFloat();

+  SQUserPointer GetInstanceUP(SQUserPointer tag) const;

+  SquirrelObject GetValue(const SQChar *key) const;

+  BOOL Exists(const SQChar *key) const;

+  FLOAT GetFloat(const SQChar *key) const;

+  INT GetInt(const SQChar *key) const;

+  const SQChar *GetString(const SQChar *key) const;

+  bool GetBool(const SQChar *key) const;

+  SquirrelObject GetValue(INT key) const;

+  FLOAT GetFloat(INT key) const;

+  INT GetInt(INT key) const;

+  const SQChar *GetString(INT key) const;

+  bool GetBool(INT key) const;

+  SquirrelObject GetAttributes(const SQChar *key = NULL);

+  SQObjectType GetType();

+  HSQOBJECT & GetObjectHandle() const {return *(HSQOBJECT*)&_o;}

+  BOOL BeginIteration();

+  BOOL Next(SquirrelObject &key,SquirrelObject &value);

+  void EndIteration();

+

+  BOOL GetTypeTag(SQUserPointer * typeTag);

+

+  // === Get the type name of item/object through string key in a table or class. Returns NULL if the type name is not set (not an SqPlus registered type).

+  const SQChar * GetTypeName(const SQChar * key);

+  // === Get the type name of item/object through INT key in a table or class. Returns NULL if the type name is not set (not an SqPlus registered type).

+  const SQChar * GetTypeName(INT key);

+  // === Get the type name of this object, else return NULL if not an SqPlus registered type.

+  const SQChar * GetTypeName(void);

+

+  // === Return base class of object using sq_getbase() === 

+  SquirrelObject GetBase();

+  

+  // === BEGIN code suggestion from the Wiki ===

+  // Get any bound type from this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.

+  template<typename _ty>

+  _ty Get(void);

+

+  // Set any bound type to this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.

+  template<typename _ty>

+  SquirrelObject SetByValue(_ty val); // classes/structs should be passed by ref (below) to avoid an extra copy.

+

+  // Set any bound type to this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.

+  template<typename _ty>

+  SquirrelObject &Set(_ty & val);

+

+  // === END code suggestion from the Wiki ===

+

+private:

+  BOOL GetSlot(const SQChar *name) const;

+  BOOL RawGetSlot(const SQChar *name) const;

+  BOOL GetSlot(INT key) const;

+  HSQOBJECT _o;

+};

+

+struct StackHandler {

+  StackHandler(HSQUIRRELVM v) {

+    _top = sq_gettop(v);

+    this->v = v;

+  }

+  SQFloat GetFloat(int idx) {

+    SQFloat x = 0.0f;

+    if(idx > 0 && idx <= _top) {

+      sq_getfloat(v,idx,&x);

+    }

+    return x;

+  }

+  SQInteger GetInt(int idx) {

+    SQInteger x = 0;

+    if(idx > 0 && idx <= _top) {

+      sq_getinteger(v,idx,&x);

+    }

+    return x;

+  }

+  HSQOBJECT GetObjectHandle(int idx) {

+    HSQOBJECT x;

+    if(idx > 0 && idx <= _top) {

+      sq_resetobject(&x);

+      sq_getstackobj(v,idx,&x);

+    }

+    return x;

+  }

+  const SQChar *GetString(int idx)

+  {

+    const SQChar *x = NULL;

+    if(idx > 0 && idx <= _top) {

+      sq_getstring(v,idx,&x);

+    }

+    return x;

+  }

+  SQUserPointer GetUserPointer(int idx)

+  {

+    SQUserPointer x = 0;

+    if(idx > 0 && idx <= _top) {

+      sq_getuserpointer(v,idx,&x);

+    }

+    return x;

+  }

+  SQUserPointer GetInstanceUp(int idx,SQUserPointer tag)

+  {

+    SQUserPointer self;

+    if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer*)&self,tag)))

+      return NULL;

+    return self;

+  }

+  SQUserPointer GetUserData(int idx,SQUserPointer tag=0)

+  {

+    SQUserPointer otag;

+    SQUserPointer up;

+    if(idx > 0 && idx <= _top) {

+      if(SQ_SUCCEEDED(sq_getuserdata(v,idx,&up,&otag))) {

+        if(tag == otag)

+          return up;

+      }

+    }

+    return NULL;

+  }

+  BOOL GetBool(int idx)

+  {

+    SQBool ret;

+    if(idx > 0 && idx <= _top) {

+      if(SQ_SUCCEEDED(sq_getbool(v,idx,&ret)))

+        return ret;

+    }

+    return FALSE;

+  }

+  int GetType(int idx)

+  {

+    if(idx > 0 && idx <= _top) {

+      return sq_gettype(v,idx);

+    }

+    return -1;

+  }

+  

+  int GetParamCount() {

+    return _top;

+  }

+  int Return(const SQChar *s)

+  {

+    sq_pushstring(v,s,-1);

+    return 1;

+  }

+  int Return(FLOAT f)

+  {

+    sq_pushfloat(v,f);

+    return 1;

+  }

+  int Return(INT i)

+  {

+    sq_pushinteger(v,i);

+    return 1;

+	}

+	int Return(bool b)

+	{

+		sq_pushbool(v,b);

+		return 1;

+	}

+  int Return(SQUserPointer p) {

+    sq_pushuserpointer(v,p);

+    return 1;

+  }

+	int Return(SquirrelObject &o)

+	{

+		sq_pushobject(v,o.GetObjectHandle());

+		return 1;

+	}

+	int Return() { return 0; }

+	int ThrowError(const SQChar *error) {

+		return sq_throwerror(v,error);

+	}

+  HSQUIRRELVM GetVMPtr() { return v; }

+private:

+	int _top;

+	HSQUIRRELVM v;

+};

+

+#endif //_SQUIRREL_OBJECT_H_

diff --git a/squirrel_3_0_1_stable/sqplus/SquirrelVM.cpp b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelVM.cpp
index 2d506d700..12b84dbe5 100644
--- a/squirrel_3_0_1_stable/sqplus/SquirrelVM.cpp
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelVM.cpp
@@ -1,505 +1,505 @@
-#include <stdio.h>
-#include <stdarg.h>
-#include <assert.h>
-
-#define _DEBUG_DUMP
-
-#include "sqplus.h"
-
-#include <sqstdio.h>
-#include <sqstdmath.h>
-#include <sqstdstring.h>
-#include <sqstdaux.h>
-#include <sqstdblob.h>
-#include <sqstdsystem.h>
-
-
-HSQUIRRELVM     SquirrelVM::_VM;
-bool            SquirrelVM::_no_vm_ref;
-int             SquirrelVM::_CallState = -1;
-SquirrelObject* SquirrelVM::_root;
-HSQUIRRELVM     SquirrelVM::_sandboxVM;
-SquirrelObject  SquirrelVM::_vm;
-
-
-// Helper struct to keep track of all SQSharedState:s created by SquirrelVM.
-#include "../squirrel/sqpcheader.h"
-#include "../squirrel/sqvm.h"
-struct SQSharedStateNode { 
-    SQSharedStateNode( SQSharedState* ps );
-    ~SQSharedStateNode( );
-    SQSharedState*     m_ps;
-    SQSharedStateNode* m_nxt;
-};
-
-// Linked list of shared states
-static SQSharedStateNode* g_sqss_fst;
-
-SQSharedStateNode::SQSharedStateNode( SQSharedState* ps ) : m_ps(ps), m_nxt(g_sqss_fst) { 
-    g_sqss_fst = this;
-}
-
-SQSharedStateNode::~SQSharedStateNode() {
-    if(m_ps) sq_delete(m_ps,SQSharedState); 
-    delete m_nxt;
-}
-
-static struct SquirrelVM_ModConstr { 
-    ~SquirrelVM_ModConstr(){ 
-        // Delete any shared states we created
-        delete g_sqss_fst;
-        g_sqss_fst = NULL;
-    }
-} g_squirrelvm_mod_constr;
-
-
-
-SquirrelError::SquirrelError() 
-{
-    const SQChar *s;
-    sq_getlasterror(SquirrelVM::_VM);
-    sq_getstring(SquirrelVM::_VM,-1,&s);
-    if(s) {
-        desc = s;
-    }
-    else {
-        desc = _SC("unknown error");
-    }
-}
-
-
-SquirrelVMSys::~SquirrelVMSys() {
-    // Must take care to release object with the 'ref' VM
-    PushRefVM( _vm.GetObjectHandle()._unVal.pThread );
-    _vm.Reset();
-    PopRefVM();
-}
-
-void SquirrelVMSys::Set( HSQUIRRELVM v ){
-    // Must take care to release object with the 'ref' VM
-    PushRefVM( v );
-    _vm = v;
-    PopRefVM( );
-}
-
-void SquirrelVMSys::Set( const SquirrelObject& ov ){
-    assert( ov.GetObjectHandle()._type==OT_THREAD );
-    // Must take care to release object with the 'ref' VM
-    PushRefVM( ov.GetObjectHandle()._unVal.pThread );
-    _vm = ov;
-    PopRefVM( );
-}
-
-SquirrelVMSys::operator HSQUIRRELVM () const { 
-    // Avoid const madness
-    SquirrelObject *pvm = (SquirrelObject*)&_vm;
-    assert( pvm->GetObjectHandle()._type==OT_THREAD );
-    return pvm->GetObjectHandle()._unVal.pThread; 
-}
-
-
-// When doing a SquirrelObject assignment, a reference using the current
-// VM is done. 
-HSQUIRRELVM g_VM_pushed;
-void SquirrelVMSys::PushRefVM( HSQUIRRELVM v ){
-    assert( !g_VM_pushed );
-    g_VM_pushed = SquirrelVM::_VM;
-    SquirrelVM::_VM = v;
-}
-
-void SquirrelVMSys::PopRefVM( ){
-    SquirrelVM::_VM = g_VM_pushed;
-    g_VM_pushed = NULL;
-}
-
-
-bool SquirrelVM::Init( HSQUIRRELVM v ){
-    if( v && v==_VM )
-        return true; 
-    
-    // Do we have a previous state?
-    Release( );
-        
-    bool created_new = false;
-    if( !v ){
-        // Create a new VM - a root VM with new SharedState.
-        v = sq_open(1024);
-        if( !v ) return false;
-        // Store the associated shared state in a linked list. The state will only 
-        // be destroyed at app shutdown. Often that is fine, but if using many 
-        // VM:s briefly, this allocation is not optimal.
-        new SQSharedStateNode( _ss(v) );
-        created_new = true;
-        sq_setprintfunc(v,SquirrelVM::PrintFunc, SquirrelVM::PrintFunc);
-        sq_pushroottable(v);
-        sqstd_register_iolib(v);
-        sqstd_register_bloblib(v);
-        sqstd_register_mathlib(v);
-        sqstd_register_stringlib(v);
-#ifdef SQPLUS_SQUIRRELVM_WITH_SYSTEMLIB        
-        sqstd_register_systemlib(v);
-#endif        
-        sqstd_seterrorhandlers(v);
-        //TODO error handler, compiler error handler
-        sq_pop(v,1);
-    }
-    
-    // After this we hold a ref
-    _no_vm_ref = false;
-    _VM = v;
-    _vm = v;
-   
-    // In the case where Squirrel is ref counted we currently
-    // hold two references to the VM (since it is created with 
-    // a ref count of 1). In the GC case, it is outside of the 
-    // chain of valid objects, so it is not referenced. Compensate 
-    // in ref counted case.
-    if( created_new )
-        DropVMRefIfRefCounted( v );
-    
-    return true;
-}
-
-bool SquirrelVM::InitNoRef( HSQUIRRELVM v ){
-    if( v && v==_VM )
-        return true; 
-    
-    // Do we have a previous state?
-    Release( );
-        
-    // Set pointer to this VM, without referencing it
-    _no_vm_ref = true;
-    _VM = v;
-    
-    return true;
-}
-
-/*
-void SquirrelVM::Init( HSQUIRRELVM v )
-{
-    if( v && v==_VM ) {
-      return;
-    }
-    
-    // Do we have a previous state?
-    Release();
-    
-    if( !v ){
-        // Create a new VM and own it
-        _VM = sq_open(1024);
-        sq_setprintfunc(_VM,SquirrelVM::PrintFunc);
-        sq_pushroottable(_VM);
-        sqstd_register_iolib(_VM);
-        sqstd_register_bloblib(_VM);
-        sqstd_register_mathlib(_VM);
-        sqstd_register_stringlib(_VM);
-        sqstd_seterrorhandlers(_VM);
-        //TODO error handler, compiler error handler
-        sq_pop(_VM,1);
-    }
-    else {
-        _VM = v;
-    }
-    // After this we hold a ref
-    _vm = _VM;
-}
-*/
-
-void SquirrelVM::Release() {
-    // Release root table object if we have one
-    if( _root ){ 
-        delete _root;
-        _root = NULL;
-    }
-    
-    // Release our ref on VM - if we should
-    if( !_no_vm_ref )
-        _vm.Reset();
-        
-    _VM = NULL;
-}
-
-void SquirrelVM::DropVMRefIfRefCounted( HSQUIRRELVM v ){ 
-#ifdef NO_GARBAGE_COLLECTOR
-    if( v ){
-        SQObject t;
-        t._unVal.pThread = v;
-        t._type = OT_THREAD;
-        sq_release( v, &t );
-    }
-#endif     
-}
-
-BOOL SquirrelVM::Update()
-{
-    //update remote debugger
-    return TRUE;
-}
-
-void SquirrelVM::PrintFunc(HSQUIRRELVM v,const SQChar* s,...)
-{
-    static SQChar temp[2048];
-    va_list vl;
-    va_start(vl, s);
-    scvsprintf( temp,s, vl);
-    SCPUTS(temp);
-    va_end(vl);
-}
-
-SquirrelObject SquirrelVM::CompileScript(const SQChar *s)
-{
-    SquirrelObject ret;
-    if(SQ_SUCCEEDED(sqstd_loadfile(_VM,s,1))) {
-        ret.AttachToStackObject(-1);
-        sq_pop(_VM,1);
-        return ret;
-    }
-    throw SquirrelError();
-}
-
-SquirrelObject SquirrelVM::CompileBuffer(const SQChar *s,const SQChar * debugInfo)
-{
-    SquirrelObject ret;
-    if(SQ_SUCCEEDED(sq_compilebuffer(_VM,s,(int)scstrlen(s)*sizeof(SQChar),debugInfo,1))) {
-        ret.AttachToStackObject(-1);
-        sq_pop(_VM,1);
-        return ret;
-    }
-    throw SquirrelError();
-}
-
-SquirrelObject SquirrelVM::RunScript(const SquirrelObject &o,SquirrelObject *_this)
-{
-    SquirrelObject ret;
-    sq_pushobject(_VM,o._o);
-    if(_this) {
-        sq_pushobject(_VM,_this->_o);
-    }
-    else {
-        sq_pushroottable(_VM);
-    }
-    if(SQ_SUCCEEDED(sq_call(_VM,1,SQTrue,SQ_CALL_RAISE_ERROR))) {
-        ret.AttachToStackObject(-1);
-        sq_pop(_VM,2);
-        return ret;
-    }
-    sq_pop(_VM,1);
-    throw SquirrelError();
-    
-}
-
-
-BOOL SquirrelVM::BeginCall(const SquirrelObject &func)
-{
-    if(_CallState != -1)
-        return FALSE;
-    _CallState = 1;
-    sq_pushobject(_VM,func._o);
-    sq_pushroottable(_VM);
-    return TRUE;
-}
-
-BOOL SquirrelVM::BeginCall(const SquirrelObject &func,SquirrelObject &_this)
-{
-    if(_CallState != -1)
-        throw SquirrelError(_SC("call already initialized"));
-    _CallState = 1;
-    sq_pushobject(_VM,func._o);
-    sq_pushobject(_VM,_this._o);
-    return TRUE;
-}
-
-#define _CHECK_CALL_STATE \
-    if(_CallState == -1) \
-        throw SquirrelError(_SC("call not initialized"));
-
-void SquirrelVM::PushParam(const SquirrelObject &o)
-{
-    _CHECK_CALL_STATE
-    sq_pushobject(_VM,o._o);
-    _CallState++;
-}
-
-void SquirrelVM::PushParam(const SQChar *s)
-{
-    _CHECK_CALL_STATE
-    sq_pushstring(_VM,s,-1);
-    _CallState++;
-}
-
-void SquirrelVM::PushParam(SQInteger n)
-{
-    _CHECK_CALL_STATE
-    sq_pushinteger(_VM,n);
-    _CallState++;
-}
-
-void SquirrelVM::PushParam(SQFloat f)
-{
-    _CHECK_CALL_STATE
-    sq_pushfloat(_VM,f);
-    _CallState++;
-}
-
-void SquirrelVM::PushParamNull()
-{
-    _CHECK_CALL_STATE
-    sq_pushnull(_VM);
-    _CallState++;
-}
-
-void SquirrelVM::PushParam(SQUserPointer up)
-{
-    _CHECK_CALL_STATE
-    sq_pushuserpointer(_VM,up);
-    _CallState++;
-}
-
-SquirrelObject SquirrelVM::EndCall()
-{
-    SquirrelObject ret;
-    if(_CallState >= 0) { 
-        int oldtop = sq_gettop(_VM);
-        int nparams = _CallState;
-        _CallState = -1;
-        if(SQ_SUCCEEDED(sq_call(_VM,nparams,SQTrue,SQ_CALL_RAISE_ERROR))) {
-            ret.AttachToStackObject(-1);
-            sq_pop(_VM,2);
-        }else {
-            sq_settop(_VM,oldtop-(nparams+1));
-            throw SquirrelError();
-        }
-        
-    }
-    return ret;
-}
-
-SquirrelObject SquirrelVM::CreateInstance(SquirrelObject &oclass)
-{
-    SquirrelObject ret;
-    int oldtop = sq_gettop(_VM);
-    sq_pushobject(_VM,oclass._o);
-    if(SQ_FAILED(sq_createinstance(_VM,-1))) {
-        sq_settop(_VM,oldtop);
-        throw SquirrelError();
-    }
-    ret.AttachToStackObject(-1);
-    sq_pop(_VM,2);
-    return ret;
-}
-
-SquirrelObject SquirrelVM::CreateTable()
-{
-    SquirrelObject ret;
-    sq_newtable(_VM);
-    ret.AttachToStackObject(-1);
-    sq_pop(_VM,1);
-    return ret;
-}
-
-SquirrelObject SquirrelVM::CreateString(const SQChar *s)
-{
-    SquirrelObject ret;
-    sq_pushstring(_VM,s,-1);
-    ret.AttachToStackObject(-1);
-    sq_pop(_VM,1);
-    return ret;
-}
-
-
-SquirrelObject SquirrelVM::CreateArray(int size)
-{
-    SquirrelObject ret;
-    sq_newarray(_VM,size);
-    ret.AttachToStackObject(-1);
-    sq_pop(_VM,1);
-    return ret;
-}
-
-SquirrelObject SquirrelVM::CreateFunction(SQFUNCTION func)
-{
-    SquirrelObject ret;
-    sq_newclosure(_VM,func,0);
-    ret.AttachToStackObject(-1);
-    sq_pop(_VM,1);
-    return ret;
-}
-
-SquirrelObject SquirrelVM::CreateUserData(int size) {
-  SquirrelObject ret;
-  sq_newuserdata(_VM,size);
-  ret.AttachToStackObject(-1);
-  sq_pop(_VM,1);
-  return ret;
-}
-
-const SquirrelObject &SquirrelVM::GetRootTable()
-{
-    if( !_root ){
-        sq_pushroottable(_VM);
-        _root = new SquirrelObject();
-        _root->AttachToStackObject(-1);
-        sq_pop(_VM,1);
-    }
-    return *_root;
-}
-
-void SquirrelVM::PushRootTable(void) {
-  sq_pushroottable(_VM);
-} // SquirrelVM::PushRootTable
-
-// Creates a function in the table or class currently on the stack.
-//void CreateFunction(HSQUIRRELVM v,const SQChar * scriptFuncName,SQFUNCTION func,int numParams=0,const SQChar * typeMask=0) {
-SquirrelObject SquirrelVM::CreateFunction(SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask) {
-  sq_pushstring(_VM,scriptFuncName,-1);
-  sq_newclosure(_VM,func,0);
-  SquirrelObject ret;
-  ret.AttachToStackObject(-1);
-  SQChar tm[64];
-  SQChar * ptm = tm;
-  int numParams = SQ_MATCHTYPEMASKSTRING;
-  if (typeMask) {
-    if (typeMask[0] == '*') {
-      ptm       = 0; // Variable args: don't check parameters.
-      numParams = 0; // Clear SQ_MATCHTYPEMASKSTRING (does not mean match 0 params. See sq_setparamscheck()).
-    } else {
-      if (SCSNPRINTF(tm,sizeof(tm),_SC("t|y|x%s"),typeMask) < 0) {
-//        sq_throwerror(_VM,_SC("CreateFunction: typeMask string too long."));
-        throw SquirrelError(_SC("CreateFunction: typeMask string too long."));
-      } // if
-    } // if
-  } else { // <TODO> Need to check object type on stack: table, class, instance, etc.
-    SCSNPRINTF(tm,sizeof(tm),_SC("%s"),_SC("t|y|x")); // table, class, instance.
-//    tm[0] = 't';
-//    tm[1] = 0;
-  } // if
-#if 0
-  sq_setparamscheck(_VM,numParams+1,ptm); // Parameters are table+args (thus, the +1).
-#else
-  if (ptm) {
-    sq_setparamscheck(_VM,numParams,ptm); // Determine arg count from type string.
-  } // if
-#endif
-#ifdef _DEBUG
-  sq_setnativeclosurename(_VM,-1,scriptFuncName); // For debugging only.
-#endif
-  sq_createslot(_VM,-3); // Create slot in table or class (assigning function to slot at scriptNameFunc).
-  return ret;
-} // SquirrelVM::CreateFunction
-
-SquirrelObject SquirrelVM::CreateFunction(SquirrelObject & so,SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask) {
-  PushObject(so);
-  SquirrelObject ret = CreateFunction(func,scriptFuncName,typeMask);
-  Pop(1);
-  return ret;
-} // SquirrelVM::CreateFunction
-
-// Create a Global function on the root table.
-//void CreateFunctionGlobal(HSQUIRRELVM v,const SQChar * scriptFuncName,SQFUNCTION func,int numParams=0,const SQChar * typeMask=0) {
-SquirrelObject SquirrelVM::CreateFunctionGlobal(SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask) {
-  PushRootTable(); // Push root table.
-  //  CreateFunction(scriptFuncName,func,numParams,typeMask);
-  SquirrelObject ret = CreateFunction(func,scriptFuncName,typeMask);
-  Pop(1);         // Pop root table.
-  return ret;
-} // SquirrelVM::CreateFunctionGlobal
+#include <stdio.h>

+#include <stdarg.h>

+#include <assert.h>

+

+#define _DEBUG_DUMP

+

+#include "sqplus.h"

+

+#include <sqstdio.h>

+#include <sqstdmath.h>

+#include <sqstdstring.h>

+#include <sqstdaux.h>

+#include <sqstdblob.h>

+#include <sqstdsystem.h>

+

+

+HSQUIRRELVM     SquirrelVM::_VM;

+bool            SquirrelVM::_no_vm_ref;

+int             SquirrelVM::_CallState = -1;

+SquirrelObject* SquirrelVM::_root;

+HSQUIRRELVM     SquirrelVM::_sandboxVM;

+SquirrelObject  SquirrelVM::_vm;

+

+

+// Helper struct to keep track of all SQSharedState:s created by SquirrelVM.

+#include "../squirrel/sqpcheader.h"

+#include "../squirrel/sqvm.h"

+struct SQSharedStateNode { 

+    SQSharedStateNode( SQSharedState* ps );

+    ~SQSharedStateNode( );

+    SQSharedState*     m_ps;

+    SQSharedStateNode* m_nxt;

+};

+

+// Linked list of shared states

+static SQSharedStateNode* g_sqss_fst;

+

+SQSharedStateNode::SQSharedStateNode( SQSharedState* ps ) : m_ps(ps), m_nxt(g_sqss_fst) { 

+    g_sqss_fst = this;

+}

+

+SQSharedStateNode::~SQSharedStateNode() {

+    if(m_ps) sq_delete(m_ps,SQSharedState); 

+    delete m_nxt;

+}

+

+static struct SquirrelVM_ModConstr { 

+    ~SquirrelVM_ModConstr(){ 

+        // Delete any shared states we created

+        delete g_sqss_fst;

+        g_sqss_fst = NULL;

+    }

+} g_squirrelvm_mod_constr;

+

+

+

+SquirrelError::SquirrelError() 

+{

+    const SQChar *s;

+    sq_getlasterror(SquirrelVM::_VM);

+    sq_getstring(SquirrelVM::_VM,-1,&s);

+    if(s) {

+        desc = s;

+    }

+    else {

+        desc = _SC("unknown error");

+    }

+}

+

+

+SquirrelVMSys::~SquirrelVMSys() {

+    // Must take care to release object with the 'ref' VM

+    PushRefVM( _vm.GetObjectHandle()._unVal.pThread );

+    _vm.Reset();

+    PopRefVM();

+}

+

+void SquirrelVMSys::Set( HSQUIRRELVM v ){

+    // Must take care to release object with the 'ref' VM

+    PushRefVM( v );

+    _vm = v;

+    PopRefVM( );

+}

+

+void SquirrelVMSys::Set( const SquirrelObject& ov ){

+    assert( ov.GetObjectHandle()._type==OT_THREAD );

+    // Must take care to release object with the 'ref' VM

+    PushRefVM( ov.GetObjectHandle()._unVal.pThread );

+    _vm = ov;

+    PopRefVM( );

+}

+

+SquirrelVMSys::operator HSQUIRRELVM () const { 

+    // Avoid const madness

+    SquirrelObject *pvm = (SquirrelObject*)&_vm;

+    assert( pvm->GetObjectHandle()._type==OT_THREAD );

+    return pvm->GetObjectHandle()._unVal.pThread; 

+}

+

+

+// When doing a SquirrelObject assignment, a reference using the current

+// VM is done. 

+HSQUIRRELVM g_VM_pushed;

+void SquirrelVMSys::PushRefVM( HSQUIRRELVM v ){

+    assert( !g_VM_pushed );

+    g_VM_pushed = SquirrelVM::_VM;

+    SquirrelVM::_VM = v;

+}

+

+void SquirrelVMSys::PopRefVM( ){

+    SquirrelVM::_VM = g_VM_pushed;

+    g_VM_pushed = NULL;

+}

+

+

+bool SquirrelVM::Init( HSQUIRRELVM v ){

+    if( v && v==_VM )

+        return true; 

+    

+    // Do we have a previous state?

+    Release( );

+        

+    bool created_new = false;

+    if( !v ){

+        // Create a new VM - a root VM with new SharedState.

+        v = sq_open(1024);

+        if( !v ) return false;

+        // Store the associated shared state in a linked list. The state will only 

+        // be destroyed at app shutdown. Often that is fine, but if using many 

+        // VM:s briefly, this allocation is not optimal.

+        new SQSharedStateNode( _ss(v) );

+        created_new = true;

+        sq_setprintfunc(v,SquirrelVM::PrintFunc, SquirrelVM::PrintFunc);

+        sq_pushroottable(v);

+        sqstd_register_iolib(v);

+        sqstd_register_bloblib(v);

+        sqstd_register_mathlib(v);

+        sqstd_register_stringlib(v);

+#ifdef SQPLUS_SQUIRRELVM_WITH_SYSTEMLIB        

+        sqstd_register_systemlib(v);

+#endif        

+        sqstd_seterrorhandlers(v);

+        //TODO error handler, compiler error handler

+        sq_pop(v,1);

+    }

+    

+    // After this we hold a ref

+    _no_vm_ref = false;

+    _VM = v;

+    _vm = v;

+   

+    // In the case where Squirrel is ref counted we currently

+    // hold two references to the VM (since it is created with 

+    // a ref count of 1). In the GC case, it is outside of the 

+    // chain of valid objects, so it is not referenced. Compensate 

+    // in ref counted case.

+    if( created_new )

+        DropVMRefIfRefCounted( v );

+    

+    return true;

+}

+

+bool SquirrelVM::InitNoRef( HSQUIRRELVM v ){

+    if( v && v==_VM )

+        return true; 

+    

+    // Do we have a previous state?

+    Release( );

+        

+    // Set pointer to this VM, without referencing it

+    _no_vm_ref = true;

+    _VM = v;

+    

+    return true;

+}

+

+/*

+void SquirrelVM::Init( HSQUIRRELVM v )

+{

+    if( v && v==_VM ) {

+      return;

+    }

+    

+    // Do we have a previous state?

+    Release();

+    

+    if( !v ){

+        // Create a new VM and own it

+        _VM = sq_open(1024);

+        sq_setprintfunc(_VM,SquirrelVM::PrintFunc);

+        sq_pushroottable(_VM);

+        sqstd_register_iolib(_VM);

+        sqstd_register_bloblib(_VM);

+        sqstd_register_mathlib(_VM);

+        sqstd_register_stringlib(_VM);

+        sqstd_seterrorhandlers(_VM);

+        //TODO error handler, compiler error handler

+        sq_pop(_VM,1);

+    }

+    else {

+        _VM = v;

+    }

+    // After this we hold a ref

+    _vm = _VM;

+}

+*/

+

+void SquirrelVM::Release() {

+    // Release root table object if we have one

+    if( _root ){ 

+        delete _root;

+        _root = NULL;

+    }

+    

+    // Release our ref on VM - if we should

+    if( !_no_vm_ref )

+        _vm.Reset();

+        

+    _VM = NULL;

+}

+

+void SquirrelVM::DropVMRefIfRefCounted( HSQUIRRELVM v ){ 

+#ifdef NO_GARBAGE_COLLECTOR

+    if( v ){

+        SQObject t;

+        t._unVal.pThread = v;

+        t._type = OT_THREAD;

+        sq_release( v, &t );

+    }

+#endif     

+}

+

+BOOL SquirrelVM::Update()

+{

+    //update remote debugger

+    return TRUE;

+}

+

+void SquirrelVM::PrintFunc(HSQUIRRELVM v,const SQChar* s,...)

+{

+    static SQChar temp[2048];

+    va_list vl;

+    va_start(vl, s);

+    scvsprintf( temp,s, vl);

+    SCPUTS(temp);

+    va_end(vl);

+}

+

+SquirrelObject SquirrelVM::CompileScript(const SQChar *s)

+{

+    SquirrelObject ret;

+    if(SQ_SUCCEEDED(sqstd_loadfile(_VM,s,1))) {

+        ret.AttachToStackObject(-1);

+        sq_pop(_VM,1);

+        return ret;

+    }

+    throw SquirrelError();

+}

+

+SquirrelObject SquirrelVM::CompileBuffer(const SQChar *s,const SQChar * debugInfo)

+{

+    SquirrelObject ret;

+    if(SQ_SUCCEEDED(sq_compilebuffer(_VM,s,(int)scstrlen(s)*sizeof(SQChar),debugInfo,1))) {

+        ret.AttachToStackObject(-1);

+        sq_pop(_VM,1);

+        return ret;

+    }

+    throw SquirrelError();

+}

+

+SquirrelObject SquirrelVM::RunScript(const SquirrelObject &o,SquirrelObject *_this)

+{

+    SquirrelObject ret;

+    sq_pushobject(_VM,o._o);

+    if(_this) {

+        sq_pushobject(_VM,_this->_o);

+    }

+    else {

+        sq_pushroottable(_VM);

+    }

+    if(SQ_SUCCEEDED(sq_call(_VM,1,SQTrue,SQ_CALL_RAISE_ERROR))) {

+        ret.AttachToStackObject(-1);

+        sq_pop(_VM,2);

+        return ret;

+    }

+    sq_pop(_VM,1);

+    throw SquirrelError();

+    

+}

+

+

+BOOL SquirrelVM::BeginCall(const SquirrelObject &func)

+{

+    if(_CallState != -1)

+        return FALSE;

+    _CallState = 1;

+    sq_pushobject(_VM,func._o);

+    sq_pushroottable(_VM);

+    return TRUE;

+}

+

+BOOL SquirrelVM::BeginCall(const SquirrelObject &func,SquirrelObject &_this)

+{

+    if(_CallState != -1)

+        throw SquirrelError(_SC("call already initialized"));

+    _CallState = 1;

+    sq_pushobject(_VM,func._o);

+    sq_pushobject(_VM,_this._o);

+    return TRUE;

+}

+

+#define _CHECK_CALL_STATE \

+    if(_CallState == -1) \

+        throw SquirrelError(_SC("call not initialized"));

+

+void SquirrelVM::PushParam(const SquirrelObject &o)

+{

+    _CHECK_CALL_STATE

+    sq_pushobject(_VM,o._o);

+    _CallState++;

+}

+

+void SquirrelVM::PushParam(const SQChar *s)

+{

+    _CHECK_CALL_STATE

+    sq_pushstring(_VM,s,-1);

+    _CallState++;

+}

+

+void SquirrelVM::PushParam(SQInteger n)

+{

+    _CHECK_CALL_STATE

+    sq_pushinteger(_VM,n);

+    _CallState++;

+}

+

+void SquirrelVM::PushParam(SQFloat f)

+{

+    _CHECK_CALL_STATE

+    sq_pushfloat(_VM,f);

+    _CallState++;

+}

+

+void SquirrelVM::PushParamNull()

+{

+    _CHECK_CALL_STATE

+    sq_pushnull(_VM);

+    _CallState++;

+}

+

+void SquirrelVM::PushParam(SQUserPointer up)

+{

+    _CHECK_CALL_STATE

+    sq_pushuserpointer(_VM,up);

+    _CallState++;

+}

+

+SquirrelObject SquirrelVM::EndCall()

+{

+    SquirrelObject ret;

+    if(_CallState >= 0) { 

+        int oldtop = sq_gettop(_VM);

+        int nparams = _CallState;

+        _CallState = -1;

+        if(SQ_SUCCEEDED(sq_call(_VM,nparams,SQTrue,SQ_CALL_RAISE_ERROR))) {

+            ret.AttachToStackObject(-1);

+            sq_pop(_VM,2);

+        }else {

+            sq_settop(_VM,oldtop-(nparams+1));

+            throw SquirrelError();

+        }

+        

+    }

+    return ret;

+}

+

+SquirrelObject SquirrelVM::CreateInstance(SquirrelObject &oclass)

+{

+    SquirrelObject ret;

+    int oldtop = sq_gettop(_VM);

+    sq_pushobject(_VM,oclass._o);

+    if(SQ_FAILED(sq_createinstance(_VM,-1))) {

+        sq_settop(_VM,oldtop);

+        throw SquirrelError();

+    }

+    ret.AttachToStackObject(-1);

+    sq_pop(_VM,2);

+    return ret;

+}

+

+SquirrelObject SquirrelVM::CreateTable()

+{

+    SquirrelObject ret;

+    sq_newtable(_VM);

+    ret.AttachToStackObject(-1);

+    sq_pop(_VM,1);

+    return ret;

+}

+

+SquirrelObject SquirrelVM::CreateString(const SQChar *s)

+{

+    SquirrelObject ret;

+    sq_pushstring(_VM,s,-1);

+    ret.AttachToStackObject(-1);

+    sq_pop(_VM,1);

+    return ret;

+}

+

+

+SquirrelObject SquirrelVM::CreateArray(int size)

+{

+    SquirrelObject ret;

+    sq_newarray(_VM,size);

+    ret.AttachToStackObject(-1);

+    sq_pop(_VM,1);

+    return ret;

+}

+

+SquirrelObject SquirrelVM::CreateFunction(SQFUNCTION func)

+{

+    SquirrelObject ret;

+    sq_newclosure(_VM,func,0);

+    ret.AttachToStackObject(-1);

+    sq_pop(_VM,1);

+    return ret;

+}

+

+SquirrelObject SquirrelVM::CreateUserData(int size) {

+  SquirrelObject ret;

+  sq_newuserdata(_VM,size);

+  ret.AttachToStackObject(-1);

+  sq_pop(_VM,1);

+  return ret;

+}

+

+const SquirrelObject &SquirrelVM::GetRootTable()

+{

+    if( !_root ){

+        sq_pushroottable(_VM);

+        _root = new SquirrelObject();

+        _root->AttachToStackObject(-1);

+        sq_pop(_VM,1);

+    }

+    return *_root;

+}

+

+void SquirrelVM::PushRootTable(void) {

+  sq_pushroottable(_VM);

+} // SquirrelVM::PushRootTable

+

+// Creates a function in the table or class currently on the stack.

+//void CreateFunction(HSQUIRRELVM v,const SQChar * scriptFuncName,SQFUNCTION func,int numParams=0,const SQChar * typeMask=0) {

+SquirrelObject SquirrelVM::CreateFunction(SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask) {

+  sq_pushstring(_VM,scriptFuncName,-1);

+  sq_newclosure(_VM,func,0);

+  SquirrelObject ret;

+  ret.AttachToStackObject(-1);

+  SQChar tm[64];

+  SQChar * ptm = tm;

+  int numParams = SQ_MATCHTYPEMASKSTRING;

+  if (typeMask) {

+    if (typeMask[0] == '*') {

+      ptm       = 0; // Variable args: don't check parameters.

+      numParams = 0; // Clear SQ_MATCHTYPEMASKSTRING (does not mean match 0 params. See sq_setparamscheck()).

+    } else {

+      if (SCSNPRINTF(tm,sizeof(tm),_SC("t|y|x%s"),typeMask) < 0) {

+//        sq_throwerror(_VM,_SC("CreateFunction: typeMask string too long."));

+        throw SquirrelError(_SC("CreateFunction: typeMask string too long."));

+      } // if

+    } // if

+  } else { // <TODO> Need to check object type on stack: table, class, instance, etc.

+    SCSNPRINTF(tm,sizeof(tm),_SC("%s"),_SC("t|y|x")); // table, class, instance.

+//    tm[0] = 't';

+//    tm[1] = 0;

+  } // if

+#if 0

+  sq_setparamscheck(_VM,numParams+1,ptm); // Parameters are table+args (thus, the +1).

+#else

+  if (ptm) {

+    sq_setparamscheck(_VM,numParams,ptm); // Determine arg count from type string.

+  } // if

+#endif

+#ifdef _DEBUG

+  sq_setnativeclosurename(_VM,-1,scriptFuncName); // For debugging only.

+#endif

+  sq_createslot(_VM,-3); // Create slot in table or class (assigning function to slot at scriptNameFunc).

+  return ret;

+} // SquirrelVM::CreateFunction

+

+SquirrelObject SquirrelVM::CreateFunction(SquirrelObject & so,SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask) {

+  PushObject(so);

+  SquirrelObject ret = CreateFunction(func,scriptFuncName,typeMask);

+  Pop(1);

+  return ret;

+} // SquirrelVM::CreateFunction

+

+// Create a Global function on the root table.

+//void CreateFunctionGlobal(HSQUIRRELVM v,const SQChar * scriptFuncName,SQFUNCTION func,int numParams=0,const SQChar * typeMask=0) {

+SquirrelObject SquirrelVM::CreateFunctionGlobal(SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask) {

+  PushRootTable(); // Push root table.

+  //  CreateFunction(scriptFuncName,func,numParams,typeMask);

+  SquirrelObject ret = CreateFunction(func,scriptFuncName,typeMask);

+  Pop(1);         // Pop root table.

+  return ret;

+} // SquirrelVM::CreateFunctionGlobal

diff --git a/squirrel_3_0_1_stable/sqplus/SquirrelVM.h b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelVM.h
index ee66a2b76..70c4f2a36 100644
--- a/squirrel_3_0_1_stable/sqplus/SquirrelVM.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/SquirrelVM.h
@@ -1,179 +1,179 @@
-#ifndef _SQUIRREL_VM_H_
-#define _SQUIRREL_VM_H_
-
-#include "SquirrelObject.h"
-
-struct SquirrelError {
-    SquirrelError();
-    SquirrelError(const SQChar* s):desc(s){}
-    const SQChar *desc;
-};
-
-// This class can hold a reference to a SquirrelVM. It keeps a Squirrel ref
-// to the VM to protect it from being deleted while held.
-struct SquirrelVMSys { 
-    SquirrelVMSys() { }
-    ~SquirrelVMSys();
-    
-    void Set( HSQUIRRELVM v );
-    void Set( const SquirrelObject& ov );
-    void Reset( ){ _vm.Reset(); } 
-    
-    SquirrelVMSys& operator = (HSQUIRRELVM v){ Set(v); return *this; }
-    operator HSQUIRRELVM () const;
-    
-protected:    
-    void PushRefVM(HSQUIRRELVM v);
-    void PopRefVM();
-    SquirrelObject _vm;
-    friend class SquirrelVM;
-};
-
-// Notes on creating / destroying SquirrelVM:s:
-//
-// VM:s created through sq_open are special since they create a new 
-// SQSharedState. That shared state is later shared by any new thread
-// or friend VM. sq_close can be used for closing VM:s created through
-// sq_open (but not for friend VMs). 
-//
-// Using squirrel references in SquirrelVMSys and SquirrelVM, one must
-// make sure that these are all reset if one calls sq_close manually.
-//
-// When there are no more references to a VM, it is destroyed automatically,
-// but the shared state is not! For VM:s created by SquirrelVM, it keeps 
-// a list of shared states it has created and will destroy them all on 
-// app shutdown. 
-
-class SquirrelVM {
-    friend class SquirrelObject;
-    friend struct SquirrelError;
-    friend struct SquirrelVMSys;
-    
-public:
-    // If a VM is passed as arg here, Init will not alter it. Otherwise 
-    // a new VM is created and initialized. A squirrel reference is kept 
-    // while it is the current VM.
-    static bool Init( HSQUIRRELVM v=NULL );
-    
-    // Initialize with an externally created VM, without adding a ref 
-    // on it. NOTE: This may not be compatible with Set/GetVMSys as 
-    // we're just working with raw pointers here.
-    static bool InitNoRef( HSQUIRRELVM v );
-    static BOOL IsInitialized(){return _VM == NULL?FALSE:TRUE;}
-    
-    static void Release();   // Release ref on VM and reset VM pointer
-    static void Shutdown(){ Release(); }
-    static void AppFinalShutdown();  // Call when finally shutting down app
-    
-    static BOOL Update(); //debugger and maybe GC later
-    
-    static SquirrelObject CompileScript(const SQChar *s);
-    static SquirrelObject CompileBuffer(const SQChar *s,const SQChar * debugInfo=_SC("console_buffer"));
-    static SquirrelObject RunScript(const SquirrelObject &o,SquirrelObject *_this = NULL);
-    
-    static void PrintFunc(HSQUIRRELVM v,const SQChar* s,...);
-    
-    static BOOL BeginCall(const SquirrelObject &func);
-    static BOOL BeginCall(const SquirrelObject &func,SquirrelObject &_this);
-    
-    static void PushParam(const SquirrelObject &o);
-    static void PushParam(const SQChar *s);
-    static void PushParam(SQInteger n);
-    static void PushParam(SQFloat f);
-    static void PushParam(SQUserPointer up);
-    static void PushParamNull();
-    
-    static SquirrelObject EndCall();
-    static SquirrelObject CreateString(const SQChar *s);
-    static SquirrelObject CreateTable();    
-    static SquirrelObject CreateArray(int size);
-    static SquirrelObject CreateInstance(SquirrelObject &oclass); // oclass is an existing class. Create an 'instance' (OT_INSTANCE) of oclass.
-    static SquirrelObject CreateFunction(SQFUNCTION func);
-    static SquirrelObject CreateUserData(int size);
-
-    static const SquirrelObject &GetRootTable();
-    static HSQUIRRELVM GetVMPtr() { return _VM; }
-
-    // The sandbox VM ptr is one which cannot access functions bound with 
-    // SqPlus. It is suitable for running non-trusted scripts that can only
-    // access basic functionality.
-    static void SetSandboxVMPtr(HSQUIRRELVM v) {
-      _sandboxVM = v;
-    } // SetSandboxVMPtr
-  
-    static HSQUIRRELVM GetSandboxVMPtr() {
-      return _sandboxVM;
-    } // GetSandboxVMPtr
-  
-    static void GetVMSys(SquirrelVMSys & vmSys) {
-      vmSys.Set( _vm );
-    } // GetVMSys
-
-    static void SetVMSys(const SquirrelVMSys & vmSys) {
-      Release();
-      HSQUIRRELVM v = (HSQUIRRELVM)vmSys;
-      if( v ) 
-          Init( v );
-    } // SetVMSys
-
-    static void PushValue(INT val) {
-        sq_pushinteger(_VM,val);
-    } // PushValue
-    static void PushValue(FLOAT val) {
-        sq_pushfloat(_VM,val);
-    } // PushValue
-    static void PushValue(bool val) { // Compiler treats SQBool as INT.
-        sq_pushbool(_VM,val);
-    } // PushValue
-    static void PushValue(SQChar * val) {
-        sq_pushstring(_VM,val,-1);
-    } // PushValue
-    static void PushValue(SQUserPointer val) {
-        sq_pushuserpointer(_VM,val);
-    } // PushValue
-    static void PushValue(const SQChar * val) {
-        sq_pushstring(_VM,val,-1);
-    } // PushValue
-    static void PushObject(SquirrelObject & so) {
-        sq_pushobject(_VM,so._o);
-    } // PushObject
-    static void Pop(SQInteger nelemstopop) {
-        sq_pop(_VM,nelemstopop);
-    } // Pop
-    
-    static void PushRootTable(void);
-    
-    // Create/bind a function on the table currently on the stack.
-    static SquirrelObject CreateFunction(SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask=0);
-    // Create/bind a function on the table so. typeMask: standard Squirrel types plus: no typemask means no args, "*" means any type of args.
-    static SquirrelObject CreateFunction(SquirrelObject & so,SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask=0);
-    // Create/bind a function to the root table. typeMask: standard Squirrel types plus: no typemask means no args, "*" means any type of args.
-    static SquirrelObject CreateFunctionGlobal(SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask=0);
-
-    // This is a helper to correct a difference in referncing new VM:s in 
-    // ref counted versus garbage collected modes. NOTE: Only use after creating
-    // a VM with:  1 - sq_open()  2 - Creating a ref to the VM (SquirrelObject)
-    static void DropVMRefIfRefCounted( HSQUIRRELVM v );
-  
-
-private:
-    static SquirrelObject _vm;        // This is a Squirrel reference to the VM
-    static HSQUIRRELVM    _VM;        // The raw C++ pointer
-    static bool           _no_vm_ref; // Set if we only keep the raw C++ pointer and no ref
-    static int _CallState;
-    static SquirrelObject * _root;    // Cached root table if non NULL
-    static HSQUIRRELVM _sandboxVM;    // The sandbox VM (that cannot use bound functions)
-};
-
-
-template<typename T>
-inline BOOL SquirrelObject::ArrayAppend(T item) {
-    sq_pushobject(SquirrelVM::_VM,GetObjectHandle());
-    SquirrelVM::PushValue(item);
-    BOOL res = sq_arrayappend(SquirrelVM::_VM,-2) == SQ_OK;
-    sq_pop(SquirrelVM::_VM,1);
-    return res;
-} // ArrayAppend
-
-#endif //_SQUIRREL_VM_H_
-
+#ifndef _SQUIRREL_VM_H_

+#define _SQUIRREL_VM_H_

+

+#include "SquirrelObject.h"

+

+struct SquirrelError {

+    SquirrelError();

+    SquirrelError(const SQChar* s):desc(s){}

+    const SQChar *desc;

+};

+

+// This class can hold a reference to a SquirrelVM. It keeps a Squirrel ref

+// to the VM to protect it from being deleted while held.

+struct SquirrelVMSys { 

+    SquirrelVMSys() { }

+    ~SquirrelVMSys();

+    

+    void Set( HSQUIRRELVM v );

+    void Set( const SquirrelObject& ov );

+    void Reset( ){ _vm.Reset(); } 

+    

+    SquirrelVMSys& operator = (HSQUIRRELVM v){ Set(v); return *this; }

+    operator HSQUIRRELVM () const;

+    

+protected:    

+    void PushRefVM(HSQUIRRELVM v);

+    void PopRefVM();

+    SquirrelObject _vm;

+    friend class SquirrelVM;

+};

+

+// Notes on creating / destroying SquirrelVM:s:

+//

+// VM:s created through sq_open are special since they create a new 

+// SQSharedState. That shared state is later shared by any new thread

+// or friend VM. sq_close can be used for closing VM:s created through

+// sq_open (but not for friend VMs). 

+//

+// Using squirrel references in SquirrelVMSys and SquirrelVM, one must

+// make sure that these are all reset if one calls sq_close manually.

+//

+// When there are no more references to a VM, it is destroyed automatically,

+// but the shared state is not! For VM:s created by SquirrelVM, it keeps 

+// a list of shared states it has created and will destroy them all on 

+// app shutdown. 

+

+class SquirrelVM {

+    friend class SquirrelObject;

+    friend struct SquirrelError;

+    friend struct SquirrelVMSys;

+    

+public:

+    // If a VM is passed as arg here, Init will not alter it. Otherwise 

+    // a new VM is created and initialized. A squirrel reference is kept 

+    // while it is the current VM.

+    static bool Init( HSQUIRRELVM v=NULL );

+    

+    // Initialize with an externally created VM, without adding a ref 

+    // on it. NOTE: This may not be compatible with Set/GetVMSys as 

+    // we're just working with raw pointers here.

+    static bool InitNoRef( HSQUIRRELVM v );

+    static BOOL IsInitialized(){return _VM == NULL?FALSE:TRUE;}

+    

+    static void Release();   // Release ref on VM and reset VM pointer

+    static void Shutdown(){ Release(); }

+    static void AppFinalShutdown();  // Call when finally shutting down app

+    

+    static BOOL Update(); //debugger and maybe GC later

+    

+    static SquirrelObject CompileScript(const SQChar *s);

+    static SquirrelObject CompileBuffer(const SQChar *s,const SQChar * debugInfo=_SC("console_buffer"));

+    static SquirrelObject RunScript(const SquirrelObject &o,SquirrelObject *_this = NULL);

+    

+    static void PrintFunc(HSQUIRRELVM v,const SQChar* s,...);

+    

+    static BOOL BeginCall(const SquirrelObject &func);

+    static BOOL BeginCall(const SquirrelObject &func,SquirrelObject &_this);

+    

+    static void PushParam(const SquirrelObject &o);

+    static void PushParam(const SQChar *s);

+    static void PushParam(SQInteger n);

+    static void PushParam(SQFloat f);

+    static void PushParam(SQUserPointer up);

+    static void PushParamNull();

+    

+    static SquirrelObject EndCall();

+    static SquirrelObject CreateString(const SQChar *s);

+    static SquirrelObject CreateTable();    

+    static SquirrelObject CreateArray(int size);

+    static SquirrelObject CreateInstance(SquirrelObject &oclass); // oclass is an existing class. Create an 'instance' (OT_INSTANCE) of oclass.

+    static SquirrelObject CreateFunction(SQFUNCTION func);

+    static SquirrelObject CreateUserData(int size);

+

+    static const SquirrelObject &GetRootTable();

+    static HSQUIRRELVM GetVMPtr() { return _VM; }

+

+    // The sandbox VM ptr is one which cannot access functions bound with 

+    // SqPlus. It is suitable for running non-trusted scripts that can only

+    // access basic functionality.

+    static void SetSandboxVMPtr(HSQUIRRELVM v) {

+      _sandboxVM = v;

+    } // SetSandboxVMPtr

+  

+    static HSQUIRRELVM GetSandboxVMPtr() {

+      return _sandboxVM;

+    } // GetSandboxVMPtr

+  

+    static void GetVMSys(SquirrelVMSys & vmSys) {

+      vmSys.Set( _vm );

+    } // GetVMSys

+

+    static void SetVMSys(const SquirrelVMSys & vmSys) {

+      Release();

+      HSQUIRRELVM v = (HSQUIRRELVM)vmSys;

+      if( v ) 

+          Init( v );

+    } // SetVMSys

+

+    static void PushValue(INT val) {

+        sq_pushinteger(_VM,val);

+    } // PushValue

+    static void PushValue(FLOAT val) {

+        sq_pushfloat(_VM,val);

+    } // PushValue

+    static void PushValue(bool val) { // Compiler treats SQBool as INT.

+        sq_pushbool(_VM,val);

+    } // PushValue

+    static void PushValue(SQChar * val) {

+        sq_pushstring(_VM,val,-1);

+    } // PushValue

+    static void PushValue(SQUserPointer val) {

+        sq_pushuserpointer(_VM,val);

+    } // PushValue

+    static void PushValue(const SQChar * val) {

+        sq_pushstring(_VM,val,-1);

+    } // PushValue

+    static void PushObject(SquirrelObject & so) {

+        sq_pushobject(_VM,so._o);

+    } // PushObject

+    static void Pop(SQInteger nelemstopop) {

+        sq_pop(_VM,nelemstopop);

+    } // Pop

+    

+    static void PushRootTable(void);

+    

+    // Create/bind a function on the table currently on the stack.

+    static SquirrelObject CreateFunction(SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask=0);

+    // Create/bind a function on the table so. typeMask: standard Squirrel types plus: no typemask means no args, "*" means any type of args.

+    static SquirrelObject CreateFunction(SquirrelObject & so,SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask=0);

+    // Create/bind a function to the root table. typeMask: standard Squirrel types plus: no typemask means no args, "*" means any type of args.

+    static SquirrelObject CreateFunctionGlobal(SQFUNCTION func,const SQChar * scriptFuncName,const SQChar * typeMask=0);

+

+    // This is a helper to correct a difference in referncing new VM:s in 

+    // ref counted versus garbage collected modes. NOTE: Only use after creating

+    // a VM with:  1 - sq_open()  2 - Creating a ref to the VM (SquirrelObject)

+    static void DropVMRefIfRefCounted( HSQUIRRELVM v );

+  

+

+private:

+    static SquirrelObject _vm;        // This is a Squirrel reference to the VM

+    static HSQUIRRELVM    _VM;        // The raw C++ pointer

+    static bool           _no_vm_ref; // Set if we only keep the raw C++ pointer and no ref

+    static int _CallState;

+    static SquirrelObject * _root;    // Cached root table if non NULL

+    static HSQUIRRELVM _sandboxVM;    // The sandbox VM (that cannot use bound functions)

+};

+

+

+template<typename T>

+inline BOOL SquirrelObject::ArrayAppend(T item) {

+    sq_pushobject(SquirrelVM::_VM,GetObjectHandle());

+    SquirrelVM::PushValue(item);

+    BOOL res = sq_arrayappend(SquirrelVM::_VM,-2) == SQ_OK;

+    sq_pop(SquirrelVM::_VM,1);

+    return res;

+} // ArrayAppend

+

+#endif //_SQUIRREL_VM_H_

+

diff --git a/squirrel_3_0_1_stable/sqplus/changes.txt b/squirrel_3_0_1_stable/_OLD_sqplus/changes.txt
index a33f32c2f..a33f32c2f 100644
--- a/squirrel_3_0_1_stable/sqplus/changes.txt
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/changes.txt
diff --git a/squirrel_3_0_1_stable/sqplus/sqplus.cbp b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.cbp
index ba10ef105..ba10ef105 100644
--- a/squirrel_3_0_1_stable/sqplus/sqplus.cbp
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.cbp
diff --git a/squirrel_3_0_1_stable/sqplus/sqplus.h b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.h
index 6116d50ec..fff1633ed 100644
--- a/squirrel_3_0_1_stable/sqplus/sqplus.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.h
@@ -1,2327 +1,2327 @@
-// SqPlus.h
-// Created by John Schultz 9/05/05, major update 10/05/05.
-// Template function call design from LuaPlusCD by Joshua C. Jensen,
-// inspired by luabind which was inspired by boost::python.
-// Const argument, const member functions, and Mac OS-X changes by Simon Michelmore.
-// DECLARE_INSTANCE_TYPE_NAME changes by Ben (Project5) from http://www.squirrel-lang.org/forums/.
-// Added Kamaitati's changes 5/28/06.
-// Free for any use.
-
-#ifndef _SQ_PLUS_H_
-#define _SQ_PLUS_H_
-
-#include <stdlib.h>
-#include <assert.h>
-
-#ifdef __APPLE__
-  #include <malloc/malloc.h>
-#else
-  #include <malloc.h>
-#endif
-#include <memory.h>
-#include <memory>
-#include <limits.h>  // For INT_MAX on GCC
-
-#include "squirrel.h"   // Include to get SQUNICODE setting from here
-#ifndef _SC
-  #error No _SC macro  - Usually defined in squirrel.h
-#endif
-// Provide a _sqT(...) macros also (same as _SC but easier to know its for Squirrel)
-#ifndef _sqT
-  #define _sqT _SC
-#endif 
-
-// For backward compatibility, define _T if outside of Windows platform.
-// (really, _SC() or _sqT() are better, since that leaves us free to run 
-// Squirrel in ASCII or wchar_t mode, regardless of the app being built).
-#if !defined(_WIN32) && !defined(_WIN64) 
-  #ifndef _T
-    #define _T _SC
-  #endif
-#endif 
-
-
-// A comment about strings. We let squirrel.h determine whether to use 
-// char or wchar_t strings. So here we follow the define SQUNICODE. This 
-// opens up for using Unicode system calls on Windows while having the script 
-// engine in ASCII mode, or vice versa. To enable this, also the macro
-// _SC("some string") is used instead of _T("some string"). 
-//
-// To handle the case where function parameters are given in the opposite
-// character mode (char if SQChar is wchar_t and vice versa), such strings
-// can be converted on the fly to the other mode in the function call, if 
-// the define SQPLUS_AUTOCONVERT_OTHER_CHAR is set below. Buffers are 
-// allocated and kept around for the duration of the function call. The 
-// same applies to returned strings of the opposite type. 
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-  #include <tchar.h>
-  #ifndef SQUNICODE
-    #define SCSNPRINTF _snprintf
-    #define SCPUTS puts
-  #else
-    #define SCSNPRINTF _snwprintf
-    #define SCPUTS _putws
-  #endif
-  #if defined(_MSC_VER)  
-    #ifndef _CRT_SECURE_NO_DEPRECATE
-	  #define _CRT_SECURE_NO_DEPRECATE    // Disable warnings around various sprintf
-    #endif
-    #pragma warning(disable: 4996)       // When above does not work 
-  #endif    
-#else
-  #ifdef SQUNICODE
-    #define SCSNPRINTF _snwprintf
-    #define SCPUTS _putws
-    #include <stdio.h> // for snprintf
-  #else
-    #define SCSNPRINTF snprintf
-    #include <stdio.h> // for snprintf
-    #define SCPUTS puts
-  #endif
-#endif
-
-
-#ifndef _WINDEF_
-  typedef int BOOL;
-  typedef int INT;
-  typedef float FLOAT;
-  #define TRUE 1
-  #define FALSE 0
-#endif
-
-#if 1
-#define SQ_CALL_RAISE_ERROR SQTrue
-#else
-#define SQ_CALL_RAISE_ERROR SQFalse
-#endif
-
-#include "SquirrelObject.h"
-#include "SquirrelVM.h"
-#include "SquirrelBindingsUtils.h"
-
-// All setup defines have moved to its own file
-#include "SqPlusSetup.h" 
-
-#ifdef SQPLUS_AUTOCONVERT_OTHER_CHAR
-#define SQPLUS_AUTOCONVERT_MAX_INSTANCES 8  // In argument conversion, don't keep more than this alive 
-#include "SqPlusOCharBuf.h" 
-#endif 
- 
-#if defined(SQPLUS_SUPPORT_STD_STRING) && defined(SQUNICODE)
-  #ifdef _MSC_VER
-    #pragma message("std::string and SQChar as wchar_t is not compatible!")
-  #else
-    #warning std::string and SQChar as wchar_t is not compatible!
-  #endif
-#endif
-
-
-namespace SqPlus {
-
-template<class T> struct TypeWrapper {};
-struct SquirrelNull {};       
-struct SQNoBaseClass {};     // For scripted classes with no base class (or no scripted base class)
-
-struct SQAnything { void * anything; }; // Needed for binding pointers to variables (cannot dereference void *).
-typedef SQAnything * SQAnythingPtr;
-typedef SQChar * SQCharPtr;
-
-// Helper struct to (sometimes) store a temporary return value as another type.
-// Useful when returning const char* and other types that require temp allocation.
-// For primitive types, it just maps onto itself.
-template<class T>
-struct Temporary { 
-	typedef T type; 
-};
-
-// References are tricky, but they should just be filtered out usually
-template<class T>
-struct SqAssignableRef { 
-    SqAssignableRef( ) : m_pt(0) { } 
-    void operator = (T& tr){ m_pt=&tr; }
-    operator T& () { return *m_pt; }
-    T *m_pt;
-};
-
-template<class T>
-struct Temporary<T&> { 
-    typedef SqAssignableRef<T> type;
-};
-
-
-// === Do not use directly: use one of the predefined sizes below ===
-
-struct ScriptStringVarBase {
-  const unsigned char MaxLength; // Real length is MaxLength+1.
-  SQChar s[1];
-  ScriptStringVarBase(int _MaxLength) : MaxLength(_MaxLength) {}
-  operator SQChar * () { return &s[0]; }
-  operator void * () { return (void *)&s[0]; }
-  const SQChar * operator = (const SQChar * _s) {
-    return safeStringCopy(s,_s,MaxLength);
-  }
-  // Special safe string copy where MaxLength is 1 less than true buffer length.
-  // strncpy() pads out nulls for the full length of the buffer specified by MaxLength.
-  static inline SQChar * safeStringCopy(SQChar * d,const SQChar * s,int MaxLength) {
-    int i=0;
-    while (s[i]) {
-      d[i] = s[i];
-      i++;
-      if (i == MaxLength) break;
-    } // while
-    d[i] = 0; // Null terminate.
-    return d;
-  } // safeStringCopy
-};
-
-// === Do not use directly: use one of the predefined sizes below ===
-
-template<int MAXLENGTH> // MAXLENGTH is max printable characters (trailing NULL is accounted for in ScriptStringVarBase::s[1]).
-struct ScriptStringVar : ScriptStringVarBase {
-  SQChar ps[MAXLENGTH];
-  ScriptStringVar() : ScriptStringVarBase(MAXLENGTH) {
-    s[0] = 0;
-  }
-  ScriptStringVar(const SQChar * _s) : ScriptStringVarBase(MAXLENGTH) {
-    *this = _s;
-  }
-  const SQChar * operator = (const SQChar * _s) {
-    return safeStringCopy(s,_s,MaxLength);
-  }
-  const SQChar * operator = (const ScriptStringVar & _s) {
-    return safeStringCopy(s,_s.s,MaxLength);
-  }
-  bool operator == (const ScriptStringVar & _s) {
-    return _strcmp(s,_s.s) == 0;
-  }
-  bool compareCaseInsensitive(const ScriptStringVar & _s) {
-    return _stricmp(s,_s.s) == 0;
-  }
-};
-
-// === Fixed size strings for scripting ===
-
-typedef ScriptStringVar<8>   ScriptStringVar8;
-typedef ScriptStringVar<16>  ScriptStringVar16;
-typedef ScriptStringVar<32>  ScriptStringVar32;
-typedef ScriptStringVar<64>  ScriptStringVar64;
-typedef ScriptStringVar<128> ScriptStringVar128;
-typedef ScriptStringVar<256> ScriptStringVar256;
-
-// === Script Variable Types ===
-
-enum ScriptVarType {
-    VAR_TYPE_NONE = -1,
-    VAR_TYPE_INT = 0,
-    VAR_TYPE_UINT,
-    VAR_TYPE_FLOAT,
-    VAR_TYPE_BOOL,
-    VAR_TYPE_CONST_STRING,
-    VAR_TYPE_STRING,
-    VAR_TYPE_USER_POINTER,
-    VAR_TYPE_INSTANCE,
-#ifdef SQPLUS_SUPPORT_STD_STRING
-    VAR_TYPE_STD_STRING,
-#endif
-};
-
-template <typename T>
-struct TypeInfo {
-  const SQChar * typeName;
-  enum {TypeID=VAR_TYPE_NONE, Size=0, TypeMask='?', IsInstance=0};
-};
-
-// === Common Variable Types ===
-
-template<>
-struct TypeInfo<INT> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("int")) {}
-  enum {TypeID=VAR_TYPE_INT,Size=sizeof(INT),TypeMask='i', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<>
-struct TypeInfo<unsigned> {
-	const SQChar * typeName;
-	TypeInfo() : typeName(_SC("uint")) {}
-	enum {TypeID=VAR_TYPE_UINT,Size=sizeof(unsigned), IsInstance=0};
-	operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<>
-struct TypeInfo<FLOAT> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("float")) {}
-  enum {TypeID=VAR_TYPE_FLOAT,Size=sizeof(FLOAT),TypeMask='f', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<>
-struct TypeInfo<bool> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("bool")) {}
-  enum {TypeID=VAR_TYPE_BOOL,Size=sizeof(bool),TypeMask='b', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<>
-struct TypeInfo<short> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("short")) {}
-  enum {TypeID=VAR_TYPE_INT,Size=sizeof(short),TypeMask='i', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<>
-struct TypeInfo<char> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("char")) {}
-  enum {TypeID=VAR_TYPE_INT,Size=sizeof(char),TypeMask='i', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<>
-struct TypeInfo<SQUserPointer> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("SQUserPointer")) {}
-  enum {TypeID=VAR_TYPE_USER_POINTER,Size=sizeof(SQUserPointer),TypeMask='u', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<>
-struct TypeInfo<SQAnything> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("SQUserPointer")) {}
-  enum {TypeID=VAR_TYPE_USER_POINTER,Size=sizeof(SQUserPointer),TypeMask='u', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<>
-struct TypeInfo<SQNoBaseClass> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(0) {}
-  enum {TypeID=-1,Size=0,TypeMask=' ', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<>
-struct TypeInfo<const SQChar *> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("const SQChar *")) {}
-  enum {TypeID=VAR_TYPE_CONST_STRING,Size=sizeof(const SQChar *),TypeMask='s', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-#ifdef SQPLUS_AUTOCONVERT_OTHER_CHAR 
-template<>
-struct TypeInfo<const SQOtherChar *> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("const SQOtherChar *")) {}
-  enum {TypeID=VAR_TYPE_CONST_STRING,Size=sizeof(const SQOtherChar *),TypeMask='s', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-template<>
-struct Temporary<SQOtherChar*> {
-	typedef SQOthCharBuf type;
-};
-template<>
-struct Temporary<const SQOtherChar*> {
-	typedef SQOthCharBuf type;
-};
-#endif // SQPLUS_AUTOCONVERT_OTHER_CHAR
-
-// base case: raw pointer 
-template<typename T, int is_inst>
-struct TypeInfoPtrBase {
-  const SQChar * typeName;
-  TypeInfoPtrBase() : typeName(TypeInfo<T>().typeName) {}
-  enum {TypeID=VAR_TYPE_USER_POINTER,Size=sizeof(T*),TypeMask='u'};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-template<typename T>
-struct TypeInfoPtrBase<T,1> : public TypeInfo<T> { };
-
-// Partial specialization for pointers (to access type without pointer / or instance typeinfo)
-template<class T>
-struct TypeInfo<T*> : public TypeInfoPtrBase<T,TypeInfo<T>::IsInstance> { };
-
-// Same thing for references
-template<class T>
-struct TypeInfo<T&> : public TypeInfoPtrBase<T,TypeInfo<T>::IsInstance> { };
-
-#ifdef SQPLUS_SUPPORT_STD_STRING
-template<>
-struct TypeInfo<std::string> {
-    const SQChar *typeName;
-    TypeInfo() : typeName(_SC("std::string")) {}
-    enum {TypeID=SqPlus::VAR_TYPE_STD_STRING,Size=sizeof(std::string),TypeMask='s'};
-    operator ScriptVarType() {return ScriptVarType(TypeID);}
-};
-#endif 
-
-template<>
-struct TypeInfo<ScriptStringVarBase> {
-  const SQChar * typeName;
-  TypeInfo() : typeName(_SC("ScriptStringVarBase")) {}
-  enum {TypeID=VAR_TYPE_STRING,Size=sizeof(ScriptStringVarBase),TypeMask='s', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-// === Fixed String Variants ===
-
-template<int N>
-struct TypeInfo<ScriptStringVar<N> > {
-  SQChar typeName[24];
-  TypeInfo() { scsprintf(typeName,_SC("ScriptStringVar<%d>"),N); }
-  enum {TypeID=VAR_TYPE_STRING,Size=N*sizeof(ScriptStringVar<N>),TypeMask='s', IsInstance=0};
-  operator ScriptVarType() { return ScriptVarType(TypeID); }
-};
-
-#ifdef SQPLUS_SMARTPOINTER_OPT
-  #define SQPLUS_SMARTPOINTER_ACCESSTYPE
-  #include "SqPlusSmartPointer.h"
-#else
-  enum VarAccessType {VAR_ACCESS_READ_WRITE=0,VAR_ACCESS_READ_ONLY=1<<0,VAR_ACCESS_CONSTANT=1<<1,VAR_ACCESS_STATIC=1<<2};
-#endif // SQPLUS_SMARTPOINTER_OPT
-
-// See VarRef and ClassType<> below: for instance assignment.
-typedef void (*CopyVarFunc)(void * dst,void * src);
-
-
-// === Class Type Helper class: returns an ID for each class type and provides base class pointer offset ===
-
-struct ClassTypeBase {
-    ClassTypeBase() : m_pbase(0), m_name(0), m_offset(0), m_may_have_offset(-1) { }
-    // Many types cannot have offset, since "this" is the same for all base classes of 
-    // an instance. Detect this, to avoid sum up base offsets all the time.
-    int MayHaveOffset( ) {
-        if( m_may_have_offset<0 ){
-            if( m_offset ) m_may_have_offset = 1;
-            else m_may_have_offset = m_pbase ? m_pbase->MayHaveOffset() : 0;
-        }
-        return m_may_have_offset;
-    }
-    int GetOffsetTo( ClassTypeBase *pbase ){
-        if( !m_pbase ) { /*printf("ClassTypeBase::getOffsetTo - Warning - Base type pointer is NULL!\n" );*/ return 0; }
-        return m_pbase==pbase ? m_offset : m_offset+m_pbase->GetOffsetTo(pbase);
-    }
-    virtual CopyVarFunc vgetCopyFunc(void) = 0;
-    virtual const SQChar* GetTypeName() = 0;
-    
-    ClassTypeBase *m_pbase;
-    const SQChar *m_name;  // Name of type
-    int m_offset;          // Adjustment of this pointer between this type and its base class
-    int m_may_have_offset; // Set to 0 for types that cannot possibly have offset
-};
-
-// This level handles instance copying in different ways
-template<typename T,bool copyable> 
-struct ClassTypeCopyImpl;
-
-// Helper struct to decide if type is copyable or not 
-template<typename T>
-struct IsCopyable { enum { value=true }; }; 
-
-#define DECLARE_NONCOPY_TYPE_INTERN(TYPE) \
-  template<> struct IsCopyable<TYPE> { enum { value=false }; };
-  
-// Macro to declare a type that should _not_ be copied using ordinary
-// c++ copy expresssion: *(T*)pt1 = *(T*)pt2; 
-#define DECLARE_NONCOPY_TYPE(TYPE) namespace SqPlus { \
-  template<> struct IsCopyable<TYPE> { enum { value=false }; }; \
-}
-  
-// Base class to do copying in ordinary C++ way
-template<typename T>
-struct ClassTypeCopyImpl<T,true> : public ClassTypeBase {
-  static void copy(T * dst,T * src) {
-    *dst = *src;                // This works types with copy ctor / assign operator
-  } // copy
-};
-
-// Base class to do copying with memcpy
-template<typename T>
-struct ClassTypeCopyImpl<T,false> : public ClassTypeBase {
-  static void copy(T * dst,T * src) {
-    memcpy(dst,src,sizeof(T));   // This works for raw data types
-  } // copy
-};
-
-// Base classes to do avoid copying altogether (void case)
-template<>
-struct ClassTypeCopyImpl<void,true> : public ClassTypeBase {
-  static void copy(void * dst,void * src) { } // copy
-};
-
-template<>
-struct ClassTypeCopyImpl<void,false> : public ClassTypeBase {
-  static void copy(void * dst,void * src) { } // copy
-};
-
-
-template<typename T>
-struct ClassType : public ClassTypeCopyImpl<T,IsCopyable<T>::value> { 
-  typedef ClassTypeCopyImpl<T,IsCopyable<T>::value> ClassTypeBase;
-  ClassType( ) { this->m_name=stGetName(); } 
-  
-  virtual CopyVarFunc vgetCopyFunc(void) { return (CopyVarFunc)&ClassTypeBase::copy; }
-  virtual const SQChar* GetTypeName(){ return this->m_name; }
-  
-  template<class BC>
-  void SetBase(TypeWrapper<BC>) { 
-    this->m_pbase = ClassType<BC>::Get(); 
-    T* pt = reinterpret_cast<T*>(this); 
-    this->m_offset = ((char*)pt)-((char*)static_cast<BC*>(pt)); 
-  }
-  static ClassType* Get(){ static ClassType<T> st_ct; return &st_ct; }
-  static ClassTypeBase* type() { return Get(); }
-  static CopyVarFunc getCopyFunc(void) { return (CopyVarFunc)&ClassTypeBase::copy; }
-  static const SQChar* stGetName(){ return TypeInfo<T>().typeName; }  
-  
-  #ifdef SQPLUS_OVERLOAD_OPT
-  #define SQPLUS_OVERLOAD_RELEASE_HOOK
-  #include "SqPlusOverload.h"
-  #endif
-};
-
-
-// === Variable references for script access ===
-
-#define SQ_PLUS_TYPE_TABLE _SC("__SqTypes")
-
-struct VarRef {
-  // In this case 'offsetOrAddrOrConst' is simpler than using an anonymous union.
-  void * offsetOrAddrOrConst;  // Instance member variable offset from 'this' pointer base (as size_t), or address if static variable (void *), or constant value.
-  ScriptVarType m_type;        // Variable type (from enum above).
-  ClassTypeBase* instanceType; // Class type of the containing class instance (for member vars only). 
-  ClassTypeBase* varType;      // The class type of the variable itself
-  short m_size;                // ATS: Use for short and char support. For debugging only (size of item when pointer to item is dereferenced). Could be used for variable max string buffer length.
-  short m_access;              // VarAccessType.
-
-  VarRef() : offsetOrAddrOrConst(0), m_type(VAR_TYPE_NONE), instanceType(0/*(SQUserPointer)-1*/), /*copyFunc(0),*/ m_size(0), m_access(VAR_ACCESS_READ_WRITE) {}
-  VarRef(void * _offsetOrAddrOrConst, ScriptVarType _type, ClassTypeBase* _instanceType, ClassTypeBase* _varType, int _size, VarAccessType _access) :
-         offsetOrAddrOrConst(_offsetOrAddrOrConst), m_type(_type), instanceType(_instanceType), varType(_varType), m_size(_size), m_access(_access) {
-#ifdef SQ_SUPPORT_INSTANCE_TYPE_INFO
-    SquirrelObject typeTable = SquirrelVM::GetRootTable().GetValue(SQ_PLUS_TYPE_TABLE);
-    if (typeTable.IsNull()) {
-      typeTable = SquirrelVM::CreateTable();
-      SquirrelObject root = SquirrelVM::GetRootTable();
-      root.SetValue(SQ_PLUS_TYPE_TABLE,typeTable);
-    } // if
-	typeTable.SetValue(INT((size_t)varType),varType->GetTypeName());
-#endif // SQ_SUPPORT_INSTANCE_TYPE_INFO
-  }
-};
-
-typedef VarRef * VarRefPtr;
-
-// Internal use only.
-inline void getVarNameTag(SQChar * buff,INT maxSize,const SQChar * scriptName) {
-//  assert(maxSize > 3);
-#if 1
-  SQChar * d = buff;
-  d[0] = '_';
-  d[1] = 'v';
-  d = &d[2];
-  maxSize -= (2+1); // +1 = space for null.
-  int pos=0;
-  while (scriptName[pos] && pos < maxSize) {
-    d[pos] = scriptName[pos];
-    pos++;
-  } // while
-  d[pos] = 0; // null terminate.
-#else
-  SCSNPRINTF(buff,maxSize,_SC("_v%s"),scriptName);
-#endif
-} // getVarNameTag
-
-// Internal use only.
-int setVarFunc(HSQUIRRELVM v);
-int getVarFunc(HSQUIRRELVM v);
-int setInstanceVarFunc(HSQUIRRELVM v);
-int getInstanceVarFunc(HSQUIRRELVM v);
-
-// === BEGIN Helpers ===
-
-inline void createTableSetGetHandlers(SquirrelObject & so) {
-  SquirrelObject delegate = so.GetDelegate();
-  if (!delegate.Exists(_SC("_set"))) {
-    delegate = SquirrelVM::CreateTable();
-    SquirrelVM::CreateFunction(delegate,setVarFunc,_SC("_set"),_SC("sn|b|s")); // String var name = number(int or float) or bool or string.
-    SquirrelVM::CreateFunction(delegate,getVarFunc,_SC("_get"),_SC("s"));      // String var name.
-    so.SetDelegate(delegate);
-  } // if
-} // createTableSetGetHandlers
-
-inline VarRefPtr createVarRef(SquirrelObject & so,const SQChar * scriptVarName) {
-  VarRefPtr pvr=0;
-  ScriptStringVar256 scriptVarTagName; getVarNameTag(scriptVarTagName,sizeof(scriptVarTagName),scriptVarName);
-  if (!so.GetUserData(scriptVarTagName,(SQUserPointer *)&pvr)) {
-    so.NewUserData(scriptVarTagName,sizeof(*pvr));
-    if (!so.GetUserData(scriptVarTagName,(SQUserPointer *)&pvr)) throw SquirrelError(_SC("Could not create UserData."));
-  } // if
-  return pvr;
-} // createVarRef
-
-template<typename T>
-void validateConstantType(T constant) {
-  switch(TypeInfo<T>()) {
-  case VAR_TYPE_INT:
-  case VAR_TYPE_FLOAT:
-  case VAR_TYPE_BOOL:
-  case VAR_TYPE_CONST_STRING:
-    break;
-  default:
-    throw SquirrelError(_SC("validateConstantType(): type must be INT, FLOAT, BOOL, or CONST CHAR *."));
-  } // case
-} // validateConstantType
-
-inline void createInstanceSetGetHandlers(SquirrelObject & so) {
-  if (!so.Exists(_SC("_set"))) {
-    SquirrelVM::CreateFunction(so,setInstanceVarFunc,_SC("_set"),_SC("sn|b|s|x")); // String var name = number(int or float) or bool or string or instance.
-    SquirrelVM::CreateFunction(so,getInstanceVarFunc,_SC("_get"),_SC("s"));      // String var name.
-  } // if
-} // createInstanceSetGetHandlers
-
-// === END Helpers ===
-
-
-// Provide an overridable way of copying / deleting objects 
-template<typename T>
-struct ObjectCloner {
-  static T* Clone(T* src){ return new T(src); }
-  static void Delete(T* dst){ if(dst) delete dst; }
-};
-
-// specialization for void type
-//template<> inline void ClassType<void>::copy(void *dst, void *src) {}
-DECLARE_NONCOPY_TYPE_INTERN(void)
-
-
-// === Bind a global or pre-allocated (not instance) class member variable or constant (for tables only (not classes)) ===
-
-template<typename T>
-void BindVariable(SquirrelObject & so,T * var,const SQChar * scriptVarName,VarAccessType access=VAR_ACCESS_READ_WRITE) {
-  VarRefPtr pvr = createVarRef(so,scriptVarName);
-  *pvr = VarRef(var,TypeInfo<T>(),NULL,ClassType<T>::type(),sizeof(*var),access);
-  createTableSetGetHandlers(so);
-} // BindVariable
-
-// === Bind a constant by value: INT, FLOAT, BOOL, or CONST CHAR * (for tables only (not classes)) ===
-
-template<typename T>
-void BindConstant(SquirrelObject & so,T constant,const SQChar * scriptVarName) {
-  validateConstantType(constant);
-  VarRefPtr pvr = createVarRef(so,scriptVarName);
-  struct CV {
-    T var;
-  } cv; // Cast Variable helper.
-  cv.var = constant;
-  *pvr = VarRef(*(void **)&cv,TypeInfo<T>(),NULL,ClassType<T>::type(),sizeof(constant),VAR_ACCESS_CONSTANT);
-  createTableSetGetHandlers(so);
-} // BindConstant
-
-template<typename T>
-void BindVariable(T * var,const SQChar * scriptVarName,VarAccessType access=VAR_ACCESS_READ_WRITE) {
-  SquirrelObject so = SquirrelVM::GetRootTable();
-  BindVariable(so,var,scriptVarName,access);
-} // BindVariable
-
-template<typename T>
-void BindConstant(T constant,const SQChar * scriptVarName) {
-  SquirrelObject so = SquirrelVM::GetRootTable();
-  BindConstant(so,constant,scriptVarName);
-} // BindConstant
-
-// === Register a class instance member variable or constant. var argument provides type and offset ( effectively &((ClassType *)0)->var ) ===
-
-// classType is the type of the member variable's containing class.
- template<typename T>
-void RegisterInstanceVariable(SquirrelObject & so,ClassTypeBase* classType,T * var,const SQChar * scriptVarName,VarAccessType access=VAR_ACCESS_READ_WRITE) {
-  VarRef * pvr = createVarRef(so,scriptVarName);
-  void * offsetOrAddrOrConst = (void *)var; // var must be passed in as &obj->var, where obj = 0 (the address is the offset), or as static/global address.
-  *pvr = VarRef(offsetOrAddrOrConst,TypeInfo<T>(),classType,ClassType<T>::type(),sizeof(*var),access);
-  createInstanceSetGetHandlers(so);
-} // RegisterInstanceVariable
-
-#ifdef SQPLUS_SMARTPOINTER_OPT
-#define SQPLUS_SMARTPOINTER_REGISTER_VARIABLE
-#include "SqPlusSmartPointer.h"
-#endif
-
-template<typename T>
-void RegisterInstanceConstant(SquirrelObject & so,ClassTypeBase *classType,T constant,const SQChar * scriptVarName) {
-  validateConstantType(constant);
-  VarRef * pvr = createVarRef(so,scriptVarName);
-  struct CV {
-    T var;
-    size_t pad;
-  } cv; // Cast Variable helper.
-  cv.var = constant;
-  *pvr = VarRef(*(void **)&cv,TypeInfo<T>(),classType,ClassType<T>::type(),sizeof(constant),VAR_ACCESS_CONSTANT);
-  createInstanceSetGetHandlers(so);
-} // RegisterInstanceConstant
-
-//////////////////////////////////////////////////////////////////////////
-/////////// BEGIN Generalized Class/Struct Instance Support //////////////
-//////////////////////////////////////////////////////////////////////////
-
-// Was previously in SqPlus namespace
-//BOOL CreateNativeClassInstance(HSQUIRRELVM v,const SQChar * classname,SQUserPointer ud,SQRELEASEHOOK hook); // In SquirrelBindingUtils.cpp.
-
-// Create native class instance and leave on stack.
-//BOOL CreateConstructNativeClassInstance(HSQUIRRELVM v,const SQChar * className);
-
-// Create new instance, copy 'classToCopy', and store result on stack.
-template<typename T>
-inline BOOL CreateCopyInstance(HSQUIRRELVM v, const SQChar * className,const T & classToCopy) {
-#ifndef SQPLUS_DISABLE_COPY_INSTANCES
-  if (!CreateConstructNativeClassInstance(v,className)) {
-    return FALSE;
-  } // if
-  SQUserPointer up=0;
-  sq_getinstanceup(v,-1,&up,ClassType<T>::type());
-  if (!up) return FALSE;
-  T * newClass = (T *)up;
-  *newClass = classToCopy; // <TODO> Optimized version that uses the copy constructor.
-  return TRUE;
-#else
-  return FALSE;
-#endif  
-} // CreateCopyInstance
-
-// Create a new copy of type 'className' and copy 'classToCopy', return result via SquirrelObject.
-template<typename T>
-inline SquirrelObject NewClassCopy(HSQUIRRELVM v, const SQChar * className,const T & classToCopy) {
-  if (CreateCopyInstance(v, className,classToCopy)) {
-	  HSQOBJECT t;
-	  sq_getstackobj(v,-1,&t);
-	  SquirrelObject obj(t);
-	  sq_poptop(v);
-	  return obj;
-  } else {
-    throw SquirrelError(_SC("NewClassCopy(): could not create class"));
-  } // if
-  return SquirrelObject();
-} // NewClassCopy
-
-// Return a new class copy on the stack from a varArgs function call.
-template<typename T>
-inline int ReturnCopy(HSQUIRRELVM v,const T & classToCopy) {
-  SquirrelObject so(NewClassCopy(v,GetTypeName(classToCopy),classToCopy));
-  return StackHandler(v).Return(so);
-} // ReturnCopy
-
-// Katsuaki Kawachi's GetInstance<> exception change. 6/27/06 jcs
-
-// Get an instance of type T from the stack at idx (for function calls).
-template<typename T,bool ExceptionOnError>
-T * GetInstance(HSQUIRRELVM v,SQInteger idx) {
-  SQUserPointer up=0;
-  if (SQ_FAILED(sq_getinstanceup(v,idx,&up,ClassType<T>::type()))) {
-    up = 0;
-  }
-  if (ExceptionOnError) { // This code block should be compiled out when ExceptionOnError is false. In any case, the compiler should not generate a test condition (include or exclude the enclosed code block).
-    if (!up) {
-      throw SquirrelError(_SC("GetInstance: Invalid argument type"));
-    }
-  } // if
-  return (T *)up;
-} // GetInstance
-
-
-template<typename T> void Push(HSQUIRRELVM v, T* pt);
-template<typename T> void Push(HSQUIRRELVM v, T& t);
-template<typename T> bool Match(TypeWrapper<T&>, HSQUIRRELVM v, int ix);
-template<typename T> bool Match(TypeWrapper<T*>, HSQUIRRELVM v, int ix);
-template<typename T> T &Get(TypeWrapper<T&>, HSQUIRRELVM v, int ix);
-template<typename T> T *Get(TypeWrapper<T*>, HSQUIRRELVM v, int ix);
-
-
-#ifdef SQPLUS_USE_GENERIC_HANDLERS
-// With template specialization, we get Push handlers per 'precise type match'
-// This adds a fallback level after that, where we can delegate the work to 
-// wider C-style functions that can do something for a whole class hierarchy.
-// (GenPush, GenGet, GenMatch).
-
-// This macro allows for a a last generic cast operation before giving control 
-// to one of GenPush/GenMatch/GenGet.
-#ifndef SQPLUS_GEN_CAST 
-    #define SQPLUS_GEN_CAST(TYPE,value) ((TYPE*)value)
-#endif 
-
-template<typename T> void Push(HSQUIRRELVM v, T* pt){ GenPush(v,SQPLUS_GEN_CAST(T,pt)); }
-template<typename T> void Push(HSQUIRRELVM v, T& t){ GenPush(v,SQPLUS_GEN_CAST(T,&t)); }
-template<typename T> bool Match(TypeWrapper<T&>, HSQUIRRELVM v, int ix){ 
-    if((ScriptVarType)TypeInfo<T>::TypeID!=VAR_TYPE_NONE) 
-        return GenMatch(SQPLUS_GEN_CAST(T*,0),TypeInfo<T>().typeName,v,ix); 
-    else return false; 
-}
-template<typename T> bool Match(TypeWrapper<T*>, HSQUIRRELVM v, int ix){ 
-    if((ScriptVarType)TypeInfo<T>::TypeID!=VAR_TYPE_NONE) 
-        return GenMatch(SQPLUS_GEN_CAST(T*,0),TypeInfo<T>().typeName,v,ix); 
-    else return false;
-}
-template<typename T> T &Get(TypeWrapper<T&>, HSQUIRRELVM v, int ix){ 
-    if((ScriptVarType)TypeInfo<T>::TypeID!=VAR_TYPE_NONE)  
-        return *(T*)GenGet(SQPLUS_GEN_CAST(T*,0),TypeInfo<T>().typeName,v,ix); 
-    else return *SQPLUS_GEN_CAST(T,0); 
-}
-template<typename T> T *Get(TypeWrapper<T*>, HSQUIRRELVM v, int ix){ 
-    if((ScriptVarType)TypeInfo<T>::TypeID!=VAR_TYPE_NONE)  
-        return (T*)GenGet(SQPLUS_GEN_CAST(T*,0),TypeInfo<T>().typeName,v,ix); 
-    else return NULL; 
-}
-#endif // SQPLUS_USE_GENERIC_HANDLERS
-
-
-// === BEGIN Function Call Handler Prototypes ===
- 
-void Push(HSQUIRRELVM v, char value);
-void Push(HSQUIRRELVM v, unsigned char value);
-void Push(HSQUIRRELVM v, short value);
-void Push(HSQUIRRELVM v, unsigned short value);
-void Push(HSQUIRRELVM v, int value);
-void Push(HSQUIRRELVM v, unsigned int value);
-void Push(HSQUIRRELVM v, long value);
-void Push(HSQUIRRELVM v, unsigned long value);
-void Push(HSQUIRRELVM v, double value);
-void Push(HSQUIRRELVM v, float value);
-void Push(HSQUIRRELVM v, const SQChar *value);
-void Push(HSQUIRRELVM v, SQChar *value);
-void Push(HSQUIRRELVM v, const SquirrelNull &);
-void Push(HSQUIRRELVM v, SQFUNCTION value);
-void Push(HSQUIRRELVM v, SQAnythingPtr value); // Cast to SQAnythingPtr instead of void * if USE_ARGUMENT_DEPENDANT_OVERLOADS can't be used by your compiler.
-void Push(HSQUIRRELVM v, SquirrelObject &so);
-
-#define USE_ARGUMENT_DEPENDANT_OVERLOADS
-#ifdef USE_ARGUMENT_DEPENDANT_OVERLOADS
-#ifdef _MSC_VER
-#pragma warning(disable:4675) // Disable warning: "resolved overload was found by argument-dependent lookup" when class/struct pointers are used as function arguments.
-#endif
-// === BEGIN Argument Dependent Overloads ===
-void Push(HSQUIRRELVM v, bool value); // Pass bool as int if USE_ARGUMENT_DEPENDANT_OVERLOADS can't be used by your compiler.
-void Push(HSQUIRRELVM v, const void *value); // Pass SQAnythingPtr instead of void * "                                             "
-void Push(HSQUIRRELVM v, const SQUserPointer &value);
-// === END Argument Dependent Overloads ===
-#endif
-
-#define SQPLUS_CHECK_GET(res) if (!SQ_SUCCEEDED(res)) throw SquirrelError(_SC("sq_get*() failed (type error)"))
-
-bool Match(TypeWrapper<bool>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<char>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<unsigned char>, HSQUIRRELVM v,  int idx);
-bool Match(TypeWrapper<short>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<unsigned short>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<int>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<unsigned int>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<long>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<unsigned long>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<float>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<double>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<const SQChar *>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<SQChar *>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<HSQUIRRELVM>, HSQUIRRELVM v, int idx); // See Get() for HSQUIRRELVM below (v is always present).
-bool Match(TypeWrapper<void*>, HSQUIRRELVM v, int idx);
-bool Match(TypeWrapper<SquirrelObject>, HSQUIRRELVM v, int idx); // See sq_getstackobj(): always returns true.
-
-void Get(TypeWrapper<void>, HSQUIRRELVM v, int);
-bool Get(TypeWrapper<bool>, HSQUIRRELVM v, int idx);
-char Get(TypeWrapper<char>, HSQUIRRELVM v, int idx);
-unsigned char Get(TypeWrapper<unsigned char>, HSQUIRRELVM v, int idx);
-short Get(TypeWrapper<short>, HSQUIRRELVM v, int idx);
-unsigned short Get(TypeWrapper<unsigned short>, HSQUIRRELVM v, int idx);
-int Get(TypeWrapper<int>, HSQUIRRELVM v, int idx);
-unsigned int Get(TypeWrapper<unsigned int>, HSQUIRRELVM v, int idx);
-long Get(TypeWrapper<long>, HSQUIRRELVM v, int idx);
-unsigned long Get(TypeWrapper<unsigned long>, HSQUIRRELVM v, int idx);
-float Get(TypeWrapper<float>, HSQUIRRELVM v, int idx);
-double Get(TypeWrapper<double>, HSQUIRRELVM v, int idx);
-const SQChar *Get(TypeWrapper<const SQChar *>, HSQUIRRELVM v, int idx);
-SquirrelNull Get(TypeWrapper<SquirrelNull>, HSQUIRRELVM v, int idx);
-void *Get(TypeWrapper<void *>, HSQUIRRELVM v, int idx);
-HSQUIRRELVM Get(TypeWrapper<HSQUIRRELVM>, HSQUIRRELVM v, int /*idx*/); // sq_poptop(v): remove UserData from stack so GetParamCount() matches normal behavior.
-SquirrelObject Get(TypeWrapper<SquirrelObject>, HSQUIRRELVM v, int idx);
-
-#ifdef SQPLUS_AUTOCONVERT_OTHER_CHAR
-  void Push(HSQUIRRELVM v, const SQOtherChar *value);
-  void Push(HSQUIRRELVM v, SQOtherChar *value);
-  bool Match(TypeWrapper<const SQOtherChar *>, HSQUIRRELVM v, int idx);
-  bool Match(TypeWrapper<SQOtherChar *>, HSQUIRRELVM v, int idx);
-  SQOthCharBuf Get(TypeWrapper<const SQOtherChar *>, HSQUIRRELVM v, int idx);
-#endif // SQPLUS_AUTOCONVERT_OTHER_CHAR
-
-#ifdef SQPLUS_SUPPORT_STD_STRING
-void Push(HSQUIRRELVM v, const std::string& value);
-bool Match(TypeWrapper<const std::string&>, HSQUIRRELVM v, int idx);
-std::string Get(TypeWrapper<const std::string&>, HSQUIRRELVM v, int idx); 
-#endif
-
-// Added jflanglois suggestion, 8/20/06. jcs
-#ifdef SQPLUS_SUPPORT_SQ_STD_STRING
-typedef std::basic_string<SQChar> sq_std_string;
-void Push(HSQUIRRELVM v,const sq_std_string & value);
-bool Match(TypeWrapper<const sq_std_string &>, HSQUIRRELVM v, int idx);
-sq_std_string Get(TypeWrapper<const sq_std_string &>, HSQUIRRELVM v, int idx); 
-#endif
-
-// Specialization to support void return type.
-void GetRet(TypeWrapper<void>, HSQUIRRELVM v,int idx);
-
-// GetRet() restores the stack for SquirrelFunction<>() calls.
-// Hold on to a reference since return value might be temporary string/instance
-template<typename RT>
-inline RT GetRet(TypeWrapper<RT>,HSQUIRRELVM v,int idx) { 
-	static SquirrelObject st_sq_ret; 
-	static typename Temporary<RT>::type st_ret; 
-	st_ret = Get(TypeWrapper<RT>(),v,idx); 
-	st_sq_ret.AttachToStackObject(idx); 
-	sq_pop(v,2); // restore stack after function call.
-	return st_ret; } 
-
-#ifndef GCC_INLINE_WORKAROUND
-# include "SqPlusFunctionCallImpl.h"
-#endif // GCC_INLINE_WORKAROUND 
- 
-// === END Function Call Handlers ===
-
-
-// Helper, only implement function bodies
-#define IMPLEMENT_ENUM_TYPE(TYPE) namespace SqPlus { \
-  bool Match(TypeWrapper<TYPE>,HSQUIRRELVM v,int idx) { return Match(TypeWrapper<int>(),v,idx); } \
-  TYPE Get(TypeWrapper<TYPE>,HSQUIRRELVM v,int idx) { return (TYPE)Get(TypeWrapper<int>(),v,idx); } \
-  void Push(HSQUIRRELVM v,TYPE value) { sq_pushinteger(v,(int)value); } \
-} // nameSpace SqPlus
-
-// To register simple types (like enums) so they can be used as arguments
-// (however, this does not handle enums as return values correctly, since 
-// we C++ gets problems with references to temporaries)
-#define DECLARE_ENUM_TYPE(TYPE) IMPLEMENT_ENUM_TYPE(TYPE) \
-namespace SqPlus { \
-  template<> struct TypeInfo<TYPE> : public TypeInfo<int> { }; \
-} // nameSpace SqPlus 
-
-// As above but use when function bodies should not be generated
-// (for a header file).
-#define PROTOS_ENUM_TYPE(TYPE) namespace SqPlus { \
-  bool Match(TypeWrapper<TYPE>,HSQUIRRELVM v,int idx); \
-  TYPE Get(TypeWrapper<TYPE>,HSQUIRRELVM v,int idx); \
-  void Push(HSQUIRRELVM v,TYPE value); \
-  template<> struct TypeInfo<TYPE> : public TypeInfo<int> { }; \
-} // nameSpace SqPlus
-
-
-// NAME and macro changes from Ben's (Project5) forum post. 2/26/06 jcs
-// Kamaitati's NULL_INSTANCE support. 5/28/06 jcs
-
-// ATS: Splitting the macros in different parts to support custom Push implementation (covariant return type)
-
-#define DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \
-  inline const SQChar * GetTypeName(const TYPE & n) { return _SC(#NAME); } \
-  template<> \
-  struct TypeInfo<TYPE> { \
-    const SQChar * typeName; \
-    TypeInfo() : typeName( _SC(#NAME)) {} \
-    enum {TypeID=VAR_TYPE_INSTANCE,Size=sizeof(TYPE),TypeMask='x', IsInstance=1}; \
-    operator ScriptVarType() { return ScriptVarType(TypeID); } \
-  }; 
-
-#define DECLARE_INSTANCE_TYPEINFO(TYPE) namespace SqPlus { \
-  DECLARE_INSTANCE_TYPEINFO_(TYPE,TYPE) \
-} // namespace SqPlus 
-
-#define DECLARE_INSTANCE_TYPEINFO_NAME(TYPE,NAME) namespace SqPlus { \
-  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \
-} // namespace SqPlus 
-
-
-#ifdef SQPLUS_SUPPORT_NULL_INSTANCES
-
-// Macro part shared by 'derived' macros
-#define DECLARE_INSTANCE_TYPE_BASE_(TYPE,NAME) \
-  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \
-  template<> inline bool Match(TypeWrapper<TYPE &>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,false>(v,idx) != NULL; } \
-  template<> inline bool Match(TypeWrapper<TYPE *>,HSQUIRRELVM v,int idx) { \
-    return (sq_gettype(v,idx)==OT_NULL) || (GetInstance<TYPE,false>(v,idx) != NULL); } \
-  template<> inline TYPE & Get(TypeWrapper<TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE,true>(v,idx); } \
-  template<> inline TYPE * Get(TypeWrapper<TYPE *>,HSQUIRRELVM v,int idx) { \
-    if (sq_gettype(v,idx)==OT_NULL) return NULL; \
-    return GetInstance<TYPE,true>(v,idx); }
-
-// Ordinary case
-#define DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) namespace SqPlus { \
-  DECLARE_INSTANCE_TYPE_BASE_(TYPE,NAME) \
-  template<> inline void Push(HSQUIRRELVM v,TYPE * value) { \
-    if (!value)  sq_pushnull(v); \
-    else if (!CreateNativeClassInstance(v,GetTypeName(*value),value,0)) \
-      throw SquirrelError( _SC( "Push(): could not create INSTANCE (check registration name)")); } \
-  template<> inline void Push(HSQUIRRELVM v,TYPE & value) { if (!CreateCopyInstance(v,GetTypeName(value),value)) throw SquirrelError( _SC( "Push(): could not create INSTANCE copy (check registration name)")); } \
-} // nameSpace SqPlus
-
-// Allows for providing custom Push handlers (protos here, impl must be provided by app)
-#define DECLARE_INSTANCE_TYPE_NAME_CUSTOM_(TYPE,NAME) namespace SqPlus { \
-  DECLARE_INSTANCE_TYPE_BASE_(TYPE,NAME) \
-  template<> void Push(HSQUIRRELVM v,TYPE * value); \
-  template<> void Push(HSQUIRRELVM v,TYPE & value); \
-} // nameSpace SqPlus
-
-
-#else
-
-#define DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) namespace SqPlus { \
-  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \
-  template<> inline void Push(HSQUIRRELVM v,TYPE * value)                 { if (!CreateNativeClassInstance(v,GetTypeName(*value),value,0)) throw SquirrelError( _SC( "Push(): could not create INSTANCE (check registration name)")); } \
-  template<> inline void Push(HSQUIRRELVM v,TYPE & value)                 { if (!CreateCopyInstance(v,GetTypeName(value),value)) throw SquirrelError( _SC( "Push(): could not create INSTANCE copy (check registration name)")); } \
-  template<> inline bool	Match(TypeWrapper<TYPE &>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,false>(v,idx) != NULL; } \
-  template<> inline bool	Match(TypeWrapper<TYPE *>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,false>(v,idx) != NULL; } \
-  template<> inline TYPE & Get(TypeWrapper<TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE,true>(v,idx); } \
-  template<> inline TYPE * Get(TypeWrapper<TYPE *>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,true>(v,idx); } \
-} // nameSpace SqPlus
-
-#endif
-
-// TYPE or NAME below must match the string name used in SQClassDef<>, otherwise name lookup won't match and Squirrel will throw a "can't create instance" error.
-#ifndef SQPLUS_CONST_OPT
-#define DECLARE_INSTANCE_TYPE(TYPE) DECLARE_INSTANCE_TYPE_NAME_(TYPE,TYPE)
-#define DECLARE_INSTANCE_TYPE_NAME(TYPE,NAME) DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME)
-#define DECLARE_INSTANCE_TYPE_CUSTOM(TYPE) DECLARE_INSTANCE_TYPE_NAME_CUSTOM_(TYPE,TYPE)
-#define DECLARE_INSTANCE_TYPE_NAME_CUSTOM(TYPE,NAME) DECLARE_INSTANCE_TYPE_NAME_CUSTOM_(TYPE,NAME)
-#else
-#define SQPLUS_DECLARE_INSTANCE_TYPE_CONST
-#include "SqPlusConst.h"
-#endif
-
-#ifdef SQPLUS_OVERLOAD_OPT
-#define SQPLUS_OVERLOAD_DECLARATION
-#include "SqPlusOverload.h"
-#endif
-
-// Versions of above for types that aren't copy constructable
-#define DECLARE_INSTANCE_TYPEINFO_NOCOPY(TYPE) \
-  DECLARE_INSTANCE_TYPEINFO(TYPE) \
-  DECLARE_NONCOPY_TYPE(TYPE)
-
-#define DECLARE_INSTANCE_TYPEINFO_NOCOPY_NAME(TYPE,NAME) namespace SqPlus { \
-  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \
-  DECLARE_NONCOPY_TYPE(TYPE)
-
-#define DECLARE_INSTANCE_TYPE_NOCOPY(TYPE) \
-  DECLARE_INSTANCE_TYPE(TYPE) \
-  DECLARE_NONCOPY_TYPE(TYPE)
-
-#define DECLARE_INSTANCE_TYPE_NOCOPY_NAME(TYPE,NAME) namespace SqPlus { \
-  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \
-  DECLARE_NONCOPY_TYPE(TYPE)
-
-
-//////////////////////////////////////////////////////////////////////////
-//////////// END Generalized Class/Struct Instance Support ///////////////
-//////////////////////////////////////////////////////////////////////////
-
-#ifndef SQ_SKIP_ARG_ASSERT
-  #define sq_argassert(arg,_index_) if (!Match(TypeWrapper<P##arg>(),v,_index_)) return sq_throwerror(v,_SC("Incorrect function argument"))
-#else
-  #define sq_argassert(arg,_index_)
-#endif
-
-// === Return value variants ===
-
-template<class RT>
-struct ReturnSpecialization {
-
-  // === Standard Function calls ===
-
-  static int Call(RT (*func)(),HSQUIRRELVM v,int /*index*/) {
-    RT ret = func();
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename P1>
-  static int Call(RT (*func)(P1),HSQUIRRELVM v,int index) {
-    sq_argassert(1,index + 0);
-    RT ret = func(
-      Get(TypeWrapper<P1>(),v,index + 0)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename P1,typename P2>
-  static int Call(RT (*func)(P1,P2),HSQUIRRELVM v,int index) {
-    sq_argassert(1,index + 0);
-    sq_argassert(2,index + 1);
-    RT ret = func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename P1,typename P2,typename P3>
-  static int Call(RT (*func)(P1,P2,P3),HSQUIRRELVM v,int index) {
-    sq_argassert(1,index + 0);
-    sq_argassert(2,index + 1);
-    sq_argassert(3,index + 2);
-    RT ret = func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4>
-  static int Call(RT (*func)(P1,P2,P3,P4),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 = func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4,typename P5>
-  static int Call(RT (*func)(P1,P2,P3,P4,P5),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 = func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
-  static int Call(RT (*func)(P1,P2,P3,P4,P5,P6),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 = func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4),
-      Get(TypeWrapper<P6>(),v,index + 5)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
-  static int Call(RT (*func)(P1,P2,P3,P4,P5,P6,P7),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 = func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4),
-      Get(TypeWrapper<P6>(),v,index + 5),
-      Get(TypeWrapper<P7>(),v,index + 6)
-    );
-    Push(v,ret);
-    return 1;
-  }
-
-  // === Member Function calls ===
-
-
-#define SQPLUS_CALL_MFUNC_RET0
-#include "SqPlusCallTemplates.h"
-
-#ifdef SQPLUS_CONST_OPT
-#define SQPLUS_CALL_MFUNC_RET0
-#include "SqPlusConst.h"
-#endif
-};
-
-// === No return value variants ===
-
-template<>
-struct ReturnSpecialization<void> {
-
-  // === Standard function calls ===
-
-  static int Call(void (*func)(),HSQUIRRELVM v,int /*index*/) {
-		(void)v;
-		func();
-		return 0;
-	}
-
-	template<typename P1>
-	static int Call(void (*func)(P1),HSQUIRRELVM v,int index) {
-    sq_argassert(1,index + 0);
-		func(
-			Get(TypeWrapper<P1>(),v,index + 0)
-		);
-		return 0;
-	}
-
-	template<typename P1,typename P2>
-	static int Call(void (*func)(P1,P2),HSQUIRRELVM v,int index) {
-    sq_argassert(1,index + 0);
-    sq_argassert(2,index + 1);
-		func(
-			Get(TypeWrapper<P1>(),v,index + 0),
-			Get(TypeWrapper<P2>(),v,index + 1)
-		);
-		return 0;
-	}
-
-  template<typename P1,typename P2,typename P3>
-  static int Call(void (*func)(P1,P2,P3),HSQUIRRELVM v,int index) {
-    sq_argassert(1,index + 0);
-    sq_argassert(2,index + 1);
-    sq_argassert(3,index + 2);
-    func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2)
-    );
-    return 0;
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4>
-  static int Call(void (*func)(P1,P2,P3,P4),HSQUIRRELVM v,int index) {
-    sq_argassert(1,index + 0);
-    sq_argassert(2,index + 1);
-    sq_argassert(3,index + 2);
-    sq_argassert(4,index + 3);
-    func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3)
-    );
-    return 0;
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4,typename P5>
-  static int Call(void (*func)(P1,P2,P3,P4,P5),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);
-    func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4)
-    );
-    return 0;
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
-  static int Call(void (*func)(P1,P2,P3,P4,P5,P6),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);
-    func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4),
-      Get(TypeWrapper<P6>(),v,index + 5)
-    );
-    return 0;
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
-  static int Call(void (*func)(P1,P2,P3,P4,P5,P6,P7),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);
-    func(
-      Get(TypeWrapper<P1>(),v,index + 0),
-      Get(TypeWrapper<P2>(),v,index + 1),
-      Get(TypeWrapper<P3>(),v,index + 2),
-      Get(TypeWrapper<P4>(),v,index + 3),
-      Get(TypeWrapper<P5>(),v,index + 4),
-      Get(TypeWrapper<P6>(),v,index + 5),
-      Get(TypeWrapper<P7>(),v,index + 6)
-    );
-    return 0;
-  }
-
-  // === Member function calls ===
-
-
-#define SQPLUS_CALL_MFUNC_NORET
-#include "SqPlusCallTemplates.h"
-
-#ifdef SQPLUS_CONST_OPT
-#define SQPLUS_CALL_MFUNC_NORET
-#include "SqPlusConst.h"
-#endif
-
-};
-
-// === STANDARD Function return value specialized call handlers ===
-
-template<typename RT>
-int Call(RT (*func)(),HSQUIRRELVM v,int index) {
-  return ReturnSpecialization<RT>::Call(func,v,index);
-}
-
-template<typename RT,typename P1>
-int Call(RT (*func)(P1),HSQUIRRELVM v,int index) {
-  return ReturnSpecialization<RT>::Call(func,v,index);
-}
-
-template<typename RT,typename P1,typename P2>
-int Call(RT (*func)(P1,P2),HSQUIRRELVM v,int index) {
-  return ReturnSpecialization<RT>::Call(func,v,index);
-}
-
-template<typename RT,typename P1,typename P2,typename P3>
-int Call(RT (*func)(P1,P2,P3),HSQUIRRELVM v,int index) {
-  return ReturnSpecialization<RT>::Call(func,v,index);
-}
-
-template<typename RT,typename P1,typename P2,typename P3,typename P4>
-int Call(RT (*func)(P1,P2,P3,P4),HSQUIRRELVM v,int index) {
-  return ReturnSpecialization<RT>::Call(func,v,index);
-}
-
-template<typename RT,typename P1,typename P2,typename P3,typename P4,typename P5>
-int Call(RT (*func)(P1,P2,P3,P4,P5),HSQUIRRELVM v,int index) {
-  return ReturnSpecialization<RT>::Call(func,v,index);
-}
-
-template<typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
-int Call(RT (*func)(P1,P2,P3,P4,P5,P6),HSQUIRRELVM v,int index) {
-  return ReturnSpecialization<RT>::Call(func,v,index);
-}
-
-template<typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
-int Call(RT (*func)(P1,P2,P3,P4,P5,P6,P7),HSQUIRRELVM v,int index) {
-  return ReturnSpecialization<RT>::Call(func,v,index);
-}
-
-// === MEMBER Function return value specialized call handlers ===
-
-
-#define SQPLUS_CALL_MFUNC_RET1
-#include "SqPlusCallTemplates.h"
-
-#ifdef SQPLUS_CONST_OPT
-#define SQPLUS_CALL_MFUNC_RET1
-#include "SqPlusConst.h"
-#endif
-
-// === Direct Call Standard Function handler ===
-
-template<typename Func>
-struct DirectCallFunction {
-  static inline int Dispatch(HSQUIRRELVM v) {
-#ifdef SQPLUS_USE_SANDBOX_VM
-    if( v==SquirrelVM::GetSandboxVMPtr() ){
-        return sq_throwerror(v, _SC("SqPlus: Cannot exec function from sandbox VM"));
-    }
-#endif   
-    StackHandler sa(v);
-    int paramCount = sa.GetParamCount();
-    Func * func = (Func *)sa.GetUserData(paramCount);
-    return Call(*func,v,2);
-  } // Dispatch
-};
-
-// === Direct Call Member Function handler ===
-
-template<typename Callee,typename Func>
-class DirectCallMemberFunction {
-public:
-  static inline int Dispatch(HSQUIRRELVM v) {
-#ifdef SQPLUS_USE_SANDBOX_VM
-    if( v==SquirrelVM::GetSandboxVMPtr() ){
-        return sq_throwerror(v, _SC("SqPlus: Cannot exec function from sandbox VM"));
-    }
-#endif   
-    StackHandler sa(v);
-    int paramCount = sa.GetParamCount();
-    unsigned char * ud = (unsigned char *)sa.GetUserData(paramCount);
-    return Call(**(Callee**)ud,*(Func*)(ud + sizeof(Callee*)),v,2);
-  } // Dispatch
-};
-
-// === Direct Call Function handlers ===
-
-#define SQ_CLASS_OBJECT_TABLE_NAME _SC("__ot")
-#define SQ_CLASS_HIER_ARRAY _SC("__ca")
-
-template<typename Callee, typename Func>
-struct DirectCallInstanceFuncPicker {
-  Callee *instance;
-  Func *func;
-  DirectCallInstanceFuncPicker(HSQUIRRELVM v) {
-#ifdef SQPLUS_USE_SANDBOX_VM
-    if( v==SquirrelVM::GetSandboxVMPtr() ){
-        instance = NULL;
-        func = NULL;
-        return;
-    }
-#endif   
-    StackHandler sa(v);
-    instance = static_cast<Callee*>(sa.GetInstanceUp(1, 0));
-    const int paramCount = sa.GetParamCount();
-    func = static_cast<Func*>(sa.GetUserData(paramCount));
-#ifdef SQ_USE_CLASS_INHERITANCE
-    SquirrelObject so(sa.GetObjectHandle(1)); // 'this'
-    SQUserPointer typetag; so.GetTypeTag(&typetag);
-    SQUserPointer calleeType = ClassType<Callee>::type();
-    if (typetag != calleeType) {
-      SquirrelObject typeTable = so.GetValue(SQ_CLASS_OBJECT_TABLE_NAME);
-      instance = static_cast<Callee*>(
-          // <TODO> 64-bit compatible version.
-          typeTable.GetUserPointer(INT((size_t)ClassType<Callee>::type()))
-        );
-    }
-#elif defined(SQ_USE_CLASS_INHERITANCE_SIMPLE)
-    SquirrelObject so(sa.GetObjectHandle(1)); // 'this'
-    ClassTypeBase *instType; so.GetTypeTag((SQUserPointer*)&instType);
-    ClassTypeBase *calleeType = ClassType<Callee>::type();
-    if (instType!=calleeType && instType->MayHaveOffset() ) {
-        // instance type is nore derived than callee, adjust pointer
-        int offset = instType->GetOffsetTo(calleeType);
-        instance = (Callee*)((char*)instance-offset);
-    }
-#endif 
-  }
-};
-
-// === Direct Call Instance Member Function handler ===
-template<typename Callee,typename Func>
-class DirectCallInstanceMemberFunction {
-public:
-  static inline int Dispatch(HSQUIRRELVM v) {
-    DirectCallInstanceFuncPicker<Callee, Func> p(v);
-    return p.instance && p.func ?
-      Call(*(p.instance), *(p.func), v, 2) :
-      sq_throwerror(v, _SC("Invalid Instance Type"));
-  }
-};
-
-// === Direct Call Instance Global Function handler ===
-template<typename Callee,typename Func>
-class DirectCallInstanceGlobalFunction {
-public:
-  static inline int Dispatch(HSQUIRRELVM v) {
-    DirectCallInstanceFuncPicker<Callee, Func> p(v);
-    return p.func ?
-      Call(*(p.func), v, 1) :
-      sq_throwerror(v, _SC("Invalid Instance Type"));
-  }
-};
-
-// === Direct Call Instance Global Function Var Args handler ===
-template<typename Callee,typename Func>
-class DirectCallInstanceGlobalFunctionVarArgs {
-public:
-  static inline int Dispatch(HSQUIRRELVM v) {
-    DirectCallInstanceFuncPicker<Callee, Func> p(v);
-    return p.func && p.instance ?
-      (*p.func)(p.instance,v) :
-      sq_throwerror(v, _SC("Invalid Instance Type"));
-  }
-};
-
-// === Direct Call Instance Member Function Variable Argument handler ===
-template<typename Callee,typename Func>
-class DirectCallInstanceMemberFunctionVarArgs {
-public:
-  static inline int Dispatch(HSQUIRRELVM v) {
-    DirectCallInstanceFuncPicker<Callee, Func> p(v);
-    sq_poptop(v); // Remove UserData from stack: so sa.GetParamCount() returns actual param count.
-    return p.func && p.instance ?
-      (p.instance->*(*p.func))(v) :
-      sq_throwerror(v, _SC("Invalid Instance Type"));
-  }
-};
-
-#ifdef SQPLUS_SMARTPOINTER_OPT
-#define SQPLUS_SMARTPOINTER_DISPATCH
-#include "SqPlusSmartPointer.h"
-#endif
-
-
-// Code fragment useful for debugging new implementations.
-#if 0
-HSQOBJECT ho = sa.GetObjectHandle(paramCount);
-SquirrelObject so(ho);
-SQObjectType sot = so.GetType();
-#endif
-
-#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK
-    #include "SqPlusTypeMask.h"
-#endif
-
-// === Standard function call ===
-
-template<typename Func>
-inline void sq_pushdirectclosure(HSQUIRRELVM v,Func func,SQUnsignedInteger nupvalues) {
-  SQUserPointer up = sq_newuserdata(v,sizeof(func)); // Also pushed on stack.
-  memcpy(up,&func,sizeof(func));
-  sq_newclosure(v,DirectCallFunction<Func>::Dispatch,nupvalues+1);
-#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK
-  sq_setparamscheck(v,0,sqTypeMask<Func>::Get());
-#endif
-} // sq_pushdirectclosure
-
-// === Fixed Class pointer call (always calls with object pointer that was registered) ===
-
-template<typename Callee,typename Func>
-inline void sq_pushdirectclosure(HSQUIRRELVM v,const Callee & callee,Func func,SQUnsignedInteger nupvalues) {
-  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(Callee*)+sizeof(func));  // Also pushed on stack.
-  const SQUserPointer pCallee = (SQUserPointer)&callee;
-  memcpy(up,&pCallee,sizeof(Callee*));
-  memcpy(up + sizeof(Callee*),&func,sizeof(func));
-  sq_newclosure(v,DirectCallMemberFunction<Callee,Func>::Dispatch,nupvalues+1);
-#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK
-  sq_setparamscheck(v,0,sqTypeMask<Func>::Get());
-#endif
-} // sq_pushdirectclosure
-
-#ifdef SQPLUS_SMARTPOINTER_OPT
-#define SQPLUS_SMARTPOINTER_DIRECT_CLOSURE
-#include "SqPlusSmartPointer.h"
-#endif
-
-// === Class Instance call: class pointer retrieved from script class instance ===
-
-template<typename Callee,typename Func>
-inline void sq_pushdirectinstanceclosure(HSQUIRRELVM v,const Callee & callee,Func func,SQUnsignedInteger nupvalues) {
-  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func));  // Also pushed on stack.
-  memcpy(up,&func,sizeof(func));
-  sq_newclosure(v,DirectCallInstanceMemberFunction<Callee,Func>::Dispatch,nupvalues+1);
-#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK
-  sq_setparamscheck(v,0,sqTypeMask<Func>::Get());
-#endif
-} // sq_pushdirectinstanceclosure
-
-// === Global function using this: class pointer retrieved from script class instance ===
-
-template<typename Callee,typename Func>
-inline void sq_pushdirectinstanceclosureglobal(HSQUIRRELVM v,const Callee & callee,Func func,SQUnsignedInteger nupvalues) {
-  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func));  // Also pushed on stack.
-  memcpy(up,&func,sizeof(func));
-  // Could check that 1st arg of Func is a Callee
-  sq_newclosure(v,DirectCallInstanceGlobalFunction<Callee,Func>::Dispatch,nupvalues+1);
-#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK
-  SQChar *tm = (SQChar*)sqTypeMask<Func>::Get();   
-  if( tm ) {
-    // Censor out the 1st arg, since SqPlus adds that automatically
-    tm[1] = _SC('x'); //tm[0];
-    tm++;
-  }
-  sq_setparamscheck(v,0,tm?tm:_SC(""));  
-#endif
-} // sq_pushdirectinstanceclosureglobal
-
-// === Global function using this: class pointer retrieved from script class instance ===
-
-template<typename Callee,typename Func>
-inline void sq_pushdirectinstanceclosureglobalvarargs(HSQUIRRELVM v,const Callee & callee,Func func,SQUnsignedInteger nupvalues) {
-  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func));  // Also pushed on stack.
-  memcpy(up,&func,sizeof(func));
-  // Could check that 1st arg of Func is a Callee
-  sq_newclosure(v,DirectCallInstanceGlobalFunctionVarArgs<Callee,Func>::Dispatch,nupvalues+1);
-#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK
-  sq_setparamscheck(v,-1,_SC("x"));  
-#endif
-} // sq_pushdirectinstanceclosureglobal
-
-// === Class Instance call: class pointer retrieved from script class instance (variable arguments) ===
-
-template<typename Callee>
-inline void sq_pushdirectinstanceclosurevarargs(HSQUIRRELVM v,const Callee & callee,int (Callee::*func)(HSQUIRRELVM),SQUnsignedInteger nupvalues) {
-  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func)); // Also pushed on stack.
-  memcpy(up,&func,sizeof(func));
-  typedef int (Callee::*FuncType)(HSQUIRRELVM);
-  sq_newclosure(v,DirectCallInstanceMemberFunctionVarArgs<Callee, FuncType>::Dispatch,nupvalues+1);
-} // sq_pushdirectinstanceclosurevarargs
-
-// === Register a STANDARD function (table or class on stack) ===
-
-template<typename Func>
-inline void Register(HSQUIRRELVM v,Func func,const SQChar * name) {
-  sq_pushstring(v,name,-1);
-  sq_pushdirectclosure(v,func,0);
-  sq_createslot(v,-3); // Stack is restored after this call (same state as before Register() call).
-} // Register
-
-// === Register a MEMBER function (table or class on stack) ===
-
-template<typename Callee,typename Func>
-inline void Register(HSQUIRRELVM v,Callee & callee,Func func,const SQChar * name) {
-  sq_pushstring(v,name,-1);
-  sq_pushdirectclosure(v,callee,func,0);
-  sq_createslot(v,-3); // Stack is restored after this call (same state as before Register() call).
-} // Register
-
-// === Register a STANDARD global function (root table) ===
-
-template<typename Func>
-inline void RegisterGlobal(HSQUIRRELVM v,Func func,const SQChar * name) {
-  sq_pushroottable(v);
-  Register(v,func,name);
-  sq_poptop(v); // Remove root table.
-} // RegisterGlobal
-
-template<typename Func>
-inline void RegisterGlobal(Func func,const SQChar * name) {
-  RegisterGlobal(SquirrelVM::GetVMPtr(),func,name);
-} // RegisterGlobal
-
-// === Register a MEMBER global function (root table) ===
-
-template<typename Callee,typename Func>
-inline void RegisterGlobal(HSQUIRRELVM v,Callee & callee,Func func,const SQChar * name) {
-  sq_pushroottable(v);
-  Register(v,callee,func,name);
-  sq_poptop(v); // Remove root table.
-} // RegisterGlobal
-
-template<typename Callee,typename Func>
-inline void RegisterGlobal(Callee & callee,Func func,const SQChar * name) {
-  RegisterGlobal(SquirrelVM::GetVMPtr(),callee,func,name);
-} // RegisterGlobal
-
-// === Register a STANDARD function (hso is table or class) ===
-
-template<typename Func>
-inline void Register(HSQUIRRELVM v,HSQOBJECT hso,Func func,const SQChar * name) {
-  sq_pushobject(v,hso);
-  Register(v,func,name);
-  sq_poptop(v); // Remove hso.
-} // Register
-
-// === Register a MEMBER function (hso is table or class) ===
-// === Fixed Class pointer call (always calls with object pointer that was registered) ===
-
-template<typename Callee,typename Func>
-inline void Register(HSQUIRRELVM v,HSQOBJECT hso,Callee & callee,Func func,const SQChar * name) {
-  sq_pushobject(v,hso);
-  Register(v,callee,func,name);
-  sq_poptop(v); // Remove hso.
-} // Register
-
-// === Register an INSTANCE MEMBER function ===
-// === Class Instance call: class pointer retrieved from script class instance ===
-
-template<typename Callee,typename Func>
-inline void RegisterInstance(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,Func func,const SQChar * name) {
-  sq_pushobject(v,hclass);
-  sq_pushstring(v,name,-1);
-  sq_pushdirectinstanceclosure(v,callee,func,0);
-  sq_createslot(v,-3);
-  sq_poptop(v); // Remove hclass.
-} // RegisterInstance
-
-
-// === Register an INSTANCE GLOBAL MEMBER function ===
-// === Class Instance call: class pointer retrieved from script class instance ===
-// Allows embedding global func that takes Callee as 1st arg as a member func
-template<typename Callee,typename Func>
-inline void RegisterInstanceGlobalFunc(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,Func func,const SQChar * name) {
-  sq_pushobject(v,hclass);
-  sq_pushstring(v,name,-1);
-  sq_pushdirectinstanceclosureglobal(v,callee,func,0);
-  sq_createslot(v,-3);
-  sq_poptop(v); // Remove hclass.
-} // RegisterInstanceGlobaFunc
-
-// === Register an INSTANCE GLOBAL MEMBER WITH VAR ARGS function ===
-// === Class Instance call: class pointer retrieved from script class instance ===
-// Allows embedding global func that takes Callee as 1st arg as a member func
-template<typename Callee,typename Func>
-inline void RegisterInstanceGlobalFuncVarArgs(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,Func func,const SQChar * name) {
-  sq_pushobject(v,hclass);
-  sq_pushstring(v,name,-1);
-  sq_pushdirectinstanceclosureglobalvarargs(v,callee,func,0);
-  sq_createslot(v,-3);
-  sq_poptop(v); // Remove hclass.
-} // RegisterInstanceGlobaFunc
-
-#ifdef SQPLUS_SMARTPOINTER_OPT
-#define SQPLUS_SMARTPOINTER_REGISTER_INSTANCE
-#include "SqPlusSmartPointer.h"
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(disable : 4995) // Deprecated _snprintf
-#endif
-
-// === Register an INSTANCE MEMBER function Variable Arguments ===
-// typeMask: "*" means don't check parameters, typeMask=0 means function takes no arguments (and is type checked for that case).
-// All the other Squirrel type-masks are passed normally.
-
-template<typename Callee>
-inline void RegisterInstanceVarArgs(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,int (Callee::*func)(HSQUIRRELVM),const SQChar * name,const SQChar * typeMask=_SC("*")) {
-  sq_pushobject(v,hclass);
-  sq_pushstring(v,name,-1);
-  sq_pushdirectinstanceclosurevarargs(v,callee,func,0);
-  SQChar tm[64];
-  SQChar * ptm = tm;
-  int numParams = SQ_MATCHTYPEMASKSTRING;
-  if (typeMask) {
-    if (typeMask[0] == '*') {
-      ptm       = 0; // Variable args: don't check parameters.
-//      numParams = 0; // Clear SQ_MATCHTYPEMASKSTRING (does not mean match 0 params. See sq_setparamscheck()).
-    } else {
-      if (SCSNPRINTF(tm,sizeof(tm),_SC("x%s"),typeMask) < 0) { // Must be an instance.
-        throw SquirrelError(_SC("RegisterInstanceVarArgs: typeMask string too long."));
-      } // if
-    } // if
-  } else { // <TODO> Need to check object type on stack: table, class, instance, etc.
-//    _snprintf(tm,sizeof(tm),"x"); // instance.
-    tm[0] = 'x';
-    tm[1] = 0;
-  } // if
-  if (ptm) { // If ptm == 0, don't check type.
-    sq_setparamscheck(v,numParams,ptm); // Determine arg count from type string.
-  } // if
-#ifdef _DEBUG
-  sq_setnativeclosurename(v,-1,name); // For debugging only.
-#endif
-  sq_createslot(v,-3);
-  sq_poptop(v); // Remove hclass.
-} // RegisterInstanceVarArgs
-
-#ifdef _MSC_VER
-#pragma warning(default : 4995)
-#endif
-
-// === Call Squirrel Functions from C/C++ ===
-// No type checking is performed for Squirrel functions as Squirrel types are dynamic:
-// Incoming types are passed unchanged to Squirrel functions. The parameter count is checked: an exception is thrown if mismatched.
-// Return values must match the RT template argument type, else an exception can be thrown on return.
-
-template<typename RT>
-struct SquirrelFunction {
-  HSQUIRRELVM v;
-  SquirrelObject object; // Table or class.
-  SquirrelObject func;
-  SquirrelFunction() : v(0) {}
-  SquirrelFunction(HSQUIRRELVM _v,const SquirrelObject & _object,const SquirrelObject & _func) : v(_v), object(_object), func(_func) {}
-  SquirrelFunction(const SquirrelObject & _object,const SquirrelObject & _func) : v(SquirrelVM::GetVMPtr()), object(_object), func(_func) {}
-  SquirrelFunction(const SquirrelObject & _object,const SQChar * name) {
-    v      = SquirrelVM::GetVMPtr();
-    object = _object;
-    func   = object.GetValue(name);
-  }
-  SquirrelFunction(const SQChar * name) {
-    v      = SquirrelVM::GetVMPtr();
-    object = SquirrelVM::GetRootTable();
-    func   = object.GetValue(name);
-  }
-
-  // Release references and reset internal objects to null.
-  void reset(void) {
-    func.Reset();
-    object.Reset();
-  } // Reset
-
-#define SQPLUS_CHECK_FNCALL(res) if (!SQ_SUCCEEDED(res)) throw SquirrelError(_SC("SquirrelFunction<> call failed"))
-
-  RT operator()(void) {
-    sq_pushobject(v,func.GetObjectHandle());
-    sq_pushobject(v,object.GetObjectHandle());
-    SQPLUS_CHECK_FNCALL(sq_call(v,1,SQTrue,SQ_CALL_RAISE_ERROR));
-    return GetRet(TypeWrapper<RT>(),v,-1);
-  }
-
-  template<typename P1>
-  RT operator()(P1 p1) {
-    sq_pushobject(v,func.GetObjectHandle());
-    sq_pushobject(v,object.GetObjectHandle());
-    Push(v,p1);
-    SQPLUS_CHECK_FNCALL(sq_call(v,2,SQTrue,SQ_CALL_RAISE_ERROR));
-    return GetRet(TypeWrapper<RT>(),v,-1);
-  }
-
-  template<typename P1,typename P2>
-  RT operator()(P1 p1,P2 p2) {
-    sq_pushobject(v,func.GetObjectHandle());
-    sq_pushobject(v,object.GetObjectHandle());
-    Push(v,p1);
-    Push(v,p2);
-    SQPLUS_CHECK_FNCALL(sq_call(v,3,SQTrue,SQ_CALL_RAISE_ERROR));
-    return GetRet(TypeWrapper<RT>(),v,-1);
-  }
-
-  template<typename P1,typename P2,typename P3>
-  RT operator()(P1 p1,P2 p2,P3 p3) {
-    sq_pushobject(v,func.GetObjectHandle());
-    sq_pushobject(v,object.GetObjectHandle());
-    Push(v,p1);
-    Push(v,p2);
-    Push(v,p3);
-    SQPLUS_CHECK_FNCALL(sq_call(v,4,SQTrue,SQ_CALL_RAISE_ERROR));
-    return GetRet(TypeWrapper<RT>(),v,-1);
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4>
-  RT operator()(P1 p1,P2 p2,P3 p3,P4 p4) {
-    sq_pushobject(v,func.GetObjectHandle());
-    sq_pushobject(v,object.GetObjectHandle());
-    Push(v,p1);
-    Push(v,p2);
-    Push(v,p3);
-    Push(v,p4);
-    SQPLUS_CHECK_FNCALL(sq_call(v,5,SQTrue,SQ_CALL_RAISE_ERROR));
-    return GetRet(TypeWrapper<RT>(),v,-1);
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4,typename P5>
-  RT operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5) {
-    sq_pushobject(v,func.GetObjectHandle());
-    sq_pushobject(v,object.GetObjectHandle());
-    Push(v,p1);
-    Push(v,p2);
-    Push(v,p3);
-    Push(v,p4);
-    Push(v,p5);
-    SQPLUS_CHECK_FNCALL(sq_call(v,6,SQTrue,SQ_CALL_RAISE_ERROR));
-    return GetRet(TypeWrapper<RT>(),v,-1);
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
-  RT operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6) {
-    sq_pushobject(v,func.GetObjectHandle());
-    sq_pushobject(v,object.GetObjectHandle());
-    Push(v,p1);
-    Push(v,p2);
-    Push(v,p3);
-    Push(v,p4);
-    Push(v,p5);
-    Push(v,p6);
-    SQPLUS_CHECK_FNCALL(sq_call(v,7,SQTrue,SQ_CALL_RAISE_ERROR));
-    return GetRet(TypeWrapper<RT>(),v,-1);
-  }
-
-  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
-  RT operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7) {
-    sq_pushobject(v,func.GetObjectHandle());
-    sq_pushobject(v,object.GetObjectHandle());
-    Push(v,p1);
-    Push(v,p2);
-    Push(v,p3);
-    Push(v,p4);
-    Push(v,p5);
-    Push(v,p6);
-    Push(v,p7);
-    SQPLUS_CHECK_FNCALL(sq_call(v,8,SQTrue,SQ_CALL_RAISE_ERROR));
-    return GetRet(TypeWrapper<RT>(),v,-1);
-  }
-
-};
-
-// === Class/Struct registration ===
-
-#define SQ_DELETE_CLASS(CLASSTYPE) if (up) { CLASSTYPE * self = (CLASSTYPE *)up; delete self;} return 0
-#define SQ_DECLARE_RELEASE(CLASSTYPE) \
-  static int release(SQUserPointer up,SQInteger size) { \
-    SQ_DELETE_CLASS(CLASSTYPE); \
-  }
-
-template<typename T>
-struct ReleaseClassPtrPtr {
-  static int release(SQUserPointer up,SQInteger size) {
-    if (up) {
-      T ** self = (T **)up;
-      delete *self;
-    } // if
-    return 0;
-  } // release
-};
-
-template<typename T>
-struct ReleaseClassPtr {
-  static int release(SQUserPointer up,SQInteger size) {
-    if (up) {
-      T * self = (T *)up;
-      delete self;
-    } // if
-    return 0;
-  } // release
-};
-
-BOOL CreateClass(HSQUIRRELVM v,SquirrelObject & newClass,SQUserPointer classType,const SQChar * name,const SQChar * baseName=0);
-
-
-template<typename T>
-inline void PopulateAncestry(HSQUIRRELVM v,
-                             SquirrelObject &instance,
-                             T *newClass)
-{
-  // 11/2/05: Create a new table for this instance.
-  SquirrelObject newObjectTable = SquirrelVM::CreateTable();
-  // <TODO> 64-bit compatible version.
-  newObjectTable.SetUserPointer(INT((size_t)ClassType<T>::type()), newClass);
-  instance.SetValue(SQ_CLASS_OBJECT_TABLE_NAME, newObjectTable);
-
-  SquirrelObject classHierArray = instance.GetValue(SQ_CLASS_HIER_ARRAY);
-  INT count = classHierArray.Len();
-
-  // This will be true when more than one C/C++ class is in the hierarchy.
-  if (count > 1) {
-    --count; // Skip the most-derived class.
-    for (INT i = 0; i < count; i++) {
-      // Kamaitati's changes for C++ inheritance support. jcs 5/28/06
-      SquirrelObject so = classHierArray.GetValue(i);
-      sq_pushobject(v,so.GetObjectHandle());
-      SQUserPointer typeTag;
-      sq_gettypetag(v,-1,&typeTag);
-      newObjectTable.SetUserPointer(INT(size_t(typeTag)),newClass);
-      sq_poptop(v);
-    }
-  }
-}
-
-
-// Call PostConstruct() at the end of custom constructors.
-template<typename T>
-inline int PostConstruct(HSQUIRRELVM v, T *newClass, SQRELEASEHOOK hook)
-{
-#ifdef SQ_USE_CLASS_INHERITANCE
-  StackHandler sa(v);
-  HSQOBJECT ho = sa.GetObjectHandle(1); // OT_INSTANCE
-  SquirrelObject instance(ho);
-  PopulateAncestry(v, instance, newClass);
-#endif // SQ_USE_CLASS_INHERITANCE
-
-  sq_setinstanceup(v, 1, newClass);
-  sq_setreleasehook(v, 1, hook);
-  return TRUE;
-} // PostConstruct
-
-inline int PostConstructSimple(HSQUIRRELVM v, void *newClass, SQRELEASEHOOK hook){
-  sq_setinstanceup(v, 1, newClass);
-  sq_setreleasehook(v, 1, hook);
-  return TRUE;
-} // PostConstructSimple
-
-
-template<typename T>
-struct ConstructReleaseClass {
-  static int construct(HSQUIRRELVM v) {
-    return PostConstruct<T>(v,new T(),release);
-  } // construct
-  SQ_DECLARE_RELEASE(T)
-};
-
-# ifdef SQPLUS_ENABLE_TYPEOF
-template<typename T>
-int sq_typeof(HSQUIRRELVM v) {
-    sq_pushstring(v,TypeInfo<T>().typeName,-1);
-    return 1;
-}
-# endif
-
-// === Helper for RegisterClassType*() ===
-inline void setupClassHierarchy(SquirrelObject newClass) {
-  // <NOTE> New member vars cannot be added to instances (OT_INSTANCE): additions must occur on the defining class (OT_CLASS), before any instances are instantiated.
-  if (!newClass.Exists(SQ_CLASS_OBJECT_TABLE_NAME)) { // Will always get table from most-derived registered class.
-    SquirrelObject objectTable = SquirrelVM::CreateTable();
-    newClass.SetValue(SQ_CLASS_OBJECT_TABLE_NAME,objectTable); // Constructors must add their 'this' pointer indexed by type to this table. See PostConstruct() above.
-    // 11/2/05: This table will behave as a static global for each instance unless overwritten during construction (see PostConstruct() above).
-  } // if
-  SquirrelObject classHierArray;
-  if (!newClass.Exists(SQ_CLASS_HIER_ARRAY)) {   // Will always get table from most-derived registered class.
-    classHierArray = SquirrelVM::CreateArray(0); // The only constructor called will be the most-derived class: this array contains all classes in the hierarchy to be constructed.
-    newClass.SetValue(SQ_CLASS_HIER_ARRAY,classHierArray);
-  } else {
-    classHierArray = newClass.GetValue(SQ_CLASS_HIER_ARRAY);
-  } // if
-  classHierArray.ArrayAppend(newClass);          // Add the class to the hierarchy array. The array values will be released and replaced with UserData to free created ancestor classes.
-} // setupClassHierarchy
-
-
-template<typename T>
-inline SquirrelObject RegisterClassType(HSQUIRRELVM v,const SQChar * scriptClassName,const SQChar * baseScriptClassName=0) {
-  int top = sq_gettop(v);
-  SquirrelObject newClass;
-  if (CreateClass(v,newClass,(SQUserPointer)ClassType<T>::type(),scriptClassName,baseScriptClassName)) {
-    SquirrelVM::CreateFunction(newClass,&ConstructReleaseClass<T>::construct,_SC("constructor"));
-# ifdef SQ_USE_CLASS_INHERITANCE
-    setupClassHierarchy(newClass);
-# endif
-# ifdef SQPLUS_ENABLE_TYPEOF
-    SquirrelVM::CreateFunction(newClass,&sq_typeof<T>,_SC("_typeof"));
-# endif
-  } // if
-  sq_settop(v,top);
-  return newClass;
-} // RegisterClassType
-
-template<typename T>
-inline SquirrelObject RegisterClassTypeNoConstructor(HSQUIRRELVM v,const SQChar * scriptClassName,const SQChar * baseScriptClassName=0) {
-  int top = sq_gettop(v);
-  SquirrelObject newClass;
-  if (CreateClass(v,newClass,(SQUserPointer)ClassType<T>::type(),scriptClassName,baseScriptClassName)) {
-# ifdef SQ_USE_CLASS_INHERITANCE
-    setupClassHierarchy(newClass);
-# endif
-# ifdef SQPLUS_ENABLE_TYPEOF
-    SquirrelVM::CreateFunction(newClass,&sq_typeof<T>,_SC("_typeof"));
-# endif
-  } // if
-  sq_settop(v,top);
-  return newClass;
-} // RegisterClassTypeNoConstructor
-
-
-// === Define and register a C++ class and its members for use with Squirrel ===
-// Constructors+destructors are automatically created. Custom constructors must use the
-// standard SQFUNCTION signature if variable argument types are required (overloads).
-// See testSqPlus2.cpp for examples.
-
-// <NOTE> Do not use SQClassDefBase<> directly, use SQClassDef<> or SQClassDefNoConstructor<>, below.
-template<typename TClassType, typename TClassBase>
-struct SQClassDefBase {
-  HSQUIRRELVM v;
-  const SQChar * name;
-  SquirrelObject newClass;
-
-#if defined(SQ_USE_CLASS_INHERITANCE) || defined(SQ_USE_CLASS_INHERITANCE_SIMPLE)
-  const SQChar * base;
-  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).
-  SQClassDefBase(HSQUIRRELVM _v,const SQChar * _name=0,const SQChar * _base=0) : v(_v), name(_name), base(_base) {InitBase();}
-  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).
-  SQClassDefBase(const SQChar * _name=0,const SQChar * _base=0) : v(SquirrelVM::GetVMPtr()), name(_name), base(_base) {InitBase(TypeWrapper<TClassBase>());}
-  template<class Base>
-  void InitBase(TypeWrapper<Base>){ /*assert(base);*/ ClassType<TClassType>::Get()->SetBase(TypeWrapper<Base>()); CheckInitDefaultNames(); }
-  void InitBase(TypeWrapper<SQNoBaseClass>){ /*assert(!base);*/ CheckInitDefaultNames(); }
-  void CheckInitDefaultNames(){ if( !name ) name=TypeInfo<TClassType>().typeName; if( !base ) base=TypeInfo<TClassBase>().typeName; }
-#else
-  SQClassDefBase(HSQUIRRELVM _v,const SQChar * _name=0) : v(_v), name(_name) { CheckInitDefaultName(); }
-  SQClassDefBase(const SQChar * _name=0) : v(SquirrelVM::GetVMPtr()), name(_name) { CheckInitDefaultName(); } 
-  void CheckInitDefaultName(){ if( !name ) name=TypeInfo<TClassType>().typeName; }
-#endif
-
-  // Register a member function.
-  template<typename Func>
-  SQClassDefBase & func(Func pfunc,const SQChar * name) {
-    RegisterInstance(v,newClass.GetObjectHandle(),*(TClassType *)0,pfunc,name);
-    return *this;
-  } // func
-
-  // Register a global function as a member function (the global takes a Callee*/& as first arg).
-  template<typename Func>
-  SQClassDefBase & globMembFunc(Func pfunc,const SQChar * name) {
-    RegisterInstanceGlobalFunc(v,newClass.GetObjectHandle(),*(TClassType *)0,pfunc,name);
-    return *this;
-  } // globMemberFunc
-
-  // Register a global function as a member function (the global takes a Callee*/& as first arg and SQVM* as 2nd).
-  template<typename Func>
-  SQClassDefBase & globMembFuncVarArgs(Func pfunc,const SQChar * name) {
-    RegisterInstanceGlobalFuncVarArgs(v,newClass.GetObjectHandle(),*(TClassType *)0,pfunc,name);
-    return *this;
-  } // globMemberFuncVarArgs
-  
-#ifdef SQPLUS_SMARTPOINTER_OPT
-#define SQPLUS_SMARTPOINTER_CLASS_DEF_FUNC
-#include "SqPlusSmartPointer.h"
-#endif
-
-  // Register a variable-argument member function (supports variable+multiple return values).
-  // typeMask: "*" means don't check parameters, typeMask=0 means function takes no arguments (and is type checked for that case).
-  // All the other Squirrel type-masks are passed normally.
-  template<typename Func>
-  SQClassDefBase & funcVarArgs(Func pfunc,const SQChar * name,const SQChar * typeMask=_SC("*")) {
-    RegisterInstanceVarArgs(v,newClass.GetObjectHandle(),*(TClassType *)0,pfunc,name,typeMask);
-    return *this;
-  } // funcVarArgs
-
-  // === BEGIN static-member+global function registration ===
-
-  // === This version is for static member functions only, such as custom constructors where 'this' is not yet valid ===
-  // typeMask: "*" means don't check parameters, typeMask=0 means function takes no arguments (and is type checked for that case).
-  // All the other Squirrel type-masks are passed normally.
-
-  template<typename Func>
-  SQClassDefBase & staticFuncVarArgs(Func pfunc,const SQChar * name,const SQChar * typeMask=_SC("*")) {
-    SquirrelVM::PushObject(newClass);
-    SquirrelVM::CreateFunction(pfunc,name,typeMask);
-    SquirrelVM::Pop(1);
-    return *this;
-  } // staticFuncVarArgs
-
-  // Register a standard global function (effectively embedding a global function in TClassType's script namespace: does not need or use a 'this' pointer).
-  template<typename Func>
-  SQClassDefBase & staticFunc(Func pfunc,const SQChar * name) {
-    Register(v,newClass.GetObjectHandle(),pfunc,name);
-    return *this;
-  } // staticFunc
-
-  // Register a function to a pre-allocated class/struct member function: will use callee's 'this' (effectively embedding a global function in TClassType's script namespace).
-  template<typename Callee,typename Func>
-  SQClassDefBase & staticFunc(Callee & callee,Func pfunc,const SQChar * name) {
-    Register(v,newClass.GetObjectHandle(),callee,pfunc,name);
-    return *this;
-  } // staticFunc
-
-  // === END static+global function registration ===
-
-  // Register a member variable.
-  template<typename VarType>
-  SQClassDefBase & var(VarType TClassType::* pvar,const SQChar * name,VarAccessType access=VAR_ACCESS_READ_WRITE) {
-    struct CV {
-      VarType TClassType::* var;
-    } cv; // Cast Variable helper.
-    cv.var = pvar;
-    RegisterInstanceVariable(newClass,ClassType<TClassType>::type(),*(VarType **)&cv,name,access);
-    return *this;
-  } // var
-
-  // Register a member variable as a UserPointer (read only).
-  template<typename VarType>
-  SQClassDefBase & varAsUserPointer(VarType TClassType::* pvar,const SQChar * name) {
-    struct CV {
-      VarType TClassType::* var;
-    } cv; // Cast Variable helper.
-    cv.var = pvar;
-    RegisterInstanceVariable(newClass,ClassType<TClassType>::type(),*(SQAnything **)&cv,name,VAR_ACCESS_READ_ONLY);
-    return *this;
-  } // varAsUserPointer
-
-#ifdef SQPLUS_SMARTPOINTER_OPT
-#define SQPLUS_SMARTPOINTER_CLASS_DEF_VAR
-#include "SqPlusSmartPointer.h"
-#endif
-
-  template<typename VarType>
-  SQClassDefBase & staticVar(VarType * pvar,const SQChar * name,VarAccessType access=VAR_ACCESS_READ_WRITE) {
-    struct CV {
-      VarType * var;
-    } cv; // Cast Variable helper.
-    cv.var = pvar;
-    RegisterInstanceVariable(newClass,ClassType<TClassType>::type(),*(VarType **)&cv,name,VarAccessType(access|VAR_ACCESS_STATIC));
-    return *this;
-  } // staticVar
-
-#ifdef SQPLUS_CONST_OPT
-#define SQ_REG_CONST_STATIC_VAR
-#include "SqPlusConst.h"
-#endif
-
-  // Member / static member script vars (ordinary Squirrel vars)
-  SQClassDefBase & scriptVar( const SQChar* name, int ival, SQBool static_var=SQFalse ) {
-    HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-    sq_pushobject(v,newClass.GetObjectHandle());
-    sq_pushstring(v,name,-1);
-    sq_pushinteger(v,ival);
-    sq_newslot(v,-3,static_var);
-    sq_pop(v,1);
-    return *this;
-  }
-
-  SQClassDefBase & scriptVar( const SQChar* name, double fval, SQBool static_var=SQFalse ) {
-    HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-    sq_pushobject(v,newClass.GetObjectHandle());
-    sq_pushstring(v,name,-1);
-    sq_pushfloat(v,fval);
-    sq_newslot(v,-3,static_var);
-    sq_pop(v,1);
-    return *this;
-  }
-  
-  SQClassDefBase & scriptVar( const SQChar* name, const SQChar* sval, SQBool static_var=SQFalse ) {
-    HSQUIRRELVM v = SquirrelVM::GetVMPtr();
-    sq_pushobject(v,newClass.GetObjectHandle());
-    sq_pushstring(v,name,-1);
-    sq_pushstring(v,sval,-1);
-    sq_newslot(v,-3,static_var);
-    sq_pop(v,1);
-    return *this;
-  }
-  
-  // Register a constant (read-only in script, passed by value (only INT, FLOAT, or BOOL types)).
-  template<typename ConstantType>
-  SQClassDefBase & constant(ConstantType constant,const SQChar * name) {
-    RegisterInstanceConstant(newClass,ClassType<TClassType>::type(),constant,name);
-    return *this;
-  } // constant
-
-  // Register an enum as an integer (read-only in script).
-  SQClassDefBase & enumInt(int constant,const SQChar * name) {
-      RegisterInstanceConstant(newClass,ClassType<TClassType>::type(),constant,name);
-      return *this;
-  } // enumInt
-
-#ifdef SQPLUS_OVERLOAD_OPT
-#define SQPLUS_OVERLOAD_IMPLEMENTATION
-#include "SqPlusOverload.h"
-#endif
-};
-
-#ifdef SQPLUS_OVERLOAD_OPT
-#define SQPLUS_OVERLOAD_FUNCTIONS
-#include "SqPlusOverload.h"
-#endif
-
-template<typename TClassType, typename TClassBase=SQNoBaseClass>
-struct SQClassDef : public SQClassDefBase<TClassType,TClassBase> {
-
-#if defined(SQ_USE_CLASS_INHERITANCE) || defined(SQ_USE_CLASS_INHERITANCE_SIMPLE)
-  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).
-  SQClassDef(HSQUIRRELVM _v,const SQChar * _name=0,const SQChar * _base=0) : SQClassDefBase<TClassType,TClassBase>(_v,_name,_base) {
-    SQClassDefBase<TClassType,TClassBase>::newClass = 
-            RegisterClassType<TClassType>( SQClassDefBase<TClassType,TClassBase>::v,
-                                           SQClassDefBase<TClassType,TClassBase>::name,
-                                           SQClassDefBase<TClassType,TClassBase>::base );
-  }
-  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).
-  SQClassDef(const SQChar * _name=0,const SQChar * _base=0) : SQClassDefBase<TClassType,TClassBase>(_name,_base) {
-    SQClassDefBase<TClassType,TClassBase>::newClass = 
-            RegisterClassType< TClassType>( SQClassDefBase<TClassType,TClassBase>::v,
-                                            SQClassDefBase<TClassType,TClassBase>::name,
-                                            SQClassDefBase<TClassType,TClassBase>::base );
-  }
-#else
-  SQClassDef(HSQUIRRELVM _v,const SQChar * _name=0) : SQClassDefBase<TClassType,TClassBase>(_v,_name) {
-    SQClassDefBase<TClassType,TClassBase>::newClass = 
-                                            RegisterClassType<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,
-                                            SQClassDefBase<TClassType,TClassBase>::name );
-  }
-  SQClassDef(const SQChar * _name=0) : SQClassDefBase<TClassType,TClassBase>(_name) {
-    SQClassDefBase<TClassType,TClassBase>::newClass = 
-                                            RegisterClassType<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,
-                                            SQClassDefBase<TClassType,TClassBase>::name );
-  }
-#endif
-};
-
-template<typename TClassType, typename TClassBase=SQNoBaseClass>
-struct SQClassDefNoConstructor : public SQClassDefBase<TClassType,TClassBase> {
-#if defined(SQ_USE_CLASS_INHERITANCE) || defined(SQ_USE_CLASS_INHERITANCE_SIMPLE)
-  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).
-  SQClassDefNoConstructor(HSQUIRRELVM _v,const SQChar * _name=0,const SQChar * _base=0) : SQClassDefBase<TClassType,TClassBase>(_v,_name,_base) {
-    SQClassDefBase<TClassType,TClassBase>::newClass = RegisterClassTypeNoConstructor<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,SQClassDefBase<TClassType,TClassBase>::name,SQClassDefBase<TClassType,TClassBase>::base);
-  }
-  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).
-  SQClassDefNoConstructor(const SQChar * _name=0,const SQChar * _base=0) : SQClassDefBase<TClassType,TClassBase>(_name,_base) {
-    SQClassDefBase<TClassType,TClassBase>::newClass = RegisterClassTypeNoConstructor<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,SQClassDefBase<TClassType,TClassBase>::name,SQClassDefBase<TClassType,TClassBase>::base);
-  }
-#else
-  SQClassDefNoConstructor(HSQUIRRELVM _v,const SQChar * _name=0) : SQClassDefBase<TClassType,TClassBase>(_v,_name) {
-    SQClassDefBase<TClassType,TClassBase>::newClass = RegisterClassTypeNoConstructor<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,SQClassDefBase<TClassType,TClassBase>::name);
-  }
-  SQClassDefNoConstructor(const SQChar * _name=0) : SQClassDefBase<TClassType,TClassBase>(_name) {
-    SQClassDefBase<TClassType,TClassBase>::newClass = RegisterClassTypeNoConstructor<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,SQClassDefBase<TClassType,TClassBase>::name);
-  }
-#endif
-};
-
-
-// === Macros for old style registration. SQClassDef registration is now easier to use (SQ_DECLARE_CLASS() is not needed) ===
-
-#define SQ_DECLARE_CLASS(CLASSNAME)                                  \
-static int _##CLASSNAME##_release(SQUserPointer up,SQInteger size) { \
-  if (up) {                                                          \
-    CLASSNAME * self = (CLASSNAME *)up;                              \
-    delete self;                                                     \
-  }                                                                  \
-  return 0;                                                          \
-}                                                                    \
-static int _##CLASSNAME##_constructor(HSQUIRRELVM v) {               \
-  CLASSNAME * pc = new CLASSNAME();                                  \
-  sq_setinstanceup(v,1,pc);                                          \
-  sq_setreleasehook(v,1,_##CLASSNAME##_release);                     \
-  return 1;                                                          \
-}
-
-#define SQ_REGISTER_CLASS(CLASSNAME)                                 \
-  RegisterClassType(SquirrelVM::GetVMPtr(),_SC(#CLASSNAME),_##CLASSNAME##_constructor)
-
-#define SQ_REGISTER_INSTANCE(NEWSQCLASS,CCLASS,FUNCNAME)             \
-  RegisterInstance(SquirrelVM::GetVMPtr(),NEWSQCLASS.GetObjectHandle(),*(CCLASS *)0,&CCLASS::FUNCNAME,_SC(#FUNCNAME));
-
-#define SQ_REGISTER_INSTANCE_VARARGS(NEWSQCLASS,CCLASS,FUNCNAME)     \
-  RegisterInstanceVarArgs(SquirrelVM::GetVMPtr(),NEWSQCLASS.GetObjectHandle(),*(CCLASS *)0,&CCLASS::FUNCNAME,_SC(#FUNCNAME));
-
-#define SQ_REGISTER_INSTANCE_VARIABLE(NEWSQCLASS,CCLASS,VARNAME)     \
-  RegisterInstanceVariable(NEWSQCLASS,&((CCLASS *)0)->VARNAME,_SC(#VARNAME));
-
-#if defined(USE_ARGUMENT_DEPENDANT_OVERLOADS) && defined(_MSC_VER)
-#pragma warning (default:4675)
-#endif
-
-}; // namespace SqPlus
-
-
-// === BEGIN code suggestion from the Wiki ===
-
-// Get any bound type from this SquirrelObject. Note that Squirrel's
-// handling of references and pointers still holds here.
-template<typename _ty>
-inline _ty SquirrelObject::Get(void) {
-  sq_pushobject(SquirrelVM::_VM,GetObjectHandle());
-  _ty val = SqPlus::Get(SqPlus::TypeWrapper<_ty>(),SquirrelVM::_VM,-1);
-  sq_poptop(SquirrelVM::_VM);
-  return val;
-}
-
-// Set any bound type to this SquirrelObject. Note that Squirrel's
-// handling of references and pointers still holds here.
-template<typename _ty>
-inline SquirrelObject SquirrelObject::SetByValue(_ty val) { // classes/structs should be passed by ref (below) to avoid an extra copy.
-  SqPlus::Push(SquirrelVM::_VM,val);
-  AttachToStackObject(-1);
-  sq_poptop(SquirrelVM::_VM);
-  return *this;
-}
-
-// Set any bound type to this SquirrelObject. Note that Squirrel's
-// handling of references and pointers still holds here.
-template<typename _ty>
-inline SquirrelObject &SquirrelObject::Set(_ty & val) {
-  SqPlus::Push(SquirrelVM::_VM,val);
-  AttachToStackObject(-1);
-  sq_poptop(SquirrelVM::_VM);
-  return *this;
-}
-
-// === END code suggestion from the Wiki ===
-
-#endif //_SQ_PLUS_H_
+// SqPlus.h

+// Created by John Schultz 9/05/05, major update 10/05/05.

+// Template function call design from LuaPlusCD by Joshua C. Jensen,

+// inspired by luabind which was inspired by boost::python.

+// Const argument, const member functions, and Mac OS-X changes by Simon Michelmore.

+// DECLARE_INSTANCE_TYPE_NAME changes by Ben (Project5) from http://www.squirrel-lang.org/forums/.

+// Added Kamaitati's changes 5/28/06.

+// Free for any use.

+

+#ifndef _SQ_PLUS_H_

+#define _SQ_PLUS_H_

+

+#include <stdlib.h>

+#include <assert.h>

+

+#ifdef __APPLE__

+  #include <malloc/malloc.h>

+#else

+  #include <malloc.h>

+#endif

+#include <memory.h>

+#include <memory>

+#include <limits.h>  // For INT_MAX on GCC

+

+#include "squirrel.h"   // Include to get SQUNICODE setting from here

+#ifndef _SC

+  #error No _SC macro  - Usually defined in squirrel.h

+#endif

+// Provide a _sqT(...) macros also (same as _SC but easier to know its for Squirrel)

+#ifndef _sqT

+  #define _sqT _SC

+#endif 

+

+// For backward compatibility, define _T if outside of Windows platform.

+// (really, _SC() or _sqT() are better, since that leaves us free to run 

+// Squirrel in ASCII or wchar_t mode, regardless of the app being built).

+#if !defined(_WIN32) && !defined(_WIN64) 

+  #ifndef _T

+    #define _T _SC

+  #endif

+#endif 

+

+

+// A comment about strings. We let squirrel.h determine whether to use 

+// char or wchar_t strings. So here we follow the define SQUNICODE. This 

+// opens up for using Unicode system calls on Windows while having the script 

+// engine in ASCII mode, or vice versa. To enable this, also the macro

+// _SC("some string") is used instead of _T("some string"). 

+//

+// To handle the case where function parameters are given in the opposite

+// character mode (char if SQChar is wchar_t and vice versa), such strings

+// can be converted on the fly to the other mode in the function call, if 

+// the define SQPLUS_AUTOCONVERT_OTHER_CHAR is set below. Buffers are 

+// allocated and kept around for the duration of the function call. The 

+// same applies to returned strings of the opposite type. 

+

+#if defined(_MSC_VER) || defined(__BORLANDC__)

+  #include <tchar.h>

+  #ifndef SQUNICODE

+    #define SCSNPRINTF _snprintf

+    #define SCPUTS puts

+  #else

+    #define SCSNPRINTF _snwprintf

+    #define SCPUTS _putws

+  #endif

+  #if defined(_MSC_VER)  

+    #ifndef _CRT_SECURE_NO_DEPRECATE

+	  #define _CRT_SECURE_NO_DEPRECATE    // Disable warnings around various sprintf

+    #endif

+    #pragma warning(disable: 4996)       // When above does not work 

+  #endif    

+#else

+  #ifdef SQUNICODE

+    #define SCSNPRINTF _snwprintf

+    #define SCPUTS _putws

+    #include <stdio.h> // for snprintf

+  #else

+    #define SCSNPRINTF snprintf

+    #include <stdio.h> // for snprintf

+    #define SCPUTS puts

+  #endif

+#endif

+

+

+#ifndef _WINDEF_

+  typedef int BOOL;

+  typedef int INT;

+  typedef float FLOAT;

+  #define TRUE 1

+  #define FALSE 0

+#endif

+

+#if 1

+#define SQ_CALL_RAISE_ERROR SQTrue

+#else

+#define SQ_CALL_RAISE_ERROR SQFalse

+#endif

+

+#include "SquirrelObject.h"

+#include "SquirrelVM.h"

+#include "SquirrelBindingsUtils.h"

+

+// All setup defines have moved to its own file

+#include "SqPlusSetup.h" 

+

+#ifdef SQPLUS_AUTOCONVERT_OTHER_CHAR

+#define SQPLUS_AUTOCONVERT_MAX_INSTANCES 8  // In argument conversion, don't keep more than this alive 

+#include "SqPlusOCharBuf.h" 

+#endif 

+ 

+#if defined(SQPLUS_SUPPORT_STD_STRING) && defined(SQUNICODE)

+  #ifdef _MSC_VER

+    #pragma message("std::string and SQChar as wchar_t is not compatible!")

+  #else

+    #warning std::string and SQChar as wchar_t is not compatible!

+  #endif

+#endif

+

+

+namespace SqPlus {

+

+template<class T> struct TypeWrapper {};

+struct SquirrelNull {};       

+struct SQNoBaseClass {};     // For scripted classes with no base class (or no scripted base class)

+

+struct SQAnything { void * anything; }; // Needed for binding pointers to variables (cannot dereference void *).

+typedef SQAnything * SQAnythingPtr;

+typedef SQChar * SQCharPtr;

+

+// Helper struct to (sometimes) store a temporary return value as another type.

+// Useful when returning const char* and other types that require temp allocation.

+// For primitive types, it just maps onto itself.

+template<class T>

+struct Temporary { 

+	typedef T type; 

+};

+

+// References are tricky, but they should just be filtered out usually

+template<class T>

+struct SqAssignableRef { 

+    SqAssignableRef( ) : m_pt(0) { } 

+    void operator = (T& tr){ m_pt=&tr; }

+    operator T& () { return *m_pt; }

+    T *m_pt;

+};

+

+template<class T>

+struct Temporary<T&> { 

+    typedef SqAssignableRef<T> type;

+};

+

+

+// === Do not use directly: use one of the predefined sizes below ===

+

+struct ScriptStringVarBase {

+  const unsigned char MaxLength; // Real length is MaxLength+1.

+  SQChar s[1];

+  ScriptStringVarBase(int _MaxLength) : MaxLength(_MaxLength) {}

+  operator SQChar * () { return &s[0]; }

+  operator void * () { return (void *)&s[0]; }

+  const SQChar * operator = (const SQChar * _s) {

+    return safeStringCopy(s,_s,MaxLength);

+  }

+  // Special safe string copy where MaxLength is 1 less than true buffer length.

+  // strncpy() pads out nulls for the full length of the buffer specified by MaxLength.

+  static inline SQChar * safeStringCopy(SQChar * d,const SQChar * s,int MaxLength) {

+    int i=0;

+    while (s[i]) {

+      d[i] = s[i];

+      i++;

+      if (i == MaxLength) break;

+    } // while

+    d[i] = 0; // Null terminate.

+    return d;

+  } // safeStringCopy

+};

+

+// === Do not use directly: use one of the predefined sizes below ===

+

+template<int MAXLENGTH> // MAXLENGTH is max printable characters (trailing NULL is accounted for in ScriptStringVarBase::s[1]).

+struct ScriptStringVar : ScriptStringVarBase {

+  SQChar ps[MAXLENGTH];

+  ScriptStringVar() : ScriptStringVarBase(MAXLENGTH) {

+    s[0] = 0;

+  }

+  ScriptStringVar(const SQChar * _s) : ScriptStringVarBase(MAXLENGTH) {

+    *this = _s;

+  }

+  const SQChar * operator = (const SQChar * _s) {

+    return safeStringCopy(s,_s,MaxLength);

+  }

+  const SQChar * operator = (const ScriptStringVar & _s) {

+    return safeStringCopy(s,_s.s,MaxLength);

+  }

+  bool operator == (const ScriptStringVar & _s) {

+    return _strcmp(s,_s.s) == 0;

+  }

+  bool compareCaseInsensitive(const ScriptStringVar & _s) {

+    return _stricmp(s,_s.s) == 0;

+  }

+};

+

+// === Fixed size strings for scripting ===

+

+typedef ScriptStringVar<8>   ScriptStringVar8;

+typedef ScriptStringVar<16>  ScriptStringVar16;

+typedef ScriptStringVar<32>  ScriptStringVar32;

+typedef ScriptStringVar<64>  ScriptStringVar64;

+typedef ScriptStringVar<128> ScriptStringVar128;

+typedef ScriptStringVar<256> ScriptStringVar256;

+

+// === Script Variable Types ===

+

+enum ScriptVarType {

+    VAR_TYPE_NONE = -1,

+    VAR_TYPE_INT = 0,

+    VAR_TYPE_UINT,

+    VAR_TYPE_FLOAT,

+    VAR_TYPE_BOOL,

+    VAR_TYPE_CONST_STRING,

+    VAR_TYPE_STRING,

+    VAR_TYPE_USER_POINTER,

+    VAR_TYPE_INSTANCE,

+#ifdef SQPLUS_SUPPORT_STD_STRING

+    VAR_TYPE_STD_STRING,

+#endif

+};

+

+template <typename T>

+struct TypeInfo {

+  const SQChar * typeName;

+  enum {TypeID=VAR_TYPE_NONE, Size=0, TypeMask='?', IsInstance=0};

+};

+

+// === Common Variable Types ===

+

+template<>

+struct TypeInfo<INT> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("int")) {}

+  enum {TypeID=VAR_TYPE_INT,Size=sizeof(INT),TypeMask='i', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<>

+struct TypeInfo<unsigned> {

+	const SQChar * typeName;

+	TypeInfo() : typeName(_SC("uint")) {}

+	enum {TypeID=VAR_TYPE_UINT,Size=sizeof(unsigned), IsInstance=0};

+	operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<>

+struct TypeInfo<FLOAT> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("float")) {}

+  enum {TypeID=VAR_TYPE_FLOAT,Size=sizeof(FLOAT),TypeMask='f', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<>

+struct TypeInfo<bool> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("bool")) {}

+  enum {TypeID=VAR_TYPE_BOOL,Size=sizeof(bool),TypeMask='b', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<>

+struct TypeInfo<short> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("short")) {}

+  enum {TypeID=VAR_TYPE_INT,Size=sizeof(short),TypeMask='i', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<>

+struct TypeInfo<char> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("char")) {}

+  enum {TypeID=VAR_TYPE_INT,Size=sizeof(char),TypeMask='i', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<>

+struct TypeInfo<SQUserPointer> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("SQUserPointer")) {}

+  enum {TypeID=VAR_TYPE_USER_POINTER,Size=sizeof(SQUserPointer),TypeMask='u', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<>

+struct TypeInfo<SQAnything> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("SQUserPointer")) {}

+  enum {TypeID=VAR_TYPE_USER_POINTER,Size=sizeof(SQUserPointer),TypeMask='u', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<>

+struct TypeInfo<SQNoBaseClass> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(0) {}

+  enum {TypeID=-1,Size=0,TypeMask=' ', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<>

+struct TypeInfo<const SQChar *> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("const SQChar *")) {}

+  enum {TypeID=VAR_TYPE_CONST_STRING,Size=sizeof(const SQChar *),TypeMask='s', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+#ifdef SQPLUS_AUTOCONVERT_OTHER_CHAR 

+template<>

+struct TypeInfo<const SQOtherChar *> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("const SQOtherChar *")) {}

+  enum {TypeID=VAR_TYPE_CONST_STRING,Size=sizeof(const SQOtherChar *),TypeMask='s', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+template<>

+struct Temporary<SQOtherChar*> {

+	typedef SQOthCharBuf type;

+};

+template<>

+struct Temporary<const SQOtherChar*> {

+	typedef SQOthCharBuf type;

+};

+#endif // SQPLUS_AUTOCONVERT_OTHER_CHAR

+

+// base case: raw pointer 

+template<typename T, int is_inst>

+struct TypeInfoPtrBase {

+  const SQChar * typeName;

+  TypeInfoPtrBase() : typeName(TypeInfo<T>().typeName) {}

+  enum {TypeID=VAR_TYPE_USER_POINTER,Size=sizeof(T*),TypeMask='u'};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+template<typename T>

+struct TypeInfoPtrBase<T,1> : public TypeInfo<T> { };

+

+// Partial specialization for pointers (to access type without pointer / or instance typeinfo)

+template<class T>

+struct TypeInfo<T*> : public TypeInfoPtrBase<T,TypeInfo<T>::IsInstance> { };

+

+// Same thing for references

+template<class T>

+struct TypeInfo<T&> : public TypeInfoPtrBase<T,TypeInfo<T>::IsInstance> { };

+

+#ifdef SQPLUS_SUPPORT_STD_STRING

+template<>

+struct TypeInfo<std::string> {

+    const SQChar *typeName;

+    TypeInfo() : typeName(_SC("std::string")) {}

+    enum {TypeID=SqPlus::VAR_TYPE_STD_STRING,Size=sizeof(std::string),TypeMask='s'};

+    operator ScriptVarType() {return ScriptVarType(TypeID);}

+};

+#endif 

+

+template<>

+struct TypeInfo<ScriptStringVarBase> {

+  const SQChar * typeName;

+  TypeInfo() : typeName(_SC("ScriptStringVarBase")) {}

+  enum {TypeID=VAR_TYPE_STRING,Size=sizeof(ScriptStringVarBase),TypeMask='s', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+// === Fixed String Variants ===

+

+template<int N>

+struct TypeInfo<ScriptStringVar<N> > {

+  SQChar typeName[24];

+  TypeInfo() { scsprintf(typeName,_SC("ScriptStringVar<%d>"),N); }

+  enum {TypeID=VAR_TYPE_STRING,Size=N*sizeof(ScriptStringVar<N>),TypeMask='s', IsInstance=0};

+  operator ScriptVarType() { return ScriptVarType(TypeID); }

+};

+

+#ifdef SQPLUS_SMARTPOINTER_OPT

+  #define SQPLUS_SMARTPOINTER_ACCESSTYPE

+  #include "SqPlusSmartPointer.h"

+#else

+  enum VarAccessType {VAR_ACCESS_READ_WRITE=0,VAR_ACCESS_READ_ONLY=1<<0,VAR_ACCESS_CONSTANT=1<<1,VAR_ACCESS_STATIC=1<<2};

+#endif // SQPLUS_SMARTPOINTER_OPT

+

+// See VarRef and ClassType<> below: for instance assignment.

+typedef void (*CopyVarFunc)(void * dst,void * src);

+

+

+// === Class Type Helper class: returns an ID for each class type and provides base class pointer offset ===

+

+struct ClassTypeBase {

+    ClassTypeBase() : m_pbase(0), m_name(0), m_offset(0), m_may_have_offset(-1) { }

+    // Many types cannot have offset, since "this" is the same for all base classes of 

+    // an instance. Detect this, to avoid sum up base offsets all the time.

+    int MayHaveOffset( ) {

+        if( m_may_have_offset<0 ){

+            if( m_offset ) m_may_have_offset = 1;

+            else m_may_have_offset = m_pbase ? m_pbase->MayHaveOffset() : 0;

+        }

+        return m_may_have_offset;

+    }

+    int GetOffsetTo( ClassTypeBase *pbase ){

+        if( !m_pbase ) { /*printf("ClassTypeBase::getOffsetTo - Warning - Base type pointer is NULL!\n" );*/ return 0; }

+        return m_pbase==pbase ? m_offset : m_offset+m_pbase->GetOffsetTo(pbase);

+    }

+    virtual CopyVarFunc vgetCopyFunc(void) = 0;

+    virtual const SQChar* GetTypeName() = 0;

+    

+    ClassTypeBase *m_pbase;

+    const SQChar *m_name;  // Name of type

+    int m_offset;          // Adjustment of this pointer between this type and its base class

+    int m_may_have_offset; // Set to 0 for types that cannot possibly have offset

+};

+

+// This level handles instance copying in different ways

+template<typename T,bool copyable> 

+struct ClassTypeCopyImpl;

+

+// Helper struct to decide if type is copyable or not 

+template<typename T>

+struct IsCopyable { enum { value=true }; }; 

+

+#define DECLARE_NONCOPY_TYPE_INTERN(TYPE) \

+  template<> struct IsCopyable<TYPE> { enum { value=false }; };

+  

+// Macro to declare a type that should _not_ be copied using ordinary

+// c++ copy expresssion: *(T*)pt1 = *(T*)pt2; 

+#define DECLARE_NONCOPY_TYPE(TYPE) namespace SqPlus { \

+  template<> struct IsCopyable<TYPE> { enum { value=false }; }; \

+}

+  

+// Base class to do copying in ordinary C++ way

+template<typename T>

+struct ClassTypeCopyImpl<T,true> : public ClassTypeBase {

+  static void copy(T * dst,T * src) {

+    *dst = *src;                // This works types with copy ctor / assign operator

+  } // copy

+};

+

+// Base class to do copying with memcpy

+template<typename T>

+struct ClassTypeCopyImpl<T,false> : public ClassTypeBase {

+  static void copy(T * dst,T * src) {

+    memcpy(dst,src,sizeof(T));   // This works for raw data types

+  } // copy

+};

+

+// Base classes to do avoid copying altogether (void case)

+template<>

+struct ClassTypeCopyImpl<void,true> : public ClassTypeBase {

+  static void copy(void * dst,void * src) { } // copy

+};

+

+template<>

+struct ClassTypeCopyImpl<void,false> : public ClassTypeBase {

+  static void copy(void * dst,void * src) { } // copy

+};

+

+

+template<typename T>

+struct ClassType : public ClassTypeCopyImpl<T,IsCopyable<T>::value> { 

+  typedef ClassTypeCopyImpl<T,IsCopyable<T>::value> ClassTypeBase;

+  ClassType( ) { this->m_name=stGetName(); } 

+  

+  virtual CopyVarFunc vgetCopyFunc(void) { return (CopyVarFunc)&ClassTypeBase::copy; }

+  virtual const SQChar* GetTypeName(){ return this->m_name; }

+  

+  template<class BC>

+  void SetBase(TypeWrapper<BC>) { 

+    this->m_pbase = ClassType<BC>::Get(); 

+    T* pt = reinterpret_cast<T*>(this); 

+    this->m_offset = ((char*)pt)-((char*)static_cast<BC*>(pt)); 

+  }

+  static ClassType* Get(){ static ClassType<T> st_ct; return &st_ct; }

+  static ClassTypeBase* type() { return Get(); }

+  static CopyVarFunc getCopyFunc(void) { return (CopyVarFunc)&ClassTypeBase::copy; }

+  static const SQChar* stGetName(){ return TypeInfo<T>().typeName; }  

+  

+  #ifdef SQPLUS_OVERLOAD_OPT

+  #define SQPLUS_OVERLOAD_RELEASE_HOOK

+  #include "SqPlusOverload.h"

+  #endif

+};

+

+

+// === Variable references for script access ===

+

+#define SQ_PLUS_TYPE_TABLE _SC("__SqTypes")

+

+struct VarRef {

+  // In this case 'offsetOrAddrOrConst' is simpler than using an anonymous union.

+  void * offsetOrAddrOrConst;  // Instance member variable offset from 'this' pointer base (as size_t), or address if static variable (void *), or constant value.

+  ScriptVarType m_type;        // Variable type (from enum above).

+  ClassTypeBase* instanceType; // Class type of the containing class instance (for member vars only). 

+  ClassTypeBase* varType;      // The class type of the variable itself

+  short m_size;                // ATS: Use for short and char support. For debugging only (size of item when pointer to item is dereferenced). Could be used for variable max string buffer length.

+  short m_access;              // VarAccessType.

+

+  VarRef() : offsetOrAddrOrConst(0), m_type(VAR_TYPE_NONE), instanceType(0/*(SQUserPointer)-1*/), /*copyFunc(0),*/ m_size(0), m_access(VAR_ACCESS_READ_WRITE) {}

+  VarRef(void * _offsetOrAddrOrConst, ScriptVarType _type, ClassTypeBase* _instanceType, ClassTypeBase* _varType, int _size, VarAccessType _access) :

+         offsetOrAddrOrConst(_offsetOrAddrOrConst), m_type(_type), instanceType(_instanceType), varType(_varType), m_size(_size), m_access(_access) {

+#ifdef SQ_SUPPORT_INSTANCE_TYPE_INFO

+    SquirrelObject typeTable = SquirrelVM::GetRootTable().GetValue(SQ_PLUS_TYPE_TABLE);

+    if (typeTable.IsNull()) {

+      typeTable = SquirrelVM::CreateTable();

+      SquirrelObject root = SquirrelVM::GetRootTable();

+      root.SetValue(SQ_PLUS_TYPE_TABLE,typeTable);

+    } // if

+	typeTable.SetValue(INT((size_t)varType),varType->GetTypeName());

+#endif // SQ_SUPPORT_INSTANCE_TYPE_INFO

+  }

+};

+

+typedef VarRef * VarRefPtr;

+

+// Internal use only.

+inline void getVarNameTag(SQChar * buff,INT maxSize,const SQChar * scriptName) {

+//  assert(maxSize > 3);

+#if 1

+  SQChar * d = buff;

+  d[0] = '_';

+  d[1] = 'v';

+  d = &d[2];

+  maxSize -= (2+1); // +1 = space for null.

+  int pos=0;

+  while (scriptName[pos] && pos < maxSize) {

+    d[pos] = scriptName[pos];

+    pos++;

+  } // while

+  d[pos] = 0; // null terminate.

+#else

+  SCSNPRINTF(buff,maxSize,_SC("_v%s"),scriptName);

+#endif

+} // getVarNameTag

+

+// Internal use only.

+int setVarFunc(HSQUIRRELVM v);

+int getVarFunc(HSQUIRRELVM v);

+int setInstanceVarFunc(HSQUIRRELVM v);

+int getInstanceVarFunc(HSQUIRRELVM v);

+

+// === BEGIN Helpers ===

+

+inline void createTableSetGetHandlers(SquirrelObject & so) {

+  SquirrelObject delegate = so.GetDelegate();

+  if (!delegate.Exists(_SC("_set"))) {

+    delegate = SquirrelVM::CreateTable();

+    SquirrelVM::CreateFunction(delegate,setVarFunc,_SC("_set"),_SC("sn|b|s")); // String var name = number(int or float) or bool or string.

+    SquirrelVM::CreateFunction(delegate,getVarFunc,_SC("_get"),_SC("s"));      // String var name.

+    so.SetDelegate(delegate);

+  } // if

+} // createTableSetGetHandlers

+

+inline VarRefPtr createVarRef(SquirrelObject & so,const SQChar * scriptVarName) {

+  VarRefPtr pvr=0;

+  ScriptStringVar256 scriptVarTagName; getVarNameTag(scriptVarTagName,sizeof(scriptVarTagName),scriptVarName);

+  if (!so.GetUserData(scriptVarTagName,(SQUserPointer *)&pvr)) {

+    so.NewUserData(scriptVarTagName,sizeof(*pvr));

+    if (!so.GetUserData(scriptVarTagName,(SQUserPointer *)&pvr)) throw SquirrelError(_SC("Could not create UserData."));

+  } // if

+  return pvr;

+} // createVarRef

+

+template<typename T>

+void validateConstantType(T constant) {

+  switch(TypeInfo<T>()) {

+  case VAR_TYPE_INT:

+  case VAR_TYPE_FLOAT:

+  case VAR_TYPE_BOOL:

+  case VAR_TYPE_CONST_STRING:

+    break;

+  default:

+    throw SquirrelError(_SC("validateConstantType(): type must be INT, FLOAT, BOOL, or CONST CHAR *."));

+  } // case

+} // validateConstantType

+

+inline void createInstanceSetGetHandlers(SquirrelObject & so) {

+  if (!so.Exists(_SC("_set"))) {

+    SquirrelVM::CreateFunction(so,setInstanceVarFunc,_SC("_set"),_SC("sn|b|s|x")); // String var name = number(int or float) or bool or string or instance.

+    SquirrelVM::CreateFunction(so,getInstanceVarFunc,_SC("_get"),_SC("s"));      // String var name.

+  } // if

+} // createInstanceSetGetHandlers

+

+// === END Helpers ===

+

+

+// Provide an overridable way of copying / deleting objects 

+template<typename T>

+struct ObjectCloner {

+  static T* Clone(T* src){ return new T(src); }

+  static void Delete(T* dst){ if(dst) delete dst; }

+};

+

+// specialization for void type

+//template<> inline void ClassType<void>::copy(void *dst, void *src) {}

+DECLARE_NONCOPY_TYPE_INTERN(void)

+

+

+// === Bind a global or pre-allocated (not instance) class member variable or constant (for tables only (not classes)) ===

+

+template<typename T>

+void BindVariable(SquirrelObject & so,T * var,const SQChar * scriptVarName,VarAccessType access=VAR_ACCESS_READ_WRITE) {

+  VarRefPtr pvr = createVarRef(so,scriptVarName);

+  *pvr = VarRef(var,TypeInfo<T>(),NULL,ClassType<T>::type(),sizeof(*var),access);

+  createTableSetGetHandlers(so);

+} // BindVariable

+

+// === Bind a constant by value: INT, FLOAT, BOOL, or CONST CHAR * (for tables only (not classes)) ===

+

+template<typename T>

+void BindConstant(SquirrelObject & so,T constant,const SQChar * scriptVarName) {

+  validateConstantType(constant);

+  VarRefPtr pvr = createVarRef(so,scriptVarName);

+  struct CV {

+    T var;

+  } cv; // Cast Variable helper.

+  cv.var = constant;

+  *pvr = VarRef(*(void **)&cv,TypeInfo<T>(),NULL,ClassType<T>::type(),sizeof(constant),VAR_ACCESS_CONSTANT);

+  createTableSetGetHandlers(so);

+} // BindConstant

+

+template<typename T>

+void BindVariable(T * var,const SQChar * scriptVarName,VarAccessType access=VAR_ACCESS_READ_WRITE) {

+  SquirrelObject so = SquirrelVM::GetRootTable();

+  BindVariable(so,var,scriptVarName,access);

+} // BindVariable

+

+template<typename T>

+void BindConstant(T constant,const SQChar * scriptVarName) {

+  SquirrelObject so = SquirrelVM::GetRootTable();

+  BindConstant(so,constant,scriptVarName);

+} // BindConstant

+

+// === Register a class instance member variable or constant. var argument provides type and offset ( effectively &((ClassType *)0)->var ) ===

+

+// classType is the type of the member variable's containing class.

+ template<typename T>

+void RegisterInstanceVariable(SquirrelObject & so,ClassTypeBase* classType,T * var,const SQChar * scriptVarName,VarAccessType access=VAR_ACCESS_READ_WRITE) {

+  VarRef * pvr = createVarRef(so,scriptVarName);

+  void * offsetOrAddrOrConst = (void *)var; // var must be passed in as &obj->var, where obj = 0 (the address is the offset), or as static/global address.

+  *pvr = VarRef(offsetOrAddrOrConst,TypeInfo<T>(),classType,ClassType<T>::type(),sizeof(*var),access);

+  createInstanceSetGetHandlers(so);

+} // RegisterInstanceVariable

+

+#ifdef SQPLUS_SMARTPOINTER_OPT

+#define SQPLUS_SMARTPOINTER_REGISTER_VARIABLE

+#include "SqPlusSmartPointer.h"

+#endif

+

+template<typename T>

+void RegisterInstanceConstant(SquirrelObject & so,ClassTypeBase *classType,T constant,const SQChar * scriptVarName) {

+  validateConstantType(constant);

+  VarRef * pvr = createVarRef(so,scriptVarName);

+  struct CV {

+    T var;

+    size_t pad;

+  } cv; // Cast Variable helper.

+  cv.var = constant;

+  *pvr = VarRef(*(void **)&cv,TypeInfo<T>(),classType,ClassType<T>::type(),sizeof(constant),VAR_ACCESS_CONSTANT);

+  createInstanceSetGetHandlers(so);

+} // RegisterInstanceConstant

+

+//////////////////////////////////////////////////////////////////////////

+/////////// BEGIN Generalized Class/Struct Instance Support //////////////

+//////////////////////////////////////////////////////////////////////////

+

+// Was previously in SqPlus namespace

+//BOOL CreateNativeClassInstance(HSQUIRRELVM v,const SQChar * classname,SQUserPointer ud,SQRELEASEHOOK hook); // In SquirrelBindingUtils.cpp.

+

+// Create native class instance and leave on stack.

+//BOOL CreateConstructNativeClassInstance(HSQUIRRELVM v,const SQChar * className);

+

+// Create new instance, copy 'classToCopy', and store result on stack.

+template<typename T>

+inline BOOL CreateCopyInstance(HSQUIRRELVM v, const SQChar * className,const T & classToCopy) {

+#ifndef SQPLUS_DISABLE_COPY_INSTANCES

+  if (!CreateConstructNativeClassInstance(v,className)) {

+    return FALSE;

+  } // if

+  SQUserPointer up=0;

+  sq_getinstanceup(v,-1,&up,ClassType<T>::type());

+  if (!up) return FALSE;

+  T * newClass = (T *)up;

+  *newClass = classToCopy; // <TODO> Optimized version that uses the copy constructor.

+  return TRUE;

+#else

+  return FALSE;

+#endif  

+} // CreateCopyInstance

+

+// Create a new copy of type 'className' and copy 'classToCopy', return result via SquirrelObject.

+template<typename T>

+inline SquirrelObject NewClassCopy(HSQUIRRELVM v, const SQChar * className,const T & classToCopy) {

+  if (CreateCopyInstance(v, className,classToCopy)) {

+	  HSQOBJECT t;

+	  sq_getstackobj(v,-1,&t);

+	  SquirrelObject obj(t);

+	  sq_poptop(v);

+	  return obj;

+  } else {

+    throw SquirrelError(_SC("NewClassCopy(): could not create class"));

+  } // if

+  return SquirrelObject();

+} // NewClassCopy

+

+// Return a new class copy on the stack from a varArgs function call.

+template<typename T>

+inline int ReturnCopy(HSQUIRRELVM v,const T & classToCopy) {

+  SquirrelObject so(NewClassCopy(v,GetTypeName(classToCopy),classToCopy));

+  return StackHandler(v).Return(so);

+} // ReturnCopy

+

+// Katsuaki Kawachi's GetInstance<> exception change. 6/27/06 jcs

+

+// Get an instance of type T from the stack at idx (for function calls).

+template<typename T,bool ExceptionOnError>

+T * GetInstance(HSQUIRRELVM v,SQInteger idx) {

+  SQUserPointer up=0;

+  if (SQ_FAILED(sq_getinstanceup(v,idx,&up,ClassType<T>::type()))) {

+    up = 0;

+  }

+  if (ExceptionOnError) { // This code block should be compiled out when ExceptionOnError is false. In any case, the compiler should not generate a test condition (include or exclude the enclosed code block).

+    if (!up) {

+      throw SquirrelError(_SC("GetInstance: Invalid argument type"));

+    }

+  } // if

+  return (T *)up;

+} // GetInstance

+

+

+template<typename T> void Push(HSQUIRRELVM v, T* pt);

+template<typename T> void Push(HSQUIRRELVM v, T& t);

+template<typename T> bool Match(TypeWrapper<T&>, HSQUIRRELVM v, int ix);

+template<typename T> bool Match(TypeWrapper<T*>, HSQUIRRELVM v, int ix);

+template<typename T> T &Get(TypeWrapper<T&>, HSQUIRRELVM v, int ix);

+template<typename T> T *Get(TypeWrapper<T*>, HSQUIRRELVM v, int ix);

+

+

+#ifdef SQPLUS_USE_GENERIC_HANDLERS

+// With template specialization, we get Push handlers per 'precise type match'

+// This adds a fallback level after that, where we can delegate the work to 

+// wider C-style functions that can do something for a whole class hierarchy.

+// (GenPush, GenGet, GenMatch).

+

+// This macro allows for a a last generic cast operation before giving control 

+// to one of GenPush/GenMatch/GenGet.

+#ifndef SQPLUS_GEN_CAST 

+    #define SQPLUS_GEN_CAST(TYPE,value) ((TYPE*)value)

+#endif 

+

+template<typename T> void Push(HSQUIRRELVM v, T* pt){ GenPush(v,SQPLUS_GEN_CAST(T,pt)); }

+template<typename T> void Push(HSQUIRRELVM v, T& t){ GenPush(v,SQPLUS_GEN_CAST(T,&t)); }

+template<typename T> bool Match(TypeWrapper<T&>, HSQUIRRELVM v, int ix){ 

+    if((ScriptVarType)TypeInfo<T>::TypeID!=VAR_TYPE_NONE) 

+        return GenMatch(SQPLUS_GEN_CAST(T*,0),TypeInfo<T>().typeName,v,ix); 

+    else return false; 

+}

+template<typename T> bool Match(TypeWrapper<T*>, HSQUIRRELVM v, int ix){ 

+    if((ScriptVarType)TypeInfo<T>::TypeID!=VAR_TYPE_NONE) 

+        return GenMatch(SQPLUS_GEN_CAST(T*,0),TypeInfo<T>().typeName,v,ix); 

+    else return false;

+}

+template<typename T> T &Get(TypeWrapper<T&>, HSQUIRRELVM v, int ix){ 

+    if((ScriptVarType)TypeInfo<T>::TypeID!=VAR_TYPE_NONE)  

+        return *(T*)GenGet(SQPLUS_GEN_CAST(T*,0),TypeInfo<T>().typeName,v,ix); 

+    else return *SQPLUS_GEN_CAST(T,0); 

+}

+template<typename T> T *Get(TypeWrapper<T*>, HSQUIRRELVM v, int ix){ 

+    if((ScriptVarType)TypeInfo<T>::TypeID!=VAR_TYPE_NONE)  

+        return (T*)GenGet(SQPLUS_GEN_CAST(T*,0),TypeInfo<T>().typeName,v,ix); 

+    else return NULL; 

+}

+#endif // SQPLUS_USE_GENERIC_HANDLERS

+

+

+// === BEGIN Function Call Handler Prototypes ===

+ 

+void Push(HSQUIRRELVM v, char value);

+void Push(HSQUIRRELVM v, unsigned char value);

+void Push(HSQUIRRELVM v, short value);

+void Push(HSQUIRRELVM v, unsigned short value);

+void Push(HSQUIRRELVM v, int value);

+void Push(HSQUIRRELVM v, unsigned int value);

+void Push(HSQUIRRELVM v, long value);

+void Push(HSQUIRRELVM v, unsigned long value);

+void Push(HSQUIRRELVM v, double value);

+void Push(HSQUIRRELVM v, float value);

+void Push(HSQUIRRELVM v, const SQChar *value);

+void Push(HSQUIRRELVM v, SQChar *value);

+void Push(HSQUIRRELVM v, const SquirrelNull &);

+void Push(HSQUIRRELVM v, SQFUNCTION value);

+void Push(HSQUIRRELVM v, SQAnythingPtr value); // Cast to SQAnythingPtr instead of void * if USE_ARGUMENT_DEPENDANT_OVERLOADS can't be used by your compiler.

+void Push(HSQUIRRELVM v, SquirrelObject &so);

+

+#define USE_ARGUMENT_DEPENDANT_OVERLOADS

+#ifdef USE_ARGUMENT_DEPENDANT_OVERLOADS

+#ifdef _MSC_VER

+#pragma warning(disable:4675) // Disable warning: "resolved overload was found by argument-dependent lookup" when class/struct pointers are used as function arguments.

+#endif

+// === BEGIN Argument Dependent Overloads ===

+void Push(HSQUIRRELVM v, bool value); // Pass bool as int if USE_ARGUMENT_DEPENDANT_OVERLOADS can't be used by your compiler.

+void Push(HSQUIRRELVM v, const void *value); // Pass SQAnythingPtr instead of void * "                                             "

+void Push(HSQUIRRELVM v, const SQUserPointer &value);

+// === END Argument Dependent Overloads ===

+#endif

+

+#define SQPLUS_CHECK_GET(res) if (!SQ_SUCCEEDED(res)) throw SquirrelError(_SC("sq_get*() failed (type error)"))

+

+bool Match(TypeWrapper<bool>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<char>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<unsigned char>, HSQUIRRELVM v,  int idx);

+bool Match(TypeWrapper<short>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<unsigned short>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<int>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<unsigned int>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<long>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<unsigned long>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<float>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<double>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<const SQChar *>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<SQChar *>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<HSQUIRRELVM>, HSQUIRRELVM v, int idx); // See Get() for HSQUIRRELVM below (v is always present).

+bool Match(TypeWrapper<void*>, HSQUIRRELVM v, int idx);

+bool Match(TypeWrapper<SquirrelObject>, HSQUIRRELVM v, int idx); // See sq_getstackobj(): always returns true.

+

+void Get(TypeWrapper<void>, HSQUIRRELVM v, int);

+bool Get(TypeWrapper<bool>, HSQUIRRELVM v, int idx);

+char Get(TypeWrapper<char>, HSQUIRRELVM v, int idx);

+unsigned char Get(TypeWrapper<unsigned char>, HSQUIRRELVM v, int idx);

+short Get(TypeWrapper<short>, HSQUIRRELVM v, int idx);

+unsigned short Get(TypeWrapper<unsigned short>, HSQUIRRELVM v, int idx);

+int Get(TypeWrapper<int>, HSQUIRRELVM v, int idx);

+unsigned int Get(TypeWrapper<unsigned int>, HSQUIRRELVM v, int idx);

+long Get(TypeWrapper<long>, HSQUIRRELVM v, int idx);

+unsigned long Get(TypeWrapper<unsigned long>, HSQUIRRELVM v, int idx);

+float Get(TypeWrapper<float>, HSQUIRRELVM v, int idx);

+double Get(TypeWrapper<double>, HSQUIRRELVM v, int idx);

+const SQChar *Get(TypeWrapper<const SQChar *>, HSQUIRRELVM v, int idx);

+SquirrelNull Get(TypeWrapper<SquirrelNull>, HSQUIRRELVM v, int idx);

+void *Get(TypeWrapper<void *>, HSQUIRRELVM v, int idx);

+HSQUIRRELVM Get(TypeWrapper<HSQUIRRELVM>, HSQUIRRELVM v, int /*idx*/); // sq_poptop(v): remove UserData from stack so GetParamCount() matches normal behavior.

+SquirrelObject Get(TypeWrapper<SquirrelObject>, HSQUIRRELVM v, int idx);

+

+#ifdef SQPLUS_AUTOCONVERT_OTHER_CHAR

+  void Push(HSQUIRRELVM v, const SQOtherChar *value);

+  void Push(HSQUIRRELVM v, SQOtherChar *value);

+  bool Match(TypeWrapper<const SQOtherChar *>, HSQUIRRELVM v, int idx);

+  bool Match(TypeWrapper<SQOtherChar *>, HSQUIRRELVM v, int idx);

+  SQOthCharBuf Get(TypeWrapper<const SQOtherChar *>, HSQUIRRELVM v, int idx);

+#endif // SQPLUS_AUTOCONVERT_OTHER_CHAR

+

+#ifdef SQPLUS_SUPPORT_STD_STRING

+void Push(HSQUIRRELVM v, const std::string& value);

+bool Match(TypeWrapper<const std::string&>, HSQUIRRELVM v, int idx);

+std::string Get(TypeWrapper<const std::string&>, HSQUIRRELVM v, int idx); 

+#endif

+

+// Added jflanglois suggestion, 8/20/06. jcs

+#ifdef SQPLUS_SUPPORT_SQ_STD_STRING

+typedef std::basic_string<SQChar> sq_std_string;

+void Push(HSQUIRRELVM v,const sq_std_string & value);

+bool Match(TypeWrapper<const sq_std_string &>, HSQUIRRELVM v, int idx);

+sq_std_string Get(TypeWrapper<const sq_std_string &>, HSQUIRRELVM v, int idx); 

+#endif

+

+// Specialization to support void return type.

+void GetRet(TypeWrapper<void>, HSQUIRRELVM v,int idx);

+

+// GetRet() restores the stack for SquirrelFunction<>() calls.

+// Hold on to a reference since return value might be temporary string/instance

+template<typename RT>

+inline RT GetRet(TypeWrapper<RT>,HSQUIRRELVM v,int idx) { 

+	static SquirrelObject st_sq_ret; 

+	static typename Temporary<RT>::type st_ret; 

+	st_ret = Get(TypeWrapper<RT>(),v,idx); 

+	st_sq_ret.AttachToStackObject(idx); 

+	sq_pop(v,2); // restore stack after function call.

+	return st_ret; } 

+

+#ifndef GCC_INLINE_WORKAROUND

+# include "SqPlusFunctionCallImpl.h"

+#endif // GCC_INLINE_WORKAROUND 

+ 

+// === END Function Call Handlers ===

+

+

+// Helper, only implement function bodies

+#define IMPLEMENT_ENUM_TYPE(TYPE) namespace SqPlus { \

+  bool Match(TypeWrapper<TYPE>,HSQUIRRELVM v,int idx) { return Match(TypeWrapper<int>(),v,idx); } \

+  TYPE Get(TypeWrapper<TYPE>,HSQUIRRELVM v,int idx) { return (TYPE)Get(TypeWrapper<int>(),v,idx); } \

+  void Push(HSQUIRRELVM v,TYPE value) { sq_pushinteger(v,(int)value); } \

+} // nameSpace SqPlus

+

+// To register simple types (like enums) so they can be used as arguments

+// (however, this does not handle enums as return values correctly, since 

+// we C++ gets problems with references to temporaries)

+#define DECLARE_ENUM_TYPE(TYPE) IMPLEMENT_ENUM_TYPE(TYPE) \

+namespace SqPlus { \

+  template<> struct TypeInfo<TYPE> : public TypeInfo<int> { }; \

+} // nameSpace SqPlus 

+

+// As above but use when function bodies should not be generated

+// (for a header file).

+#define PROTOS_ENUM_TYPE(TYPE) namespace SqPlus { \

+  bool Match(TypeWrapper<TYPE>,HSQUIRRELVM v,int idx); \

+  TYPE Get(TypeWrapper<TYPE>,HSQUIRRELVM v,int idx); \

+  void Push(HSQUIRRELVM v,TYPE value); \

+  template<> struct TypeInfo<TYPE> : public TypeInfo<int> { }; \

+} // nameSpace SqPlus

+

+

+// NAME and macro changes from Ben's (Project5) forum post. 2/26/06 jcs

+// Kamaitati's NULL_INSTANCE support. 5/28/06 jcs

+

+// ATS: Splitting the macros in different parts to support custom Push implementation (covariant return type)

+

+#define DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \

+  inline const SQChar * GetTypeName(const TYPE & n) { return _SC(#NAME); } \

+  template<> \

+  struct TypeInfo<TYPE> { \

+    const SQChar * typeName; \

+    TypeInfo() : typeName( _SC(#NAME)) {} \

+    enum {TypeID=VAR_TYPE_INSTANCE,Size=sizeof(TYPE),TypeMask='x', IsInstance=1}; \

+    operator ScriptVarType() { return ScriptVarType(TypeID); } \

+  }; 

+

+#define DECLARE_INSTANCE_TYPEINFO(TYPE) namespace SqPlus { \

+  DECLARE_INSTANCE_TYPEINFO_(TYPE,TYPE) \

+} // namespace SqPlus 

+

+#define DECLARE_INSTANCE_TYPEINFO_NAME(TYPE,NAME) namespace SqPlus { \

+  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \

+} // namespace SqPlus 

+

+

+#ifdef SQPLUS_SUPPORT_NULL_INSTANCES

+

+// Macro part shared by 'derived' macros

+#define DECLARE_INSTANCE_TYPE_BASE_(TYPE,NAME) \

+  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \

+  template<> inline bool Match(TypeWrapper<TYPE &>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,false>(v,idx) != NULL; } \

+  template<> inline bool Match(TypeWrapper<TYPE *>,HSQUIRRELVM v,int idx) { \

+    return (sq_gettype(v,idx)==OT_NULL) || (GetInstance<TYPE,false>(v,idx) != NULL); } \

+  template<> inline TYPE & Get(TypeWrapper<TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE,true>(v,idx); } \

+  template<> inline TYPE * Get(TypeWrapper<TYPE *>,HSQUIRRELVM v,int idx) { \

+    if (sq_gettype(v,idx)==OT_NULL) return NULL; \

+    return GetInstance<TYPE,true>(v,idx); }

+

+// Ordinary case

+#define DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) namespace SqPlus { \

+  DECLARE_INSTANCE_TYPE_BASE_(TYPE,NAME) \

+  template<> inline void Push(HSQUIRRELVM v,TYPE * value) { \

+    if (!value)  sq_pushnull(v); \

+    else if (!CreateNativeClassInstance(v,GetTypeName(*value),value,0)) \

+      throw SquirrelError( _SC( "Push(): could not create INSTANCE (check registration name)")); } \

+  template<> inline void Push(HSQUIRRELVM v,TYPE & value) { if (!CreateCopyInstance(v,GetTypeName(value),value)) throw SquirrelError( _SC( "Push(): could not create INSTANCE copy (check registration name)")); } \

+} // nameSpace SqPlus

+

+// Allows for providing custom Push handlers (protos here, impl must be provided by app)

+#define DECLARE_INSTANCE_TYPE_NAME_CUSTOM_(TYPE,NAME) namespace SqPlus { \

+  DECLARE_INSTANCE_TYPE_BASE_(TYPE,NAME) \

+  template<> void Push(HSQUIRRELVM v,TYPE * value); \

+  template<> void Push(HSQUIRRELVM v,TYPE & value); \

+} // nameSpace SqPlus

+

+

+#else

+

+#define DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) namespace SqPlus { \

+  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \

+  template<> inline void Push(HSQUIRRELVM v,TYPE * value)                 { if (!CreateNativeClassInstance(v,GetTypeName(*value),value,0)) throw SquirrelError( _SC( "Push(): could not create INSTANCE (check registration name)")); } \

+  template<> inline void Push(HSQUIRRELVM v,TYPE & value)                 { if (!CreateCopyInstance(v,GetTypeName(value),value)) throw SquirrelError( _SC( "Push(): could not create INSTANCE copy (check registration name)")); } \

+  template<> inline bool	Match(TypeWrapper<TYPE &>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,false>(v,idx) != NULL; } \

+  template<> inline bool	Match(TypeWrapper<TYPE *>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,false>(v,idx) != NULL; } \

+  template<> inline TYPE & Get(TypeWrapper<TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE,true>(v,idx); } \

+  template<> inline TYPE * Get(TypeWrapper<TYPE *>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE,true>(v,idx); } \

+} // nameSpace SqPlus

+

+#endif

+

+// TYPE or NAME below must match the string name used in SQClassDef<>, otherwise name lookup won't match and Squirrel will throw a "can't create instance" error.

+#ifndef SQPLUS_CONST_OPT

+#define DECLARE_INSTANCE_TYPE(TYPE) DECLARE_INSTANCE_TYPE_NAME_(TYPE,TYPE)

+#define DECLARE_INSTANCE_TYPE_NAME(TYPE,NAME) DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME)

+#define DECLARE_INSTANCE_TYPE_CUSTOM(TYPE) DECLARE_INSTANCE_TYPE_NAME_CUSTOM_(TYPE,TYPE)

+#define DECLARE_INSTANCE_TYPE_NAME_CUSTOM(TYPE,NAME) DECLARE_INSTANCE_TYPE_NAME_CUSTOM_(TYPE,NAME)

+#else

+#define SQPLUS_DECLARE_INSTANCE_TYPE_CONST

+#include "SqPlusConst.h"

+#endif

+

+#ifdef SQPLUS_OVERLOAD_OPT

+#define SQPLUS_OVERLOAD_DECLARATION

+#include "SqPlusOverload.h"

+#endif

+

+// Versions of above for types that aren't copy constructable

+#define DECLARE_INSTANCE_TYPEINFO_NOCOPY(TYPE) \

+  DECLARE_INSTANCE_TYPEINFO(TYPE) \

+  DECLARE_NONCOPY_TYPE(TYPE)

+

+#define DECLARE_INSTANCE_TYPEINFO_NOCOPY_NAME(TYPE,NAME) namespace SqPlus { \

+  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \

+  DECLARE_NONCOPY_TYPE(TYPE)

+

+#define DECLARE_INSTANCE_TYPE_NOCOPY(TYPE) \

+  DECLARE_INSTANCE_TYPE(TYPE) \

+  DECLARE_NONCOPY_TYPE(TYPE)

+

+#define DECLARE_INSTANCE_TYPE_NOCOPY_NAME(TYPE,NAME) namespace SqPlus { \

+  DECLARE_INSTANCE_TYPEINFO_(TYPE,NAME) \

+  DECLARE_NONCOPY_TYPE(TYPE)

+

+

+//////////////////////////////////////////////////////////////////////////

+//////////// END Generalized Class/Struct Instance Support ///////////////

+//////////////////////////////////////////////////////////////////////////

+

+#ifndef SQ_SKIP_ARG_ASSERT

+  #define sq_argassert(arg,_index_) if (!Match(TypeWrapper<P##arg>(),v,_index_)) return sq_throwerror(v,_SC("Incorrect function argument"))

+#else

+  #define sq_argassert(arg,_index_)

+#endif

+

+// === Return value variants ===

+

+template<class RT>

+struct ReturnSpecialization {

+

+  // === Standard Function calls ===

+

+  static int Call(RT (*func)(),HSQUIRRELVM v,int /*index*/) {

+    RT ret = func();

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename P1>

+  static int Call(RT (*func)(P1),HSQUIRRELVM v,int index) {

+    sq_argassert(1,index + 0);

+    RT ret = func(

+      Get(TypeWrapper<P1>(),v,index + 0)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename P1,typename P2>

+  static int Call(RT (*func)(P1,P2),HSQUIRRELVM v,int index) {

+    sq_argassert(1,index + 0);

+    sq_argassert(2,index + 1);

+    RT ret = func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename P1,typename P2,typename P3>

+  static int Call(RT (*func)(P1,P2,P3),HSQUIRRELVM v,int index) {

+    sq_argassert(1,index + 0);

+    sq_argassert(2,index + 1);

+    sq_argassert(3,index + 2);

+    RT ret = func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4>

+  static int Call(RT (*func)(P1,P2,P3,P4),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 = func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4,typename P5>

+  static int Call(RT (*func)(P1,P2,P3,P4,P5),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 = func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>

+  static int Call(RT (*func)(P1,P2,P3,P4,P5,P6),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 = func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4),

+      Get(TypeWrapper<P6>(),v,index + 5)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>

+  static int Call(RT (*func)(P1,P2,P3,P4,P5,P6,P7),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 = func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4),

+      Get(TypeWrapper<P6>(),v,index + 5),

+      Get(TypeWrapper<P7>(),v,index + 6)

+    );

+    Push(v,ret);

+    return 1;

+  }

+

+  // === Member Function calls ===

+

+

+#define SQPLUS_CALL_MFUNC_RET0

+#include "SqPlusCallTemplates.h"

+

+#ifdef SQPLUS_CONST_OPT

+#define SQPLUS_CALL_MFUNC_RET0

+#include "SqPlusConst.h"

+#endif

+};

+

+// === No return value variants ===

+

+template<>

+struct ReturnSpecialization<void> {

+

+  // === Standard function calls ===

+

+  static int Call(void (*func)(),HSQUIRRELVM v,int /*index*/) {

+		(void)v;

+		func();

+		return 0;

+	}

+

+	template<typename P1>

+	static int Call(void (*func)(P1),HSQUIRRELVM v,int index) {

+    sq_argassert(1,index + 0);

+		func(

+			Get(TypeWrapper<P1>(),v,index + 0)

+		);

+		return 0;

+	}

+

+	template<typename P1,typename P2>

+	static int Call(void (*func)(P1,P2),HSQUIRRELVM v,int index) {

+    sq_argassert(1,index + 0);

+    sq_argassert(2,index + 1);

+		func(

+			Get(TypeWrapper<P1>(),v,index + 0),

+			Get(TypeWrapper<P2>(),v,index + 1)

+		);

+		return 0;

+	}

+

+  template<typename P1,typename P2,typename P3>

+  static int Call(void (*func)(P1,P2,P3),HSQUIRRELVM v,int index) {

+    sq_argassert(1,index + 0);

+    sq_argassert(2,index + 1);

+    sq_argassert(3,index + 2);

+    func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2)

+    );

+    return 0;

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4>

+  static int Call(void (*func)(P1,P2,P3,P4),HSQUIRRELVM v,int index) {

+    sq_argassert(1,index + 0);

+    sq_argassert(2,index + 1);

+    sq_argassert(3,index + 2);

+    sq_argassert(4,index + 3);

+    func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3)

+    );

+    return 0;

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4,typename P5>

+  static int Call(void (*func)(P1,P2,P3,P4,P5),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);

+    func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4)

+    );

+    return 0;

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>

+  static int Call(void (*func)(P1,P2,P3,P4,P5,P6),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);

+    func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4),

+      Get(TypeWrapper<P6>(),v,index + 5)

+    );

+    return 0;

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>

+  static int Call(void (*func)(P1,P2,P3,P4,P5,P6,P7),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);

+    func(

+      Get(TypeWrapper<P1>(),v,index + 0),

+      Get(TypeWrapper<P2>(),v,index + 1),

+      Get(TypeWrapper<P3>(),v,index + 2),

+      Get(TypeWrapper<P4>(),v,index + 3),

+      Get(TypeWrapper<P5>(),v,index + 4),

+      Get(TypeWrapper<P6>(),v,index + 5),

+      Get(TypeWrapper<P7>(),v,index + 6)

+    );

+    return 0;

+  }

+

+  // === Member function calls ===

+

+

+#define SQPLUS_CALL_MFUNC_NORET

+#include "SqPlusCallTemplates.h"

+

+#ifdef SQPLUS_CONST_OPT

+#define SQPLUS_CALL_MFUNC_NORET

+#include "SqPlusConst.h"

+#endif

+

+};

+

+// === STANDARD Function return value specialized call handlers ===

+

+template<typename RT>

+int Call(RT (*func)(),HSQUIRRELVM v,int index) {

+  return ReturnSpecialization<RT>::Call(func,v,index);

+}

+

+template<typename RT,typename P1>

+int Call(RT (*func)(P1),HSQUIRRELVM v,int index) {

+  return ReturnSpecialization<RT>::Call(func,v,index);

+}

+

+template<typename RT,typename P1,typename P2>

+int Call(RT (*func)(P1,P2),HSQUIRRELVM v,int index) {

+  return ReturnSpecialization<RT>::Call(func,v,index);

+}

+

+template<typename RT,typename P1,typename P2,typename P3>

+int Call(RT (*func)(P1,P2,P3),HSQUIRRELVM v,int index) {

+  return ReturnSpecialization<RT>::Call(func,v,index);

+}

+

+template<typename RT,typename P1,typename P2,typename P3,typename P4>

+int Call(RT (*func)(P1,P2,P3,P4),HSQUIRRELVM v,int index) {

+  return ReturnSpecialization<RT>::Call(func,v,index);

+}

+

+template<typename RT,typename P1,typename P2,typename P3,typename P4,typename P5>

+int Call(RT (*func)(P1,P2,P3,P4,P5),HSQUIRRELVM v,int index) {

+  return ReturnSpecialization<RT>::Call(func,v,index);

+}

+

+template<typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>

+int Call(RT (*func)(P1,P2,P3,P4,P5,P6),HSQUIRRELVM v,int index) {

+  return ReturnSpecialization<RT>::Call(func,v,index);

+}

+

+template<typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>

+int Call(RT (*func)(P1,P2,P3,P4,P5,P6,P7),HSQUIRRELVM v,int index) {

+  return ReturnSpecialization<RT>::Call(func,v,index);

+}

+

+// === MEMBER Function return value specialized call handlers ===

+

+

+#define SQPLUS_CALL_MFUNC_RET1

+#include "SqPlusCallTemplates.h"

+

+#ifdef SQPLUS_CONST_OPT

+#define SQPLUS_CALL_MFUNC_RET1

+#include "SqPlusConst.h"

+#endif

+

+// === Direct Call Standard Function handler ===

+

+template<typename Func>

+struct DirectCallFunction {

+  static inline int Dispatch(HSQUIRRELVM v) {

+#ifdef SQPLUS_USE_SANDBOX_VM

+    if( v==SquirrelVM::GetSandboxVMPtr() ){

+        return sq_throwerror(v, _SC("SqPlus: Cannot exec function from sandbox VM"));

+    }

+#endif   

+    StackHandler sa(v);

+    int paramCount = sa.GetParamCount();

+    Func * func = (Func *)sa.GetUserData(paramCount);

+    return Call(*func,v,2);

+  } // Dispatch

+};

+

+// === Direct Call Member Function handler ===

+

+template<typename Callee,typename Func>

+class DirectCallMemberFunction {

+public:

+  static inline int Dispatch(HSQUIRRELVM v) {

+#ifdef SQPLUS_USE_SANDBOX_VM

+    if( v==SquirrelVM::GetSandboxVMPtr() ){

+        return sq_throwerror(v, _SC("SqPlus: Cannot exec function from sandbox VM"));

+    }

+#endif   

+    StackHandler sa(v);

+    int paramCount = sa.GetParamCount();

+    unsigned char * ud = (unsigned char *)sa.GetUserData(paramCount);

+    return Call(**(Callee**)ud,*(Func*)(ud + sizeof(Callee*)),v,2);

+  } // Dispatch

+};

+

+// === Direct Call Function handlers ===

+

+#define SQ_CLASS_OBJECT_TABLE_NAME _SC("__ot")

+#define SQ_CLASS_HIER_ARRAY _SC("__ca")

+

+template<typename Callee, typename Func>

+struct DirectCallInstanceFuncPicker {

+  Callee *instance;

+  Func *func;

+  DirectCallInstanceFuncPicker(HSQUIRRELVM v) {

+#ifdef SQPLUS_USE_SANDBOX_VM

+    if( v==SquirrelVM::GetSandboxVMPtr() ){

+        instance = NULL;

+        func = NULL;

+        return;

+    }

+#endif   

+    StackHandler sa(v);

+    instance = static_cast<Callee*>(sa.GetInstanceUp(1, 0));

+    const int paramCount = sa.GetParamCount();

+    func = static_cast<Func*>(sa.GetUserData(paramCount));

+#ifdef SQ_USE_CLASS_INHERITANCE

+    SquirrelObject so(sa.GetObjectHandle(1)); // 'this'

+    SQUserPointer typetag; so.GetTypeTag(&typetag);

+    SQUserPointer calleeType = ClassType<Callee>::type();

+    if (typetag != calleeType) {

+      SquirrelObject typeTable = so.GetValue(SQ_CLASS_OBJECT_TABLE_NAME);

+      instance = static_cast<Callee*>(

+          // <TODO> 64-bit compatible version.

+          typeTable.GetUserPointer(INT((size_t)ClassType<Callee>::type()))

+        );

+    }

+#elif defined(SQ_USE_CLASS_INHERITANCE_SIMPLE)

+    SquirrelObject so(sa.GetObjectHandle(1)); // 'this'

+    ClassTypeBase *instType; so.GetTypeTag((SQUserPointer*)&instType);

+    ClassTypeBase *calleeType = ClassType<Callee>::type();

+    if (instType!=calleeType && instType->MayHaveOffset() ) {

+        // instance type is nore derived than callee, adjust pointer

+        int offset = instType->GetOffsetTo(calleeType);

+        instance = (Callee*)((char*)instance-offset);

+    }

+#endif 

+  }

+};

+

+// === Direct Call Instance Member Function handler ===

+template<typename Callee,typename Func>

+class DirectCallInstanceMemberFunction {

+public:

+  static inline int Dispatch(HSQUIRRELVM v) {

+    DirectCallInstanceFuncPicker<Callee, Func> p(v);

+    return p.instance && p.func ?

+      Call(*(p.instance), *(p.func), v, 2) :

+      sq_throwerror(v, _SC("Invalid Instance Type"));

+  }

+};

+

+// === Direct Call Instance Global Function handler ===

+template<typename Callee,typename Func>

+class DirectCallInstanceGlobalFunction {

+public:

+  static inline int Dispatch(HSQUIRRELVM v) {

+    DirectCallInstanceFuncPicker<Callee, Func> p(v);

+    return p.func ?

+      Call(*(p.func), v, 1) :

+      sq_throwerror(v, _SC("Invalid Instance Type"));

+  }

+};

+

+// === Direct Call Instance Global Function Var Args handler ===

+template<typename Callee,typename Func>

+class DirectCallInstanceGlobalFunctionVarArgs {

+public:

+  static inline int Dispatch(HSQUIRRELVM v) {

+    DirectCallInstanceFuncPicker<Callee, Func> p(v);

+    return p.func && p.instance ?

+      (*p.func)(p.instance,v) :

+      sq_throwerror(v, _SC("Invalid Instance Type"));

+  }

+};

+

+// === Direct Call Instance Member Function Variable Argument handler ===

+template<typename Callee,typename Func>

+class DirectCallInstanceMemberFunctionVarArgs {

+public:

+  static inline int Dispatch(HSQUIRRELVM v) {

+    DirectCallInstanceFuncPicker<Callee, Func> p(v);

+    sq_poptop(v); // Remove UserData from stack: so sa.GetParamCount() returns actual param count.

+    return p.func && p.instance ?

+      (p.instance->*(*p.func))(v) :

+      sq_throwerror(v, _SC("Invalid Instance Type"));

+  }

+};

+

+#ifdef SQPLUS_SMARTPOINTER_OPT

+#define SQPLUS_SMARTPOINTER_DISPATCH

+#include "SqPlusSmartPointer.h"

+#endif

+

+

+// Code fragment useful for debugging new implementations.

+#if 0

+HSQOBJECT ho = sa.GetObjectHandle(paramCount);

+SquirrelObject so(ho);

+SQObjectType sot = so.GetType();

+#endif

+

+#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK

+    #include "SqPlusTypeMask.h"

+#endif

+

+// === Standard function call ===

+

+template<typename Func>

+inline void sq_pushdirectclosure(HSQUIRRELVM v,Func func,SQUnsignedInteger nupvalues) {

+  SQUserPointer up = sq_newuserdata(v,sizeof(func)); // Also pushed on stack.

+  memcpy(up,&func,sizeof(func));

+  sq_newclosure(v,DirectCallFunction<Func>::Dispatch,nupvalues+1);

+#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK

+  sq_setparamscheck(v,0,sqTypeMask<Func>::Get());

+#endif

+} // sq_pushdirectclosure

+

+// === Fixed Class pointer call (always calls with object pointer that was registered) ===

+

+template<typename Callee,typename Func>

+inline void sq_pushdirectclosure(HSQUIRRELVM v,const Callee & callee,Func func,SQUnsignedInteger nupvalues) {

+  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(Callee*)+sizeof(func));  // Also pushed on stack.

+  const SQUserPointer pCallee = (SQUserPointer)&callee;

+  memcpy(up,&pCallee,sizeof(Callee*));

+  memcpy(up + sizeof(Callee*),&func,sizeof(func));

+  sq_newclosure(v,DirectCallMemberFunction<Callee,Func>::Dispatch,nupvalues+1);

+#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK

+  sq_setparamscheck(v,0,sqTypeMask<Func>::Get());

+#endif

+} // sq_pushdirectclosure

+

+#ifdef SQPLUS_SMARTPOINTER_OPT

+#define SQPLUS_SMARTPOINTER_DIRECT_CLOSURE

+#include "SqPlusSmartPointer.h"

+#endif

+

+// === Class Instance call: class pointer retrieved from script class instance ===

+

+template<typename Callee,typename Func>

+inline void sq_pushdirectinstanceclosure(HSQUIRRELVM v,const Callee & callee,Func func,SQUnsignedInteger nupvalues) {

+  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func));  // Also pushed on stack.

+  memcpy(up,&func,sizeof(func));

+  sq_newclosure(v,DirectCallInstanceMemberFunction<Callee,Func>::Dispatch,nupvalues+1);

+#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK

+  sq_setparamscheck(v,0,sqTypeMask<Func>::Get());

+#endif

+} // sq_pushdirectinstanceclosure

+

+// === Global function using this: class pointer retrieved from script class instance ===

+

+template<typename Callee,typename Func>

+inline void sq_pushdirectinstanceclosureglobal(HSQUIRRELVM v,const Callee & callee,Func func,SQUnsignedInteger nupvalues) {

+  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func));  // Also pushed on stack.

+  memcpy(up,&func,sizeof(func));

+  // Could check that 1st arg of Func is a Callee

+  sq_newclosure(v,DirectCallInstanceGlobalFunction<Callee,Func>::Dispatch,nupvalues+1);

+#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK

+  SQChar *tm = (SQChar*)sqTypeMask<Func>::Get();   

+  if( tm ) {

+    // Censor out the 1st arg, since SqPlus adds that automatically

+    tm[1] = _SC('x'); //tm[0];

+    tm++;

+  }

+  sq_setparamscheck(v,0,tm?tm:_SC(""));  

+#endif

+} // sq_pushdirectinstanceclosureglobal

+

+// === Global function using this: class pointer retrieved from script class instance ===

+

+template<typename Callee,typename Func>

+inline void sq_pushdirectinstanceclosureglobalvarargs(HSQUIRRELVM v,const Callee & callee,Func func,SQUnsignedInteger nupvalues) {

+  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func));  // Also pushed on stack.

+  memcpy(up,&func,sizeof(func));

+  // Could check that 1st arg of Func is a Callee

+  sq_newclosure(v,DirectCallInstanceGlobalFunctionVarArgs<Callee,Func>::Dispatch,nupvalues+1);

+#ifdef SQPLUS_ENABLE_AUTO_TYPEMASK

+  sq_setparamscheck(v,-1,_SC("x"));  

+#endif

+} // sq_pushdirectinstanceclosureglobal

+

+// === Class Instance call: class pointer retrieved from script class instance (variable arguments) ===

+

+template<typename Callee>

+inline void sq_pushdirectinstanceclosurevarargs(HSQUIRRELVM v,const Callee & callee,int (Callee::*func)(HSQUIRRELVM),SQUnsignedInteger nupvalues) {

+  unsigned char * up = (unsigned char *)sq_newuserdata(v,sizeof(func)); // Also pushed on stack.

+  memcpy(up,&func,sizeof(func));

+  typedef int (Callee::*FuncType)(HSQUIRRELVM);

+  sq_newclosure(v,DirectCallInstanceMemberFunctionVarArgs<Callee, FuncType>::Dispatch,nupvalues+1);

+} // sq_pushdirectinstanceclosurevarargs

+

+// === Register a STANDARD function (table or class on stack) ===

+

+template<typename Func>

+inline void Register(HSQUIRRELVM v,Func func,const SQChar * name) {

+  sq_pushstring(v,name,-1);

+  sq_pushdirectclosure(v,func,0);

+  sq_createslot(v,-3); // Stack is restored after this call (same state as before Register() call).

+} // Register

+

+// === Register a MEMBER function (table or class on stack) ===

+

+template<typename Callee,typename Func>

+inline void Register(HSQUIRRELVM v,Callee & callee,Func func,const SQChar * name) {

+  sq_pushstring(v,name,-1);

+  sq_pushdirectclosure(v,callee,func,0);

+  sq_createslot(v,-3); // Stack is restored after this call (same state as before Register() call).

+} // Register

+

+// === Register a STANDARD global function (root table) ===

+

+template<typename Func>

+inline void RegisterGlobal(HSQUIRRELVM v,Func func,const SQChar * name) {

+  sq_pushroottable(v);

+  Register(v,func,name);

+  sq_poptop(v); // Remove root table.

+} // RegisterGlobal

+

+template<typename Func>

+inline void RegisterGlobal(Func func,const SQChar * name) {

+  RegisterGlobal(SquirrelVM::GetVMPtr(),func,name);

+} // RegisterGlobal

+

+// === Register a MEMBER global function (root table) ===

+

+template<typename Callee,typename Func>

+inline void RegisterGlobal(HSQUIRRELVM v,Callee & callee,Func func,const SQChar * name) {

+  sq_pushroottable(v);

+  Register(v,callee,func,name);

+  sq_poptop(v); // Remove root table.

+} // RegisterGlobal

+

+template<typename Callee,typename Func>

+inline void RegisterGlobal(Callee & callee,Func func,const SQChar * name) {

+  RegisterGlobal(SquirrelVM::GetVMPtr(),callee,func,name);

+} // RegisterGlobal

+

+// === Register a STANDARD function (hso is table or class) ===

+

+template<typename Func>

+inline void Register(HSQUIRRELVM v,HSQOBJECT hso,Func func,const SQChar * name) {

+  sq_pushobject(v,hso);

+  Register(v,func,name);

+  sq_poptop(v); // Remove hso.

+} // Register

+

+// === Register a MEMBER function (hso is table or class) ===

+// === Fixed Class pointer call (always calls with object pointer that was registered) ===

+

+template<typename Callee,typename Func>

+inline void Register(HSQUIRRELVM v,HSQOBJECT hso,Callee & callee,Func func,const SQChar * name) {

+  sq_pushobject(v,hso);

+  Register(v,callee,func,name);

+  sq_poptop(v); // Remove hso.

+} // Register

+

+// === Register an INSTANCE MEMBER function ===

+// === Class Instance call: class pointer retrieved from script class instance ===

+

+template<typename Callee,typename Func>

+inline void RegisterInstance(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,Func func,const SQChar * name) {

+  sq_pushobject(v,hclass);

+  sq_pushstring(v,name,-1);

+  sq_pushdirectinstanceclosure(v,callee,func,0);

+  sq_createslot(v,-3);

+  sq_poptop(v); // Remove hclass.

+} // RegisterInstance

+

+

+// === Register an INSTANCE GLOBAL MEMBER function ===

+// === Class Instance call: class pointer retrieved from script class instance ===

+// Allows embedding global func that takes Callee as 1st arg as a member func

+template<typename Callee,typename Func>

+inline void RegisterInstanceGlobalFunc(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,Func func,const SQChar * name) {

+  sq_pushobject(v,hclass);

+  sq_pushstring(v,name,-1);

+  sq_pushdirectinstanceclosureglobal(v,callee,func,0);

+  sq_createslot(v,-3);

+  sq_poptop(v); // Remove hclass.

+} // RegisterInstanceGlobaFunc

+

+// === Register an INSTANCE GLOBAL MEMBER WITH VAR ARGS function ===

+// === Class Instance call: class pointer retrieved from script class instance ===

+// Allows embedding global func that takes Callee as 1st arg as a member func

+template<typename Callee,typename Func>

+inline void RegisterInstanceGlobalFuncVarArgs(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,Func func,const SQChar * name) {

+  sq_pushobject(v,hclass);

+  sq_pushstring(v,name,-1);

+  sq_pushdirectinstanceclosureglobalvarargs(v,callee,func,0);

+  sq_createslot(v,-3);

+  sq_poptop(v); // Remove hclass.

+} // RegisterInstanceGlobaFunc

+

+#ifdef SQPLUS_SMARTPOINTER_OPT

+#define SQPLUS_SMARTPOINTER_REGISTER_INSTANCE

+#include "SqPlusSmartPointer.h"

+#endif

+

+#ifdef _MSC_VER

+#pragma warning(disable : 4995) // Deprecated _snprintf

+#endif

+

+// === Register an INSTANCE MEMBER function Variable Arguments ===

+// typeMask: "*" means don't check parameters, typeMask=0 means function takes no arguments (and is type checked for that case).

+// All the other Squirrel type-masks are passed normally.

+

+template<typename Callee>

+inline void RegisterInstanceVarArgs(HSQUIRRELVM v,HSQOBJECT hclass,Callee & callee,int (Callee::*func)(HSQUIRRELVM),const SQChar * name,const SQChar * typeMask=_SC("*")) {

+  sq_pushobject(v,hclass);

+  sq_pushstring(v,name,-1);

+  sq_pushdirectinstanceclosurevarargs(v,callee,func,0);

+  SQChar tm[64];

+  SQChar * ptm = tm;

+  int numParams = SQ_MATCHTYPEMASKSTRING;

+  if (typeMask) {

+    if (typeMask[0] == '*') {

+      ptm       = 0; // Variable args: don't check parameters.

+//      numParams = 0; // Clear SQ_MATCHTYPEMASKSTRING (does not mean match 0 params. See sq_setparamscheck()).

+    } else {

+      if (SCSNPRINTF(tm,sizeof(tm),_SC("x%s"),typeMask) < 0) { // Must be an instance.

+        throw SquirrelError(_SC("RegisterInstanceVarArgs: typeMask string too long."));

+      } // if

+    } // if

+  } else { // <TODO> Need to check object type on stack: table, class, instance, etc.

+//    _snprintf(tm,sizeof(tm),"x"); // instance.

+    tm[0] = 'x';

+    tm[1] = 0;

+  } // if

+  if (ptm) { // If ptm == 0, don't check type.

+    sq_setparamscheck(v,numParams,ptm); // Determine arg count from type string.

+  } // if

+#ifdef _DEBUG

+  sq_setnativeclosurename(v,-1,name); // For debugging only.

+#endif

+  sq_createslot(v,-3);

+  sq_poptop(v); // Remove hclass.

+} // RegisterInstanceVarArgs

+

+#ifdef _MSC_VER

+#pragma warning(default : 4995)

+#endif

+

+// === Call Squirrel Functions from C/C++ ===

+// No type checking is performed for Squirrel functions as Squirrel types are dynamic:

+// Incoming types are passed unchanged to Squirrel functions. The parameter count is checked: an exception is thrown if mismatched.

+// Return values must match the RT template argument type, else an exception can be thrown on return.

+

+template<typename RT>

+struct SquirrelFunction {

+  HSQUIRRELVM v;

+  SquirrelObject object; // Table or class.

+  SquirrelObject func;

+  SquirrelFunction() : v(0) {}

+  SquirrelFunction(HSQUIRRELVM _v,const SquirrelObject & _object,const SquirrelObject & _func) : v(_v), object(_object), func(_func) {}

+  SquirrelFunction(const SquirrelObject & _object,const SquirrelObject & _func) : v(SquirrelVM::GetVMPtr()), object(_object), func(_func) {}

+  SquirrelFunction(const SquirrelObject & _object,const SQChar * name) {

+    v      = SquirrelVM::GetVMPtr();

+    object = _object;

+    func   = object.GetValue(name);

+  }

+  SquirrelFunction(const SQChar * name) {

+    v      = SquirrelVM::GetVMPtr();

+    object = SquirrelVM::GetRootTable();

+    func   = object.GetValue(name);

+  }

+

+  // Release references and reset internal objects to null.

+  void reset(void) {

+    func.Reset();

+    object.Reset();

+  } // Reset

+

+#define SQPLUS_CHECK_FNCALL(res) if (!SQ_SUCCEEDED(res)) throw SquirrelError(_SC("SquirrelFunction<> call failed"))

+

+  RT operator()(void) {

+    sq_pushobject(v,func.GetObjectHandle());

+    sq_pushobject(v,object.GetObjectHandle());

+    SQPLUS_CHECK_FNCALL(sq_call(v,1,SQTrue,SQ_CALL_RAISE_ERROR));

+    return GetRet(TypeWrapper<RT>(),v,-1);

+  }

+

+  template<typename P1>

+  RT operator()(P1 p1) {

+    sq_pushobject(v,func.GetObjectHandle());

+    sq_pushobject(v,object.GetObjectHandle());

+    Push(v,p1);

+    SQPLUS_CHECK_FNCALL(sq_call(v,2,SQTrue,SQ_CALL_RAISE_ERROR));

+    return GetRet(TypeWrapper<RT>(),v,-1);

+  }

+

+  template<typename P1,typename P2>

+  RT operator()(P1 p1,P2 p2) {

+    sq_pushobject(v,func.GetObjectHandle());

+    sq_pushobject(v,object.GetObjectHandle());

+    Push(v,p1);

+    Push(v,p2);

+    SQPLUS_CHECK_FNCALL(sq_call(v,3,SQTrue,SQ_CALL_RAISE_ERROR));

+    return GetRet(TypeWrapper<RT>(),v,-1);

+  }

+

+  template<typename P1,typename P2,typename P3>

+  RT operator()(P1 p1,P2 p2,P3 p3) {

+    sq_pushobject(v,func.GetObjectHandle());

+    sq_pushobject(v,object.GetObjectHandle());

+    Push(v,p1);

+    Push(v,p2);

+    Push(v,p3);

+    SQPLUS_CHECK_FNCALL(sq_call(v,4,SQTrue,SQ_CALL_RAISE_ERROR));

+    return GetRet(TypeWrapper<RT>(),v,-1);

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4>

+  RT operator()(P1 p1,P2 p2,P3 p3,P4 p4) {

+    sq_pushobject(v,func.GetObjectHandle());

+    sq_pushobject(v,object.GetObjectHandle());

+    Push(v,p1);

+    Push(v,p2);

+    Push(v,p3);

+    Push(v,p4);

+    SQPLUS_CHECK_FNCALL(sq_call(v,5,SQTrue,SQ_CALL_RAISE_ERROR));

+    return GetRet(TypeWrapper<RT>(),v,-1);

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4,typename P5>

+  RT operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5) {

+    sq_pushobject(v,func.GetObjectHandle());

+    sq_pushobject(v,object.GetObjectHandle());

+    Push(v,p1);

+    Push(v,p2);

+    Push(v,p3);

+    Push(v,p4);

+    Push(v,p5);

+    SQPLUS_CHECK_FNCALL(sq_call(v,6,SQTrue,SQ_CALL_RAISE_ERROR));

+    return GetRet(TypeWrapper<RT>(),v,-1);

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>

+  RT operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6) {

+    sq_pushobject(v,func.GetObjectHandle());

+    sq_pushobject(v,object.GetObjectHandle());

+    Push(v,p1);

+    Push(v,p2);

+    Push(v,p3);

+    Push(v,p4);

+    Push(v,p5);

+    Push(v,p6);

+    SQPLUS_CHECK_FNCALL(sq_call(v,7,SQTrue,SQ_CALL_RAISE_ERROR));

+    return GetRet(TypeWrapper<RT>(),v,-1);

+  }

+

+  template<typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>

+  RT operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7) {

+    sq_pushobject(v,func.GetObjectHandle());

+    sq_pushobject(v,object.GetObjectHandle());

+    Push(v,p1);

+    Push(v,p2);

+    Push(v,p3);

+    Push(v,p4);

+    Push(v,p5);

+    Push(v,p6);

+    Push(v,p7);

+    SQPLUS_CHECK_FNCALL(sq_call(v,8,SQTrue,SQ_CALL_RAISE_ERROR));

+    return GetRet(TypeWrapper<RT>(),v,-1);

+  }

+

+};

+

+// === Class/Struct registration ===

+

+#define SQ_DELETE_CLASS(CLASSTYPE) if (up) { CLASSTYPE * self = (CLASSTYPE *)up; delete self;} return 0

+#define SQ_DECLARE_RELEASE(CLASSTYPE) \

+  static int release(SQUserPointer up,SQInteger size) { \

+    SQ_DELETE_CLASS(CLASSTYPE); \

+  }

+

+template<typename T>

+struct ReleaseClassPtrPtr {

+  static int release(SQUserPointer up,SQInteger size) {

+    if (up) {

+      T ** self = (T **)up;

+      delete *self;

+    } // if

+    return 0;

+  } // release

+};

+

+template<typename T>

+struct ReleaseClassPtr {

+  static int release(SQUserPointer up,SQInteger size) {

+    if (up) {

+      T * self = (T *)up;

+      delete self;

+    } // if

+    return 0;

+  } // release

+};

+

+BOOL CreateClass(HSQUIRRELVM v,SquirrelObject & newClass,SQUserPointer classType,const SQChar * name,const SQChar * baseName=0);

+

+

+template<typename T>

+inline void PopulateAncestry(HSQUIRRELVM v,

+                             SquirrelObject &instance,

+                             T *newClass)

+{

+  // 11/2/05: Create a new table for this instance.

+  SquirrelObject newObjectTable = SquirrelVM::CreateTable();

+  // <TODO> 64-bit compatible version.

+  newObjectTable.SetUserPointer(INT((size_t)ClassType<T>::type()), newClass);

+  instance.SetValue(SQ_CLASS_OBJECT_TABLE_NAME, newObjectTable);

+

+  SquirrelObject classHierArray = instance.GetValue(SQ_CLASS_HIER_ARRAY);

+  INT count = classHierArray.Len();

+

+  // This will be true when more than one C/C++ class is in the hierarchy.

+  if (count > 1) {

+    --count; // Skip the most-derived class.

+    for (INT i = 0; i < count; i++) {

+      // Kamaitati's changes for C++ inheritance support. jcs 5/28/06

+      SquirrelObject so = classHierArray.GetValue(i);

+      sq_pushobject(v,so.GetObjectHandle());

+      SQUserPointer typeTag;

+      sq_gettypetag(v,-1,&typeTag);

+      newObjectTable.SetUserPointer(INT(size_t(typeTag)),newClass);

+      sq_poptop(v);

+    }

+  }

+}

+

+

+// Call PostConstruct() at the end of custom constructors.

+template<typename T>

+inline int PostConstruct(HSQUIRRELVM v, T *newClass, SQRELEASEHOOK hook)

+{

+#ifdef SQ_USE_CLASS_INHERITANCE

+  StackHandler sa(v);

+  HSQOBJECT ho = sa.GetObjectHandle(1); // OT_INSTANCE

+  SquirrelObject instance(ho);

+  PopulateAncestry(v, instance, newClass);

+#endif // SQ_USE_CLASS_INHERITANCE

+

+  sq_setinstanceup(v, 1, newClass);

+  sq_setreleasehook(v, 1, hook);

+  return TRUE;

+} // PostConstruct

+

+inline int PostConstructSimple(HSQUIRRELVM v, void *newClass, SQRELEASEHOOK hook){

+  sq_setinstanceup(v, 1, newClass);

+  sq_setreleasehook(v, 1, hook);

+  return TRUE;

+} // PostConstructSimple

+

+

+template<typename T>

+struct ConstructReleaseClass {

+  static int construct(HSQUIRRELVM v) {

+    return PostConstruct<T>(v,new T(),release);

+  } // construct

+  SQ_DECLARE_RELEASE(T)

+};

+

+# ifdef SQPLUS_ENABLE_TYPEOF

+template<typename T>

+int sq_typeof(HSQUIRRELVM v) {

+    sq_pushstring(v,TypeInfo<T>().typeName,-1);

+    return 1;

+}

+# endif

+

+// === Helper for RegisterClassType*() ===

+inline void setupClassHierarchy(SquirrelObject newClass) {

+  // <NOTE> New member vars cannot be added to instances (OT_INSTANCE): additions must occur on the defining class (OT_CLASS), before any instances are instantiated.

+  if (!newClass.Exists(SQ_CLASS_OBJECT_TABLE_NAME)) { // Will always get table from most-derived registered class.

+    SquirrelObject objectTable = SquirrelVM::CreateTable();

+    newClass.SetValue(SQ_CLASS_OBJECT_TABLE_NAME,objectTable); // Constructors must add their 'this' pointer indexed by type to this table. See PostConstruct() above.

+    // 11/2/05: This table will behave as a static global for each instance unless overwritten during construction (see PostConstruct() above).

+  } // if

+  SquirrelObject classHierArray;

+  if (!newClass.Exists(SQ_CLASS_HIER_ARRAY)) {   // Will always get table from most-derived registered class.

+    classHierArray = SquirrelVM::CreateArray(0); // The only constructor called will be the most-derived class: this array contains all classes in the hierarchy to be constructed.

+    newClass.SetValue(SQ_CLASS_HIER_ARRAY,classHierArray);

+  } else {

+    classHierArray = newClass.GetValue(SQ_CLASS_HIER_ARRAY);

+  } // if

+  classHierArray.ArrayAppend(newClass);          // Add the class to the hierarchy array. The array values will be released and replaced with UserData to free created ancestor classes.

+} // setupClassHierarchy

+

+

+template<typename T>

+inline SquirrelObject RegisterClassType(HSQUIRRELVM v,const SQChar * scriptClassName,const SQChar * baseScriptClassName=0) {

+  int top = sq_gettop(v);

+  SquirrelObject newClass;

+  if (CreateClass(v,newClass,(SQUserPointer)ClassType<T>::type(),scriptClassName,baseScriptClassName)) {

+    SquirrelVM::CreateFunction(newClass,&ConstructReleaseClass<T>::construct,_SC("constructor"));

+# ifdef SQ_USE_CLASS_INHERITANCE

+    setupClassHierarchy(newClass);

+# endif

+# ifdef SQPLUS_ENABLE_TYPEOF

+    SquirrelVM::CreateFunction(newClass,&sq_typeof<T>,_SC("_typeof"));

+# endif

+  } // if

+  sq_settop(v,top);

+  return newClass;

+} // RegisterClassType

+

+template<typename T>

+inline SquirrelObject RegisterClassTypeNoConstructor(HSQUIRRELVM v,const SQChar * scriptClassName,const SQChar * baseScriptClassName=0) {

+  int top = sq_gettop(v);

+  SquirrelObject newClass;

+  if (CreateClass(v,newClass,(SQUserPointer)ClassType<T>::type(),scriptClassName,baseScriptClassName)) {

+# ifdef SQ_USE_CLASS_INHERITANCE

+    setupClassHierarchy(newClass);

+# endif

+# ifdef SQPLUS_ENABLE_TYPEOF

+    SquirrelVM::CreateFunction(newClass,&sq_typeof<T>,_SC("_typeof"));

+# endif

+  } // if

+  sq_settop(v,top);

+  return newClass;

+} // RegisterClassTypeNoConstructor

+

+

+// === Define and register a C++ class and its members for use with Squirrel ===

+// Constructors+destructors are automatically created. Custom constructors must use the

+// standard SQFUNCTION signature if variable argument types are required (overloads).

+// See testSqPlus2.cpp for examples.

+

+// <NOTE> Do not use SQClassDefBase<> directly, use SQClassDef<> or SQClassDefNoConstructor<>, below.

+template<typename TClassType, typename TClassBase>

+struct SQClassDefBase {

+  HSQUIRRELVM v;

+  const SQChar * name;

+  SquirrelObject newClass;

+

+#if defined(SQ_USE_CLASS_INHERITANCE) || defined(SQ_USE_CLASS_INHERITANCE_SIMPLE)

+  const SQChar * base;

+  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).

+  SQClassDefBase(HSQUIRRELVM _v,const SQChar * _name=0,const SQChar * _base=0) : v(_v), name(_name), base(_base) {InitBase();}

+  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).

+  SQClassDefBase(const SQChar * _name=0,const SQChar * _base=0) : v(SquirrelVM::GetVMPtr()), name(_name), base(_base) {InitBase(TypeWrapper<TClassBase>());}

+  template<class Base>

+  void InitBase(TypeWrapper<Base>){ /*assert(base);*/ ClassType<TClassType>::Get()->SetBase(TypeWrapper<Base>()); CheckInitDefaultNames(); }

+  void InitBase(TypeWrapper<SQNoBaseClass>){ /*assert(!base);*/ CheckInitDefaultNames(); }

+  void CheckInitDefaultNames(){ if( !name ) name=TypeInfo<TClassType>().typeName; if( !base ) base=TypeInfo<TClassBase>().typeName; }

+#else

+  SQClassDefBase(HSQUIRRELVM _v,const SQChar * _name=0) : v(_v), name(_name) { CheckInitDefaultName(); }

+  SQClassDefBase(const SQChar * _name=0) : v(SquirrelVM::GetVMPtr()), name(_name) { CheckInitDefaultName(); } 

+  void CheckInitDefaultName(){ if( !name ) name=TypeInfo<TClassType>().typeName; }

+#endif

+

+  // Register a member function.

+  template<typename Func>

+  SQClassDefBase & func(Func pfunc,const SQChar * name) {

+    RegisterInstance(v,newClass.GetObjectHandle(),*(TClassType *)0,pfunc,name);

+    return *this;

+  } // func

+

+  // Register a global function as a member function (the global takes a Callee*/& as first arg).

+  template<typename Func>

+  SQClassDefBase & globMembFunc(Func pfunc,const SQChar * name) {

+    RegisterInstanceGlobalFunc(v,newClass.GetObjectHandle(),*(TClassType *)0,pfunc,name);

+    return *this;

+  } // globMemberFunc

+

+  // Register a global function as a member function (the global takes a Callee*/& as first arg and SQVM* as 2nd).

+  template<typename Func>

+  SQClassDefBase & globMembFuncVarArgs(Func pfunc,const SQChar * name) {

+    RegisterInstanceGlobalFuncVarArgs(v,newClass.GetObjectHandle(),*(TClassType *)0,pfunc,name);

+    return *this;

+  } // globMemberFuncVarArgs

+  

+#ifdef SQPLUS_SMARTPOINTER_OPT

+#define SQPLUS_SMARTPOINTER_CLASS_DEF_FUNC

+#include "SqPlusSmartPointer.h"

+#endif

+

+  // Register a variable-argument member function (supports variable+multiple return values).

+  // typeMask: "*" means don't check parameters, typeMask=0 means function takes no arguments (and is type checked for that case).

+  // All the other Squirrel type-masks are passed normally.

+  template<typename Func>

+  SQClassDefBase & funcVarArgs(Func pfunc,const SQChar * name,const SQChar * typeMask=_SC("*")) {

+    RegisterInstanceVarArgs(v,newClass.GetObjectHandle(),*(TClassType *)0,pfunc,name,typeMask);

+    return *this;

+  } // funcVarArgs

+

+  // === BEGIN static-member+global function registration ===

+

+  // === This version is for static member functions only, such as custom constructors where 'this' is not yet valid ===

+  // typeMask: "*" means don't check parameters, typeMask=0 means function takes no arguments (and is type checked for that case).

+  // All the other Squirrel type-masks are passed normally.

+

+  template<typename Func>

+  SQClassDefBase & staticFuncVarArgs(Func pfunc,const SQChar * name,const SQChar * typeMask=_SC("*")) {

+    SquirrelVM::PushObject(newClass);

+    SquirrelVM::CreateFunction(pfunc,name,typeMask);

+    SquirrelVM::Pop(1);

+    return *this;

+  } // staticFuncVarArgs

+

+  // Register a standard global function (effectively embedding a global function in TClassType's script namespace: does not need or use a 'this' pointer).

+  template<typename Func>

+  SQClassDefBase & staticFunc(Func pfunc,const SQChar * name) {

+    Register(v,newClass.GetObjectHandle(),pfunc,name);

+    return *this;

+  } // staticFunc

+

+  // Register a function to a pre-allocated class/struct member function: will use callee's 'this' (effectively embedding a global function in TClassType's script namespace).

+  template<typename Callee,typename Func>

+  SQClassDefBase & staticFunc(Callee & callee,Func pfunc,const SQChar * name) {

+    Register(v,newClass.GetObjectHandle(),callee,pfunc,name);

+    return *this;

+  } // staticFunc

+

+  // === END static+global function registration ===

+

+  // Register a member variable.

+  template<typename VarType>

+  SQClassDefBase & var(VarType TClassType::* pvar,const SQChar * name,VarAccessType access=VAR_ACCESS_READ_WRITE) {

+    struct CV {

+      VarType TClassType::* var;

+    } cv; // Cast Variable helper.

+    cv.var = pvar;

+    RegisterInstanceVariable(newClass,ClassType<TClassType>::type(),*(VarType **)&cv,name,access);

+    return *this;

+  } // var

+

+  // Register a member variable as a UserPointer (read only).

+  template<typename VarType>

+  SQClassDefBase & varAsUserPointer(VarType TClassType::* pvar,const SQChar * name) {

+    struct CV {

+      VarType TClassType::* var;

+    } cv; // Cast Variable helper.

+    cv.var = pvar;

+    RegisterInstanceVariable(newClass,ClassType<TClassType>::type(),*(SQAnything **)&cv,name,VAR_ACCESS_READ_ONLY);

+    return *this;

+  } // varAsUserPointer

+

+#ifdef SQPLUS_SMARTPOINTER_OPT

+#define SQPLUS_SMARTPOINTER_CLASS_DEF_VAR

+#include "SqPlusSmartPointer.h"

+#endif

+

+  template<typename VarType>

+  SQClassDefBase & staticVar(VarType * pvar,const SQChar * name,VarAccessType access=VAR_ACCESS_READ_WRITE) {

+    struct CV {

+      VarType * var;

+    } cv; // Cast Variable helper.

+    cv.var = pvar;

+    RegisterInstanceVariable(newClass,ClassType<TClassType>::type(),*(VarType **)&cv,name,VarAccessType(access|VAR_ACCESS_STATIC));

+    return *this;

+  } // staticVar

+

+#ifdef SQPLUS_CONST_OPT

+#define SQ_REG_CONST_STATIC_VAR

+#include "SqPlusConst.h"

+#endif

+

+  // Member / static member script vars (ordinary Squirrel vars)

+  SQClassDefBase & scriptVar( const SQChar* name, int ival, SQBool static_var=SQFalse ) {

+    HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+    sq_pushobject(v,newClass.GetObjectHandle());

+    sq_pushstring(v,name,-1);

+    sq_pushinteger(v,ival);

+    sq_newslot(v,-3,static_var);

+    sq_pop(v,1);

+    return *this;

+  }

+

+  SQClassDefBase & scriptVar( const SQChar* name, double fval, SQBool static_var=SQFalse ) {

+    HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+    sq_pushobject(v,newClass.GetObjectHandle());

+    sq_pushstring(v,name,-1);

+    sq_pushfloat(v,fval);

+    sq_newslot(v,-3,static_var);

+    sq_pop(v,1);

+    return *this;

+  }

+  

+  SQClassDefBase & scriptVar( const SQChar* name, const SQChar* sval, SQBool static_var=SQFalse ) {

+    HSQUIRRELVM v = SquirrelVM::GetVMPtr();

+    sq_pushobject(v,newClass.GetObjectHandle());

+    sq_pushstring(v,name,-1);

+    sq_pushstring(v,sval,-1);

+    sq_newslot(v,-3,static_var);

+    sq_pop(v,1);

+    return *this;

+  }

+  

+  // Register a constant (read-only in script, passed by value (only INT, FLOAT, or BOOL types)).

+  template<typename ConstantType>

+  SQClassDefBase & constant(ConstantType constant,const SQChar * name) {

+    RegisterInstanceConstant(newClass,ClassType<TClassType>::type(),constant,name);

+    return *this;

+  } // constant

+

+  // Register an enum as an integer (read-only in script).

+  SQClassDefBase & enumInt(int constant,const SQChar * name) {

+      RegisterInstanceConstant(newClass,ClassType<TClassType>::type(),constant,name);

+      return *this;

+  } // enumInt

+

+#ifdef SQPLUS_OVERLOAD_OPT

+#define SQPLUS_OVERLOAD_IMPLEMENTATION

+#include "SqPlusOverload.h"

+#endif

+};

+

+#ifdef SQPLUS_OVERLOAD_OPT

+#define SQPLUS_OVERLOAD_FUNCTIONS

+#include "SqPlusOverload.h"

+#endif

+

+template<typename TClassType, typename TClassBase=SQNoBaseClass>

+struct SQClassDef : public SQClassDefBase<TClassType,TClassBase> {

+

+#if defined(SQ_USE_CLASS_INHERITANCE) || defined(SQ_USE_CLASS_INHERITANCE_SIMPLE)

+  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).

+  SQClassDef(HSQUIRRELVM _v,const SQChar * _name=0,const SQChar * _base=0) : SQClassDefBase<TClassType,TClassBase>(_v,_name,_base) {

+    SQClassDefBase<TClassType,TClassBase>::newClass = 

+            RegisterClassType<TClassType>( SQClassDefBase<TClassType,TClassBase>::v,

+                                           SQClassDefBase<TClassType,TClassBase>::name,

+                                           SQClassDefBase<TClassType,TClassBase>::base );

+  }

+  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).

+  SQClassDef(const SQChar * _name=0,const SQChar * _base=0) : SQClassDefBase<TClassType,TClassBase>(_name,_base) {

+    SQClassDefBase<TClassType,TClassBase>::newClass = 

+            RegisterClassType< TClassType>( SQClassDefBase<TClassType,TClassBase>::v,

+                                            SQClassDefBase<TClassType,TClassBase>::name,

+                                            SQClassDefBase<TClassType,TClassBase>::base );

+  }

+#else

+  SQClassDef(HSQUIRRELVM _v,const SQChar * _name=0) : SQClassDefBase<TClassType,TClassBase>(_v,_name) {

+    SQClassDefBase<TClassType,TClassBase>::newClass = 

+                                            RegisterClassType<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,

+                                            SQClassDefBase<TClassType,TClassBase>::name );

+  }

+  SQClassDef(const SQChar * _name=0) : SQClassDefBase<TClassType,TClassBase>(_name) {

+    SQClassDefBase<TClassType,TClassBase>::newClass = 

+                                            RegisterClassType<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,

+                                            SQClassDefBase<TClassType,TClassBase>::name );

+  }

+#endif

+};

+

+template<typename TClassType, typename TClassBase=SQNoBaseClass>

+struct SQClassDefNoConstructor : public SQClassDefBase<TClassType,TClassBase> {

+#if defined(SQ_USE_CLASS_INHERITANCE) || defined(SQ_USE_CLASS_INHERITANCE_SIMPLE)

+  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).

+  SQClassDefNoConstructor(HSQUIRRELVM _v,const SQChar * _name=0,const SQChar * _base=0) : SQClassDefBase<TClassType,TClassBase>(_v,_name,_base) {

+    SQClassDefBase<TClassType,TClassBase>::newClass = RegisterClassTypeNoConstructor<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,SQClassDefBase<TClassType,TClassBase>::name,SQClassDefBase<TClassType,TClassBase>::base);

+  }

+  // Optional base arg is the name of a base class to inherit from (must already be defined in the Squirrel VM).

+  SQClassDefNoConstructor(const SQChar * _name=0,const SQChar * _base=0) : SQClassDefBase<TClassType,TClassBase>(_name,_base) {

+    SQClassDefBase<TClassType,TClassBase>::newClass = RegisterClassTypeNoConstructor<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,SQClassDefBase<TClassType,TClassBase>::name,SQClassDefBase<TClassType,TClassBase>::base);

+  }

+#else

+  SQClassDefNoConstructor(HSQUIRRELVM _v,const SQChar * _name=0) : SQClassDefBase<TClassType,TClassBase>(_v,_name) {

+    SQClassDefBase<TClassType,TClassBase>::newClass = RegisterClassTypeNoConstructor<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,SQClassDefBase<TClassType,TClassBase>::name);

+  }

+  SQClassDefNoConstructor(const SQChar * _name=0) : SQClassDefBase<TClassType,TClassBase>(_name) {

+    SQClassDefBase<TClassType,TClassBase>::newClass = RegisterClassTypeNoConstructor<TClassType>(SQClassDefBase<TClassType,TClassBase>::v,SQClassDefBase<TClassType,TClassBase>::name);

+  }

+#endif

+};

+

+

+// === Macros for old style registration. SQClassDef registration is now easier to use (SQ_DECLARE_CLASS() is not needed) ===

+

+#define SQ_DECLARE_CLASS(CLASSNAME)                                  \

+static int _##CLASSNAME##_release(SQUserPointer up,SQInteger size) { \

+  if (up) {                                                          \

+    CLASSNAME * self = (CLASSNAME *)up;                              \

+    delete self;                                                     \

+  }                                                                  \

+  return 0;                                                          \

+}                                                                    \

+static int _##CLASSNAME##_constructor(HSQUIRRELVM v) {               \

+  CLASSNAME * pc = new CLASSNAME();                                  \

+  sq_setinstanceup(v,1,pc);                                          \

+  sq_setreleasehook(v,1,_##CLASSNAME##_release);                     \

+  return 1;                                                          \

+}

+

+#define SQ_REGISTER_CLASS(CLASSNAME)                                 \

+  RegisterClassType(SquirrelVM::GetVMPtr(),_SC(#CLASSNAME),_##CLASSNAME##_constructor)

+

+#define SQ_REGISTER_INSTANCE(NEWSQCLASS,CCLASS,FUNCNAME)             \

+  RegisterInstance(SquirrelVM::GetVMPtr(),NEWSQCLASS.GetObjectHandle(),*(CCLASS *)0,&CCLASS::FUNCNAME,_SC(#FUNCNAME));

+

+#define SQ_REGISTER_INSTANCE_VARARGS(NEWSQCLASS,CCLASS,FUNCNAME)     \

+  RegisterInstanceVarArgs(SquirrelVM::GetVMPtr(),NEWSQCLASS.GetObjectHandle(),*(CCLASS *)0,&CCLASS::FUNCNAME,_SC(#FUNCNAME));

+

+#define SQ_REGISTER_INSTANCE_VARIABLE(NEWSQCLASS,CCLASS,VARNAME)     \

+  RegisterInstanceVariable(NEWSQCLASS,&((CCLASS *)0)->VARNAME,_SC(#VARNAME));

+

+#if defined(USE_ARGUMENT_DEPENDANT_OVERLOADS) && defined(_MSC_VER)

+#pragma warning (default:4675)

+#endif

+

+}; // namespace SqPlus

+

+

+// === BEGIN code suggestion from the Wiki ===

+

+// Get any bound type from this SquirrelObject. Note that Squirrel's

+// handling of references and pointers still holds here.

+template<typename _ty>

+inline _ty SquirrelObject::Get(void) {

+  sq_pushobject(SquirrelVM::_VM,GetObjectHandle());

+  _ty val = SqPlus::Get(SqPlus::TypeWrapper<_ty>(),SquirrelVM::_VM,-1);

+  sq_poptop(SquirrelVM::_VM);

+  return val;

+}

+

+// Set any bound type to this SquirrelObject. Note that Squirrel's

+// handling of references and pointers still holds here.

+template<typename _ty>

+inline SquirrelObject SquirrelObject::SetByValue(_ty val) { // classes/structs should be passed by ref (below) to avoid an extra copy.

+  SqPlus::Push(SquirrelVM::_VM,val);

+  AttachToStackObject(-1);

+  sq_poptop(SquirrelVM::_VM);

+  return *this;

+}

+

+// Set any bound type to this SquirrelObject. Note that Squirrel's

+// handling of references and pointers still holds here.

+template<typename _ty>

+inline SquirrelObject &SquirrelObject::Set(_ty & val) {

+  SqPlus::Push(SquirrelVM::_VM,val);

+  AttachToStackObject(-1);

+  sq_poptop(SquirrelVM::_VM);

+  return *this;

+}

+

+// === END code suggestion from the Wiki ===

+

+#endif //_SQ_PLUS_H_

diff --git a/squirrel_3_0_1_stable/sqplus/sqplus.vcproj b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.vcproj
index fdc22e06b..fdc22e06b 100644
--- a/squirrel_3_0_1_stable/sqplus/sqplus.vcproj
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.vcproj
diff --git a/squirrel_3_0_1_stable/sqplus/sqplus.vcxproj b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.vcxproj
index fca6ce402..fca6ce402 100644
--- a/squirrel_3_0_1_stable/sqplus/sqplus.vcxproj
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.vcxproj
diff --git a/squirrel_3_0_1_stable/sqplus/sqplus.vcxproj.filters b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.vcxproj.filters
index a61b1ca90..a61b1ca90 100644
--- a/squirrel_3_0_1_stable/sqplus/sqplus.vcxproj.filters
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.vcxproj.filters
diff --git a/squirrel_3_0_1_stable/sqplus/sqplus.vcxproj.user b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.vcxproj.user
index 695b5c78b..695b5c78b 100644
--- a/squirrel_3_0_1_stable/sqplus/sqplus.vcxproj.user
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus.vcxproj.user
diff --git a/squirrel_3_0_1_stable/sqplus/sqplus71.vcproj b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus71.vcproj
index fc3ac5555..fc3ac5555 100644
--- a/squirrel_3_0_1_stable/sqplus/sqplus71.vcproj
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/sqplus71.vcproj
diff --git a/squirrel_3_0_1_stable/sqplus/sqplusWin32.h b/squirrel_3_0_1_stable/_OLD_sqplus/sqplusWin32.h
index bf46fd6cf..98741bcfe 100644
--- a/squirrel_3_0_1_stable/sqplus/sqplusWin32.h
+++ b/squirrel_3_0_1_stable/_OLD_sqplus/sqplusWin32.h
@@ -1,7 +1,7 @@
-#ifndef _SQ_PLUS_WIN32_H_
-#define _SQ_PLUS_WIN32_H_
-
-#include "sqplus.h"
-#include "SquirrelBindingsUtilsWin32.h"
-
+#ifndef _SQ_PLUS_WIN32_H_

+#define _SQ_PLUS_WIN32_H_

+

+#include "sqplus.h"

+#include "SquirrelBindingsUtilsWin32.h"

+

 #endif //_SQ_PLUS_WIN32_H_
\ No newline at end of file