initial

vscript/languages/squirrel/sqplus/Makefile

@@ -0,0 +1,18 @@
+SQUIRREL= ..
+
+OUT= $(SQUIRREL)/lib/libsqplus.a
+INCDIRS= -I$(SQUIRREL)/include -I. -Iinclude 
+
+ALLSRCS = $(wildcard *.cpp)
+WIN32SRCS = $(wildcard *Win32*)
+SRCS = $(filter-out $(WIN32SRCS),$(ALLSRCS))
+	
+sqplus:
+#	g++ -fno-rtti -c $(SRCS) $(INCDIRS)
+	g++ -O3  -fno-rtti -Os -c $(SRCS) $(INCDIRS)
+	ar rc $(OUT) *.o
+	rm *.o
+	
+
+#g++ -O3  -fno-rtti -Os -c $(SRCS) $(INCDIRS)
+#g++ -ggdb  -fno-rtti -c $(SRCS) $(INCDIRS)

vscript/languages/squirrel/sqplus/SqPlus.cpp

@@ -0,0 +1,298 @@
+#include "sqplus.h"
+#ifdef _PS3
+#undef _STD_USING
+#endif
+#include <stdio.h>
+#if defined(VSCRIPT_DLL_EXPORT) || defined(VSQUIRREL_TEST)
+#include "memdbgon.h"
+#endif
+
+namespace SqPlus {
+
+static int getVarInfo(StackHandler & sa,VarRefPtr & vr) {
+  HSQOBJECT htable = sa.GetObjectHandle(1);
+  SquirrelObject table(htable);
+#ifdef _DEBUG
+  SQObjectType type = (SQObjectType)sa.GetType(2);
+#endif
+  const SQChar * el = sa.GetString(2);
+  ScriptStringVar256 varNameTag;
+  getVarNameTag(varNameTag,sizeof(varNameTag),el);
+  SQUserPointer data=0;
+  if (!table.RawGetUserData(varNameTag,&data)) {
+//    throw SquirrelError("getVarInfo: Could not retrieve UserData");
+    return sa.ThrowError(_T("getVarInfo: Could not retrieve UserData")); // Results in variable not being found error.
+  } // if
+  vr = (VarRefPtr)data;
+  return SQ_OK;
+} // getVarInfo
+
+static int getInstanceVarInfo(StackHandler & sa,VarRefPtr & vr,SQUserPointer & data) {
+  HSQOBJECT ho = sa.GetObjectHandle(1);
+  SquirrelObject instance(ho);
+#ifdef _DEBUG
+  SQObjectType type = (SQObjectType)sa.GetType(2);
+#endif
+  const SQChar * el = sa.GetString(2);
+  ScriptStringVar256 varNameTag;
+  getVarNameTag(varNameTag,sizeof(varNameTag),el);
+  SQUserPointer ivrData=0;
+  if (!instance.RawGetUserData(varNameTag,&ivrData)) {
+//    throw SquirrelError("getInstanceVarInfo: Could not retrieve UserData");
+    return sa.ThrowError(_T("getInstanceVarInfo: Could not retrieve UserData")); // Results in variable not being found error.
+  } // if
+  vr = (VarRefPtr)ivrData;
+  unsigned char * up;
+  if (!(vr->access & (VAR_ACCESS_STATIC|VAR_ACCESS_CONSTANT))) {
+#ifdef SQ_USE_CLASS_INHERITANCE
+    SQUserPointer typetag; instance.GetTypeTag(&typetag);
+    if (typetag != vr->instanceType) {
+      SquirrelObject typeTable = instance.GetValue(SQ_CLASS_OBJECT_TABLE_NAME);
+      up = (unsigned char *)typeTable.GetUserPointer(INT((size_t)vr->instanceType)); // <TODO> 64-bit compatible version.
+      if (!up) {
+        throw SquirrelError(_T("Invalid Instance Type"));
+      } // if
+    } else {
+      up = (unsigned char *)instance.GetInstanceUP(0);
+    } // if
+#else
+    up = (unsigned char *)instance.GetInstanceUP(0);
+#endif
+    up += (size_t)vr->offsetOrAddrOrConst;         // Offset
+  } else {
+    up = (unsigned char *)vr->offsetOrAddrOrConst; // Address
+  } // if
+  data = up;
+  return SQ_OK;
+} // getInstanceVarInfo
+
+static int setVar(StackHandler & sa,VarRef * vr,void * data) {
+  if (vr->access & (VAR_ACCESS_READ_ONLY|VAR_ACCESS_CONSTANT)) {
+    ScriptStringVar256 msg;
+    const SQChar * el = sa.GetString(2);
+    SCSNPRINTF(msg.s,sizeof(msg),_T("setVar(): Cannot write to constant: %s"),el);
+    throw SquirrelError(msg.s);
+  } // if
+  switch (vr->type) {
+  case TypeInfo<INT>::TypeID: {
+    INT * val = (INT *)data; // Address
+    if (val) {
+      *val = sa.GetInt(3);
+      return sa.Return(*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();
+    // vr->copyFunc is the LHS variable type: the RHS var's type is ClassType<>::type() (both point to ClassType<>::copy()).
+    // src will be null if the LHS and RHS types don't match.
+    SQUserPointer src = sa.GetInstanceUp(3,(SQUserPointer)vr->copyFunc); // Effectively performs: ClassType<>::type() == ClassType<>getCopyFunc().
+    if (!src) throw SquirrelError(_T("INSTANCE type assignment mismatch"));
+    vr->copyFunc(data,src);
+#if 0 // Return an instance on the stack (allocates memory)
+    if (!CreateNativeClassInstance(sa.GetVMPtr(),vr->typeName,data,0)) { // data = address
+      ScriptStringVar256 msg;
+      SCSNPRINTF(msg.s,sizeof(msg),_T("getVar(): Could not create instance: %s"),vr->typeName);
+      throw SquirrelError(msg.s);
+    } // if
+    return 1;
+#else // Don't return on stack.
+    return 0;
+#endif
+  }
+  case TypeInfo<SQUserPointer>::TypeID: {
+    ScriptStringVar256 msg;
+    const SQChar * el = sa.GetString(2);
+    SCSNPRINTF(msg.s,sizeof(msg),_T("setVar(): Cannot write to an SQUserPointer: %s"),el);
+    throw SquirrelError(msg.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
+  } // switch
+  return SQ_ERROR;
+} // setVar
+
+static int getVar(StackHandler & sa,VarRef * vr,void * data) {
+  switch (vr->type) {
+  case TypeInfo<INT>::TypeID: {
+    if (!(vr->access & VAR_ACCESS_CONSTANT)) {
+      INT * val = (INT *)data; // Address
+      if (val) {
+        return sa.Return(*val);
+      } // if
+    } else {
+      INT * val = (INT *)&data; // Constant value
+      return sa.Return(*val);
+    } // if
+    break;
+  } // case
+  case TypeInfo<FLOAT>::TypeID: {
+    if (!(vr->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->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->typeName,data,0)) { // data = address. Allocates memory.
+      ScriptStringVar256 msg;
+      SCSNPRINTF(msg.s,sizeof(msg),_T("getVar(): Could not create instance: %s"),vr->typeName);
+      throw SquirrelError(msg.s);
+    } // if
+    return 1;
+  case TypeInfo<SQUserPointer>::TypeID: {
+    return sa.Return(data); // The address of member variable, not the variable itself.
+  } // case
+  case TypeInfo<ScriptStringVarBase>::TypeID: {
+    if (!(vr->access & VAR_ACCESS_CONSTANT)) {
+      ScriptStringVarBase * val = (ScriptStringVarBase *)data; // Address
+      if (val) {
+        return sa.Return(val->s);
+      } // if
+    } else {
+      throw SquirrelError(_T("getVar(): Invalid type+access: 'ScriptStringVarBase' with VAR_ACCESS_CONSTANT (use VAR_ACCESS_READ_ONLY instead)"));
+    } // if
+    break;
+  } // case
+  case TypeInfo<const SQChar *>::TypeID: {
+    if (!(vr->access & VAR_ACCESS_CONSTANT)) {
+      throw SquirrelError(_T("getVar(): Invalid type+access: 'const SQChar *' without VAR_ACCESS_CONSTANT"));
+    } else {
+      return sa.Return((const SQChar *)data); // Address
+    } // if
+    break;
+  } // case
+  } // switch
+  return SQ_ERROR;
+} // getVar
+
+// === Global Vars ===
+
+SQInteger setVarFunc(HSQUIRRELVM v) {
+  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
+
+SQInteger getVarFunc(HSQUIRRELVM v) {
+  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 ===
+
+SQInteger setInstanceVarFunc(HSQUIRRELVM v) {
+  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
+
+SQInteger getInstanceVarFunc(HSQUIRRELVM v) {
+  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) {
+  int top = sq_gettop(v);
+  SquirrelObject newClass;
+  if (CreateClass(v,newClass,classType,scriptClassName)) {
+    SquirrelVM::CreateFunction(newClass,constructor,_T("constructor"));
+  } // if
+  sq_settop(v,top);
+  return newClass;
+} // RegisterClassType
+
+}; // namespace SqPlus
+
+// sqPlus

vscript/languages/squirrel/sqplus/SqPlusConst.h

@@ -0,0 +1,334 @@
+// 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(TYPE,NAME) \
+DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) \
+namespace SqPlus { \
+inline void Push(HSQUIRRELVM v,const TYPE * value) { \
+  if (!value) sq_pushnull(v); \
+  else if (!CreateNativeClassInstance(v,GetTypeName(*value),(TYPE*)value,0)) \
+    throw SquirrelError(_T("Push(): could not create INSTANCE (check registration name)")); } \
+inline void Push(HSQUIRRELVM v,const TYPE & value) { if (!CreateCopyInstance(GetTypeName(value),value)) throw SquirrelError(_T("Push(): could not create INSTANCE copy (check registration 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); } \
+} // nameSpace SqPlus
+
+#else
+
+#define DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME) \
+DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) \
+namespace SqPlus { \
+inline void Push(HSQUIRRELVM v,const TYPE * value) { if (!CreateNativeClassInstance(v,GetTypeName(*value),(TYPE*)value,0)) throw SquirrelError(_T("Push(): could not create INSTANCE (check registration name)")); } \
+inline void Push(HSQUIRRELVM v,const TYPE & value) { if (!CreateCopyInstance(GetTypeName(value),value)) throw SquirrelError(_T("Push(): could not create INSTANCE copy (check registration 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); } \
+} // 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)
+#endif
+
+#ifdef SQPLUS_CALL_CONST_MFUNC_RET0
+#undef SQPLUS_CALL_CONST_MFUNC_RET0
+template <typename Callee>
+static int Call(Callee & callee,RT (Callee::*func)() const,HSQUIRRELVM v,int /*index*/) {
+  RT ret = (callee.*func)();
+  Push(v,ret);
+  return 1;
+}
+
+template <typename Callee,typename P1>
+static int Call(Callee & callee,RT (Callee::*func)(P1) const,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 (Callee::*func)(P1,P2) const,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 (Callee::*func)(P1,P2,P3) const,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 (Callee::*func)(P1,P2,P3,P4) const,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 (Callee::*func)(P1,P2,P3,P4,P5) const,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 (Callee::*func)(P1,P2,P3,P4,P5,P6) const,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 (Callee::*func)(P1,P2,P3,P4,P5,P6,P7) const,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;
+}
+#endif
+
+#ifdef SQPLUS_CALL_CONST_MFUNC_NORET
+#undef SQPLUS_CALL_CONST_MFUNC_NORET
+template<typename Callee>
+static int Call(Callee & callee,void (Callee::*func)() const,HSQUIRRELVM,int /*index*/) {
+  (callee.*func)();
+  return 0;
+}
+
+template<typename Callee,typename P1>
+static int Call(Callee & callee,void (Callee::*func)(P1) const,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 (Callee::*func)(P1,P2) const,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 (Callee::*func)(P1,P2,P3) const,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 (Callee::*func)(P1,P2,P3,P4) const,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 (Callee::*func)(P1,P2,P3,P4,P5) const,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 (Callee::*func)(P1,P2,P3,P4,P5,P6) const,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 (Callee::*func)(P1,P2,P3,P4,P5,P6,P7) const,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;
+}
+#endif
+
+#ifdef SQPLUS_CALL_CONST_MFUNC_RET1
+#undef SQPLUS_CALL_CONST_MFUNC_RET1
+template<typename Callee,typename RT>
+int Call(Callee & callee, RT (Callee::*func)() const,HSQUIRRELVM v,int index) {
+  return ReturnSpecialization<RT>::Call(callee,func,v,index);
+}
+
+template<typename Callee,typename RT,typename P1>
+int Call(Callee & callee,RT (Callee::*func)(P1) const,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 (Callee::*func)(P1,P2) const,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 (Callee::*func)(P1,P2,P3) const,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 (Callee::*func)(P1,P2,P3,P4) const,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 (Callee::*func)(P1,P2,P3,P4,P5) const,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 (Callee::*func)(P1,P2,P3,P4,P5,P6) const,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 (Callee::*func)(P1,P2,P3,P4,P5,P6,P7) const,HSQUIRRELVM v,int index) {
+  return ReturnSpecialization<RT>::Call(callee,func,v,index);
+}
+#undef SQPLUS_CALL_CONST_MFUNC_RET1
+#endif
+
+#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

vscript/languages/squirrel/sqplus/SquirrelBindingsUtils.cpp

@@ -0,0 +1,122 @@
+#include "sqplus.h"
+#if defined(VSCRIPT_DLL_EXPORT) || defined(VSQUIRREL_TEST)
+#include "memdbgon.h"
+#endif
+
+
+
+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)
+{
+	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;
+	}
+	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;
+}

vscript/languages/squirrel/sqplus/SquirrelBindingsUtils.h

@@ -0,0 +1,151 @@
+#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,_T(#classname),-1); \
+			return 1; \
+		} \
+		struct ScriptClassMemberDecl __##classname##_members[] = { \
+		{_T("_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) {_T(#name),type,val},
+#define _CONSTANT_IMPL(name,type) {_T(#name),type,name},
+
+#define _MEMBER_FUNCTION(classname,name,nparams,typemask) \
+	{_T(#name),__##classname##_##name,nparams,typemask},
+
+#define _END_NAMESPACE(classname,delegate) {NULL,OT_NULL,0}}; \
+struct ScriptNamespaceDecl __##classname##_decl = {   \
+	_T(#classname), __##classname##_members,__##classname##_constants,delegate };
+
+#define _END_CLASS(classname) {NULL,NULL,0,NULL}}; \
+struct SquirrelClassDecl __##classname##_decl = {  \
+	_T(#classname), NULL, __##classname##_members };
+
+
+#define _END_CLASS_INHERITANCE(classname,base) {NULL,NULL,NULL,NULL}}; \
+struct SquirrelClassDecl __##classname##_decl = {  \
+	_T(#classname), _T(#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,_T("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,_T("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(),_T(#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);
+
+#endif // SQUIRREL_BINDINGS_UTILS_H
+

vscript/languages/squirrel/sqplus/SquirrelBindingsUtilsWin32.cpp

@@ -0,0 +1,34 @@
+#include "sqplus.h"
+
+//#include "SquirrelObject.h"
+//#include "SquirrelVM.h"
+#include "SquirrelBindingsUtilsWin32.h"
+#if defined(VSCRIPT_DLL_EXPORT) || defined(VSQUIRREL_TEST)
+#include "memdbgon.h"
+#endif
+
+SQInteger refcounted_release_hook(SQUserPointer p, SQInteger 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);
+}

vscript/languages/squirrel/sqplus/SquirrelBindingsUtilsWin32.h

@@ -0,0 +1,43 @@
+#ifndef SQUIRREL_BINDINGS_UTILS_WIN32_H
+#define SQUIRREL_BINDINGS_UTILS_WIN32_H
+
+#ifdef WIN32
+#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
+#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(),_T(#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(),_T(#classname),ptr)) { \
+		return sa.ThrowError(_T("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);
+SQInteger refcounted_release_hook(SQUserPointer p, SQInteger size);
+int construct_RefCounted(IUnknown *p);
+
+#endif // SQUIRREL_BINDINGS_UTILS_WIN32_H
+

vscript/languages/squirrel/sqplus/SquirrelObject.cpp

@@ -0,0 +1,640 @@
+#include "sqplus.h"
+#if defined(VSCRIPT_DLL_EXPORT) || defined(VSQUIRREL_TEST)
+#include "memdbgon.h"
+#endif
+
+SquirrelObject::SquirrelObject(void)
+{
+	 sq_resetobject(&_o);
+}
+
+SquirrelObject::~SquirrelObject()
+{
+	if(SquirrelVM::_VM)
+		sq_release(SquirrelVM::_VM,&_o);
+}
+
+SquirrelObject::SquirrelObject(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);
+  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_release(SquirrelVM::_VM,&_o);
+	_o = t;
+	return *this;
+}
+
+SquirrelObject & SquirrelObject::operator =(int n)
+{
+	sq_pushinteger(SquirrelVM::_VM,n);
+	AttachToStackObject(-1);
+	sq_pop(SquirrelVM::_VM,1);
+	return *this;
+}
+
+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)))
+						return TRUE;
+					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
+{
+	SQFloat 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
+{
+	intp 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
+{
+	BOOL ret = FALSE;
+	if(GetSlot(key)) {
+		ret = TRUE;
+	}
+	sq_pop(SquirrelVM::_VM,1);
+	return ret;
+}
+////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+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
+{
+	SQFloat 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
+{
+	intp 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->typeName;
+#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
+
+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);
+}
+

vscript/languages/squirrel/sqplus/SquirrelObject.h

@@ -0,0 +1,248 @@
+#ifndef _SQUIRREL_OBJECT_H_
+#define _SQUIRREL_OBJECT_H_
+
+class SquirrelObject
+{
+	friend class SquirrelVM;
+public:
+	SquirrelObject();
+	virtual ~SquirrelObject();
+	SquirrelObject(SquirrelObject & o);
+	SquirrelObject(HSQOBJECT o);
+  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.
+	SquirrelObject & operator =(const SquirrelObject &o);
+	SquirrelObject & operator =(int n);
+	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(INT 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(){return _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);
+
+  // === 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 Get(void);
+
+  // Set any bound type to this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.
+  template<typename _ty>
+  inline SquirrelObject SetByValue(_ty val);
+
+  // 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);
+		}
+		else
+		{
+			x._type = OT_NULL;
+			x._unVal.pUserPointer = 0;
+		}
+		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_
+
+

vscript/languages/squirrel/sqplus/SquirrelObjectImpl.h

@@ -0,0 +1,36 @@
+// This is part of squirrelobject.h that removes circular dependency between sqplus.h and squirrelobject.h: it depends on both
+
+#ifndef _SQUIRREL_OBJECT_IMPL_H_
+#define _SQUIRREL_OBJECT_IMPL_H_
+
+// === 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

vscript/languages/squirrel/sqplus/SquirrelVM.cpp

@@ -0,0 +1,346 @@
+#include <stdio.h>
+#include <stdarg.h>
+
+#define _DEBUG_DUMP
+
+#include "sqplus.h"
+
+#include <sqstdio.h>
+#include <sqstdmath.h>
+#include <sqstdstring.h>
+#include <sqstdaux.h>
+#include <sqstdblob.h>
+#if defined(VSCRIPT_DLL_EXPORT) || defined(VSQUIRREL_TEST)
+#include "memdbgon.h"
+#endif
+
+#ifdef _MSC_VER
+#define STRLEN(n) _tcslen(n)
+#else
+#define STRLEN(n) strlen(n)
+#endif
+
+HSQUIRRELVM SquirrelVM::_VM = NULL;
+int SquirrelVM::_CallState = -1;
+SquirrelObject * SquirrelVM::_root = NULL;
+
+SquirrelError::SquirrelError() 
+{
+	const SQChar *s;
+	sq_getlasterror(SquirrelVM::_VM);
+	sq_getstring(SquirrelVM::_VM,-1,&s);
+	if(s) {
+		desc = s;
+	}
+	else {
+		desc = _T("unknown error");
+	}
+}
+
+void SquirrelVM::Init()
+{
+	_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);
+  _root = new SquirrelObject();
+	_root->AttachToStackObject(-1);
+	sq_pop(_VM,1);
+	//TODO error handler, compiler error handler
+}
+
+BOOL SquirrelVM::Update()
+{
+	//update remote debugger
+	return TRUE;
+}
+
+void SquirrelVM::Cleanup()
+{
+	//cleans the root table
+	sq_pushnull(_VM);
+	sq_setroottable(_VM);
+}
+
+void SquirrelVM::Shutdown()
+{
+  if (_VM) {
+    Cleanup();
+#if 0
+    sq_release(_VM,&_root->_o);
+    sq_resetobject(&_root->_o);
+#endif
+    delete _root;
+    _root = NULL;
+    HSQUIRRELVM v = _VM;
+    _VM = NULL;
+    sq_close(v);
+  } // if
+}
+
+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)
+{
+#define MAX_EXPANDED_PATH 1023
+	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)STRLEN(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,1);
+		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(_T("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(_T("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()
+{
+	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),_T("t|y|x%s"),typeMask) < 0) {
+//        sq_throwerror(_VM,_T("CreateFunction: typeMask string too long."));
+        throw SquirrelError(_T("CreateFunction: typeMask string too long."));
+      } // if
+    } // if
+  } else { // <TODO> Need to check object type on stack: table, class, instance, etc.
+    SCSNPRINTF(tm,sizeof(tm),_T("%s"),_T("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

vscript/languages/squirrel/sqplus/SquirrelVM.h

@@ -0,0 +1,112 @@
+#ifndef _SQUIRREL_VM_H_
+#define _SQUIRREL_VM_H_
+
+struct SquirrelError {
+	SquirrelError();
+	SquirrelError(const SQChar* s):desc(s){}
+	const SQChar *desc;
+};
+
+struct SquirrelVMSys {
+  HSQUIRRELVM _VM;
+  SquirrelObject * _root;
+};
+
+class SquirrelVM
+{
+	friend class SquirrelObject;
+	friend struct SquirrelError;
+public:
+	static void Init();
+	static BOOL IsInitialized(){return _VM == NULL?FALSE:TRUE;}
+	static void Shutdown();
+	static void Cleanup();
+	static BOOL Update(); //debugger and maybe GC later
+	static SquirrelObject CompileScript(const SQChar *s);
+	static SquirrelObject CompileBuffer(const SQChar *s,const SQChar * debugInfo=_T("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; }
+
+#if 0
+  static void SetVMPtr(HSQUIRRELVM v) {
+    _VM = v;
+  } // setVMPtr
+#endif
+
+  static void GetVMSys(SquirrelVMSys & vmSys) {
+    vmSys._VM   = _VM;
+    vmSys._root = _root;
+  } // GetVMSys
+
+  static void SetVMSys(const SquirrelVMSys & vmSys) {
+    _VM   = vmSys._VM;
+    _root = vmSys._root;
+  } // 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);
+
+private:
+	static HSQUIRRELVM _VM;
+	static int _CallState;
+	static SquirrelObject * _root;
+};
+
+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_
+

vscript/languages/squirrel/sqplus/sqplus.cbp

@@ -0,0 +1,190 @@
+<?xml version="1.0"?>
+<!DOCTYPE CodeBlocks_project_file>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="1"/>
+	<Project>
+		<Option title="sqplus"/>
+		<Option makefile="Makefile"/>
+		<Option makefile_is_custom="0"/>
+		<Option default_target="-1"/>
+		<Option compiler="0"/>
+		<Build>
+			<Target title="Debug">
+				<Option output="..\lib\libsqplusD.a"/>
+				<Option working_dir=""/>
+				<Option object_output="Debug"/>
+				<Option deps_output=".deps"/>
+				<Option type="2"/>
+				<Option compiler="0"/>
+				<Option createDefFile="1"/>
+				<Option projectResourceIncludeDirsRelation="2"/>
+				<Compiler>
+					<Add option="-DWIN32"/>
+					<Add option="-D_DEBUG"/>
+					<Add option="-D_LIB"/>
+					<Add option="-D_CRT_SECURE_NO_DEPRECATE"/>
+					<Add option="-W"/>
+					<Add option="-O0"/>
+					<Add directory="..\include"/>
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="..\lib\libsqplus.a"/>
+				<Option working_dir=""/>
+				<Option object_output="Release"/>
+				<Option deps_output=".deps"/>
+				<Option type="2"/>
+				<Option compiler="0"/>
+				<Option createDefFile="1"/>
+				<Option projectResourceIncludeDirsRelation="2"/>
+				<Compiler>
+					<Add option="-DWIN32"/>
+					<Add option="-DNDEBUG"/>
+					<Add option="-D_LIB"/>
+					<Add option="-D_CRT_SECURE_NO_DEPRECATE"/>
+					<Add option="-W"/>
+					<Add option="-g"/>
+					<Add directory="..\include"/>
+				</Compiler>
+			</Target>
+			<Target title="Debug - Unicode">
+				<Option output="..\lib\libsqplusDU.a"/>
+				<Option working_dir=""/>
+				<Option object_output="Debug - Unicode"/>
+				<Option deps_output=".deps"/>
+				<Option type="2"/>
+				<Option compiler="0"/>
+				<Option createDefFile="1"/>
+				<Option projectResourceIncludeDirsRelation="2"/>
+				<Compiler>
+					<Add option="-DWIN32"/>
+					<Add option="-D_DEBUG"/>
+					<Add option="-D_LIB"/>
+					<Add option="-D_CRT_SECURE_NO_DEPRECATE"/>
+					<Add option="-D_CRT_NON_CONFORMING_SWPRINTFS"/>
+					<Add option="-W"/>
+					<Add option="-O0"/>
+					<Add directory="..\include"/>
+				</Compiler>
+			</Target>
+			<Target title="Release - Unicode">
+				<Option output="..\lib\libsqplusU.a"/>
+				<Option working_dir=""/>
+				<Option object_output="Release - Unicode"/>
+				<Option deps_output=".deps"/>
+				<Option type="2"/>
+				<Option compiler="0"/>
+				<Option createDefFile="1"/>
+				<Option projectResourceIncludeDirsRelation="2"/>
+				<Compiler>
+					<Add option="-DWIN32"/>
+					<Add option="-DNDEBUG"/>
+					<Add option="-D_LIB"/>
+					<Add option="-D_CRT_SECURE_NO_DEPRECATE"/>
+					<Add option="-D_CRT_NON_CONFORMING_SWPRINTFS"/>
+					<Add option="-W"/>
+					<Add option="-g"/>
+					<Add directory="..\include"/>
+				</Compiler>
+			</Target>
+		</Build>
+		<Unit filename="SqPlus.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="SqPlusConst.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="SquirrelBindingsUtils.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="SquirrelBindingsUtils.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="SquirrelBindingsUtilsWin32.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="SquirrelBindingsUtilsWin32.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="SquirrelObject.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="SquirrelObject.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="SquirrelVM.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="SquirrelVM.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="sqplus.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+		<Unit filename="sqplusWin32.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="Debug"/>
+			<Option target="Release"/>
+			<Option target="Debug - Unicode"/>
+			<Option target="Release - Unicode"/>
+		</Unit>
+	</Project>
+</CodeBlocks_project_file>

vscript/languages/squirrel/sqplus/sqplus.vcproj

@@ -0,0 +1,339 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="sqplus"
+	ProjectGUID="{F9811314-C694-49A4-BD87-BA2E7F30D358}"
+	RootNamespace="sqplus"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="../lib/sqplusD.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="../lib/sqplus.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug - Unicode|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="../lib/sqplusDU.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release - Unicode|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="../lib/sqplusU.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\SqPlus.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\SquirrelBindingsUtils.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\SquirrelBindingsUtilsWin32.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\SquirrelObject.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\SquirrelVM.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath=".\sqplus.h"
+				>
+			</File>
+			<File
+				RelativePath=".\SqPlusConst.h"
+				>
+			</File>
+			<File
+				RelativePath=".\sqplusWin32.h"
+				>
+			</File>
+			<File
+				RelativePath=".\SquirrelBindingsUtils.h"
+				>
+			</File>
+			<File
+				RelativePath=".\SquirrelBindingsUtilsWin32.h"
+				>
+			</File>
+			<File
+				RelativePath=".\SquirrelObject.h"
+				>
+			</File>
+			<File
+				RelativePath=".\SquirrelVM.h"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

vscript/languages/squirrel/sqplus/sqplus71.vcproj

@@ -0,0 +1,229 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="sqplus"
+	ProjectGUID="{F9811314-C694-49A4-BD87-BA2E7F30D358}"
+	RootNamespace="sqplus"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="../lib/sqplusD.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="../lib/sqplus.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug - Unicode|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="1">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="../lib/sqplusDU.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release - Unicode|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="1">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="../lib/sqplusU.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath=".\SqPlus.cpp">
+			</File>
+			<File
+				RelativePath=".\SquirrelBindingsUtils.cpp">
+			</File>
+			<File
+				RelativePath=".\SquirrelBindingsUtilsWin32.cpp">
+			</File>
+			<File
+				RelativePath=".\SquirrelObject.cpp">
+			</File>
+			<File
+				RelativePath=".\SquirrelVM.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+			<File
+				RelativePath=".\sqplus.h">
+			</File>
+			<File
+				RelativePath=".\SqPlusConst.h">
+			</File>
+			<File
+				RelativePath=".\sqplusWin32.h">
+			</File>
+			<File
+				RelativePath=".\SquirrelBindingsUtils.h">
+			</File>
+			<File
+				RelativePath=".\SquirrelBindingsUtilsWin32.h">
+			</File>
+			<File
+				RelativePath=".\SquirrelObject.h">
+			</File>
+			<File
+				RelativePath=".\SquirrelVM.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

vscript/languages/squirrel/sqplus/sqplusWin32.h

@@ -0,0 +1,7 @@
+#ifndef _SQ_PLUS_WIN32_H_
+#define _SQ_PLUS_WIN32_H_
+
+#include "sqplus.h"
+#include "SquirrelBindingsUtilsWin32.h"
+
+#endif //_SQ_PLUS_WIN32_H_