void CSquirrelVM::Push(const CString& str)
{
sq_pushstring(m_pVM, str.Get(), str.GetLength());
}
void Interactive(HSQUIRRELVM v)
{
#define MAXINPUT 1024
SQChar buffer[MAXINPUT];
SQInteger blocks =0;
SQInteger string=0;
SQInteger retval=0;
SQInteger done=0;
PrintVersionInfos();
sq_pushroottable(v);
sq_pushstring(v,_SC("quit"),-1);
sq_pushuserpointer(v,&done);
sq_newclosure(v,quit,1);
sq_setparamscheck(v,1,NULL);
sq_newslot(v,-3,SQFalse);
sq_pop(v,1);
while (!done)
{
SQInteger i = 0;
scprintf(_SC("\nsq>"));
for(;;) {
int c;
if(done)return;
c = getchar();
if (c == _SC('\n')) {
if (i>0 && buffer[i-1] == _SC('\\'))
{
buffer[i-1] = _SC('\n');
}
else if(blocks==0)break;
buffer[i++] = _SC('\n');
}
else if (c==_SC('}')) {blocks--; buffer[i++] = (SQChar)c;}
else if(c==_SC('{') && !string){
blocks++;
buffer[i++] = (SQChar)c;
}
else if(c==_SC('"') || c==_SC('\'')){
string=!string;
buffer[i++] = (SQChar)c;
}
else if (i >= MAXINPUT-1) {
scfprintf(stderr, _SC("sq : input line too long\n"));
break;
}
else{
buffer[i++] = (SQChar)c;
}
}
buffer[i] = _SC('\0');
if(buffer[0]==_SC('=')){
scsprintf(sq_getscratchpad(v,MAXINPUT),_SC("return (%s)"),&buffer[1]);
memcpy(buffer,sq_getscratchpad(v,-1),(scstrlen(sq_getscratchpad(v,-1))+1)*sizeof(SQChar));
retval=1;
}
i=scstrlen(buffer);
if(i>0){
SQInteger oldtop=sq_gettop(v);
if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,_SC("interactive console"),SQTrue))){
sq_pushroottable(v);
if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) && retval){
scprintf(_SC("\n"));
sq_pushroottable(v);
sq_pushstring(v,_SC("print"),-1);
sq_get(v,-2);
sq_pushroottable(v);
sq_push(v,-4);
sq_call(v,2,SQFalse,SQTrue);
retval=0;
scprintf(_SC("\n"));
}
}
sq_settop(v,oldtop);
}
}
}
/*
* Returns default locale
*/
SQInteger emoGetDefaultLocale(HSQUIRRELVM v) {
sq_pushstring(v,
engine->javaGlue->callVoid_String("getDefaultLocale").c_str(), -1);
return 1;
}
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);
}
void Squirrel::AddClassBegin(const char *class_name)
{
sq_pushroottable(this->vm);
sq_pushstring(this->vm, OTTD2SQ(class_name), -1);
sq_newclass(this->vm, SQFalse);
}
/*
** 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;
}
// null 登録
void registNull(const tjs_char *functionName) {
sq_pushstring(v, functionName, -1);
sq_pushnull(v);
sq_createslot(v, -3);
}
static SQRESULT sq_zlib_version(HSQUIRRELVM v)
{
sq_pushstring(v, zlibVersion(), -1);
return 1;
}
/*
* returns latest database error message
*/
SQInteger emoDatabaseGetLastErrorMessage(HSQUIRRELVM v) {
const char* str = engine->database->lastErrorMessage.c_str();
sq_pushstring(v, str, strlen(str));
return 1;
}
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;
}
void Squirrel::AddConst(const char *var_name, int value)
{
sq_pushstring(this->vm, var_name, -1);
sq_pushinteger(this->vm, value);
sq_newslot(this->vm, -3, SQTrue);
}
void SquirrelVM::PushParam(const SQChar *s)
{
_CHECK_CALL_STATE
sq_pushstring(_VM,s,-1);
_CallState++;
}
ScriptBehavior::ScriptBehavior( HSQUIRRELVM vm,HSQOBJECT classObject,const std::map< tstring_symbol,ScriptParameterInterfacePtr >& scriptParameters )
: m_vm(vm)
, m_start(false)
{
int top = sq_gettop(m_vm);
sq_pushobject(m_vm, classObject);
sq_pushroottable( m_vm );
m_initialize = false;
m_haveAwake = false;
m_haveStart = false;
m_haveUpdate = false;
if( SQ_SUCCEEDED( sq_call( m_vm,1,SQTrue,SQTrue) ) )
{
if( SQ_SUCCEEDED( sq_getstackobj(m_vm, -1, &m_instance) ) )
{
sq_addref( m_vm,&m_instance );
m_initialize = true;
sq_pushstring( m_vm,_SC("Awake"),-1 );
if( SQ_SUCCEEDED( sq_get(m_vm,-2 ) ) )
{
if( SQ_SUCCEEDED( sq_getstackobj(m_vm, -1, &m_awakeFunction) ) )
{
sq_addref( m_vm,&m_awakeFunction );
m_haveAwake = true;
}
}
sq_pop(m_vm,1);
sq_pushstring( m_vm,_SC("Start"),-1 );
if( SQ_SUCCEEDED( sq_get(m_vm,-2 ) ) )
{
if( SQ_SUCCEEDED( sq_getstackobj(m_vm, -1, &m_startFunction) ) )
{
sq_addref( m_vm,&m_startFunction );
m_haveStart = true;
}
}
sq_pop(m_vm,1);
sq_pushstring( m_vm,_SC("Update"),-1 );
if( SQ_SUCCEEDED( sq_get(m_vm,-2 ) ) )
{
if( SQ_SUCCEEDED( sq_getstackobj(m_vm, -1, &m_updateFunction) ) )
{
sq_addref( m_vm,&m_updateFunction );
m_haveUpdate = true;
}
}
sq_pop(m_vm,1);
std::map< tstring_symbol,ScriptParameterInterfacePtr >::const_iterator it = scriptParameters.begin();
while( it!=scriptParameters.end() )
{
it->second->SetParameter( m_vm );
it++;
}
}
}
sq_settop( m_vm,top );
}
bool ScriptObject::_getSlot(const char* name) const
{
sq_pushobject(mSqvm, mObj);
sq_pushstring(mSqvm, name, -1);
return SQ_SUCCEEDED(sq_get(mSqvm, -2));
}
// getHostname()
SQInteger CServerNatives::GetHostName(SQVM * pVM)
{
sq_pushstring(pVM, CVAR_GET_STRING("hostname"), -1);
return 1;
}
static void _set_integer_slot(HSQUIRRELVM v,const SQChar *name,SQInteger val)
{
sq_pushstring(v,name,-1);
sq_pushinteger(v,val);
sq_rawset(v,-3);
}
// getWeaponName(weaponid)
SQInteger CServerNatives::GetWeaponName(SQVM * pVM)
{
SQInteger iWeaponId;
sq_getinteger(pVM, -1, &iWeaponId);
switch(iWeaponId)
{
case 0:
sq_pushstring(pVM, "Fists", -1);
break;
case 1:
sq_pushstring(pVM, "Baseball Bat", -1);
break;
case 2:
sq_pushstring(pVM, "Pool Cue", -1);
break;
case 3:
sq_pushstring(pVM, "Knife", -1);
break;
case 4:
sq_pushstring(pVM, "Grenade", -1);
break;
case 5:
sq_pushstring(pVM, "Molotov Cocktail", -1);
break;
case 7:
sq_pushstring(pVM, "Pistol", -1);
break;
case 9:
sq_pushstring(pVM, "Desert Eagle", -1);
break;
case 10:
sq_pushstring(pVM, "Shotgun", -1);
break;
case 11:
sq_pushstring(pVM, "Baretta", -1);
break;
case 12:
sq_pushstring(pVM, "Micro UZI", -1);
break;
case 13:
sq_pushstring(pVM, "MP5", -1);
break;
case 14:
sq_pushstring(pVM, "AK-47", -1);
break;
case 15:
sq_pushstring(pVM, "M4", -1);
break;
case 16:
sq_pushstring(pVM, "Sniper Rifle", -1);
break;
case 17:
sq_pushstring(pVM, "M40-A1", -1);
break;
case 18:
sq_pushstring(pVM, "Rocket Launcher", -1);
break;
case 19:
sq_pushstring(pVM, "Flame Thrower", -1);
break;
case 20:
sq_pushstring(pVM, "Minigun", -1);
break;
default:
sq_pushbool(pVM, false);
break;
}
return 1;
}
// ------------------------------------------------------------------------------------------------
SQInteger SockAddr::Typename(HSQUIRRELVM vm)
{
static const SQChar name[] = _SC("SqMMSockAddr");
sq_pushstring(vm, name, sizeof(name));
return 1;
}
/**
* クラスの登録
* @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;
}
inline SQRESULT getKey(HSQUIRRELVM vm, const char* key) {
sq_pushstring(vm, key, -1);
return sq_get(vm, -2);
}
// ------------------------------------------------------------------------------------------------
SQInteger LookupResult::Typename(HSQUIRRELVM vm)
{
static const SQChar name[] = _SC("SqMMLookupResult");
sq_pushstring(vm, name, sizeof(name));
return 1;
}
static SQInteger _regexp__typeof( HSQUIRRELVM v ) {
sq_pushstring( v, _SC( "regexp" ), -1 );
return 1;
}
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);
}
static SQInteger _string_format( HSQUIRRELVM v ) {
const SQChar *format;
SQChar *dest;
SQChar fmt[MAX_FORMAT_LEN];
sq_getstring( v, 2, &format );
SQInteger allocated = ( sq_getsize( v, 2 ) + 1 ) * sizeof( SQChar );
dest = sq_getscratchpad( v, allocated );
SQInteger n = 0, i = 0, nparam = 3, w = 0;
while ( format[n] != '\0' ) {
if ( format[n] != '%' ) {
assert( i < allocated );
dest[i++] = format[n];
n++;
} else if ( format[n+1] == '%' ) { //handles %%
dest[i++] = '%';
n += 2;
} else {
n++;
if ( nparam > sq_gettop( v ) )
return sq_throwerror( v, _SC( "not enough paramters for the given format string" ) );
n = validate_format( v, fmt, format, n, w );
if ( n < 0 ) return -1;
SQInteger addlen = 0;
SQInteger valtype = 0;
const SQChar *ts;
SQInteger ti;
SQFloat tf;
switch ( format[n] ) {
case 's':
if ( SQ_FAILED( sq_getstring( v, nparam, &ts ) ) )
return sq_throwerror( v, _SC( "string expected for the specified format" ) );
addlen = ( sq_getsize( v, nparam ) * sizeof( SQChar ) ) + ( ( w + 1 ) * sizeof( SQChar ) );
valtype = 's';
break;
case 'i': case 'd': case 'c': case 'o': case 'u': case 'x': case 'X':
if ( SQ_FAILED( sq_getinteger( v, nparam, &ti ) ) )
return sq_throwerror( v, _SC( "integer expected for the specified format" ) );
addlen = ( ADDITIONAL_FORMAT_SPACE ) + ( ( w + 1 ) * sizeof( SQChar ) );
valtype = 'i';
break;
case 'f': case 'g': case 'G': case 'e': case 'E':
if ( SQ_FAILED( sq_getfloat( v, nparam, &tf ) ) )
return sq_throwerror( v, _SC( "float expected for the specified format" ) );
addlen = ( ADDITIONAL_FORMAT_SPACE ) + ( ( w + 1 ) * sizeof( SQChar ) );
valtype = 'f';
break;
default:
return sq_throwerror( v, _SC( "invalid format" ) );
}
n++;
//if((allocated-i) < addlen)
allocated += addlen;
dest = sq_getscratchpad( v, allocated );
switch ( valtype ) {
case 's': i += scsprintf( &dest[i], fmt, ts ); break;
case 'i': i += scsprintf( &dest[i], fmt, ti ); break;
case 'f': i += scsprintf( &dest[i], fmt, tf ); break;
};
nparam ++;
}
}
sq_pushstring( v, dest, i );
return 1;
}
static SQInteger _file__typeof(HSQUIRRELVM v)
{
sq_pushstring(v,_SC("file"),-1);
return 1;
}
static SQRESULT sq_axtls_version(HSQUIRRELVM v){
sq_pushstring(v,(const char*)ssl_version(), -1);
return 1;
}
//<<FIXME>> this func is a mess
int getargs(HSQUIRRELVM v,int argc, char* argv[],SQInteger *retval)
{
int i;
int compiles_only = 0;
static SQChar temp[500];
const SQChar *ret=NULL;
char * output = NULL;
int lineinfo=0;
*retval = 0;
if(argc>1)
{
int arg=1,exitloop=0;
while(arg < argc && !exitloop)
{
if(argv[arg][0]=='-')
{
switch(argv[arg][1])
{
case 'd': //DEBUG(debug infos)
sq_enabledebuginfo(v,1);
break;
case 'c':
compiles_only = 1;
break;
case 'o':
if(arg < argc) {
arg++;
output = argv[arg];
}
break;
case 'v':
PrintVersionInfos();
return _DONE;
case 'h':
PrintVersionInfos();
PrintUsage();
return _DONE;
default:
PrintVersionInfos();
scprintf(_SC("unknown prameter '-%c'\n"),argv[arg][1]);
PrintUsage();
*retval = -1;
return _ERROR;
}
}else break;
arg++;
}
// src file
if(arg<argc) {
const SQChar *filename=NULL;
#ifdef SQUNICODE
mbstowcs(temp,argv[arg],strlen(argv[arg]));
filename=temp;
#else
filename=argv[arg];
#endif
arg++;
//sq_pushstring(v,_SC("ARGS"),-1);
//sq_newarray(v,0);
//sq_createslot(v,-3);
//sq_pop(v,1);
if(compiles_only) {
if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,SQTrue))){
const SQChar *outfile = _SC("out.cnut");
if(output) {
#ifdef SQUNICODE
int len = (int)(strlen(output)+1);
mbstowcs(sq_getscratchpad(v,len*sizeof(SQChar)),output,len);
outfile = sq_getscratchpad(v,-1);
#else
outfile = output;
#endif
}
if(SQ_SUCCEEDED(sqstd_writeclosuretofile(v,outfile)))
return _DONE;
}
}
else {
//if(SQ_SUCCEEDED(sqstd_dofile(v,filename,SQFalse,SQTrue))) {
//return _DONE;
//}
if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,SQTrue))) {
int callargs = 1;
sq_pushroottable(v);
for(i=arg;i<argc;i++)
{
const SQChar *a;
#ifdef SQUNICODE
int alen=(int)strlen(argv[i]);
a=sq_getscratchpad(v,(int)(alen*sizeof(SQChar)));
mbstowcs(sq_getscratchpad(v,-1),argv[i],alen);
sq_getscratchpad(v,-1)[alen] = _SC('\0');
#else
a=argv[i];
#endif
sq_pushstring(v,a,-1);
callargs++;
//sq_arrayappend(v,-2);
}
if(SQ_SUCCEEDED(sq_call(v,callargs,SQTrue,SQTrue))) {
SQObjectType type = sq_gettype(v,-1);
if(type == OT_INTEGER) {
*retval = type;
sq_getinteger(v,-1,retval);
}
return _DONE;
}
else{
return _ERROR;
}
}
}
//if this point is reached an error occured
{
const SQChar *err;
sq_getlasterror(v);
if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) {
scprintf(_SC("Error [%s]\n"),err);
*retval = -2;
return _ERROR;
}
}
}
}
return _INTERACTIVE;
}
// getServerPassword()
SQInteger CServerNatives::GetPassword(SQVM * pVM)
{
String sPass = CVAR_GET_STRING("password");
sq_pushstring(pVM, sPass.C_String(), sPass.GetLength());
return 1;
}
/*
* Returns OS name
*/
SQInteger emoRuntimeGetOSName(HSQUIRRELVM v) {
sq_pushstring(v, (SQChar*) OS_ANDROID, -1);
return 1;
}
void CSquirrelVM::RegisterClassFunction(const char* szFunctionName, scriptFunction pfnFunction, int iParameterCount, const char* szFunctionTemplate)
{
sq_pushstring(m_pVM, szFunctionName, -1);
sq_newclosure(m_pVM, (SQFUNCTION)pfnFunction, 0);
sq_newslot(m_pVM, -3, SQFalse);
}
