SQInteger SQLexer::GetIDType(const SQChar *s,SQInteger len)
{
SQObjectPtr t;
if(_keywords->GetStr(s,len, t)) {
return SQInteger(_integer(t));
}
return TK_IDENTIFIER;
}
SQInteger SQLexer::GetIDType(SQChar *s)
{
SQObjectPtr t;
if(_keywords->Get(SQString::Create(_sharedstate, s), t)) {
return SQInteger(_integer(t));
}
return TK_IDENTIFIER;
}
void SQFuncState::AddOuterValue(const SQObject &name)
{
SQInteger pos=-1;
if(_parent) {
pos = _parent->GetLocalVariable(name);
if(pos == -1) {
pos = _parent->GetOuterVariable(name);
if(pos != -1) {
_outervalues.push_back(SQOuterVar(name,SQObjectPtr(SQInteger(pos)),otOUTER)); //local
return;
}
}
else {
_outervalues.push_back(SQOuterVar(name,SQObjectPtr(SQInteger(pos)),otLOCAL)); //local
return;
}
}
_outervalues.push_back(SQOuterVar(name,name,otSYMBOL)); //global
}
void Printer::PrintArray(std::string *result, Sqrat::Array array) {
result->append("[");
for (int i = 0; i < array.GetSize(); i++) {
if (i > 0) {
result->append(",");
}
Sqrat::Object obj = array.GetSlot(SQInteger(i));
PrintValue(result, obj);
}
result->append("]");
}
SQInteger SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
{
SQInteger idx = (SQInteger)TranslateIndex(refpos);
while(idx < _len){
outkey = (SQInteger)idx;
outval = SQInteger(_val[idx]);
//return idx for the next iteration
return ++idx;
}
//nothing to iterate anymore
return -1;
}
bool str2num(const SQChar *s,SQObjectPtr &res)
{
SQChar *end;
if(scstrstr(s,_SC("."))){
SQFloat r = SQFloat(scstrtod(s,&end));
if(s == end) return false;
res = r;
return true;
}
else{
SQInteger r = SQInteger(scstrtol(s,&end,10));
if(s == end) return false;
res = r;
return true;
}
}
int main (int argc, char** argv)
{
ENABLE_LEAK_CHECK();
#if defined(SHELL_PLATFORM_WINDOWS)
SetConsoleTitle("Squirrel Shell " SHELL_VERSION_STR " (" SHELL_CPUARCH ")");
#else
stderrIsRedirected = !isatty(2);
#endif
// Parse command line arguments.
const char* fileName = NULL;
bool interactive = argc == 1;
int firstArg = 0,
i;
bool isDebug = false;
int debuggerPort = 0;
for (i = 1; argv[i]; ++i)
{
char* arg = argv[i];
if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
{
printf("Squirrel Shell %s for %s on %s (" __DATE__ ")\n"
SHELL_VERSION_COPYRIGHT "\n"
"\n"
"This is free software, and comes WITHOUT ANY WARRANTY; without even the implied\n"
"warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
"General Public License for more details.\n"
"\n"
"MD5 hash calculation code (c) Colin Plumb\n"
"PCRE (c) University of Cambridge\n"
"Squirrel (c) Alberto Demichelis\n"
"zlib (c) Jean-loup Gailly and Mark Adler\n"
"\n"
"Usage:\n"
" squirrelsh [options] [script_file] [script_arguments]\n"
"\n"
"Options:\n"
" -h, --help Display this text\n"
" -d<PORT> Enable the debugger, in the specified port\n"
" -i, --interactive Run shell in interactive mode\n"
" If script file is specified, it will be executed before\n"
" entering this mode\n"
" -s, --silent Do not display error and warning messages\n"
" -v, --version Display shell version number\n"
"\n"
"Examples:\n"
" squirrelsh Run shell in interactive mode\n"
" squirrelsh foo.nut Run foo.nut script without arguments\n"
" squirrelsh -i foo.nut 1 2 3 Run foo.nut script with arguments \"1\", \"2\"\n"
" and \"3\", and switch into interactive mode\n",
SHELL_VERSION_STR,
SHELL_PLATFORM,
SHELL_CPUARCH);
return EXIT_SUCCESS;
}
else if (!strncmp(arg, "-d", 2))
{
// RVF +
isDebug = true;
debuggerPort = std::atoi(arg + 2);
if (debuggerPort == 0)
{
printf("No debugger port specified\n");
return EXIT_FAILURE;
}
// RVF -
}
else if (!strcmp(arg, "-i") || !strcmp(arg, "--interactive"))
interactive = true;
else if (!strcmp(arg, "-v") || !strcmp(arg, "--version"))
{
printf("%s\n", SHELL_VERSION_STR);
return EXIT_SUCCESS;
}
else if (!strcmp(arg, "-s") || !strcmp(arg, "--silent"))
silent = true;
else
{
// First unreserved argument will be treated as script file name.
fileName = arg;
firstArg = i;
break;
}
}
if (!fileName && !interactive)
{
PrintError("ERROR: Script file not specified.\n");
return EXIT_FAILURE;
}
// Initialize Squirrel.
sqvm = sq_open(1024);
if (!sqvm)
{
PrintError("ERROR: Failed to create Squirrel VM.\n");
return EXIT_FAILURE;
}
sqstd_seterrorhandlers(sqvm);
HSQREMOTEDBG rdbg = nullptr;
if (isDebug)
{
rdbg = sq_rdbg_init(sqvm, debuggerPort, SQTrue);
sq_enabledebuginfo(sqvm, SQTrue);
//!! SUSPENDS THE APP UNTIL THE DEBUGGER CLIENT CONNECTS
scprintf("Waiting for the debugger to connect...\n");
if (!SQ_SUCCEEDED(sq_rdbg_waitforconnections(rdbg)))
{
PrintError("ERROR: Failed to connect to the debugger.\n");
return EXIT_FAILURE;
}
scprintf(_SC("Connected to the debugger\n"));
}
//sq_setcompilererrorhandler(sqvm, SquirrelCompileError);
_RPT0(_CRT_WARN, "--- Squirrel initialized\n");
// Register some globals.
SetSqString("SHELL_VERSION", SHELL_VERSION_STR, SQTrue);
SetSqString("SQUIRREL_VERSION", SQUIRREL_VERSION_SHORT, SQTrue);
SetSqString("PLATFORM", SHELL_PLATFORM, SQTrue);
SetSqString("CPU_ARCH", SHELL_CPUARCH, SQTrue);
// Initialize libraries.
Init_Base();
Init_IO();
Init_File();
Init_Math();
Init_Util();
Init_Hash();
Init_RegExp();
_RPT0(_CRT_WARN, "--- Libraries initialized\n");
// Set up global variables...
sq_pushroottable(sqvm);
// RVF +
// Initialize squirrel std libraries
//sqstd_register_bloblib(sqvm);
sqstd_register_iolib(sqvm); // We need this one because of the handy "dofile" function
sqstd_register_stringfunctions(sqvm); // This registers only some string functions that are useful and don't clash with Squirrel Shell
// NOTE: Not registering the other libraries, because there are name clashing between Squirrel Shell and SqStdLib
//sqstd_register_systemlib(sqvm);
//sqstd_register_mathlib(sqvm);
//sqstd_register_stringlib(sqvm);
// RVF -
// ... number of command line arguments...
sq_pushstring(sqvm, "__argc", -1);
sq_pushinteger(sqvm, SQInteger(argc - firstArg));
if (SQ_FAILED(sq_newslot(sqvm, -3, SQFalse)))
{
PrintError("ERROR: Failed to create \"__argc\" integer value.\n");
Shutdown();
return EXIT_FAILURE;
}
// ... and arguments themselves.
sq_pushstring(sqvm, "__argv", -1);
sq_newarray(sqvm, 0);
for (i = firstArg; argv[i]; ++i)
{
sq_pushstring(sqvm, argv[i], -1);
sq_arrayappend(sqvm, -2);
}
if (SQ_FAILED(sq_newslot(sqvm, -3, SQFalse)))
{
PrintError("ERROR: Failed to create \"__argv\" array.\n");
Shutdown();
return EXIT_FAILURE;
}
sq_pop(sqvm, 1);
// Load and run script.
SQInteger result = EXIT_SUCCESS;
if (fileName && LoadScript(fileName))
{
sq_pushroottable(sqvm);
if (SQ_FAILED(sq_call(sqvm, 1, SQTrue, isDebug ? SQTrue : SQFalse)))
{
if (!silent)
{
const SQChar* errMsg = "Unknown error.";
sq_getlasterror(sqvm);
if (sq_gettype(sqvm, -1) == OT_STRING)
sq_getstring(sqvm, -1, &errMsg);
PrintError("ERROR: %s\n", errMsg);
}
Shutdown();
return EXIT_FAILURE;
}
// Get script execution result.
if (sq_getvmstate(sqvm) == SQ_VMSTATE_SUSPENDED)
result = retCode;
else
{
if (sq_gettype(sqvm, -1) == OT_INTEGER)
sq_getinteger(sqvm, -1, &result);
}
// Pop everything except root table.
sq_settop(sqvm, 1);
}
// Enter interactive mode (if necessary).
if (interactive)
{
SQChar cmd[MAX_CMD_LENGTH + 1];
do
{
#if defined(SHELL_PLATFORM_WINDOWS)
GetCurrentDirectory(sizeof(cmd), cmd);
#else
getcwd(cmd, sizeof(cmd));
#endif
cmd[sizeof(cmd) - 1] = 0;
printf("%s> ", ConvPath(cmd, SQFalse));
fgets(cmd, MAX_CMD_LENGTH, stdin);
if (SQ_FAILED(sq_compilebuffer(sqvm, cmd, SQInteger(strlen(cmd)), "", SQTrue)))
continue;
sq_pushroottable(sqvm);
if (SQ_FAILED(sq_call(sqvm, 1, SQFalse, SQFalse)) && !silent)
{
const SQChar* errMsg = "Unknown error.";
sq_getlasterror(sqvm);
if (sq_gettype(sqvm, -1) == OT_STRING)
sq_getstring(sqvm, -1, &errMsg);
PrintError("ERROR: %s\n", errMsg);
}
} while(sq_getvmstate(sqvm) != SQ_VMSTATE_SUSPENDED);
result = retCode;
}
if (isDebug)
{
sq_rdbg_shutdown(rdbg);
}
Shutdown();
return int(result);
}
// Load script from file
// Script is first read into memory buffer and then line beginning with "#!" (line with script interpreter specification in
// Linux) is converted into Squirrel comment. This line must be BEFORE actual script text
static bool LoadScript (const char* fileName)
{
bool res = false;
FILE* file = NULL;
SQChar* buf = NULL;
// RVF +
std::string canonicalizedFilename = prepareFilename(fileName);
fileName = canonicalizedFilename.c_str();
// RVF -
try
{
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
if (fopen_s(&file, ConvPath(fileName, SQTrue), "rb"))
file = NULL;
#else
file = fopen(ConvPath(fileName, SQTrue), "rb");
#endif
if (!file)
throw "Failed to open the file";
fseek(file, 0, SEEK_END);
SQInteger size = SQInteger(ftell(file));
if (!size)
throw "File is empty";
buf = (SQChar*)malloc(size + 1);
if (!buf)
throw "Not enough memory for script";
fseek(file, 0, SEEK_SET);
if (!fread(buf, size, 1, file))
throw "Failed to read script";
buf[size - 1] = 0;
for (SQChar* c = buf; *c; ++c)
{
if (!isspace(*c))
{
if ((c[0] == '#') && (c[1] == '!'))
c[0] = c[1] = '/';
break;
}
}
if (SQ_FAILED(sq_compilebuffer(sqvm, buf, size, fileName, SQTrue)))
throw "Failed to compile script";
res = true;
}
catch (const char* errMsg)
{
PrintError("ERROR: %s: %s.\n", fileName, errMsg);
}
if (file)
fclose(file);
free(buf);
return res;
}
/* static */ bool ScriptObject::DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint cmd, const char *text, Script_SuspendCallbackProc *callback)
{
if (!ScriptObject::CanSuspend()) {
throw Script_FatalError("You are not allowed to execute any DoCommand (even indirect) in your constructor, Save(), Load(), and any valuator.");
}
if (ScriptObject::GetCompany() != OWNER_DEITY && !::Company::IsValidID(ScriptObject::GetCompany())) {
ScriptObject::SetLastError(ScriptError::ERR_PRECONDITION_INVALID_COMPANY);
return false;
}
assert(StrEmpty(text) || (GetCommandFlags(cmd) & CMD_STR_CTRL) != 0 || StrValid(text, text + strlen(text)));
/* Set the default callback to return a true/false result of the DoCommand */
if (callback == NULL) callback = &ScriptInstance::DoCommandReturn;
/* Are we only interested in the estimate costs? */
bool estimate_only = GetDoCommandMode() != NULL && !GetDoCommandMode()();
#ifdef ENABLE_NETWORK
/* Only set p2 when the command does not come from the network. */
if (GetCommandFlags(cmd) & CMD_CLIENT_ID && p2 == 0) p2 = UINT32_MAX;
#endif
/* Try to perform the command. */
CommandCost res = ::DoCommandPInternal(tile, p1, p2, cmd, (_networking && !_generating_world) ? ScriptObject::GetActiveInstance()->GetDoCommandCallback() : NULL, text, false, estimate_only);
/* We failed; set the error and bail out */
if (res.Failed()) {
SetLastError(ScriptError::StringToError(res.GetErrorMessage()));
return false;
}
/* No error, then clear it. */
SetLastError(ScriptError::ERR_NONE);
/* Estimates, update the cost for the estimate and be done */
if (estimate_only) {
IncreaseDoCommandCosts(res.GetCost());
return true;
}
/* Costs of this operation. */
SetLastCost(res.GetCost());
SetLastCommandRes(true);
if (_generating_world) {
IncreaseDoCommandCosts(res.GetCost());
if (callback != NULL) {
/* Insert return value into to stack and throw a control code that
* the return value in the stack should be used. */
callback(GetActiveInstance());
throw SQInteger(1);
}
return true;
} else if (_networking) {
/* Suspend the script till the command is really executed. */
throw Script_Suspend(-(int)GetDoCommandDelay(), callback);
} else {
IncreaseDoCommandCosts(res.GetCost());
/* Suspend the script player for 1+ ticks, so it simulates multiplayer. This
* both avoids confusion when a developer launched his script in a
* multiplayer game, but also gives time for the GUI and human player
* to interact with the game. */
throw Script_Suspend(GetDoCommandDelay(), callback);
}
NOT_REACHED();
}
static SQInteger default_delegate_len(HSQUIRRELVM v)
{
v->Push(SQInteger(sq_getsize(v,1)));
return 1;
}
//
// JsonPrinter
//
void JsonPrinter::PrintArray(Json::Value &value, Sqrat::Array array) {
for (int i = 0; i < array.GetSize(); i++) {
Sqrat::Object obj = array.GetSlot(SQInteger(i));
value.append(PrintValue(obj));
}
}
