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;
}
SQInteger sqstd_register_stringlib(HSQUIRRELVM v)
{
sq_pushstring(v,_SC("regexp"),-1);
sq_newclass(v,SQFalse);
SQInteger i = 0;
while(rexobj_funcs[i].name != 0) {
SQRegFunction &f = rexobj_funcs[i];
sq_pushstring(v,f.name,-1);
sq_newclosure(v,f.f,0);
sq_setparamscheck(v,f.nparamscheck,f.typemask);
sq_setnativeclosurename(v,-1,f.name);
sq_newslot(v,-3,SQFalse);
i++;
}
sq_newslot(v,-3,SQFalse);
i = 0;
while(stringlib_funcs[i].name!=0)
{
sq_pushstring(v,stringlib_funcs[i].name,-1);
sq_newclosure(v,stringlib_funcs[i].f,0);
sq_setparamscheck(v,stringlib_funcs[i].nparamscheck,stringlib_funcs[i].typemask);
sq_setnativeclosurename(v,-1,stringlib_funcs[i].name);
sq_newslot(v,-3,SQFalse);
i++;
}
return 1;
}
// プロパティ登録
void registerProperty(const tjs_char *propertyName, tTJSVariant &property, bool staticMember) {
ttstr name = L"set";
name += toupper(*propertyName);
name += (propertyName + 1);
sq_pushstring(v, name.c_str(), -1);
sq_pushvariant(v, property);
if (staticMember) {
sq_pushvariant(v, tjsClassObj);
sq_newclosure(v, TJSObject::tjsStaticSetter, 2);
sq_newslot(v, -3, SQTrue);
} else {
sq_newclosure(v, TJSObject::tjsSetter, 1);
sq_newslot(v, -3, SQFalse);
}
name = L"get";
name += toupper(*propertyName);
name += (propertyName + 1);
sq_pushstring(v, name.c_str(), -1);
sq_pushvariant(v, property);
if (staticMember) {
sq_pushvariant(v, tjsClassObj);
sq_newclosure(v, TJSObject::tjsStaticGetter, 2);
sq_newslot(v, -3, SQTrue);
} else {
sq_newclosure(v, TJSObject::tjsGetter, 1);
sq_newslot(v, -3, SQFalse);
}
}
void init_streamclass(HSQUIRRELVM v)
{
sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_stream"),-1);
if(SQ_FAILED(sq_get(v,-2))) {
sq_pushstring(v,_SC("std_stream"),-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(SQUserPointer)SQSTD_STREAM_TYPE_TAG);
SQInteger i = 0;
while(_stream_methods[i].name != 0) {
const SQRegFunction &f = _stream_methods[i];
sq_pushstring(v,f.name,-1);
sq_newclosure(v,f.f,0);
sq_setparamscheck(v,f.nparamscheck,f.typemask);
sq_newslot(v,-3,SQFalse);
i++;
}
sq_newslot(v,-3,SQFalse);
sq_pushroottable(v);
sq_pushstring(v,_SC("stream"),-1);
sq_pushstring(v,_SC("std_stream"),-1);
sq_get(v,-4);
sq_newslot(v,-3,SQFalse);
sq_pop(v,1);
}
else {
sq_pop(v,1); //result
}
sq_pop(v,1);
}
SQRESULT sqext_register_MySQL(HSQUIRRELVM v)
{
sq_pushstring(v,MySQL_TAG,-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)MySQL_TAG);
sq_insert_reg_funcs(v, sq_mysql_methods);
sq_newslot(v,-3,SQTrue);
sq_pushstring(v,MySQL_Statement_TAG,-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)MySQL_Statement_TAG);
sq_insert_reg_funcs(v, sq_mysql_statement_methods);
sq_newslot(v,-3,SQTrue);
sq_pushstring(v,MySQL_Result_TAG,-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)MySQL_Result_TAG);
sq_insert_reg_funcs(v, sq_mysql_result_methods);
sq_pushstring(v, _curr_row_key, -1);
sq_pushnull(v);
sq_newslot(v, -3, SQFalse);
sq_newslot(v,-3,SQTrue);
return 0;
}
/* This defines a function that opens up your library. */
SQRESULT sqext_register_axtls (HSQUIRRELVM v) {
//add a namespace axtls
sq_pushstring(v, SQ_LIBNAME, -1);
sq_newtable(v);
sq_insert_reg_funcs(v, axtls_obj_funcs);
//add constants
KeyIntPtrType KeyIntPtr;
for (KeyIntPtr = axtls_constants; KeyIntPtr->Str; KeyIntPtr++) {
sq_pushstring(v, KeyIntPtr->Str, -1); //first the key
sq_pushinteger(v, KeyIntPtr->Val); //then the value
sq_newslot(v, -3, SQFalse); //store then
}
//now create the SSL Context class
sq_pushstring(v,ssl_ctx_NAME,-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)SSL_CTX_Tag);
sq_insert_reg_funcs(v, ssl_ctx_obj_funcs);
sq_newslot(v,-3,SQFalse);
//now create the SSL class
sq_pushstring(v,ssl_NAME,-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)SSL_Tag);
sq_insert_reg_funcs(v, ssl_obj_funcs);
sq_newslot(v,-3,SQFalse);
sq_newslot(v,-3,SQFalse); //add axtls table to the root table
return SQ_OK;
}
HSQOBJECT class_init(HSQUIRRELVM v,SQFUNCTION c,const SQChar * p_name)
{
HSQOBJECT class_id;
sq_pushroottable(v);
sq_pushstring(v,p_name,-1);
sq_newclass(v,SQFalse);
sq_getstackobj(v,-1,&class_id);
sq_settypetag(v,-1,&class_id);
HSQOBJECT string_constructor;
sq_pushstring(v,_SC("constructor"),-1);
sq_resetobject(&string_constructor);
sq_getstackobj(v,-1,&string_constructor);
sq_newclosure(v,c,0);
sq_newslot(v,-3,false);
sq_pushstring(v,_SC("_cloned"),-1);
sq_newclosure(v,clone<T>,0);
sq_newslot(v,-3,false);
sq_newslot(v,-3,false);
sq_pop(v,1);
return class_id;
}
// ファンクション登録
void registerFunction(const tjs_char *functionName, tTJSVariant &function, bool staticMember) {
sq_pushstring(v, functionName, -1);
sq_pushvariant(v, function);
if (staticMember) {
sq_pushvariant(v, tjsClassObj);
sq_newclosure(v, TJSObject::tjsStaticInvoker, 2);
sq_newslot(v, -3, SQTrue);
} else {
sq_newclosure(v, TJSObject::tjsInvoker, 1);
sq_newslot(v, -3, SQFalse);
}
}
SQRESULT declare_stream(HSQUIRRELVM v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals)
{
if(sq_gettype(v,-1) != OT_TABLE)
return sq_throwerror(v,_SC("table expected"));
SQInteger top = sq_gettop(v);
//create delegate
init_streamclass(v);
sq_pushregistrytable(v);
sq_pushstring(v,reg_name,-1);
sq_pushstring(v,_SC("std_stream"),-1);
if(SQ_SUCCEEDED(sq_get(v,-3))) {
sq_newclass(v,SQTrue);
sq_settypetag(v,-1,typetag);
SQInteger i = 0;
while(methods[i].name != 0) {
const SQRegFunction &f = methods[i];
sq_pushstring(v,f.name,-1);
sq_newclosure(v,f.f,0);
sq_setparamscheck(v,f.nparamscheck,f.typemask);
sq_setnativeclosurename(v,-1,f.name);
sq_newslot(v,-3,SQFalse);
i++;
}
sq_newslot(v,-3,SQFalse);
sq_pop(v,1);
i = 0;
while(globals[i].name!=0)
{
const SQRegFunction &f = globals[i];
sq_pushstring(v,f.name,-1);
sq_newclosure(v,f.f,0);
sq_setparamscheck(v,f.nparamscheck,f.typemask);
sq_setnativeclosurename(v,-1,f.name);
sq_newslot(v,-3,SQFalse);
i++;
}
//register the class in the target table
sq_pushstring(v,name,-1);
sq_pushregistrytable(v);
sq_pushstring(v,reg_name,-1);
sq_get(v,-2);
sq_remove(v,-2);
sq_newslot(v,-3,SQFalse);
sq_settop(v,top);
return SQ_OK;
}
sq_settop(v,top);
return SQ_ERROR;
}
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
}
SQInteger sqlang_register_global_func(HSQUIRRELVM J, SQFUNCTION f, char *fname)
{
sq_pushstring(J, fname, -1);
sq_newclosure(J, f, 0); /* create a new function */
sq_newslot(J, -3, SQFalse);
return 0;
}
void BindInput()
{
Sqrat::Class<CInput, Sqrat::NoConstructor> def;
def.Func("KeyUp", &CInput::KeyUp);
def.Func("KeyPressed", &CInput::KeyPressed);
def.Func("KeyHeld", &CInput::KeyHeld);
def.Func("KeyReleased", &CInput::KeyReleased);
Sqrat::RootTable().Bind("InputSystem", def);
//Sqrat::ConstTable().Const("KEY_LEFT", KEY_LEFT);
MAKE_KEY( KEY_LEFT );
MAKE_KEY( KEY_RIGHT );
MAKE_KEY( KEY_UP );
MAKE_KEY( KEY_DOWN );
MAKE_KEY( KEY_Q );
MAKE_KEY( KEY_W );
MAKE_KEY( KEY_PAGEUP );
MAKE_KEY( KEY_PAGEDOWN );
MAKE_KEY( KEY_HOME );
// Push the singleton to squirrel
sq_pushroottable( Sqrat::DefaultVM::Get() );
sq_pushstring( Sqrat::DefaultVM::Get(), "InputSystem", -1 );
sq_get( Sqrat::DefaultVM::Get(), -2 );
sq_pushstring( Sqrat::DefaultVM::Get(), "Input", -1 );
sq_createinstance( Sqrat::DefaultVM::Get(), -2 );
sq_setinstanceup( Sqrat::DefaultVM::Get(), -1, (SQUserPointer)Input() );
sq_newslot( Sqrat::DefaultVM::Get(), -4, SQFalse );
sq_pop( Sqrat::DefaultVM::Get(), 2 );
}
void Sq_RegisterFunc(HSQUIRRELVM v,SQFUNCTION f,const char *fname, int ParamNum, const char *params) {
sq_pushstring(v,fname,-1);
sq_newclosure(v,f,0);
sq_newslot(v,-3,SQFalse);
if(params)
sq_setparamscheck(v, ParamNum, _SC(params));
}
SQInteger register_global_func(HSQUIRRELVM& v,SQFUNCTION f,const char *fname)
{
sq_pushroottable(v);
sq_pushstring(v,fname,-1);
sq_newclosure(v,f,0);
sq_newslot(v,-3,SQFalse);
sq_pop(v,1);
}
void setGlobalFunction(HSQUIRRELVM vm, const char * name, SQFUNCTION cb_func)
{
sq_pushroottable(vm);
sq_pushstring(vm, name, -1);
sq_newclosure(vm, cb_func, 0);
sq_newslot(vm, -3, false);
sq_pop(vm, 1); // pop roottable
}
SQInteger register_member_func(HSQUIRRELVM& v,SQFUNCTION f,const char *fname,HSQOBJECT id)
{
sq_pushobject(v,id);
sq_pushstring(v,fname,-1);
sq_newclosure(v,f,0);
sq_newslot(v,-3,SQFalse);
sq_pop(v,1);
}
SQInteger SbuRegisterGlobalFunc(HSQUIRRELVM v, SQFUNCTION f, const SQChar* fname)
{
sq_pushroottable(v);
sq_pushstring(v,fname,-1);
sq_newclosure(v,f,0); //create a new function
sq_newslot(v,-3,SQFalse);
sq_pop(v,1); //pops the root table
return 0;
}
/* This defines a function that opens up your library. */
SQRESULT sqext_register_fossil (HSQUIRRELVM sqvm) {
//add a namespace sqmix
sq_pushstring(sqvm,_SC("sqfossil"),-1);
sq_newclass(sqvm,SQFalse);
sq_insert_reg_funcs(sqvm, fossil_obj_funcs);
sq_newslot(sqvm,-3,SQTrue); //add sq_fossil table to the root table
return SQ_OK;
}
/*
* Register member method.
* Must be called before loading script files
*/
void register_member_func(HSQUIRRELVM v, const char* cname, const char* fname, SQFUNCTION func) {
sq_pushroottable(v);
sq_pushstring(v, cname, -1);
if(SQ_SUCCEEDED(sq_get(v, -2))) {
sq_pushstring(v, fname, -1);
sq_newclosure(v, func, 0);
sq_newslot(v, -3, true);
}
sq_pop(v, 1);
}
SQRESULT sqstd_register_mathlib(HSQUIRRELVM v)
{
SQInteger i=0;
while(mathlib_funcs[i].name!=0) {
sq_pushstring(v,mathlib_funcs[i].name,-1);
sq_newclosure(v,mathlib_funcs[i].f,0);
sq_setparamscheck(v,mathlib_funcs[i].nparamscheck,mathlib_funcs[i].typemask);
sq_setnativeclosurename(v,-1,mathlib_funcs[i].name);
sq_newslot(v,-3,SQFalse);
i++;
}
sq_pushstring(v,_SC("RAND_MAX"),-1);
sq_pushinteger(v,RAND_MAX);
sq_newslot(v,-3,SQFalse);
sq_pushstring(v,_SC("PI"),-1);
sq_pushfloat(v,(SQFloat)M_PI);
sq_newslot(v,-3,SQFalse);
return SQ_OK;
}
SQRESULT sqext_register_libclang(HSQUIRRELVM v)
{
sq_pushstring(v,LibClang_TAG,-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(void*)LibClang_TAG);
sq_insert_reg_funcs(v, sq_libclang_methods);
sq_newslot(v,-3,SQTrue);
return 0;
}
void GlobalUtility::Set()
{
Module::instance().getScriptInterface().PushDocumentTable(mVM, m_pDoc);
SQRESULT sqr;
if (m_pSelf)
{
ElementWrapper wrapper;
wrapper.setElement(m_pSelf);
//Add the global slot self
sq_pushstring(mVM, "self", -1);
sqr = sqb::Push<ElementWrapper>(mVM, wrapper);
ROCKETSQUIRREL_ASSERT(SQ_SUCCEEDED(sqr));
sqr = sq_newslot(mVM, -3, false);
ROCKETSQUIRREL_ASSERT(SQ_SUCCEEDED(sqr));
mSelfSet = true;
}
if (m_pEvt)
{
EventWrapper wrapper(m_pEvt);
//Add the global slot event
sq_pushstring(mVM, "event", -1);
sqr = sqb::Push<EventWrapper>(mVM, wrapper);
ROCKETSQUIRREL_ASSERT(SQ_SUCCEEDED(sqr));
sqr = sq_newslot(mVM, -3, false);
ROCKETSQUIRREL_ASSERT(SQ_SUCCEEDED(sqr));
mEvtSet = true;
}
sq_poptop(mVM);
}
SQRESULT sqrat_register_importlib(HSQUIRRELVM v) {
sq_pushroottable(v);
sq_pushstring(v, _SC("import"), -1);
sq_newclosure(v, &sqratbase_import, 0);
sq_newslot(v, -3, 0);
sq_pop(v, 1); // pop sqrat table
return SQ_OK;
}
MTR_DCLSPC void MTR_CALL MTR_ScriptsRegisterFunction(SQFUNCTION func,
const char * funcname)
{
sq_pushroottable(mtrVm);
sq_pushstring(mtrVm, funcname, -1);
sq_newclosure(mtrVm, func, 0); //create a new function
sq_newslot(mtrVm, -3, SQFalse);
sq_pop(mtrVm, 1); //pops the root table
MTR_LogWrite_s("Script function added:", 3, MTR_LMT_INFO, funcname);
return;
}
/* This defines a function that opens up your library. */
SQRESULT sqext_register_BitVector (HSQUIRRELVM v) {
//add a namespace BitVector
sq_pushstring(v, SQ_LIBNAME, -1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(SQUserPointer)BitVector_Tag);
sq_insert_reg_funcs(v, BitVector_obj_funcs);
sq_newslot(v,-3,SQFalse); //add BitVector table to the root table
return SQ_OK;
}
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 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;
}
void sq_base_register(HSQUIRRELVM v)
{
SQInteger i=0;
sq_pushroottable(v);
while(base_funcs[i].name!=0) {
sq_pushstring(v,base_funcs[i].name,-1);
sq_newclosure(v,base_funcs[i].f,0);
sq_setnativeclosurename(v,-1,base_funcs[i].name);
sq_setparamscheck(v,base_funcs[i].nparamscheck,base_funcs[i].typemask);
sq_newslot(v,-3, SQFalse);
i++;
}
sq_pushstring(v,_SC("_versionnumber_"),-1);
sq_pushinteger(v,SQUIRREL_VERSION_NUMBER);
sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_version_"),-1);
sq_pushstring(v,SQUIRREL_VERSION,-1);
sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_charsize_"),-1);
sq_pushinteger(v,sizeof(SQChar));
sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_intsize_"),-1);
sq_pushinteger(v,sizeof(SQInteger));
sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_floatsize_"),-1);
sq_pushinteger(v,sizeof(SQFloat));
sq_newslot(v,-3, SQFalse);
sq_pop(v,1);
}
SQInteger regGlobals(HSQUIRRELVM v) {
SQInteger i=0;
SQRegFunction* pfpps = global_funcs;
while(pfpps[i].name!=0) {
sq_pushstring(v,pfpps[i].name,-1);
sq_newclosure(v,pfpps[i].f,0);
sq_setparamscheck(v,pfpps[i].nparamscheck,pfpps[i].typemask);
sq_setnativeclosurename(v,-1,pfpps[i].name);
sq_newslot(v,-3,SQFalse);
i++;
}
return 1;
}
//-----------------------------------------------------------------
bool RegisterFunctions(HSQUIRRELVM v, const Function* functions, bool areStatic)
{
assert(functions);
for (int i = 0; functions[i].name != 0; i++) {
sq_pushstring(v, functions[i].name, -1);
sq_newclosure(v, functions[i].function, 0);
sq_setnativeclosurename(v, -1, functions[i].debugName);
if (!SQ_SUCCEEDED(sq_newslot(v, -3, (areStatic ? SQTrue : SQFalse)))) {
return false;
}
}
return true;
}
