/*
* invoke impact event
*/
static SQBool invokeImpactEvent(HSQUIRRELVM v, ContactPoint cp) {
SQBool result = false;
SQInteger top = sq_gettop(v);
sq_pushroottable(v);
sq_pushstring(v, "emo", -1);
if (SQ_SUCCEEDED(sq_get(v, -2))) {
sq_pushstring(v, "_onImpact", -1);
if(SQ_SUCCEEDED(sq_get(v, -2))) {
sq_pushroottable(v);
sq_pushuserpointer(v, cp.fixtureA);
sq_pushuserpointer(v, cp.fixtureB);
sq_pushuserpointer(v, cp.fixtureA->GetBody());
sq_pushuserpointer(v, cp.fixtureB->GetBody());
pushVec2(v, cp.position);
pushVec2(v, cp.normal);
sq_pushfloat(v, cp.normalImpulse);
sq_pushfloat(v, cp.tangentImpulse);
result = SQ_SUCCEEDED(sq_call(v, 9, SQFalse, SQTrue));
}
}
sq_settop(v,top);
return result;
}
bool SquirrelScriptContext::RegisterUserClass(ClassDesc* desc)
{
MultiScriptAssert(desc->m_constructor);
MultiScriptAssert(desc->m_destructor);
SquirrelClassInfo* classInfo = new SquirrelClassInfo();
classInfo->m_desc = desc;
classInfo->m_context = this;
// Create class
sq_pushstring(m_vm, desc->m_name, -1);
// TODO: Handle subclass via 2nd parameter
sq_newclass(m_vm, SQFalse);
// Add methods
for (unsigned int i = 0; i < desc->m_methods.size(); ++i)
{
sq_pushstring(m_vm, desc->m_methods[i].m_name, -1);
sq_pushuserpointer(m_vm, classInfo);
sq_pushinteger(m_vm, i);
sq_newclosure(m_vm, SquirrelClassMethodCallback, 2);
sq_createslot(m_vm, -3);
}
// Add constructor
sq_pushstring(m_vm, "constructor", -1);
sq_pushuserpointer(m_vm, classInfo);
sq_newclosure(m_vm, SquirrelClassConstructorCallback, 1);
sq_createslot(m_vm, -3);
// Add to-string method
sq_pushstring(m_vm, "AsString", -1);
sq_pushuserpointer(m_vm, classInfo);
sq_newclosure(m_vm, SquirrelClassToStringMethodCallback, 1);
sq_createslot(m_vm, -3);
// Add optional destructor
if (!desc->m_garbageCollect)
{
// Add destructor
sq_pushstring(m_vm, "Destroy", -1);
sq_pushuserpointer(m_vm, classInfo);
sq_newclosure(m_vm, SquirrelClassDestructorCallback, 1);
sq_createslot(m_vm, -3);
}
else
{
// TODO: Add garbage collection callback here
}
// Add class to root table
sq_createslot(m_vm, -3);
// Add class info
m_classes.push_back(classInfo);
return true;
}
bool SQDbgServer::Init()
{
//creates an environment table for the debugger
sq_newtable(_v);
sq_getstackobj(_v,-1,&_debugroot);
sq_addref(_v,&_debugroot);
//creates a emptyslot to store the watches
sq_pushstring(_v,_SC("watches"),-1);
sq_pushnull(_v);
sq_createslot(_v,-3);
sq_pushstring(_v,_SC("beginelement"),-1);
sq_pushuserpointer(_v,this);
sq_newclosure(_v,beginelement,1);
sq_setparamscheck(_v,2,_SC(".s"));
sq_createslot(_v,-3);
sq_pushstring(_v,_SC("endelement"),-1);
sq_pushuserpointer(_v,this);
sq_newclosure(_v,endelement,1);
sq_setparamscheck(_v,2,_SC(".s"));
sq_createslot(_v,-3);
sq_pushstring(_v,_SC("attribute"),-1);
sq_pushuserpointer(_v,this);
sq_newclosure(_v,attribute,1);
sq_setparamscheck(_v,3,_SC(".ss"));
sq_createslot(_v,-3);
sq_pop(_v,1);
//stores debug hook and error handler in the registry
sq_pushregistrytable(_v);
sq_pushstring(_v,SQDBG_DEBUG_HOOK,-1);
sq_pushuserpointer(_v,this);
sq_newclosure(_v,debug_hook,1);
sq_createslot(_v,-3);
sq_pushstring(_v,SQDBG_ERROR_HANDLER,-1);
sq_pushuserpointer(_v,this);
sq_newclosure(_v,error_handler,1);
sq_createslot(_v,-3);
sq_pop(_v,1);
//sets the error handlers
SetErrorHandlers();
return true;
}
void CSquirrelVM::BeginRegisterScriptClass(const char* className, scriptFunction pfnFunction, void* userPointer, const char* baseClass)
{
iFuncIndex = 0;
#if 1
int n = 0;
oldtop = sq_gettop(m_pVM);
sq_pushroottable(m_pVM);
sq_pushstring(m_pVM, className, -1);
if(baseClass) {
sq_pushstring(m_pVM, baseClass, -1);
if(SQ_FAILED(sq_get(m_pVM, -3))) { // make sure base exists
sq_settop(m_pVM, oldtop);
return;
}
}
if(SQ_FAILED(sq_newclass(m_pVM, baseClass ? 1 : 0))) {
sq_settop(m_pVM, oldtop);
return;
}
sq_pushstring(m_pVM, _SC("constructor"), -1);
if (userPointer != nullptr)
{
sq_pushuserpointer(m_pVM, userPointer);
sq_newclosure(m_pVM, (SQFUNCTION) pfnFunction, 1);
}
else
sq_newclosure(m_pVM, (SQFUNCTION)pfnFunction, 0);
sq_newslot(m_pVM, -3, false); // Add the constructor method
#endif
}
SQRESULT sqext_register_ffi(HSQUIRRELVM v)
{
int saved_top = sq_gettop(v);
//add a namespace ffi
sq_pushstring(v,_SC("ffi"),-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)FFI_LIB_TAG);
sq_insert_reg_funcs(v, sq_ffi_methods);
int i;
for (i = 0; ffi_types_wrap[i].name != 0; i++) {
struct FFI_type_name *e = &ffi_types_wrap[i];
sq_pushstring(v, e->name, -1);
sq_pushuserpointer(v, e->type);
sq_newslot(v, -3, SQFalse);
}
sq_newslot(v,-3,SQTrue); //add ffi table to the root table
sq_create_delegate_table(v, sq_lib_methods, FFI_LIB_LIB_TAG);
sq_create_delegate_table(v, sq_func_methods, FFI_LIB_FUNC_TAG);
sq_create_delegate_table(v, sq_var_methods, FFI_LIB_VAR_TAG);
sq_settop(v, saved_top);
return SQ_OK;
}
static SQRESULT sq_mysql_constructor(HSQUIRRELVM v)
{
SQ_FUNC_VARS(v);
SQ_GET_STRING(v, 2, host);
SQ_GET_STRING(v, 3, username);
SQ_GET_STRING(v, 4, password);
SQ_GET_STRING(v, 5, sourcename);
SQ_OPT_INTEGER(v, 6, port, 3306);
SQ_OPT_STRING(v, 7, sockname, NULL);
SQ_OPT_INTEGER(v, 8, optflags, 0);
MYSQL *self=0;
if(load_libmysqlclient(dynamicLibName))
{
self = dlmysql_init(NULL);
if (!self) return sq_throwerror(v, _SC("error connecting: Out of memory."));
if (!dlmysql_real_connect(self, host, username, password, sourcename, port, sockname, optflags))
{
SQRESULT res = sq_throwerror(v, _SC("error connecting to database. MySQL: %s"), dlmysql_error(self));
dlmysql_close (self); /* Close conn if connect failed */
return res;
}
}
else return sq_throwerror(v, _SC("Failed to load libmysqlclient !"));
sq_setinstanceup(v, 1, self);
sq_setreleasehook(v,1, sq_mysql_releasehook);
//save a weakref to allow statement return it's db
sq_pushuserpointer(v, self);
sq_weakref(v, 1);
sq_setonregistrytable(v);
return 1;
}
/*
* invoke contact event
*/
static SQBool invokeContactEvent(HSQUIRRELVM v, ContactPoint cp) {
SQBool result = false;
SQInteger top = sq_gettop(v);
sq_pushroottable(v);
sq_pushstring(v, "emo", -1);
if (SQ_SUCCEEDED(sq_get(v, -2))) {
sq_pushstring(v, "_onContact", -1);
if(SQ_SUCCEEDED(sq_get(v, -2))) {
sq_pushroottable(v);
switch(cp.state) {
case b2_addState:
sq_pushinteger(v, PHYSICS_STATE_ADD);
break;
case b2_persistState:
sq_pushinteger(v, PHYSICS_STATE_PERSIST);
break;
case b2_removeState:
sq_pushinteger(v, PHYSICS_STATE_REMOVE);
break;
default:
sq_pushinteger(v, PHYSICS_STATE_NULL);
}
sq_pushuserpointer(v, cp.fixtureA);
sq_pushuserpointer(v, cp.fixtureB);
sq_pushuserpointer(v, cp.fixtureA->GetBody());
sq_pushuserpointer(v, cp.fixtureB->GetBody());
pushVec2(v, cp.position);
pushVec2(v, cp.normal);
sq_pushfloat(v, cp.normalImpulse);
sq_pushfloat(v, cp.tangentImpulse);
result = SQ_SUCCEEDED(sq_call(v, 10, SQFalse, SQTrue));
}
}
sq_settop(v,top);
return result;
}
static SQInteger sq_ffi_load(HSQUIRRELVM v)
{
const SQChar *fname;
sq_getstring(v, 2, &fname);
void *mod = OPEN_LIB(fname);
if (!mod)
return sq_throwerror(v, "Cannot load library");
sq_pushuserpointer(v, mod);
void **p = (void**)sq_newuserdata(v, sizeof(mod));
*p = mod;
sq_push_delegate_table(v, FFI_LIB_LIB_TAG);
sq_setdelegate(v, -2);
return 1;
}
bool SquirrelScriptContext::RegisterFunction(FunctionDesc* desc)
{
SquirrelFunctionInfo* info = new SquirrelFunctionInfo();
info->m_desc = desc;
info->m_context = this;
sq_pushroottable(m_vm);
sq_pushstring(m_vm, desc->m_name, -1);
sq_pushuserpointer(m_vm, info);
sq_newclosure(m_vm, SquirrelFunctionCallback, 1);
sq_createslot(m_vm, -3);
sq_pop(m_vm, 1);
m_functions.push_back(info);
return true;
}
int Xml_load (HSQUIRRELVM v) {
SQ_FUNC_VARS_NO_TOP(v);
SQ_GET_STRING(v, 2, filename);
FILE * file=fopen(filename,"r");
if(!file) return sq_throwerror(v, _SC("SQXml ERROR: \"%s\" file error or file not found!"),filename);
fseek (file , 0 , SEEK_END);
size_t sz = ftell (file);
rewind (file);
char* buffer = (char*)sq_malloc(sz+1);
sz = fread (buffer,1,sz,file);
fclose(file);
buffer[sz]=0;
sq_pushuserpointer(v,buffer);
sq_replace(v,2);
return Xml_eval(v);
};
// handle fopen(string path, string mode)
// Open file
// 'mode' may be either one of modes used by fopen() function in libc or one of these values:
// READ_ONLY - open for reading only (the file must exist);
// WRITE_ONLY - open for writing only;
// READ_WRITE - open for both reading and writing (the file must exist);
// APPEND - open for appending (writing data at the end of the file).
static SQInteger FOpen (HSQUIRRELVM)
{
if (numFiles == MAX_OPENED_FILES)
{
PrintError("ERROR: Too many opened files.\n");
sq_pushnull(sqvm);
return 1;
}
// Find first unopened file
unsigned i;
for (i = 0; i < MAX_OPENED_FILES; ++i)
{
if (!files[i])
break;
}
const SQChar *path, *mode;
sq_getstring(sqvm, 2, &path);
sq_getstring(sqvm, 3, &mode);
// Binary file I/O isn't provided to scripts
// FIXME: Wouldn't binary file I/O be useful?
SQChar* c = (SQChar*)strchr(mode, 'b');
if (c)
*c = 0;
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
if (fopen_s(&files[i], ConvPath(path, SQTrue), mode))
files[i] = NULL;
#else
files[i] = fopen(ConvPath(path, SQTrue), mode);
#endif
FILE* res = files[i];
if (res)
{
sq_pushuserpointer(sqvm, res);
++numFiles;
_RPT2(_CRT_WARN, "--- Opened file #%d. %d file(s) are opened.\n", i, numFiles);
}
else
sq_pushnull(sqvm);
return 1;
}
// 初期化用
void
TJSObject::init(HSQUIRRELVM vm)
{
// squirrel インスタンスを TJS側で保持するためのIDを取得
classId = TJSRegisterNativeClass(L"SquirrelClass");
// TJSObjectクラスを定義
SQTemplate<TJSObject, sqobject::Object> cls(vm);
// メソッド登録
sq_pushroottable(vm);
sq_pushstring(vm, _SC("createTJSClass"), -1);
sq_newclosure(vm, createTJSClass, 0);
sq_createslot(vm, -3);
sq_pushstring(vm, _SC("tjsNull"), -1);
sq_pushuserpointer(vm, NULL);
sq_createslot(vm, -3);
sq_pop(vm, 1);
}
static SQInteger _mod_fopen(HSQUIRRELVM v) {
const SQChar *fname,*how;
sq_getstring(v,2,&fname);
sq_getstring(v,3,&how);
if(fname) {
char fullname[512];
if(fname[0]=='/')
sprintf(fullname,"%s",fname);
else
sprintf(fullname,"%s/%s",__pSQ->ctx()->_dir_home,fname);
FILE* pf = fopen(fullname, how);
if(pf) {
// ::fcntl(fileno(pf), F_SETFD, FD_CLOEXEC);
sq_pushuserpointer(v,(SQUserPointer)pf);
return 1;
}
}
// ?? ERROR handling
return 0;
}
SQRESULT NitLibCom(HSQUIRRELVM v)
{
NitLibCom::Register(v);
NitBindComTypeLib::Register(v);
NitBindCom* com = new NitBindCom(v);
sq_pushroottable(v);
sq_pushstring(v, "com", -1);
NitBind::push(v, com);
sq_newslot(v, -3, true);
sq_poptop(v);
// Prevent deletion from registry
sq_pushregistrytable(v);
sq_pushuserpointer(v, com);
NitBind::push(v, com);
sq_newslot(v, -3, true);
sq_poptop(v);
return SQ_OK;
}
SQRESULT sqstd_createfile(HSQUIRRELVM v, SQFILE file,SQBool own)
{
SQInteger top = sq_gettop(v);
sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_file"),-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) {
sq_remove(v,-2); //removes the registry
sq_pushroottable(v); // push the this
sq_pushuserpointer(v,file); //file
if(own){
sq_pushinteger(v,1); //true
}
else{
sq_pushnull(v); //false
}
if(SQ_SUCCEEDED( sq_call(v,3,SQTrue,SQFalse) )) {
sq_remove(v,-2);
return SQ_OK;
}
}
sq_settop(v,top);
return SQ_OK;
}
SQInteger _VwSetTimerInternal(HSQUIRRELVM v, TIMERPROC lpTimerFunc)
{
SQInteger nargs = sq_gettop(v);
SQInteger Handle = 0;
SQInteger uElapse = 0;
LPCTSTR pstrFunc = NULL;
SetTimerParam* pTimerParam = NULL;
SQUserPointer nRet = NULL;
if (!v || 3 + 1 != nargs) {goto _Exit_;}
if (OT_INTEGER != sq_gettype(v, 2)) {goto _Exit_;}
if (OT_STRING != sq_gettype(v, 3)) {goto _Exit_;}
if (OT_INSTANCE != sq_gettype(v, 4)) {goto _Exit_;}
sq_getinteger(v, 2, &uElapse);
sq_getstring(v, 3, &pstrFunc);
pTimerParam = new SetTimerParam();
pTimerParam->v = v;
pTimerParam->sFunc = pstrFunc;
sq_getstackobj(v, 4, &pTimerParam->Obj);
CScriptMgr* pMgr = (CScriptMgr*)sq_getforeignptr(v);
if (!pMgr) {goto _Exit_;}
CPaintManagerUI* pPM = pMgr->GetManager();
if (!pPM) {goto _Exit_;}
if (NULL != ::SetTimer(pPM->GetPaintWindow(), (UINT_PTR)pTimerParam, uElapse, lpTimerFunc)) {
nRet = (SQUserPointer)pTimerParam;
} else {
nRet = NULL;
}
_Exit_:
sq_pushuserpointer(v, nRet);
return 1;
}
void Interactive(HSQUIRRELVM v)
{
#define MAXINPUT 1024
SQChar buffer[MAXINPUT];
SQInteger blocks =0;
SQInteger string=0;
SQInteger retval=0;
SQInteger done=0;
PrintVersionInfos();
sq_pushroottable(v);
sq_pushstring(v,_SC("quit"),-1);
sq_pushuserpointer(v,&done);
sq_newclosure(v,quit,1);
sq_setparamscheck(v,1,NULL);
sq_newslot(v,-3,SQFalse);
sq_pop(v,1);
while (!done)
{
SQInteger i = 0;
scprintf(_SC("\nsq>"));
for(;;) {
int c;
if(done)return;
c = getchar();
if (c == _SC('\n')) {
if (i>0 && buffer[i-1] == _SC('\\'))
{
buffer[i-1] = _SC('\n');
}
else if(blocks==0)break;
buffer[i++] = _SC('\n');
}
else if (c==_SC('}')) {blocks--; buffer[i++] = (SQChar)c;}
else if(c==_SC('{') && !string){
blocks++;
buffer[i++] = (SQChar)c;
}
else if(c==_SC('"') || c==_SC('\'')){
string=!string;
buffer[i++] = (SQChar)c;
}
else if (i >= MAXINPUT-1) {
scfprintf(stderr, _SC("sq : input line too long\n"));
break;
}
else{
buffer[i++] = (SQChar)c;
}
}
buffer[i] = _SC('\0');
if(buffer[0]==_SC('=')){
scsprintf(sq_getscratchpad(v,MAXINPUT),_SC("return (%s)"),&buffer[1]);
memcpy(buffer,sq_getscratchpad(v,-1),(scstrlen(sq_getscratchpad(v,-1))+1)*sizeof(SQChar));
retval=1;
}
i=scstrlen(buffer);
if(i>0){
SQInteger oldtop=sq_gettop(v);
if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,_SC("interactive console"),SQTrue))){
sq_pushroottable(v);
if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) && retval){
scprintf(_SC("\n"));
sq_pushroottable(v);
sq_pushstring(v,_SC("print"),-1);
sq_get(v,-2);
sq_pushroottable(v);
sq_push(v,-4);
sq_call(v,2,SQFalse,SQTrue);
retval=0;
scprintf(_SC("\n"));
}
}
sq_settop(v,oldtop);
}
}
}
template <> inline int Return<void *> (HSQUIRRELVM vm, void *res) { sq_pushuserpointer(vm, res); return 1; }
/*
** Copies values from State src to State dst.
*/
static SQRESULT copy_values_between_vms (HSQUIRRELVM dst, HSQUIRRELVM src, int argc, int argIdx)
{
SQRESULT _rc_;
sq_reservestack(dst, argc + 20);
argc += argIdx; //we will work with argc args starting at argIdx
for (; argIdx < argc; argIdx++)
{
switch (sq_gettype(src, argIdx))
{
case OT_INTEGER:
SQ_GET_INTEGER(src, argIdx, vint);
sq_pushinteger(dst, vint);
break;
case OT_FLOAT:
SQ_GET_FLOAT(src, argIdx, vfloat);
sq_pushfloat (dst, vfloat);
break;
case OT_BOOL:
SQ_GET_BOOL(src, argIdx, vbool);
sq_pushbool (dst, vbool);
break;
case OT_STRING:
{
SQ_GET_STRING(src, argIdx, vstr)
sq_pushstring (dst, vstr, vstr_size);
}
break;
case OT_ARRAY:
{
SQInteger size = sq_getsize(src, argIdx);
sq_newarray(dst, size);
for(SQInteger i=0; i<size; ++i)
{
sq_pushinteger(src, i);
sq_get(src, -2);
sq_pushinteger(dst, i);
if(copy_values_between_vms(dst, src, 1, sq_gettop(src)) != SQ_OK) return SQ_ERROR;
sq_poptop(src);
sq_set(dst, -3);
}
}
break;
case OT_TABLE:
{
sq_newtable(dst);
sq_pushnull(src);
while(sq_next(src, -2) == SQ_OK)
{
SQInteger src_top = sq_gettop(src);
if(copy_values_between_vms(dst, src, 1, src_top-1) != SQ_OK
|| copy_values_between_vms(dst, src, 1, src_top) != SQ_OK) return SQ_ERROR;
sq_newslot(dst, -3, SQFalse);
sq_pop(src, 2);
}
sq_pop(src,1);
}
break;
case OT_USERPOINTER:
{
SQUserPointer ptr;
sq_getuserpointer(src, argIdx, &ptr);
sq_pushuserpointer(dst, ptr);
}
break;
case OT_NULL:
sq_pushnull(dst);
break;
default:
return SQ_ERROR;
}
}
return SQ_OK;
}
void SquirrelVM::PushParam(SQUserPointer up)
{
_CHECK_CALL_STATE
sq_pushuserpointer(_VM,up);
_CallState++;
}
void sq_pushentity(SQVM* pVM, CEntity* pEntity)
{
sq_pushuserpointer(pVM,(SQUserPointer)pEntity->GetID());
}
