SQInteger SQLexer::GetIDType(SQChar *s)
{
SQObjectPtr t;
if(_keywords->Get(SQString::Create(_sharedstate, s), t)) {
return SQInteger(_integer(t));
}
return TK_IDENTIFIER;
}
SQInteger SQLexer::GetIDType(const SQChar *s,SQInteger len)
{
SQObjectPtr t;
if(_keywords->GetStr(s,len, t)) {
return SQInteger(_integer(t));
}
return TK_IDENTIFIER;
}
bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
{
SQInteger res;
SQInteger i1 = _integer(o1), i2 = _integer(o2);
if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER))
{
switch(op) {
case BW_AND: res = i1 & i2; break;
case BW_OR: res = i1 | i2; break;
case BW_XOR: res = i1 ^ i2; break;
case BW_SHIFTL: res = i1 << i2; break;
case BW_SHIFTR: res = i1 >> i2; break;
case BW_USHIFTR:res = (SQInteger)(*((SQUnsignedInteger*)&i1) >> i2); break;
default: { Raise_Error(_SC("internal vm error bitwise op failed")); return false; }
}
}
else { Raise_Error(_SC("bitwise op between '%s' and '%s'"),GetTypeName(o1),GetTypeName(o2)); return false;}
SQInteger SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name)
{
if(type(name) != OT_STRING)
return -1;
SQObjectPtr ret;
if(_table(_metamethodsmap)->Get(name,ret)) {
return _integer(ret);
}
return -1;
}
SQUnsignedInteger TranslateIndex( const SQObjectPtr &idx ) {
switch ( type( idx ) ) {
case OT_NULL:
return 0;
case OT_INTEGER:
return ( SQUnsignedInteger )_integer( idx );
}
assert( 0 );
return 0;
}
const SQChar *SQLexer::Tok2Str(SQInteger tok)
{
SQObjectPtr itr, key, val;
SQInteger nitr;
while((nitr = _keywords->Next(false,itr, key, val)) != -1) {
itr = (SQInteger)nitr;
if(((SQInteger)_integer(val)) == tok)
return _stringval(key);
}
return NULL;
}
SQInteger SQFuncState::GetConstant(const SQObject &cons)
{
SQObjectPtr val;
if(!_table(_literals)->Get(cons,val))
{
val = _nliterals;
_table(_literals)->NewSlot(cons,val);
_nliterals++;
if(_nliterals > MAX_LITERALS) {
val.Null();
Error(_SC("internal compiler error: too many literals"));
}
}
return _integer(val);
}
SQString *SQVM::PrintObjVal(const SQObject &o)
{
char buf[NUMBER_MAX_CHAR+1];
switch(type(o)) {
case OT_STRING: return _string(o);
case OT_INTEGER:
seprintf(buf, lastof(buf), OTTD_PRINTF64, _integer(o));
return SQString::Create(_ss(this), buf);
case OT_FLOAT:
seprintf(buf, lastof(buf), "%.14g", _float(o));
return SQString::Create(_ss(this), buf);
default:
return SQString::Create(_ss(this), GetTypeName(o));
}
}
SQString *SQVM::PrintObjVal(const SQObject &o)
{
switch(type(o)) {
case OT_STRING: return _string(o);
case OT_INTEGER:
// C::B patch: Support for Windows 64 bit
#if defined(_WIN64)
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%I64d"), _integer(o));
// C::B patch: Support for Linux 64 bit
#elif defined(_SQ64)
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%ld"), _integer(o));
#else
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%d"), _integer(o));
#endif
return SQString::Create(_ss(this), _spval);
break;
case OT_FLOAT:
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%.14g"), _float(o));
return SQString::Create(_ss(this), _spval);
break;
default:
return SQString::Create(_ss(this), GetTypeName(o));
}
}
SQString *SQVM::PrintObjVal(const SQObject &o)
{
switch(type(o)) {
case OT_STRING: return _string(o);
case OT_INTEGER:
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%d"), _integer(o));
return SQString::Create(_ss(this), _spval);
break;
case OT_FLOAT:
scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%.14g"), _float(o));
return SQString::Create(_ss(this), _spval);
break;
default:
return SQString::Create(_ss(this), GetTypeName(o));
}
}
bool WriteObject( HSQUIRRELVM v, SQUserPointer up, SQWRITEFUNC write, SQObjectPtr &o ) {
_CHECK_IO( SafeWrite( v, write, up, &type( o ), sizeof( SQObjectType ) ) );
switch ( type( o ) ) {
case OT_STRING:
_CHECK_IO( SafeWrite( v, write, up, &_string( o )->_len, sizeof( SQInteger ) ) );
_CHECK_IO( SafeWrite( v, write, up, _stringval( o ), rsl( _string( o )->_len ) ) );
break;
case OT_INTEGER:
_CHECK_IO( SafeWrite( v, write, up, &_integer( o ), sizeof( SQInteger ) ) );break;
case OT_FLOAT:
_CHECK_IO( SafeWrite( v, write, up, &_float( o ), sizeof( SQFloat ) ) );break;
case OT_NULL:
break;
default:
v->Raise_Error( _SC( "cannot serialize a %s" ), GetTypeName( o ) );
return false;
}
return true;
}
static SQInteger default_delegate_tointeger(HSQUIRRELVM v)
{
SQObjectPtr &o=stack_get(v,1);
switch(type(o)){
case OT_STRING:{
SQObjectPtr res;
if(str2num(_stringval(o),res)){
v->Push(SQObjectPtr(tointeger(res)));
break;
}}
return sq_throwerror(v, _SC("cannot convert the string"));
break;
case OT_INTEGER:case OT_FLOAT:
v->Push(SQObjectPtr(tointeger(o)));
break;
case OT_BOOL:
v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0));
break;
default:
v->Push(_null_);
break;
}
return 1;
}
void SQFuncState::Dump(SQFunctionProto *func)
{
SQUnsignedInteger n=0,i;
SQInteger si;
scprintf(_SC("SQInstruction sizeof %d\n"),sizeof(SQInstruction));
scprintf(_SC("SQObject sizeof %d\n"),sizeof(SQObject));
scprintf(_SC("--------------------------------------------------------------------\n"));
scprintf(_SC("*****FUNCTION [%s]\n"),type(func->_name)==OT_STRING?_stringval(func->_name):_SC("unknown"));
scprintf(_SC("-----LITERALS\n"));
SQObjectPtr refidx,key,val;
SQInteger idx;
SQObjectPtrVec templiterals;
templiterals.resize(_nliterals);
while((idx=_table(_literals)->Next(false,refidx,key,val))!=-1) {
refidx=idx;
templiterals[_integer(val)]=key;
}
for(i=0;i<templiterals.size();i++){
scprintf(_SC("[%d] "),n);
DumpLiteral(templiterals[i]);
scprintf(_SC("\n"));
n++;
}
scprintf(_SC("-----PARAMS\n"));
if(_varparams)
scprintf(_SC("<<VARPARAMS>>\n"));
n=0;
for(i=0;i<_parameters.size();i++){
scprintf(_SC("[%d] "),n);
DumpLiteral(_parameters[i]);
scprintf(_SC("\n"));
n++;
}
scprintf(_SC("-----LOCALS\n"));
for(si=0;si<func->_nlocalvarinfos;si++){
SQLocalVarInfo lvi=func->_localvarinfos[si];
scprintf(_SC("[%d] %s \t%d %d\n"),lvi._pos,_stringval(lvi._name),lvi._start_op,lvi._end_op);
n++;
}
scprintf(_SC("-----LINE INFO\n"));
for(i=0;i<_lineinfos.size();i++){
SQLineInfo li=_lineinfos[i];
scprintf(_SC("op [%d] line [%d] \n"),li._op,li._line);
n++;
}
scprintf(_SC("-----dump\n"));
n=0;
for(i=0;i<_instructions.size();i++){
SQInstruction &inst=_instructions[i];
if(inst.op==_OP_LOAD || inst.op==_OP_DLOAD || inst.op==_OP_PREPCALLK || inst.op==_OP_GETK ){
SQInteger lidx = inst._arg1;
scprintf(_SC("[%03d] %15s %d "),n,g_InstrDesc[inst.op].name,inst._arg0);
if(lidx >= 0xFFFFFFFF)
scprintf(_SC("null"));
else {
SQInteger refidx;
SQObjectPtr val,key,refo;
while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) {
refo = refidx;
}
DumpLiteral(key);
}
if(inst.op != _OP_DLOAD) {
scprintf(_SC(" %d %d \n"),inst._arg2,inst._arg3);
}
else {
scprintf(_SC(" %d "),inst._arg2);
lidx = inst._arg3;
if(lidx >= 0xFFFFFFFF)
scprintf(_SC("null"));
else {
SQInteger refidx;
SQObjectPtr val,key,refo;
while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) {
refo = refidx;
}
DumpLiteral(key);
scprintf(_SC("\n"));
}
}
}
else if(inst.op==_OP_LOADFLOAT) {
scprintf(_SC("[%03d] %15s %d %f %d %d\n"),n,g_InstrDesc[inst.op].name,inst._arg0,*((SQFloat*)&inst._arg1),inst._arg2,inst._arg3);
}
/* else if(inst.op==_OP_ARITH){
scprintf(_SC("[%03d] %15s %d %d %d %c\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
}*/
else {
scprintf(_SC("[%03d] %15s %d %d %d %d\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
}
n++;
}
scprintf(_SC("-----\n"));
scprintf(_SC("stack size[%d]\n"),func->_stacksize);
scprintf(_SC("--------------------------------------------------------------------\n\n"));
}
