int endelement(HSQUIRRELVM v)
{
SQUserPointer up;
const SQChar *name;
sq_getuserpointer(v,-1,&up);
SQDbgServer *self = (SQDbgServer*)up;
sq_getuserpointer(v,-1,&up);
sq_getstring(v,2,&name);
self->EndElement(name);
return 0;
}
int attribute(HSQUIRRELVM v)
{
SQUserPointer up;
const SQChar *name,*value;
sq_getuserpointer(v,-1,&up);
SQDbgServer *self = (SQDbgServer*)up;
sq_getuserpointer(v,-1,&up);
sq_getstring(v,2,&name);
sq_getstring(v,3,&value);
self->Attribute(name,value);
return 0;
}
int SquirrelScriptContext::SquirrelClassMethodCallback(HSQUIRRELVM vm)
{
// Get class info
MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER );
void* userPtr = NULL;
sq_getuserpointer(vm, -1, &userPtr);
sq_pop(vm, 1);
SquirrelClassInfo* classInfo = (SquirrelClassInfo*) userPtr;
// Get method index
MultiScriptAssert( sq_gettype(vm, -1) == OT_INTEGER );
int methodIndex;
sq_getinteger(vm, -1, &methodIndex);
sq_pop(vm, 1);
// Get the instance
MultiScriptAssert( sq_gettype(vm, 1) == OT_INSTANCE );
sq_getinstanceup(vm, 1, &userPtr, 0);
SquirrelScriptObject* scriptObject = (SquirrelScriptObject*) userPtr;
MultiScriptAssert(scriptObject->m_objectPtr);
SquirrelScriptStack stack(classInfo->m_context, false);
const bool result = classInfo->m_desc->m_methods[methodIndex].m_method(scriptObject, &stack);
MultiScriptAssert( result );
return stack.m_numPushed;
}
int SquirrelScriptContext::SquirrelClassToStringMethodCallback(HSQUIRRELVM vm)
{
// Get class info
MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER );
void* userPtr = NULL;
sq_getuserpointer(vm, -1, &userPtr);
sq_pop(vm, 1);
SquirrelClassInfo* classInfo = (SquirrelClassInfo*) userPtr;
// Get the instance
MultiScriptAssert( sq_gettype(vm, 1) == OT_INSTANCE );
sq_getinstanceup(vm, 1, &userPtr, 0);
SquirrelScriptObject* scriptObject = (SquirrelScriptObject*) userPtr;
MultiScriptAssert(scriptObject->m_objectPtr);
// Invoke to-string method
char buffer[1 << 8];
if (classInfo->m_desc->m_toStringMethod)
{
SquirrelScriptStack stack(classInfo->m_context, false);
const bool result = classInfo->m_desc->m_toStringMethod(scriptObject, buffer, 1 << 8);
MultiScriptAssert( result );
MultiScriptAssert( stack.m_numPushed == 0 );
}
else
MultiScriptSprintf(buffer, 1 << 8, "[%s]", classInfo->m_desc->m_name);
sq_pushstring(vm, buffer, -1);
return 1;
}
int SquirrelScriptContext::SquirrelClassConstructorCallback(HSQUIRRELVM vm)
{
MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER );
// Get class info
void* userPtr = NULL;
sq_getuserpointer(vm, -1, &userPtr);
sq_pop(vm, 1);
SquirrelClassInfo* classInfo = (SquirrelClassInfo*) userPtr;
// Construct object
SquirrelScriptObject* scriptObject = new SquirrelScriptObject();
scriptObject->m_classInfo = classInfo;
SquirrelScriptStack stack(classInfo->m_context, false);
classInfo->m_desc->m_constructor(&stack, scriptObject);
MultiScriptAssert( scriptObject->m_objectPtr );
MultiScriptAssert( stack.m_numPushed == 0 );
// There is already an instance on the stack (pushed automatically when constructor was invoked from script)
// Attach our object to created instance
sq_setinstanceup(vm, -1, scriptObject);
// Set garbage collection callback for this instance
sq_setreleasehook(vm, -1, SquirrelClassGCCallback);
return 0;
}
SQInteger quit(HSQUIRRELVM v)
{
int *done;
sq_getuserpointer(v,-1,(SQUserPointer*)&done);
*done=1;
return 0;
}
static SQInteger _file_constructor(HSQUIRRELVM v)
{
const SQChar *filename,*mode;
bool owns = true;
SQFile *f;
SQFILE newf;
if(sq_gettype(v,2) == OT_STRING && sq_gettype(v,3) == OT_STRING) {
sq_getstring(v, 2, &filename);
sq_getstring(v, 3, &mode);
newf = sqstd_fopen(filename, mode);
if(!newf) return sq_throwerror(v, _SC("cannot open file"));
} else if(sq_gettype(v,2) == OT_USERPOINTER) {
owns = !(sq_gettype(v,3) == OT_NULL);
sq_getuserpointer(v,2,&newf);
} else {
return sq_throwerror(v,_SC("wrong parameter"));
}
f = new SQFile(newf,owns);
if(SQ_FAILED(sq_setinstanceup(v,1,f))) {
delete f;
return sq_throwerror(v, _SC("cannot create blob with negative size"));
}
sq_setreleasehook(v,1,_file_releasehook);
return 0;
}
static SQInteger _mod_fclose(HSQUIRRELVM v) {
SQUserPointer pd = 0;
sq_getuserpointer(v, 2, &pd);
if(pd) {
fclose((FILE*)pd);
}
return 1;
}
static SQInteger _mod_ftell(HSQUIRRELVM v) {
SQUserPointer pf = 0;
sq_getuserpointer(v, 2, &pf);
if(pf) {
sq_pushinteger(v, ftell((FILE*)pf));
return 1;
}
return -1;
}
static SQInteger _mod_fwrite(HSQUIRRELVM v) {
SQUserPointer pf = 0;
const SQChar* data;
sq_getuserpointer(v, 2, &pf);
sq_getstring(v, 3, &data);
if(pf) {
return (SQInteger)fprintf((FILE*)pf,"%s", data);
}
return 0;
}
CEntity* sq_toentity(SQVM* pVM, int idx)
{
SQUserPointer ptr;
if(SQ_SUCCEEDED(sq_getuserpointer(pVM,idx,&ptr)))
{
CEntity* pEntity = CEntityIDs::Get( (int)ptr );
if( pEntity )
return pEntity;
}
return NULL;
}
static SQRESULT squirrel_get_allocator(HSQUIRRELVM v,
WasmAllocator** out_allocator) {
SQUserPointer allocator_up;
sq_pushregistrytable(v);
sq_pushstring(v, WASM_ALLOCATOR_NAME, -1);
CHECK_SQ_RESULT(sq_get(v, -2));
CHECK_SQ_RESULT(sq_getuserpointer(v, -1, &allocator_up));
*out_allocator = allocator_up;
sq_pop(v, 2);
return SQ_OK;
}
static SQInteger _mod_fsize(HSQUIRRELVM v) {
SQUserPointer pf = 0;
sq_getuserpointer(v, 2, &pf);
if(pf) {
struct stat stt;
if(fstat(fileno((FILE*)pf), &stt)) {
sq_pushinteger(v, stt.st_size);
return stt.st_size;
}
}
return -1;
}
static SQInteger sq_ffi_sym(HSQUIRRELVM v)
{
void *mod;
const SQChar *symname;
sq_getuserpointer(v, 2, &mod);
sq_getstring(v, 3, &symname);
void *sym = GET_SYM(mod, symname);
printf("GET_SYM(%s) = %p\n", symname, sym);
if (!sym)
return sq_throwerror(v, "Cannot find symbol");
void **p = (void**)sq_newuserdata(v, sizeof(sym));
*p = sym;
return 1;
}
static SQInteger _mod_fseek(HSQUIRRELVM v) {
SQUserPointer pf = 0;
SQInteger seek;
SQInteger pos;
sq_getuserpointer(v, 2, &pf);
sq_getinteger(v, 3, &seek);
sq_getinteger(v, 4, &pos);
if(pf) {
fseek((FILE*)pf,seek,pos);
return 1;
}
return 0;
}
int SquirrelScriptContext::SquirrelFunctionCallback(HSQUIRRELVM vm)
{
MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER );
void* userPtr = NULL;
sq_getuserpointer(vm, -1, &userPtr);
sq_pop(vm, 1);
SquirrelFunctionInfo* info = (SquirrelFunctionInfo*) userPtr;
SquirrelScriptStack stack(info->m_context, false);
const bool result = info->m_desc->m_function(&stack);
MultiScriptAssert( result );
return stack.m_numPushed;
}
// Get file from Squirrel stack
static FILE* GetFile ()
{
FILE* file;
sq_getuserpointer(sqvm, 2, (SQUserPointer*)&file);
if (file)
{
if (file == stdout || file == stderr)
return file;
for (unsigned i = 0; i < MAX_OPENED_FILES; ++i)
{
if (file == files[i])
return file;
}
}
return NULL;
}
// fclose(handle file)
// Close file
static SQInteger FClose (HSQUIRRELVM)
{
FILE* file;
sq_getuserpointer(sqvm, 2, (SQUserPointer*)&file);
if (file)
{
for (unsigned i = 0; i < MAX_OPENED_FILES; ++i)
{
if (file != files[i])
continue;
fclose(file);
files[i] = NULL;
--numFiles;
_RPT2(_CRT_WARN, "--- Closed file #%d. %d file(s) are still opened.\n", i, numFiles);
break;
}
}
return 0;
}
/*
* get instance member value as user pointer
*/
bool getInstanceMemberAsUserPointer(HSQUIRRELVM v, int idx,
const char *cname, const char *name, SQUserPointer* value) {
if (sq_gettype(v, idx) == OT_NULL) return false;
sq_pushstring(v, cname, -1);
if (!SQ_SUCCEEDED(sq_get(v, idx))) {
sq_pop(v, 1);
return false;
}
sq_pushstring(v, name, -1);
if (!SQ_SUCCEEDED(sq_get(v, -2))) {
sq_pop(v, 2);
return false;
}
if (sq_gettype(v, -1) != OT_USERPOINTER) {
sq_pop(v, 2);
return false;
}
sq_getuserpointer(v, -1, value);
sq_pop(v, 2);
return true;
}
static ffi_type *get_ffi_type(HSQUIRRELVM v, int idx)
{
int type = sq_gettype(v, idx);
void *p;
const SQChar *s;
ffi_type *t;
switch (type) {
case OT_USERPOINTER:
sq_getuserpointer(v, idx, &p);
return (ffi_type*)p;
case OT_STRING:
sq_getstring(v, idx, &s);
t = char2ffi_type(*s);
if (t)
return t;
default:
sq_throwerror(v, "Type spec must be string or ffi_type");
return NULL;
}
}
static SQInteger _mod_fread(HSQUIRRELVM v) {
SQUserPointer pf = 0;
SQInteger bytes;
sq_getuserpointer(v, 2, &pf);
sq_getinteger(v, 3, &bytes);
if(pf) {
char* pc = new char[bytes+1];
if(pc) {
bytes = fread(pc, 1, bytes, (FILE*)pf);
if(bytes>0) {
pc[bytes] = 0;
sq_pushstring(v, pc, bytes);
delete[] pc;
return 1;
}
sq_pushstring(v, "", 0);
delete[] pc;
}
}
return 0;
}
// BOOL VwKillTimer(SQInteger uIDEvent)
SQInteger VwKillTimer(HSQUIRRELVM v)
{
SQUserPointer uIDEvent = 0;
SQInteger nargs = sq_gettop(v);
if (!v || 1 + 1 != nargs) {goto _Exit_;}
if (OT_USERPOINTER != sq_gettype(v, 2)) {goto _Exit_;}
sq_getuserpointer(v, 2, &uIDEvent);
CScriptMgr* pMgr = (CScriptMgr*)sq_getforeignptr(v);
if (!pMgr) {goto _Exit_;}
CPaintManagerUI* pPM = pMgr->GetManager();
if (!pPM) {goto _Exit_;}
::KillTimer(pPM->GetPaintWindow(), (UINT_PTR)uIDEvent);
delete (SetTimerParam*)uIDEvent;
_Exit_:
sq_pushbool(v, TRUE);
return 1;
}
static SQInteger _mod_fgets(HSQUIRRELVM v) {
SQUserPointer pf = 0;
char* bytes;
sq_getuserpointer(v, 2, &pf);
if(pf) {
if(feof((FILE*)pf))
{
sq_pushstring(v, "", 0);
return 0;
}
char local[256] = {0};
bytes = fgets(local, 255, (FILE*)pf);
if(bytes)
{
const char* pl = str_deleol(local);
size_t len = strlen(pl);
sq_pushstring(v, pl, len);
return len;
}
sq_pushstring(v, "", 0);
}
return 0;
}
int SquirrelScriptContext::SquirrelClassDestructorCallback(HSQUIRRELVM vm)
{
// Get class info
MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER );
void* userPtr = NULL;
sq_getuserpointer(vm, -1, &userPtr);
sq_pop(vm, 1);
SquirrelClassInfo* classInfo = (SquirrelClassInfo*) userPtr;
// Get the instance
MultiScriptAssert( sq_gettype(vm, 1) == OT_INSTANCE );
sq_getinstanceup(vm, 1, &userPtr, 0);
SquirrelScriptObject* scriptObject = (SquirrelScriptObject*) userPtr;
MultiScriptAssert(scriptObject->m_objectPtr);
// Invoke user supplied destructor
scriptObject->m_lockedByScript = true;
classInfo->m_desc->m_destructor(scriptObject);
scriptObject->m_lockedByScript = false;
scriptObject->m_objectPtr = NULL;
return 0;
}
int Xml_eval(HSQUIRRELVM v) {
SQ_FUNC_VARS_NO_TOP(v);
SQChar* str = 0;
size_t str_size=0;
if(sq_gettype(v,2) == OT_USERPOINTER) sq_getuserpointer(v, 2, &str);
else {
SQ_GET_STRING(v, 2, sTmp);
str = (SQChar*)sq_malloc(sTmp_size+(sizeof(SQChar)));
memcpy(str, sTmp, sTmp_size);
str[sTmp_size]=0;
str_size = sTmp_size;
}
Tokenizer* tok = Tokenizer_new(str, str_size ? str_size : scstrlen(str));
sq_settop(v,0);
const SQChar* token=0;
int firstStatement = 1;
while((token=Tokenizer_next(tok))!=0) if(token[0]==OPN) { // new tag found
if(sq_gettop(v)) {
int newIndex=sq_size(v,-1)+1;
sq_pushinteger(v,newIndex);
sq_newtable(v);
sq_set(v, -3);
sq_pushinteger(v,newIndex);
sq_get(v,-2);
}
else {
if (firstStatement) {
sq_newtable(v);
firstStatement = 0;
}
else return lua_gettop(L);
}
// set metatable:
sq_newtable(v);
sq_pushliteral(v, _SC("__index"));
sq_getglobal(v, "xml");
lua_settable(v, -3);
sq_pushliteral(v, _SC("__tostring")); // set __tostring metamethod
lua_getglobal(L, "xml");
lua_pushliteral(L,"str");
lua_gettable(v, -2);
sq_remove(v, -2);
sq_set(v, -3);
lua_setmetatable(L, -2);
// parse tag and content:
sq_pushinteger(v,0); // use index 0 for storing the tag
sq_pushstring(v, Tokenizer_next(tok), -1);
sq_set(v, -3);
while(((token = Tokenizer_next(tok))!=0)&&(token[0]!=CLS)&&(token[0]!=ESC)) { // parse tag header
size_t sepPos=find(token, "=", 0);
if(token[sepPos]) { // regular attribute
const SQChar* aVal =token+sepPos+2;
sq_pushstring(v, token, sepPos);
size_t lenVal = strlen(aVal)-1;
if(!lenVal) Xml_pushDecode(v, _SC(""), 0);
else Xml_pushDecode(v, aVal, lenVal);
sq_set(v, -3);
}
}
if(!token||(token[0]==ESC)) {
if(sq_gettop(v)>1) sq_settop(v,-2); // this tag has no content, only attributes
else break;
}
}
else if(token[0]==ESC) { // previous tag is over
if(sq_gettop(v)>1) sq_settop(v,-2); // pop current table
else break;
}
else { // read elements
sq_pushinteger(v,sq_size(v,-1)+1);
Xml_pushDecode(v, token, 0);
sq_rawset(v, -3);
}
Tokenizer_delete(tok);
sq_free(str);
return sq_gettop(v);
}
template <> inline void *GetParam(ForceType<void *> , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer tmp; sq_getuserpointer(vm, index, &tmp); return tmp; }
/*
** 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* CSquirrelVM::GetUserData(int idx)
{
SQUserPointer p;
sq_getuserpointer(m_pVM, -1, &p);
return (void*)p;
}
