static void _addrexmatch(HSQUIRRELVM v,const SQChar *str,const SQChar *begin,const SQChar *end)
{
sq_newtable(v);
sq_pushstring(v,_SC("begin"),-1);
sq_pushinteger(v,begin - str);
sq_rawset(v,-3);
sq_pushstring(v,_SC("end"),-1);
sq_pushinteger(v,end - str);
sq_rawset(v,-3);
}
void CSquirrelVM::PushTable(const CScriptArguments &table)
{
sq_newtable(m_pVM);
for(auto iter = table.m_Arguments.begin(); iter != table.m_Arguments.end(); iter++)
{
(*iter)->Push(this);
++iter;
(*iter)->Push(this);
sq_createslot(m_pVM, -3);
}
}
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;
}
bool CSquirrelArgument::push(SQVM* pVM)
{
switch(type)
{
case OT_NULL:
sq_pushnull(pVM);
break;
case OT_INTEGER:
sq_pushinteger(pVM, data.i);
break;
case OT_BOOL:
sq_pushbool(pVM, data.b);
break;
case OT_FLOAT:
sq_pushfloat(pVM, data.f);
break;
case OT_STRING:
sq_pushstring(pVM, data.str->Get(), data.str->GetLength());
break;
case OT_ARRAY:
{
sq_newarray(pVM, 0);
for(auto pArgument : *data.pArray->GetArguments())
{
pArgument->push(pVM);
sq_arrayappend(pVM, -2);
}
break;
}
case OT_TABLE:
{
sq_newtable(pVM);
int i = 0;
assert( data.pArray->GetArguments()->size() % 2 == 0 );
for(auto iter = data.pArray->GetArguments()->begin(); iter != data.pArray->GetArguments()->end(); ++ iter, ++ i )
{
(*iter)->push(pVM);
++ iter;
(*iter)->push(pVM);
sq_createslot(pVM, -3);
}
break;
}
break;
default:
sq_pushnull(pVM); // table, whatsoever. do not even care. fix it if you dare.
assert(0);
return false;
}
return true;
}
static SQInteger base_getstackinfos(HSQUIRRELVM v)
{
SQInteger level;
SQStackInfos si;
SQInteger seq = 0;
const SQChar *name = NULL;
sq_getinteger(v, -1, &level);
if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
{
const SQChar *fn = _SC("unknown");
const SQChar *src = _SC("unknown");
if(si.funcname)fn = si.funcname;
if(si.source)src = si.source;
sq_newtable(v);
sq_pushstring(v, _SC("func"), -1);
sq_pushstring(v, fn, -1);
sq_createslot(v, -3);
sq_pushstring(v, _SC("src"), -1);
sq_pushstring(v, src, -1);
sq_createslot(v, -3);
sq_pushstring(v, _SC("line"), -1);
sq_pushinteger(v, si.line);
sq_createslot(v, -3);
sq_pushstring(v, _SC("locals"), -1);
sq_newtable(v);
seq=0;
while ((name = sq_getlocal(v, level, seq))) {
sq_pushstring(v, name, -1);
sq_push(v, -2);
sq_createslot(v, -4);
sq_pop(v, 1);
seq++;
}
sq_createslot(v, -3);
return 1;
}
return 0;
}
SQInteger Sq_GetLevelTbl(HSQUIRRELVM v) {
const SQChar *Search;
sq_getstring(v, 2, &Search);
char Search2[strlen(Search)+1];
strcpy(Search2, Search);
cJSON *Find = cJSON_Search(LevelJSON, Search2);
if(Find) {
sq_newtable(v);
Sq_DecodeJSONTable(v, Find->child);
}
else sq_pushnull(v);
return 1;
}
/**
* グローバルメソッド登録
*/
void
Thread::registerGlobal()
{
// メソッド登録（名前つき）
#define REGISTERMETHODNAME(name, method) \
sq_pushstring(v, _SC(#name), -1);\
sq_newclosure(v, method, 0);\
sq_createslot(v, -3);
// enum 登録（名前つき）
#define REGISTERENUM(name, value) \
sq_pushstring(v, _SC(#name), -1); /* 名前を push */ \
sq_pushinteger(v, value); /* 値を push */ \
sq_createslot(v, -3) /* テーブルに登録 */
HSQUIRRELVM v = getGlobalVM();
// グローバルメソッドの登録
sq_pushroottable(v); // root
REGISTERMETHODNAME(getCurrentTick, global_getCurrentTick);
REGISTERMETHODNAME(getDiffTick, global_getDiffTick);
REGISTERMETHODNAME(getCurrentThread, global_getCurrentThread);
REGISTERMETHODNAME(getThreadList, global_getThreadList);
REGISTERMETHODNAME(fork, global_fork);
REGISTERMETHODNAME(exec, global_exec);
REGISTERMETHODNAME(exit, global_exit);
REGISTERMETHODNAME(system, global_system);
REGISTERMETHODNAME(wait, global_wait);
REGISTERMETHODNAME(notify, global_trigger);
REGISTERMETHODNAME(execOnBase, global_execOnBase);
sq_pop(v, 1); // root
// 定数の登録
sq_pushconsttable(v); // consttable
sq_pushstring(v, _SC("THREADSTATUS"), -1); // テーブル名を push
sq_newtable(v); // 新しい enum テーブル
REGISTERENUM(NONE,THREAD_NONE);
REGISTERENUM(LOADING_FILE,THREAD_LOADING_FILE);
REGISTERENUM(LOADING_FUNC,THREAD_LOADING_FUNC);
REGISTERENUM(STOP,THREAD_STOP);
REGISTERENUM(RUN,THREAD_RUN);
REGISTERENUM(WAIT,THREAD_WAIT);
sq_createslot(v, -3); /* テーブルに登録 */
sq_pop(v, 1); // consttable
}
HSQUIRRELVM Sq_Open(const char *File) {
HSQUIRRELVM v;
v = sq_open(1024);
sqstd_seterrorhandlers(v);
sq_setprintfunc(v, Sq_PrintFunc,Sq_ErrorFunc);
sq_pushroottable(v);
sqstd_register_mathlib(v);
sqstd_register_stringlib(v);
sq_pop(v,1);
sq_pushroottable(v);
sq_pushstring(v, "api", -1);
sq_newtable(v);
sq_newslot(v,-3,SQFalse);
sq_pushstring(v, "api", -1);
sq_get(v, -2);
Sq_RegisterFunc(v, Sq_StrToL, "Num", 2, "si");
Sq_RegisterFunc(v, Sq_MessageBox, "MessageBox", 1, "s");
Sq_RegisterFunc(v, Sq_AskForInput, "AskForInput", 1, "s");
Sq_RegisterFunc(v, Sq_GetLevelJSON, "GetLevelJSON", 1, "si.");
Sq_RegisterFunc(v, Sq_SetLevelJSON, "SetLevelJSON", 2, "s.");
Sq_RegisterFunc(v, Sq_GetLayerRects, "GetLayerRects", 2, "s");
Sq_RegisterFunc(v, Sq_SetLayerRects, "SetLayerRects", 2, "sa");
Sq_RegisterFunc(v, Sq_GetLayerMap, "GetLayerMap", -1, "siiii");
Sq_RegisterFunc(v, Sq_SetLayerMap, "SetLayerMap", -2, "saiiii");
Sq_RegisterFunc(v, Sq_RegisterExport, "RegisterExport", 2, "cs");
Sq_RegisterFunc(v, Sq_RegisterMenu, "RegisterMenu", 2, "cs");
Sq_RegisterFunc(v, Sq_ExportOpen, "ExportOpen", 1, "s");
Sq_RegisterFunc(v, Sq_ExportWrite, "ExportWrite", 2, "is");
Sq_RegisterFunc(v, Sq_ExportClose, "ExportClose", 1, "i");
Sq_RegisterFunc(v, Sq_GetInfo, "GetInfo", 1, "s");
Sq_RegisterFunc(v, Sq_GetLevelInt, "GetLevelInt", 2, "is");
Sq_RegisterFunc(v, Sq_GetLevelStr, "GetLevelStr", 2, "ss");
Sq_RegisterFunc(v, Sq_GetLevelTbl, "GetLevelTbl", 1, "s");
Sq_RegisterFunc(v, Sq_DecodeJSON, "DecodeJSON", 1, "s");
Sq_RegisterFunc(v, Sq_Interpolate, "Interpolate", 3, "ssa");
sq_pop(v,1); // pop api table
Sq_DoFile(v, "data/common.nut");
if(File) Sq_DoFile(v, File);
return v;
}
void
Statistics::serialize_to_squirrel(HSQUIRRELVM vm)
{
// TODO: there's some bug in the unserialization routines that breaks stuff when an empty statistics table is written, so -- as a workaround -- let's make sure we will actually write something first
if (!((coins != nv_coins) || (total_coins != nv_coins) || (badguys != nv_badguys) || (total_badguys != nv_badguys) || (time != nv_time) || (secrets != nv_secrets) || (total_secrets != nv_secrets))) return;
sq_pushstring(vm, "statistics", -1);
sq_newtable(vm);
if (coins != nv_coins) scripting::store_int(vm, "coins-collected", coins);
if (total_coins != nv_coins) scripting::store_int(vm, "coins-collected-total", total_coins);
if (badguys != nv_badguys) scripting::store_int(vm, "badguys-killed", badguys);
if (total_badguys != nv_badguys) scripting::store_int(vm, "badguys-killed-total", total_badguys);
if (time != nv_time) scripting::store_float(vm, "time-needed", time);
if (secrets != nv_secrets) scripting::store_int(vm, "secrets-found", secrets);
if (total_secrets != nv_secrets) scripting::store_int(vm, "secrets-found-total", total_secrets);
if(SQ_FAILED(sq_createslot(vm, -3)))
throw scripting::SquirrelError(vm, "Couldn't create statistics table");
}
// getConfig()
SQInteger CServerNatives::GetConfig(SQVM * pVM)
{
// Create a new table
sq_newtable(pVM);
for(std::map<String, SettingsValue *>::iterator iter = CSettings::GetValues()->begin(); iter != CSettings::GetValues()->end(); iter++)
{
// Get the setting
SettingsValue * setting = iter->second;
// Push the setting name onto the stack
sq_pushstring(pVM, iter->first.Get(), iter->first.GetLength());
// Push the value onto the stack
if(setting->IsBool())
sq_pushbool(pVM, setting->bValue);
else if(setting->IsInteger())
sq_pushinteger(pVM, setting->iValue);
else if(setting->IsFloat())
sq_pushfloat(pVM, setting->fValue);
else if(setting->IsString())
sq_pushstring(pVM, setting->strValue, setting->strValue.GetLength());
else if(setting->IsList())
{
// Create a new array
sq_newarray(pVM, 0);
for(std::list<String>::iterator iter2 = setting->listValue.begin(); iter2 != setting->listValue.end(); iter2++)
{
// Push the list value onto the stack
sq_pushstring(pVM, (*iter2).Get(), (*iter2).GetLength());
// Create a new array slot
sq_arrayappend(pVM, -2);
}
}
// Create a new table slot
sq_createslot(pVM, -3);
}
return 1;
}
char *ScriptEventAdminPort::ReadTable(HSQUIRRELVM vm, char *p)
{
sq_newtable(vm);
SKIP_EMPTY(p);
if (*p++ != '{') RETURN_ERROR(1);
for (;;) {
SKIP_EMPTY(p);
if (*p++ != '"') RETURN_ERROR(1);
p = ReadString(vm, p);
if (p == NULL) {
sq_pop(vm, 1);
return NULL;
}
SKIP_EMPTY(p);
if (*p++ != ':') RETURN_ERROR(2);
p = this->ReadValue(vm, p);
if (p == NULL) {
sq_pop(vm, 2);
return NULL;
}
sq_rawset(vm, -3);
/* The key (-2) and value (-1) are popped from the stack by squirrel. */
SKIP_EMPTY(p);
if (*p == ',') {
p++;
continue;
}
break;
}
SKIP_EMPTY(p);
if (*p++ != '}') RETURN_ERROR(1);
return p;
}
//------------------------------------------------------------------------------
void SN_API pushTable(HSQUIRRELVM vm, const Variant::Dictionary & d)
{
sq_newtable(vm);
for (auto it = d.begin(); it != d.end(); ++it)
{
// Push key
const std::string & key = it->first;
sq_pushstring(vm, key.c_str(), key.size());
// Push value
const Variant & value = it->second;
pushValue(vm, value);
// Set or create
if (SQ_FAILED(sq_newslot(vm, -3, SQFalse)))
{
SN_WARNING("Variant => Squirrel: failed to set key " << key);
}
}
}
void Sq_DecodeJSONTable(HSQUIRRELVM v, cJSON *Item) {
if(!Item)
return;
while(Item) {
if(Item->string)
sq_pushstring(v, Item->string, -1);
switch(Item->type) {
case cJSON_False:
sq_pushbool(v, SQFalse);
break;
case cJSON_True:
sq_pushbool(v, SQTrue);
break;
case cJSON_NULL:
sq_pushnull(v);
break;
case cJSON_Number:
if(Item->valueint == Item->valuedouble)
sq_pushinteger(v, Item->valueint);
else
sq_pushfloat(v, Item->valuedouble);
break;
case cJSON_String:
sq_pushstring(v, Item->valuestring, -1);
break;
case cJSON_Array:
sq_newarray(v, 0);
Sq_DecodeJSONTable(v, Item->child);
break;
case cJSON_Object:
sq_newtable(v);
Sq_DecodeJSONTable(v, Item->child);
break;
}
if(Item->string)
sq_newslot(v,-3,SQFalse);
else
sq_arrayappend(v, -2);
Item = Item->next;
}
}
SQRESULT sqext_register_sq_zlib(HSQUIRRELVM v)
{
sq_pushliteral(v,_SC("zlib"));
sq_newtable(v);
INT_CONST(v, Z_DEFAULT_COMPRESSION);
INT_CONST(v, Z_BEST_SPEED);
INT_CONST(v, Z_BEST_COMPRESSION);
sq_insertfunc(v, _SC("version"), sq_zlib_version, 1, _SC("."), SQTrue);
sq_insertfunc(v, _SC("deflate"), sq_zlib_deflate, -2, _SC(".si"), SQTrue);
sq_insertfunc(v, _SC("inflate"), sq_zlib_inflate, -2, _SC(".si"), SQTrue);
sq_pushliteral(v,_SC("Unzip"));
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)sq_minizip_unzip_TAG);
sq_insert_reg_funcs(v, sq_minizip_unzip_methods);
sq_newslot(v,-3,SQTrue);
sq_newslot(v,-3,SQTrue); //push zlib table
return 0;
}
static SQInteger _system_date(HSQUIRRELVM v)
{
time_t t;
SQInteger it;
SQInteger format = 'l';
if(sq_gettop(v) > 1) {
sq_getinteger(v,2,&it);
t = it;
if(sq_gettop(v) > 2) {
sq_getinteger(v,3,(SQInteger*)&format);
}
}
else {
time(&t);
}
#if defined( MONASQ )
// tm not supported.
return sq_throwerror(v,_SC("crt api failure"));
#else
tm *date;
if(format == 'u')
date = gmtime(&t);
else
date = localtime(&t);
if(!date)
return sq_throwerror(v,_SC("crt api failure"));
sq_newtable(v);
_set_integer_slot(v, _SC("sec"), date->tm_sec);
_set_integer_slot(v, _SC("min"), date->tm_min);
_set_integer_slot(v, _SC("hour"), date->tm_hour);
_set_integer_slot(v, _SC("day"), date->tm_mday);
_set_integer_slot(v, _SC("month"), date->tm_mon);
_set_integer_slot(v, _SC("year"), date->tm_year+1900);
_set_integer_slot(v, _SC("wday"), date->tm_wday);
_set_integer_slot(v, _SC("yday"), date->tm_yday);
return 1;
#endif
}
SQInteger CSystemNatives::Date(SQVM * pVM)
{
time_t t;
SQInteger it;
SQInteger format = 'l';
if(sq_gettop(pVM) > 1)
{
sq_getinteger(pVM,2,&it);
t = it;
if(sq_gettop(pVM) > 2)
sq_getinteger(pVM, 3, (SQInteger*)&format);
}
else
time(&t);
tm *date;
if(format == 'u')
date = gmtime(&t);
else
date = localtime(&t);
if(!date)
return sq_throwerror(pVM, "crt api failure");
sq_newtable(pVM);
_set_integer_slot(pVM, _SC("sec"), date->tm_sec);
_set_integer_slot(pVM, _SC("min"), date->tm_min);
_set_integer_slot(pVM, _SC("hour"), date->tm_hour);
_set_integer_slot(pVM, _SC("day"), date->tm_mday);
_set_integer_slot(pVM, _SC("month"), date->tm_mon);
_set_integer_slot(pVM, _SC("year"), date->tm_year+1900);
_set_integer_slot(pVM, _SC("wday"), date->tm_wday);
_set_integer_slot(pVM, _SC("yday"), date->tm_yday);
return 1;
}
void get_or_create_table_entry(HSQUIRRELVM vm, const std::string& name)
{
sq_pushstring(vm, name.c_str(), -1);
if(SQ_FAILED(sq_get(vm, -2)))
{
sq_pushstring(vm, name.c_str(), -1);
sq_newtable(vm);
if(SQ_FAILED(sq_createslot(vm, -3)))
{
std::ostringstream msg;
msg << "failed to create '" << name << "' table entry";
throw scripting::SquirrelError(vm, msg.str());
}
else
{
get_table_entry(vm, name);
}
}
else
{
// successfully placed result on stack
}
}
void SQDbgServer::SerializeState(HSQUIRRELVM v)
{
sq_pushnull(v);
sq_setdebughook(v);
sq_pushnull(v);
sq_seterrorhandler(v);
sq_pushobject(v, _serializefunc);
sq_pushobject(v, _debugroot);
sq_pushstring(v, _SC("watches"), -1);
sq_newtable(v);
for (WatchSetItor i = _watches.begin(); i != _watches.end(); ++i) {
sq_pushinteger(v, i->_id);
sq_pushstring(v, i->_exp.c_str(), (SQInteger) i->_exp.length());
sq_createslot(v, -3);
}
sq_rawset(v, -3);
if (SQ_SUCCEEDED(sq_call(v, 1, SQTrue, SQFalse))) {
//if(SQ_SUCCEEDED(sqstd_getblob(v,-1,(SQUserPointer*)&sz)))
//SendChunk(sz);
}
sq_pop(v, 2);
SetErrorHandlers(v);
}
// getPlayers()
SQInteger CServerNatives::GetPlayers(SQVM * pVM)
{
SQInteger iCount = 0;
sq_newtable(pVM);
for(EntityId i = 0; i < MAX_PLAYERS; i++)
{
if(g_pPlayerManager->DoesExist(i))
{
CPlayer * pPlayer = g_pPlayerManager->GetAt(i);
if(pPlayer)
{
sq_pushinteger(pVM, i);
sq_pushstring(pVM, pPlayer->GetName(), -1);
sq_createslot(pVM, -3);
++iCount;
}
}
}
return 1;
}
static SQRESULT sq_minizip_unzip_get_file_info(HSQUIRRELVM v)
{
SQ_FUNC_VARS_NO_TOP(v);
GET_minizip_unzip_INSTANCE();
char filename_inzip[LZ_MAX_ZIP_NAME_SIZE];
unz_file_info64 file_info;
int err = unzGetCurrentFileInfo64(self,&file_info,filename_inzip,LZ_MAX_ZIP_NAME_SIZE,NULL,0,NULL,0);
if (err!=UNZ_OK)
{
return sq_throwerror(v, _SC("error %d with zipfile in unzGetCurrentFileInfo\n"),err);
}
sq_newtable(v);
sq_pushliteral(v, "name");
sq_pushstring(v, filename_inzip, -1);
sq_rawset(v, -3);
sq_pushliteral(v, "size");
sq_pushinteger(v, file_info.uncompressed_size);
sq_rawset(v, -3);
sq_pushliteral(v, "is_dir");
sq_pushbool(v, file_info.external_fa & ZIP_DOS_DIR_ATTRIBUTE_BITFLAG);
sq_rawset(v, -3);
return 1;
}
TextureManager::TextureManager() {
HSQUIRRELVM vm = engine::script_engine->vm;
sq_pushroottable(vm); // 1
sq_pushstring(vm, "Resources", -1); // 2
CSQ(sq_get(vm, -2)); // 2
sq_pushstring(vm, "TextureInfo", -1); // 3
sq_newtable(vm); // 4
CSQ(sq_newslot(vm, -3, SQFalse)); // 2
sq_poptop(vm); // 1
#define ADD_CONSTANT(name) \
sq_pushstring(vm, PREFIX #name, -1); \
sq_pushinteger(vm, static_cast<SQInteger>(ENUM_PREFIX name)); \
CSQ(sq_newslot(vm, -3, SQFalse))
#define PREFIX "TEXFILTER_"
#define ENUM_PREFIX Texture::FilterMode::
ADD_CONSTANT(NEAREST);
ADD_CONSTANT(LINEAR);
ADD_CONSTANT(MIPMAP_LINEAR);
#undef PREFIX
#undef ENUM_PREFIX
#define PREFIX "TEXREPEAT_"
#define ENUM_PREFIX Texture::RepeatMode::
ADD_CONSTANT(CLAMP);
ADD_CONSTANT(WRAP);
#undef PREFIX
#undef ENUM_PREFIX
#undef ADD_CONSTANT
sq_poptop(vm); // 0
}
bool CSquirrelArgument::push(SQVM * pVM)
{
switch(type)
{
case OT_NULL:
sq_pushnull(pVM);
break;
case OT_INTEGER:
sq_pushinteger(pVM, data.i);
break;
case OT_BOOL:
sq_pushbool(pVM, data.b);
break;
case OT_FLOAT:
sq_pushfloat(pVM, data.f);
break;
case OT_STRING:
sq_pushstring(pVM, data.str->Get(), data.str->GetLength());
break;
case OT_ARRAY:
{
sq_newarray(pVM, 0);
for(CSquirrelArguments::iterator iter = data.pArray->begin(); iter != data.pArray->end(); iter++)
{
(*iter)->push(pVM);
sq_arrayappend(pVM, -2);
}
break;
}
case OT_TABLE:
{
assert(data.pArray->size() % 2 == 0);
sq_newtable(pVM);
for(CSquirrelArguments::iterator iter = data.pArray->begin(); iter != data.pArray->end(); iter++)
{
(*iter)->push(pVM);
++iter;
(*iter)->push(pVM);
sq_createslot(pVM, -3);
}
break;
}
break;
case OT_CLOSURE:
case OT_NATIVECLOSURE:
sq_pushobject(pVM, data.sqObject);
break;
case OT_INSTANCE:
{
SQObject obj;
obj._type = OT_INSTANCE;
obj._unVal.pInstance = data.pInstance;
sq_pushobject(pVM, obj);
}
break;
default:
sq_pushnull(pVM); // whatsoever. do not even care. fix it if you dare.
assert(0);
return false;
}
return true;
}
/**
* クラスの登録
* @param HSQUIRRELVM v
*/
SQRESULT
TJSObject::createTJSClass(HSQUIRRELVM v)
{
SQInteger top = sq_gettop(v);
if (top < 2) {
return sq_throwerror(v, _SC("invalid param"));
}
// クラスを生成
sq_pushobject(v, SQClassType<TJSObject>::ClassObject());
sq_newclass(v, true); // 継承する
// メンバ登録
const tjs_char *tjsClassName = NULL;
tTJSVariant tjsClassObj;
for (SQInteger i=top; i>1; i--) {
if ((tjsClassName = sqobject::getString(v,i))) {
TVPExecuteExpression(tjsClassName, &tjsClassObj);
if (tjsClassObj.Type() == tvtObject &&
TJS_SUCCEEDED(tjsClassObj.AsObjectClosureNoAddRef().IsInstanceOf(0,NULL,NULL,L"Class",NULL))) {
MemberRegister *r = new MemberRegister(v, tjsClassObj);
tTJSVariantClosure closure(r);
tjsClassObj.AsObjectClosureNoAddRef().EnumMembers(TJS_IGNOREPROP, &closure, NULL);
r->Release();
}
}
}
if (tjsClassName) {
// コンストラクタ登録
sq_pushstring(v, _SC("constructor"), -1);
sq_pushvariant(v, tjsClassObj);
sq_newclosure(v, tjsConstructor, 1);
sq_createslot(v, -3);
// クラス属性に tjsクラスを登録
sq_pushnull(v);
sq_newtable(v);
if (SQ_SUCCEEDED(sq_setattributes(v,-3))) {
sq_pop(v,1);
sq_pushnull(v);
if (SQ_SUCCEEDED(sq_getattributes(v, -2))) {
sq_pushstring(v, tjsClassAttrName, -1);
sq_pushvariant(v, tjsClassObj);
if (SQ_SUCCEEDED(sq_createslot(v, -3))) {
sq_pop(v,1);
} else {
sq_pop(v,2);
}
} else {
// XXX
sq_pop(v,1);
}
} else {
// XXX
sq_pop(v,2);
}
// TJS機能メソッドを登録
sq_pushstring(v, _SC("tjsIsValid"), -1);
sq_newclosure(v, TJSObject::tjsIsValid, 0);
sq_createslot(v, -3);
sq_pushstring(v, _SC("tjsOverride"), -1);
sq_newclosure(v, TJSObject::tjsOverride, 0);
sq_setparamscheck(v, -2, _SC(".sc"));
sq_createslot(v, -3);
}
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;
}
SQInteger sqlang_open_KSR(HSQUIRRELVM J)
{
SQRegFunction *_sr_crt_J_KSRMethods = NULL;
sr_kemi_module_t *emods = NULL;
int emods_size = 0;
int i;
int k;
int n;
char mname[128];
char malias[256];
_sr_J_KSRMethods = malloc(SR_SQLANG_KSR_METHODS_SIZE * sizeof(SQRegFunction));
if(_sr_J_KSRMethods==NULL) {
LM_ERR("no more pkg memory\n");
return 0;
}
memset(_sr_J_KSRMethods, 0, SR_SQLANG_KSR_METHODS_SIZE * sizeof(SQRegFunction));
emods_size = sr_kemi_modules_size_get();
emods = sr_kemi_modules_get();
n = 0;
_sr_crt_J_KSRMethods = _sr_J_KSRMethods;
if(emods_size==0 || emods[0].kexp==NULL) {
LM_ERR("no kemi exports registered\n");
return 0;
}
sq_pushroottable(J); /* stack[1] */
sq_pushstring(J, "KSR", -1); /* stack[2] */
sq_newtable(J); /* stack[3] */
for(i=0; emods[0].kexp[i].func!=NULL; i++) {
LM_DBG("exporting KSR.%s(...)\n", emods[0].kexp[i].fname.s);
_sr_crt_J_KSRMethods[i].name = emods[0].kexp[i].fname.s;
_sr_crt_J_KSRMethods[i].f =
sr_kemi_sqlang_export_associate(&emods[0].kexp[i]);
if(_sr_crt_J_KSRMethods[i].f == NULL) {
LM_ERR("failed to associate kemi function with sqlang export\n");
free(_sr_J_KSRMethods);
_sr_J_KSRMethods = NULL;
goto error;
}
_sr_crt_J_KSRMethods[i].nparamscheck = 0;
snprintf(malias, 254, "%s", emods[0].kexp[i].fname.s);
sqlang_register_global_func(J, _sr_crt_J_KSRMethods[i].f, malias);
n++;
}
/* special modules - pv.get(...) can return int or str */
sq_pushstring(J, "pv", -1); /* stack[4] */
sq_newtable(J); /* stack[5] */
i=0;
while(_sr_kemi_pv_J_Map[i].name!=0) {
snprintf(malias, 254, "%s", _sr_kemi_pv_J_Map[i].name);
sqlang_register_global_func(J, _sr_kemi_pv_J_Map[i].f, malias);
i++;
}
sq_newslot(J, -3, SQFalse);
sq_pushstring(J, "x", -1); /* stack[4] */
sq_newtable(J); /* stack[5] */
i=0;
while(_sr_kemi_x_J_Map[i].name!=0) {
snprintf(malias, 254, "%s", _sr_kemi_x_J_Map[i].name);
sqlang_register_global_func(J, _sr_kemi_x_J_Map[i].f, malias);
i++;
}
sq_newslot(J, -3, SQFalse);
/* registered kemi modules */
if(emods_size>1) {
for(k=1; k<emods_size; k++) {
n++;
_sr_crt_J_KSRMethods = _sr_J_KSRMethods + n;
snprintf(mname, 128, "%s", emods[k].kexp[0].mname.s);
sq_pushstring(J, mname, -1); /* stack[4] */
sq_newtable(J); /* stack[5] */
for(i=0; emods[k].kexp[i].func!=NULL; i++) {
LM_DBG("exporting %s.%s(...)\n", mname,
emods[k].kexp[i].fname.s);
_sr_crt_J_KSRMethods[i].name = emods[k].kexp[i].fname.s;
_sr_crt_J_KSRMethods[i].f =
sr_kemi_sqlang_export_associate(&emods[k].kexp[i]);
if(_sr_crt_J_KSRMethods[i].f == NULL) {
LM_ERR("failed to associate kemi function with func export\n");
free(_sr_J_KSRMethods);
_sr_J_KSRMethods = NULL;
goto error;
}
_sr_crt_J_KSRMethods[i].nparamscheck = 0;
snprintf(malias, 256, "%s", _sr_crt_J_KSRMethods[i].name);
sqlang_register_global_func(J, _sr_crt_J_KSRMethods[i].f, malias);
n++;
}
sq_newslot(J, -3, SQFalse);
LM_DBG("initializing kemi sub-module: %s (%s)\n", mname,
emods[k].kexp[0].mname.s);
}
}
sq_newslot(J, -3, SQFalse);
sq_pop(J ,1); /* pops the root table */
LM_DBG("module 'KSR' has been initialized\n");
return 1;
error:
sq_pop(J ,1); /* pops the root table */
return 0;
}
void bindTransport(HSQUIRRELVM vm)
{
// create package table
sq_pushstring(vm, "Transport", -1);
sq_newtable(vm);
// static method schedule
sq_pushstring(vm, _SC("schedule"), -1);
sq_newclosure(vm, &Transportschedule, 0);
sq_newslot(vm, -3, false);
// static method start
sq_pushstring(vm, _SC("start"), -1);
sq_newclosure(vm, &Transportstart, 0);
sq_newslot(vm, -3, false);
// static method stop
sq_pushstring(vm, _SC("stop"), -1);
sq_newclosure(vm, &Transportstop, 0);
sq_newslot(vm, -3, false);
// create class Transport.Master
sq_pushstring(vm, "Master", -1);
sq_newclass(vm, false);
sq_getstackobj(vm, -1, &TransportMasterObject);
sq_settypetag(vm, -1, &TransportMasterObject);
// ctor for class Master
sq_pushstring(vm, _SC("constructor"), -1);
sq_newclosure(vm, &TransportMasterCtor, 0);
sq_newslot(vm, -3, false);
// clone for class Master
sq_pushstring(vm, _SC("_cloned"), -1);
sq_newclosure(vm, &unclonable, 0);
sq_newslot(vm, -3, false);
// methods for class Master
sq_pushstring(vm, _SC("timeSignature"), -1);
sq_newclosure(vm, &TransportMastertimeSignature, 0);
sq_newslot(vm, -3, false);
// push Master to Transport package table
sq_newslot(vm, -3, false);
// create class Transport.Position
sq_pushstring(vm, "Position", -1);
sq_newclass(vm, false);
sq_getstackobj(vm, -1, &TransportPositionObject);
sq_settypetag(vm, -1, &TransportPositionObject);
// ctor for class Position
sq_pushstring(vm, _SC("constructor"), -1);
sq_newclosure(vm, &TransportPositionCtor, 0);
sq_newslot(vm, -3, false);
// clone for class Position
sq_pushstring(vm, _SC("_cloned"), -1);
sq_newclosure(vm, &TransportPositionClone, 0);
sq_newslot(vm, -3, false);
// methods for class Position
sq_pushstring(vm, _SC("bar"), -1);
sq_newclosure(vm, &TransportPositionbar, 0);
sq_newslot(vm, -3, false);
sq_pushstring(vm, _SC("div"), -1);
sq_newclosure(vm, &TransportPositiondiv, 0);
sq_newslot(vm, -3, false);
sq_pushstring(vm, _SC("num"), -1);
sq_newclosure(vm, &TransportPositionnum, 0);
sq_newslot(vm, -3, false);
sq_pushstring(vm, _SC("time"), -1);
sq_newclosure(vm, &TransportPositiontime, 0);
sq_newslot(vm, -3, false);
// push Position to Transport package table
sq_newslot(vm, -3, false);
// create class Transport.TimeSignature
sq_pushstring(vm, "TimeSignature", -1);
sq_newclass(vm, false);
sq_getstackobj(vm, -1, &TransportTimeSignatureObject);
sq_settypetag(vm, -1, &TransportTimeSignatureObject);
// ctor for class TimeSignature
sq_pushstring(vm, _SC("constructor"), -1);
sq_newclosure(vm, &TransportTimeSignatureCtor, 0);
sq_newslot(vm, -3, false);
// clone for class TimeSignature
sq_pushstring(vm, _SC("_cloned"), -1);
sq_newclosure(vm, &TransportTimeSignatureClone, 0);
sq_newslot(vm, -3, false);
// methods for class TimeSignature
sq_pushstring(vm, _SC("denominator"), -1);
sq_newclosure(vm, &TransportTimeSignaturedenominator, 0);
sq_newslot(vm, -3, false);
sq_pushstring(vm, _SC("numerator"), -1);
sq_newclosure(vm, &TransportTimeSignaturenumerator, 0);
sq_newslot(vm, -3, false);
// push TimeSignature to Transport package table
sq_newslot(vm, -3, false);
// push package "Transport" to root table
sq_newslot(vm, -3, false);
}
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);
}
