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;
}
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;
}
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 );
}
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 SQRESULT sq_mysql_close(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_mysql_INSTANCE();
dlmysql_close(self);
sq_setinstanceup(v, 1, 0); //next calls will fail with "database is closed"
return 0;
}
/* static */ SQInteger GameInfo::Constructor(HSQUIRRELVM vm)
{
/* Get the GameInfo */
SQUserPointer instance = NULL;
if (SQ_FAILED(sq_getinstanceup(vm, 2, &instance, 0)) || instance == NULL) return sq_throwerror(vm, _SC("Pass an instance of a child class of GameInfo to RegisterGame"));
GameInfo *info = (GameInfo *)instance;
SQInteger res = ScriptInfo::Constructor(vm, info);
if (res != 0) return res;
if (info->engine->MethodExists(*info->SQ_instance, "MinVersionToLoad")) {
if (!info->engine->CallIntegerMethod(*info->SQ_instance, "MinVersionToLoad", &info->min_loadable_version, MAX_GET_OPS)) return SQ_ERROR;
} else {
info->min_loadable_version = info->GetVersion();
}
/* When there is an IsSelectable function, call it. */
if (info->engine->MethodExists(*info->SQ_instance, "IsDeveloperOnly")) {
if (!info->engine->CallBoolMethod(*info->SQ_instance, "IsDeveloperOnly", &info->is_developer_only, MAX_GET_OPS)) return SQ_ERROR;
} else {
info->is_developer_only = false;
}
/* Try to get the API version the AI is written for. */
if (!info->CheckMethod("GetAPIVersion")) return SQ_ERROR;
if (!info->engine->CallStringMethodStrdup(*info->SQ_instance, "GetAPIVersion", &info->api_version, MAX_GET_OPS)) return SQ_ERROR;
if (!CheckAPIVersion(info->api_version)) {
DEBUG(script, 1, "Loading info.nut from (%s.%d): GetAPIVersion returned invalid version", info->GetName(), info->GetVersion());
return SQ_ERROR;
}
/* Remove the link to the real instance, else it might get deleted by RegisterGame() */
sq_setinstanceup(vm, 2, NULL);
/* Register the Game to the base system */
info->GetScanner()->RegisterScript(info);
return 0;
}
static SQRESULT sq_mysql_statement_close(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_mysql_statement_INSTANCE();
sq_mysql_statement_releasehook(self->stmt, 0, v);
sq_setinstanceup(v, 1, 0); //next calls will fail with "Pgstatement is closed"
return 0;
}
static SQRESULT sq_slave_vm_close(HSQUIRRELVM v)
{
GET_sq_slave_vm_INSTANCE(v, 1);
sq_close(self);
sq_setinstanceup(v, 1, 0); //next calls will fail with "vm is closed"
return 0;
}
/*
* create a instance
*/
SQInteger createSQObject(HSQUIRRELVM v,
const char* package_name, const char* name,
SQUserPointer ptr, SQRELEASEHOOK releaseHook) {
sq_pushroottable(v);
sq_pushstring(v, package_name, -1);
if (!SQ_SUCCEEDED(sq_get(v, -2))) {
sq_pop(v, 1);
return 0;
}
if (name != NULL) {
sq_pushstring(v, name, -1);
if (!SQ_SUCCEEDED(sq_get(v, -2))) {
sq_pop(v, 2);
return 0;
}
}
sq_createinstance(v, -1);
sq_setinstanceup(v, -1, ptr);
if (releaseHook != NULL) {
sq_setreleasehook(v, -1, releaseHook);
}
sq_remove(v, -2);
sq_remove(v, -2);
return 1;
}
static SQRESULT sq_mysql_exec_query(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_mysql_INSTANCE();
SQ_GET_STRING(v, 2, szSQL);
if (dlmysql_real_query(self, szSQL, szSQL_size))
/* error executing query */
return sq_throwerror(v, _SC("error executing query. MySQL: %s"), dlmysql_error(self));
MYSQL_RES *qres = dlmysql_store_result(self);
sq_pushroottable(v);
sq_pushstring(v, MySQL_Result_TAG, -1);
if(sq_get(v, -2) == SQ_OK){
if(sq_createinstance(v, -1) == SQ_OK){
sq_setinstanceup(v, -1, qres);
sq_setreleasehook(v, -1, sq_mysql_result_releasehook);
sq_pushstring(v, _curr_row_key, -1);
sq_pushinteger(v, -1);
sq_set(v, -3);
return 1;
}
}
return SQ_ERROR;
}
static SQRESULT sq_libclang_close(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
GET_libclang_INSTANCE();
sq_libclang_releasehook(self, sizeof(MyLibClang), v);
sq_setinstanceup(v, 1, 0); //next calls will fail with "libclang is closed"
return 0;
}
BOOL SquirrelObject::SetInstanceUP(SQUserPointer up)
{
if(!sq_isinstance(_o)) return FALSE;
sq_pushobject(m_Vm.GetVMPtr(),_o);
sq_setinstanceup(m_Vm.GetVMPtr(),-1,up);
sq_pop(m_Vm.GetVMPtr(),1);
return TRUE;
}
static SQRESULT sq_ssl_free(HSQUIRRELVM v)
{
SQ_FUNC_VARS_NO_TOP(v);
GET_ssl_INSTANCE();
ssl_release_hook(self, 0, v);
sq_setinstanceup(v, 1, 0);
return 0;
}
bool ScriptObject::setInstanceUp(SQUserPointer up)
{
MCD_ASSERT(sq_isinstance(mObj));
sq_pushobject(mSqvm, mObj);
sq_setinstanceup(mSqvm, -1, up);
sq_poptop(mSqvm);
return true;
}
//
// Transport.Position class
//
SQInteger TransportPositionPush(HSQUIRRELVM vm, TimePosition *obj)
{
sq_pushobject(vm, TransportPositionObject);
sq_createinstance(vm, -1);
sq_remove(vm, -2);
sq_setinstanceup(vm, -1, new TimePosition(*obj));
sq_setreleasehook(vm, -1, &TransportPositionRelease);
}
static SQInteger _regexp_constructor( HSQUIRRELVM v ) {
const SQChar *error, *pattern;
sq_getstring( v, 2, &pattern );
SQRex *rex = sqstd_rex_compile( pattern, &error );
if ( !rex ) return sq_throwerror( v, error );
sq_setinstanceup( v, 1, rex );
sq_setreleasehook( v, 1, _rexobj_releasehook );
return 0;
}
static SQRESULT sq_minizip_unzip_destroy(HSQUIRRELVM v)
{
SQ_FUNC_VARS_NO_TOP(v);
GET_minizip_unzip_INSTANCE();
int rc = sq_minizip_unzip_releasehook(self, 0, v);
if(rc == 0) sq_setinstanceup(v, 1, 0);
sq_pushinteger(v, rc);
return 1;
}
static SQRESULT sq_BitVector_constructor(HSQUIRRELVM v){
SQ_FUNC_VARS_NO_TOP(v);
SQ_GET_INTEGER(v, 2, int_size);
// Bitvec *sqlite3BitvecCreate(u32)
Bitvec *bv = sqlite3BitvecCreate((u32)int_size);
SQInteger rc = sq_setinstanceup(v, 1, bv);
sq_setreleasehook(v,1, BitVector_release_hook);
return rc;
}
SQInteger cross(HSQUIRRELVM v){
T * lhs,* rhs;
sq_getinstanceup(v,2,(SQUserPointer*)&lhs, 0);
sq_getinstanceup(v,3,(SQUserPointer*)&rhs, 0);
T * instance = new T( glm::cross(*lhs,*rhs) );
sq_setinstanceup(v, 3, instance);
sq_setreleasehook(v,3, delete_instance<T>);
return 1;
}
SQInteger TransportTimeSignatureClone(HSQUIRRELVM vm)
{
// get instance ptr of original
SQUserPointer userPtr;
sq_getinstanceup(vm, 2, &userPtr, 0);
// set instance ptr to a copy
sq_setinstanceup(vm, 1, new TimeSignature(*(TimeSignature*)userPtr));
sq_setreleasehook(vm, 1, &TransportTimeSignatureRelease);
return 0;
}
void CSquirrelVM::SetClassInstance(const char* szClassName, void * pInstance)
{
sq_setinstanceup(m_pVM, 1, (SQUserPointer *) pInstance);
sq_setreleasehook(m_pVM, 1, deleteClassInstance);
HSQOBJECT instance;
sq_resetobject(&instance);
sq_getstackobj(m_pVM, 1, &instance);
sq_addref(m_pVM, &instance);
m_Instances.insert(std::pair<void*, HSQOBJECT>(pInstance, instance));
}
SQInteger constructor<glm::vec2>(HSQUIRRELVM v){
SQChar const * key; sq_getstring(v,2,(SQChar const**)&key);
SQFloat x,y;
SQInteger error = 0;
error = with_assert_sq_getfloat(v,2,x);if(error) return error;
error = with_assert_sq_getfloat(v,3,y);if(error) return error;
glm::vec2 * instance = new glm::vec2(x,y);
sq_setinstanceup(v, 1, instance);
sq_setreleasehook(v,1, delete_instance<glm::vec2>);
return 0;
}
SQInteger div_v(HSQUIRRELVM v) {
SQChar const * buff; sq_getstring(v,2,(SQChar const**)&buff);
T* lhs;
sq_getinstanceup(v,1,(SQUserPointer*)&lhs, 0);
T* rhs;
sq_getinstanceup(v,2,(SQUserPointer*)&rhs, 0);
T * instance = new T(*lhs / *rhs);
sq_setinstanceup(v, 2, instance);
sq_setreleasehook(v,2, delete_instance<T>);
return 1;
}
static SQRESULT sq_minizip_unzip_constructor(HSQUIRRELVM v)
{
SQ_FUNC_VARS_NO_TOP(v);
SQ_GET_STRING(v, 2, zip_fname);
unzFile zip_archive = unzOpen64(zip_fname);
if(!zip_archive)
{
return sq_throwerror(v, _SC("Cannot open %s\n"),zip_fname);
}
sq_setinstanceup(v, 1, zip_archive);
sq_setreleasehook(v,1, sq_minizip_unzip_releasehook);
return 1;
}
static SQRESULT sq_ssl_ctx_constructor(HSQUIRRELVM v)
{
SQInteger options, num_sessions;
sq_getinteger(v, 2, &options);
sq_getinteger(v, 3, &num_sessions);
SSL_CTX *ssl_ctx = ssl_ctx_new(options, num_sessions);
if(!ssl_ctx)
return sq_throwerror(v, _SC("Could'nt create an ssl context."));
sq_setinstanceup(v, 1, ssl_ctx);
sq_setreleasehook(v,1, ssl_ctx_release_hook);
return 1;
}
static SQRESULT sq_libclang_constructor(HSQUIRRELVM v)
{
//SQ_FUNC_VARS_NO_TOP(v);
if(!load_dynamicLib(dynamicLibName)) return sq_throwerror(v, _SC("Failed to load libclang !"));
MyLibClang *self = (MyLibClang *)sq_malloc(sizeof(MyLibClang));
memset(self, 0, sizeof(MyLibClang));
self->v = v;
self->index = dlclang_createIndex(0, 0);
sq_setinstanceup(v, 1, self);
sq_setreleasehook(v,1, sq_libclang_releasehook);
return 1;
}
/* static */ SQInteger AIInfo::Constructor(HSQUIRRELVM vm)
{
/* Get the AIInfo */
SQUserPointer instance = NULL;
if (SQ_FAILED(sq_getinstanceup(vm, 2, &instance, 0)) || instance == NULL) return sq_throwerror(vm, _SC("Pass an instance of a child class of AIInfo to RegisterAI"));
AIInfo *info = (AIInfo *)instance;
SQInteger res = AIFileInfo::Constructor(vm, info);
if (res != 0) return res;
AIConfigItem config = _start_date_config;
config.name = strdup(config.name);
config.description = strdup(config.description);
info->config_list.push_back(config);
/* Check if we have settings */
if (info->engine->MethodExists(*info->SQ_instance, "GetSettings")) {
if (!info->GetSettings()) return SQ_ERROR;
}
if (info->engine->MethodExists(*info->SQ_instance, "MinVersionToLoad")) {
if (!info->engine->CallIntegerMethod(*info->SQ_instance, "MinVersionToLoad", &info->min_loadable_version, MAX_GET_SETTING_OPS)) return SQ_ERROR;
} else {
info->min_loadable_version = info->GetVersion();
}
/* When there is an UseAsRandomAI function, call it. */
if (info->engine->MethodExists(*info->SQ_instance, "UseAsRandomAI")) {
if (!info->engine->CallBoolMethod(*info->SQ_instance, "UseAsRandomAI", &info->use_as_random, MAX_GET_SETTING_OPS)) return SQ_ERROR;
} else {
info->use_as_random = true;
}
/* Try to get the API version the AI is written for. */
if (info->engine->MethodExists(*info->SQ_instance, "GetAPIVersion")) {
if (!info->engine->CallStringMethodStrdup(*info->SQ_instance, "GetAPIVersion", &info->api_version, MAX_GET_SETTING_OPS)) return SQ_ERROR;
if (!CheckAPIVersion(info->api_version)) {
DEBUG(ai, 1, "Loading info.nut from (%s.%d): GetAPIVersion returned invalid version", info->GetName(), info->GetVersion());
return SQ_ERROR;
}
} else {
info->api_version = strdup("0.7");
}
/* Remove the link to the real instance, else it might get deleted by RegisterAI() */
sq_setinstanceup(vm, 2, NULL);
/* Register the AI to the base system */
info->base->RegisterAI(info);
return 0;
}
inline SQInteger DefSQConstructorCallback(HSQUIRRELVM vm)
{
/* Find the amount of params we got */
int nparam = sq_gettop(vm);
try {
/* Create the real instance */
Tcls *instance = HelperT<Tmethod>::SQConstruct((Tcls *)NULL, (Tmethod)NULL, vm);
sq_setinstanceup(vm, -Tnparam, instance);
sq_setreleasehook(vm, -Tnparam, DefSQDestructorCallback<Tcls>);
instance->AddRef();
return 0;
} catch (SQInteger e) {
sq_pop(vm, nparam);
return e;
}
}
static SQRESULT ssl_constructor(HSQUIRRELVM v, SSL *ssl, int free_on_gc)
{
if(!ssl)
return sq_throwerror(v, _SC("Could'nt create an ssl object."));
sq_pushstring(v, SQ_LIBNAME, -1);
if(sq_getonroottable(v) == SQ_OK){
sq_pushstring(v, ssl_NAME, -1);
if(sq_get(v, -2) == SQ_OK){
if(sq_createinstance(v, -1) == SQ_OK){
sq_setinstanceup(v, -1, ssl);
if(free_on_gc) sq_setreleasehook(v,-1, ssl_release_hook);
return 1;
}
}
}
return SQ_ERROR;
}
/* static */ bool Squirrel::CreateClassInstanceVM(HSQUIRRELVM vm, const char *class_name, void *real_instance, HSQOBJECT *instance, SQRELEASEHOOK release_hook, bool prepend_API_name)
{
Squirrel *engine = (Squirrel *)sq_getforeignptr(vm);
int oldtop = sq_gettop(vm);
/* First, find the class */
sq_pushroottable(vm);
if (prepend_API_name) {
size_t len = strlen(class_name) + strlen(engine->GetAPIName()) + 1;
char *class_name2 = (char *)alloca(len);
seprintf(class_name2, class_name2 + len - 1, "%s%s", engine->GetAPIName(), class_name);
sq_pushstring(vm, class_name2, -1);
} else {
sq_pushstring(vm, class_name, -1);
}
if (SQ_FAILED(sq_get(vm, -2))) {
DEBUG(misc, 0, "[squirrel] Failed to find class by the name '%s%s'", prepend_API_name ? engine->GetAPIName() : "", class_name);
sq_settop(vm, oldtop);
return false;
}
/* Create the instance */
if (SQ_FAILED(sq_createinstance(vm, -1))) {
DEBUG(misc, 0, "[squirrel] Failed to create instance for class '%s%s'", prepend_API_name ? engine->GetAPIName() : "", class_name);
sq_settop(vm, oldtop);
return false;
}
if (instance != NULL) {
/* Find our instance */
sq_getstackobj(vm, -1, instance);
/* Add a reference to it, so it survives for ever */
sq_addref(vm, instance);
}
sq_remove(vm, -2); // Class-name
sq_remove(vm, -2); // Root-table
/* Store it in the class */
sq_setinstanceup(vm, -1, real_instance);
if (release_hook != NULL) sq_setreleasehook(vm, -1, release_hook);
if (instance != NULL) sq_settop(vm, oldtop);
return true;
}
