void Squirrel::AddClassBegin(const char *class_name, const char *parent_class) { sq_pushroottable(this->vm); sq_pushstring(this->vm, OTTD2SQ(class_name), -1); sq_pushstring(this->vm, OTTD2SQ(parent_class), -1); if (SQ_FAILED(sq_get(this->vm, -3))) { DEBUG(misc, 0, "[squirrel] Failed to initialize class '%s' based on parent class '%s'", class_name, parent_class); DEBUG(misc, 0, "[squirrel] Make sure that '%s' exists before trying to define '%s'", parent_class, class_name); return; } sq_newclass(this->vm, SQTrue); }
void Squirrel::AddMethod(const char *method_name, SQFUNCTION proc, uint nparam, const char *params, void *userdata, int size) { sq_pushstring(this->vm, OTTD2SQ(method_name), -1); if (size != 0) { void *ptr = sq_newuserdata(vm, size); memcpy(ptr, userdata, size); } sq_newclosure(this->vm, proc, size != 0 ? 1 : 0); if (nparam != 0) sq_setparamscheck(this->vm, nparam, OTTD2SQ(params)); sq_setnativeclosurename(this->vm, -1, OTTD2SQ(method_name)); sq_newslot(this->vm, -3, SQFalse); }
/* 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) { char *class_name2 = (char *)alloca(strlen(class_name) + strlen(engine->GetAPIName()) + 1); sprintf(class_name2, "%s%s", engine->GetAPIName(), class_name); sq_pushstring(vm, OTTD2SQ(class_name2), -1); } else { sq_pushstring(vm, OTTD2SQ(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; }
bool Squirrel::CallMethod(HSQOBJECT instance, const char *method_name, HSQOBJECT *ret, int suspend) { assert(!this->crashed); /* Store the stack-location for the return value. We need to * restore this after saving or the stack will be corrupted * if we're in the middle of a DoCommand. */ SQInteger last_target = this->vm->_suspended_target; /* Store the current top */ int top = sq_gettop(this->vm); /* Go to the instance-root */ sq_pushobject(this->vm, instance); /* Find the function-name inside the script */ sq_pushstring(this->vm, OTTD2SQ(method_name), -1); if (SQ_FAILED(sq_get(this->vm, -2))) { DEBUG(misc, 0, "[squirrel] Could not find '%s' in the class", method_name); sq_settop(this->vm, top); return false; } /* Call the method */ sq_pushobject(this->vm, instance); if (SQ_FAILED(sq_call(this->vm, 1, ret == NULL ? SQFalse : SQTrue, SQTrue, suspend))) return false; if (ret != NULL) sq_getstackobj(vm, -1, ret); /* Reset the top, but don't do so for the AI main function, as we need * a correct stack when resuming. */ if (suspend == -1 || !this->IsSuspended()) sq_settop(this->vm, top); /* Restore the return-value location. */ this->vm->_suspended_target = last_target; return true; }
char *ScriptEventAdminPort::ReadString(HSQUIRRELVM vm, char *p) { char *value = p; bool escape = false; for (;;) { if (*p == '\\') { escape = true; p++; continue; } if (*p == '"' && escape) { escape = false; p++; continue; } escape = false; if (*p == '"') break; if (*p == '\0') RETURN_ERROR(0); p++; } *p = '\0'; sq_pushstring(vm, OTTD2SQ(value), -1); *p++ = '"'; return p; }
/** Run the dummy info.nut. */ void Script_CreateDummyInfo(HSQUIRRELVM vm, const char *type, const char *dir) { char dummy_script[4096]; char *dp = dummy_script; dp += seprintf(dp, lastof(dummy_script), "class Dummy%s extends %sInfo {\n", type, type); dp += seprintf(dp, lastof(dummy_script), "function GetAuthor() { return \"OpenTTD Developers Team\"; }\n"); dp += seprintf(dp, lastof(dummy_script), "function GetName() { return \"Dummy%s\"; }\n", type); dp += seprintf(dp, lastof(dummy_script), "function GetShortName() { return \"DUMM\"; }\n"); dp += seprintf(dp, lastof(dummy_script), "function GetDescription() { return \"A Dummy %s that is loaded when your %s/ dir is empty\"; }\n", type, dir); dp += seprintf(dp, lastof(dummy_script), "function GetVersion() { return 1; }\n"); dp += seprintf(dp, lastof(dummy_script), "function GetDate() { return \"2008-07-26\"; }\n"); dp += seprintf(dp, lastof(dummy_script), "function CreateInstance() { return \"Dummy%s\"; }\n", type); dp += seprintf(dp, lastof(dummy_script), "} RegisterDummy%s(Dummy%s());\n", type, type); const SQChar *sq_dummy_script = OTTD2SQ(dummy_script); sq_pushroottable(vm); /* Load and run the script */ if (SQ_SUCCEEDED(sq_compilebuffer(vm, sq_dummy_script, scstrlen(sq_dummy_script), _SC("dummy"), SQTrue))) { sq_push(vm, -2); if (SQ_SUCCEEDED(sq_call(vm, 1, SQFalse, SQTrue))) { sq_pop(vm, 1); return; } } NOT_REACHED(); }
inline SQInteger DefSQAdvancedNonStaticCallback(HSQUIRRELVM vm) { /* Find the amount of params we got */ int nparam = sq_gettop(vm); SQUserPointer ptr = NULL; SQUserPointer real_instance = NULL; HSQOBJECT instance; /* Get the 'SQ' instance of this class */ Squirrel::GetInstance(vm, &instance); /* Protect against calls to a non-static method in a static way */ sq_pushroottable(vm); sq_pushstring(vm, OTTD2SQ(Tcls::GetClassName()), -1); sq_get(vm, -2); sq_pushobject(vm, instance); if (sq_instanceof(vm) != SQTrue) return sq_throwerror(vm, _SC("class method is non-static")); sq_pop(vm, 3); /* Get the 'real' instance of this class */ sq_getinstanceup(vm, 1, &real_instance, 0); /* Get the real function pointer */ sq_getuserdata(vm, nparam, &ptr, 0); if (real_instance == NULL) return sq_throwerror(vm, _SC("couldn't detect real instance of class for non-static call")); /* Remove the userdata from the stack */ sq_pop(vm, 1); /* Call the function, which its only param is always the VM */ return (SQInteger)(((Tcls *)real_instance)->*(*(Tmethod *)ptr))(vm); }
inline SQInteger DefSQNonStaticCallback(HSQUIRRELVM vm) { /* Find the amount of params we got */ int nparam = sq_gettop(vm); SQUserPointer ptr = NULL; SQUserPointer real_instance = NULL; HSQOBJECT instance; /* Get the 'SQ' instance of this class */ Squirrel::GetInstance(vm, &instance); /* Protect against calls to a non-static method in a static way */ sq_pushroottable(vm); sq_pushstring(vm, OTTD2SQ(Tcls::GetClassName()), -1); sq_get(vm, -2); sq_pushobject(vm, instance); if (sq_instanceof(vm) != SQTrue) return sq_throwerror(vm, _SC("class method is non-static")); sq_pop(vm, 3); /* Get the 'real' instance of this class */ sq_getinstanceup(vm, 1, &real_instance, 0); /* Get the real function pointer */ sq_getuserdata(vm, nparam, &ptr, 0); if (real_instance == NULL) return sq_throwerror(vm, _SC("couldn't detect real instance of class for non-static call")); /* Remove the userdata from the stack */ sq_pop(vm, 1); try { /* Delegate it to a template that can handle this specific function */ return HelperT<Tmethod>::SQCall((Tcls *)real_instance, *(Tmethod *)ptr, vm); } catch (SQInteger e) { sq_pop(vm, nparam); return e; } }
/* static */ bool ScriptInstance::LoadObjects(HSQUIRRELVM vm) { SlObject(NULL, _script_byte); switch (_script_sl_byte) { case SQSL_INT: { int value; SlArray(&value, 1, SLE_INT32); if (vm != NULL) sq_pushinteger(vm, (SQInteger)value); return true; } case SQSL_STRING: { SlObject(NULL, _script_byte); static char buf[256]; SlArray(buf, _script_sl_byte, SLE_CHAR); if (vm != NULL) sq_pushstring(vm, OTTD2SQ(buf), -1); return true; } case SQSL_ARRAY: { if (vm != NULL) sq_newarray(vm, 0); while (LoadObjects(vm)) { if (vm != NULL) sq_arrayappend(vm, -2); /* The value is popped from the stack by squirrel. */ } return true; } case SQSL_TABLE: { if (vm != NULL) sq_newtable(vm); while (LoadObjects(vm)) { LoadObjects(vm); if (vm != NULL) sq_rawset(vm, -3); /* The key (-2) and value (-1) are popped from the stack by squirrel. */ } return true; } case SQSL_BOOL: { SlObject(NULL, _script_byte); if (vm != NULL) sq_pushinteger(vm, (SQBool)(_script_sl_byte != 0)); return true; } case SQSL_NULL: { if (vm != NULL) sq_pushnull(vm); return true; } case SQSL_ARRAY_TABLE_END: { return false; } default: NOT_REACHED(); } }
/** Run the dummy AI and let it generate an error message. */ void Script_CreateDummy(HSQUIRRELVM vm, StringID string, const char *type) { /* We want to translate the error message. * We do this in three steps: * 1) We get the error message */ char error_message[1024]; GetString(error_message, string, lastof(error_message)); /* Make escapes for all quotes and slashes. */ char safe_error_message[1024]; char *q = safe_error_message; for (const char *p = error_message; *p != '\0' && q < lastof(safe_error_message) - 2; p++, q++) { if (*p == '"' || *p == '\\') *q++ = '\\'; *q = *p; } *q = '\0'; /* 2) We construct the AI's code. This is done by merging a header, body and footer */ char dummy_script[4096]; char *dp = dummy_script; dp += seprintf(dp, lastof(dummy_script), "class Dummy%s extends %sController {\n function Start()\n {\n", type, type); /* As special trick we need to split the error message on newlines and * emit each newline as a separate error printing string. */ char *newline; char *p = safe_error_message; do { newline = strchr(p, '\n'); if (newline != NULL) *newline = '\0'; dp += seprintf(dp, lastof(dummy_script), " %sLog.Error(\"%s\");\n", type, p); p = newline + 1; } while (newline != NULL); dp = strecpy(dp, " }\n}\n", lastof(dummy_script)); /* 3) We translate the error message in the character format that Squirrel wants. * We can use the fact that the wchar string printing also uses %s to print * old style char strings, which is what was generated during the script generation. */ const SQChar *sq_dummy_script = OTTD2SQ(dummy_script); /* And finally we load and run the script */ sq_pushroottable(vm); if (SQ_SUCCEEDED(sq_compilebuffer(vm, sq_dummy_script, scstrlen(sq_dummy_script), _SC("dummy"), SQTrue))) { sq_push(vm, -2); if (SQ_SUCCEEDED(sq_call(vm, 1, SQFalse, SQTrue))) { sq_pop(vm, 1); return; } } NOT_REACHED(); }
bool Squirrel::MethodExists(HSQOBJECT instance, const char *method_name) { assert(!this->crashed); int top = sq_gettop(this->vm); /* Go to the instance-root */ sq_pushobject(this->vm, instance); /* Find the function-name inside the script */ sq_pushstring(this->vm, OTTD2SQ(method_name), -1); if (SQ_FAILED(sq_get(this->vm, -2))) { sq_settop(this->vm, top); return false; } sq_settop(this->vm, top); return true; }
/* static */ bool Squirrel::CreateClassInstanceVM(HSQUIRRELVM vm, const char *class_name, void *real_instance, HSQOBJECT *instance, SQRELEASEHOOK release_hook) { int oldtop = sq_gettop(vm); /* First, find the class */ sq_pushroottable(vm); sq_pushstring(vm, OTTD2SQ(class_name), -1); if (SQ_FAILED(sq_get(vm, -2))) { DEBUG(misc, 0, "[squirrel] Failed to find class by the name '%s'", 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'", 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; }
bool ScriptInstance::CallLoad() { HSQUIRRELVM vm = this->engine->GetVM(); /* Is there save data that we should load? */ if (!this->is_save_data_on_stack) return true; /* Whatever happens, after CallLoad the savegame data is removed from the stack. */ this->is_save_data_on_stack = false; if (!this->engine->MethodExists(*this->instance, "Load")) { ScriptLog::Warning("Loading failed: there was data for the script to load, but the script does not have a Load() function."); /* Pop the savegame data and version. */ sq_pop(vm, 2); return true; } /* Go to the instance-root */ sq_pushobject(vm, *this->instance); /* Find the function-name inside the script */ sq_pushstring(vm, OTTD2SQ("Load"), -1); /* Change the "Load" string in a function pointer */ sq_get(vm, -2); /* Push the main instance as "this" object */ sq_pushobject(vm, *this->instance); /* Push the version data and savegame data as arguments */ sq_push(vm, -5); sq_push(vm, -5); /* Call the script load function. sq_call removes the arguments (but not the * function pointer) from the stack. */ if (SQ_FAILED(sq_call(vm, 3, SQFalse, SQFalse, MAX_SL_OPS))) return false; /* Pop 1) The version, 2) the savegame data, 3) the object instance, 4) the function pointer. */ sq_pop(vm, 4); return true; }
bool AIScanner::ImportLibrary(const char *library, const char *class_name, int version, HSQUIRRELVM vm, AIController *controller) { /* Internally we store libraries as 'library.version' */ char library_name[1024]; snprintf(library_name, sizeof(library_name), "%s.%d", library, version); strtolower(library_name); /* Check if the library + version exists */ AILibraryList::iterator iter = this->library_list.find(library_name); if (iter == this->library_list.end()) { char error[1024]; /* Now see if the version doesn't exist, or the library */ iter = this->library_list.find(library); if (iter == this->library_list.end()) { snprintf(error, sizeof(error), "couldn't find library '%s'", library); } else { snprintf(error, sizeof(error), "couldn't find library '%s' version %d. The latest version available is %d", library, version, (*iter).second->GetVersion()); } sq_throwerror(vm, OTTD2SQ(error)); return false; } /* Get the current table/class we belong to */ HSQOBJECT parent; sq_getstackobj(vm, 1, &parent); char fake_class[1024]; int next_number; if (!controller->LoadedLibrary(library_name, &next_number, &fake_class[0], sizeof(fake_class))) { /* Create a new fake internal name */ snprintf(fake_class, sizeof(fake_class), "_internalNA%d", next_number); /* Load the library in a 'fake' namespace, so we can link it to the name the user requested */ sq_pushroottable(vm); sq_pushstring(vm, OTTD2SQ(fake_class), -1); sq_newclass(vm, SQFalse); /* Load the library */ if (!Squirrel::LoadScript(vm, (*iter).second->GetMainScript(), false)) { char error[1024]; snprintf(error, sizeof(error), "there was a compile error when importing '%s' version %d", library, version); sq_throwerror(vm, OTTD2SQ(error)); return false; } /* Create the fake class */ sq_newslot(vm, -3, SQFalse); sq_pop(vm, 1); controller->AddLoadedLibrary(library_name, fake_class); } /* Find the real class inside the fake class (like 'sets.Vector') */ sq_pushroottable(vm); sq_pushstring(vm, OTTD2SQ(fake_class), -1); if (SQ_FAILED(sq_get(vm, -2))) { sq_throwerror(vm, _SC("internal error assigning library class")); return false; } sq_pushstring(vm, OTTD2SQ((*iter).second->GetInstanceName()), -1); if (SQ_FAILED(sq_get(vm, -2))) { char error[1024]; snprintf(error, sizeof(error), "unable to find class '%s' in the library '%s' version %d", (*iter).second->GetInstanceName(), library, version); sq_throwerror(vm, OTTD2SQ(error)); return false; } HSQOBJECT obj; sq_getstackobj(vm, -1, &obj); sq_pop(vm, 3); if (StrEmpty(class_name)) { sq_pushobject(vm, obj); return true; } /* Now link the name the user wanted to our 'fake' class */ sq_pushobject(vm, parent); sq_pushstring(vm, OTTD2SQ(class_name), -1); sq_pushobject(vm, obj); sq_newclass(vm, SQTrue); sq_newslot(vm, -3, SQFalse); sq_pop(vm, 1); sq_pushobject(vm, obj); return true; }
template <> inline int Return<const char *>(HSQUIRRELVM vm, const char *res) { if (res == NULL) sq_pushnull(vm); else { sq_pushstring(vm, OTTD2SQ(res), -1); } return 1; }
/** * Throw a Squirrel error that will be nicely displayed to the user. */ void ThrowError(const char *error) { sq_throwerror(this->vm, OTTD2SQ(error)); }
/* static */ HSQOBJECT ScriptController::Import(const char *library, const char *class_name, int version) { ScriptController *controller = ScriptObject::GetActiveInstance()->GetController(); Squirrel *engine = ScriptObject::GetActiveInstance()->engine; HSQUIRRELVM vm = engine->GetVM(); /* Internally we store libraries as 'library.version' */ char library_name[1024]; snprintf(library_name, sizeof(library_name), "%s.%d", library, version); strtolower(library_name); ScriptInfo *lib = ScriptObject::GetActiveInstance()->FindLibrary(library, version); if (lib == NULL) { char error[1024]; snprintf(error, sizeof(error), "couldn't find library '%s' with version %d", library, version); throw sq_throwerror(vm, OTTD2SQ(error)); } /* Get the current table/class we belong to */ HSQOBJECT parent; sq_getstackobj(vm, 1, &parent); char fake_class[1024]; LoadedLibraryList::iterator iter = controller->loaded_library.find(library_name); if (iter != controller->loaded_library.end()) { ttd_strlcpy(fake_class, (*iter).second, sizeof(fake_class)); } else { int next_number = ++controller->loaded_library_count; /* Create a new fake internal name */ snprintf(fake_class, sizeof(fake_class), "_internalNA%d", next_number); /* Load the library in a 'fake' namespace, so we can link it to the name the user requested */ sq_pushroottable(vm); sq_pushstring(vm, OTTD2SQ(fake_class), -1); sq_newclass(vm, SQFalse); /* Load the library */ if (!engine->LoadScript(vm, lib->GetMainScript(), false)) { char error[1024]; snprintf(error, sizeof(error), "there was a compile error when importing '%s' version %d", library, version); throw sq_throwerror(vm, OTTD2SQ(error)); } /* Create the fake class */ sq_newslot(vm, -3, SQFalse); sq_pop(vm, 1); controller->loaded_library[strdup(library_name)] = strdup(fake_class); } /* Find the real class inside the fake class (like 'sets.Vector') */ sq_pushroottable(vm); sq_pushstring(vm, OTTD2SQ(fake_class), -1); if (SQ_FAILED(sq_get(vm, -2))) { throw sq_throwerror(vm, _SC("internal error assigning library class")); } sq_pushstring(vm, OTTD2SQ(lib->GetInstanceName()), -1); if (SQ_FAILED(sq_get(vm, -2))) { char error[1024]; snprintf(error, sizeof(error), "unable to find class '%s' in the library '%s' version %d", lib->GetInstanceName(), library, version); throw sq_throwerror(vm, OTTD2SQ(error)); } HSQOBJECT obj; sq_getstackobj(vm, -1, &obj); sq_pop(vm, 3); if (StrEmpty(class_name)) return obj; /* Now link the name the user wanted to our 'fake' class */ sq_pushobject(vm, parent); sq_pushstring(vm, OTTD2SQ(class_name), -1); sq_pushobject(vm, obj); sq_newclass(vm, SQTrue); sq_newslot(vm, -3, SQFalse); sq_pop(vm, 1); return obj; }
void Squirrel::AddConst(const char *var_name, bool value) { sq_pushstring(this->vm, OTTD2SQ(var_name), -1); sq_pushbool(this->vm, value); sq_newslot(this->vm, -3, SQTrue); }
void Squirrel::AddClassBegin(const char *class_name) { sq_pushroottable(this->vm); sq_pushstring(this->vm, OTTD2SQ(class_name), -1); sq_newclass(this->vm, SQFalse); }