text: /*
  	see copyright notice in squirrel.h
  */
  #include "sqpcheader.h"
  #ifndef NO_COMPILER
  #include <stdarg.h>
  #include <setjmp.h>
  #include "sqopcodes.h"
  #include "sqstring.h"
  #include "sqfuncproto.h"
  #include "sqcompiler.h"
  #include "sqfuncstate.h"
  #include "sqlexer.h"
  #include "sqvm.h"
  #include "sqtable.h"
  
  #define EXPR   1
  #define OBJECT 2
  #define BASE   3
  #define LOCAL  4
  #define OUTER  5
  
  struct SQExpState {
    SQInteger  etype;       /* expr. type; one of EXPR, OBJECT, BASE, OUTER or LOCAL */
    SQInteger  epos;        /* expr. location on stack; -1 for OBJECT and BASE */
    bool       donot_get;   /* signal not to deref the next value */
  };
  
  struct SQScope {
  	SQInteger outers;
  	SQInteger stacksize;
  };
  
  #define BEGIN_SCOPE() SQScope __oldscope__ = _scope; \
  					 _scope.outers = _fs->_outers; \
  					 _scope.stacksize = _fs->GetStackSize();
  
  #define RESOLVE_OUTERS() if(_fs->GetStackSize() != _scope.stacksize) { \
  							if(_fs->CountOuters(_scope.stacksize)) { \
  								_fs->AddInstruction(_OP_CLOSE,0,_scope.stacksize); \
  							} \
  						}
  
  #define END_SCOPE_NO_CLOSE() {	if(_fs->GetStackSize() != _scope.stacksize) { \
  							_fs->SetStackSize(_scope.stacksize); \
  						} \
  						_scope = __oldscope__; \
  					}
  
  #define END_SCOPE() {	SQInteger oldouters = _fs->_outers;\
  						if(_fs->GetStackSize() != _scope.stacksize) { \
  							_fs->SetStackSize(_scope.stacksize); \
  							if(oldouters != _fs->_outers) { \
  								_fs->AddInstruction(_OP_CLOSE,0,_scope.stacksize); \
  							} \
  						} \
  						_scope = __oldscope__; \
  					}
  
  #define BEGIN_BREAKBLE_BLOCK()	SQInteger __nbreaks__=_fs->_unresolvedbreaks.size(); \
  							SQInteger __ncontinues__=_fs->_unresolvedcontinues.size(); \
  							_fs->_breaktargets.push_back(0);_fs->_continuetargets.push_back(0);
  
  #define END_BREAKBLE_BLOCK(continue_target) {__nbreaks__=_fs->_unresolvedbreaks.size()-__nbreaks__; \
  					__ncontinues__=_fs->_unresolvedcontinues.size()-__ncontinues__; \
  					if(__ncontinues__>0)ResolveContinues(_fs,__ncontinues__,continue_target); \
  					if(__nbreaks__>0)ResolveBreaks(_fs,__nbreaks__); \
  					_fs->_breaktargets.pop_back();_fs->_continuetargets.pop_back();}
  
  class SQCompiler
  {
  public:
  	SQCompiler(SQVM *v, SQLEXREADFUNC rg, SQUserPointer up, const SQChar* sourcename, bool raiseerror, bool lineinfo)
  	{
  		_vm=v;
  		_lex.Init(_ss(v), rg, up,ThrowError,this);
  		_sourcename = SQString::Create(_ss(v), sourcename);
  		_lineinfo = lineinfo;_raiseerror = raiseerror;
  		_scope.outers = 0;
  		_scope.stacksize = 0;
  		compilererror = NULL;
  	}
  	static void ThrowError(void *ud, const SQChar *s) {
  		SQCompiler *c = (SQCompiler *)ud;
  		c->Error(s);
  	}
  	void Error(const SQChar *s, ...)
  	{
  		static SQChar temp[256];
  		va_list vl;
  		va_start(vl, s);
  		scvsprintf(temp, s, vl);
  		va_end(vl);
  		compilererror = temp;
  		longjmp(_errorjmp,1);
  	}
  	void Lex(){	_token = _lex.Lex();}
  	SQObject Expect(SQInteger tok)
  	{
  		
  		if(_token != tok) {
  			if(_token == TK_CONSTRUCTOR && tok == TK_IDENTIFIER) {
  				//do nothing
  			}
  			else {
  				const SQChar *etypename;
  				if(tok > 255) {
  					switch(tok)
  					{
  					case TK_IDENTIFIER:
  						etypename = _SC("IDENTIFIER");
  						break;
  					case TK_STRING_LITERAL:
  						etypename = _SC("STRING_LITERAL");
  						break;
  					case TK_INTEGER:
  						etypename = _SC("INTEGER");
  						break;
  					case TK_FLOAT:
  						etypename = _SC("FLOAT");
  						break;
  					default:
  						etypename = _lex.Tok2Str(tok);
  					}
  					Error(_SC("expected '%s'"), etypename);
  				}
  				Error(_SC("expected '%c'"), tok);
  			}
  		}
  		SQObjectPtr ret;
  		switch(tok)
  		{
  		case TK_IDENTIFIER:
  			ret = _fs->CreateString(_lex._svalue);
  			break;
  		case TK_STRING_LITERAL:
  			ret = _fs->CreateString(_lex._svalue,_lex._longstr.size()-1);
  			break;
  		case TK_INTEGER:
  			ret = SQObjectPtr(_lex._nvalue);
  			break;
  		case TK_FLOAT:
  			ret = SQObjectPtr(_lex._fvalue);
  			break;
  		}
  		Lex();
  		return ret;
  	}
  	bool IsEndOfStatement() { return ((_lex._prevtoken == _SC('\n')) || (_token == SQUIRREL_EOB) || (_token == _SC('}')) || (_token == _SC(';'))); }
  	void OptionalSemicolon()
  	{
  		if(_token == _SC(';')) { Lex(); return; }
  		if(!IsEndOfStatement()) {
  			Error(_SC("end of statement expected (; or lf)"));
  		}
  	}
  	void MoveIfCurrentTargetIsLocal() {
  		SQInteger trg = _fs->TopTarget();
  		if(_fs->IsLocal(trg)) {
  			trg = _fs->PopTarget(); //no pops the target and move it
  			_fs->AddInstruction(_OP_MOVE, _fs->PushTarget(), trg);
  		}
  	}
  	bool Compile(SQObjectPtr &o)
  	{
  		_debugline = 1;
  		_debugop = 0;
  
  		SQFuncState funcstate(_ss(_vm), NULL,ThrowError,this);
  		funcstate._name = SQString::Create(_ss(_vm), _SC("main"));
  		_fs = &funcstate;
  		_fs->AddParameter(_fs->CreateString(_SC("this")));
  		_fs->AddParameter(_fs->CreateString(_SC("vargv")));
  		_fs->_varparams = true;
  		_fs->_sourcename = _sourcename;
  		SQInteger stacksize = _fs->GetStackSize();
  		if(setjmp(_errorjmp) == 0) {
  			Lex();
  			while(_token > 0){
  				Statement();
  				if(_lex._prevtoken != _SC('}') && _lex._prevtoken != _SC(';')) OptionalSemicolon();
  			}
  			_fs->SetStackSize(stacksize);
  			_fs->AddLineInfos(_lex._currentline, _lineinfo, true);
  			_fs->AddInstruction(_OP_RETURN, 0xFF);
  			_fs->SetStackSize(0);
  			o =_fs->BuildProto();
  #ifdef _DEBUG_DUMP
  			_fs->Dump(_funcproto(o));
  #endif
  		}
  		else {
  			if(_raiseerror && _ss(_vm)->_compilererrorhandler) {
  				_ss(_vm)->_compilererrorhandler(_vm, compilererror, type(_sourcename) == OT_STRING?_stringval(_sourcename):_SC("unknown"),
  					_lex._currentline, _lex._currentcolumn);
  			}
  			_vm->_lasterror = SQString::Create(_ss(_vm), compilererror, -1);
  			return false;
  		}
  		return true;
  	}
  	void Statements()
  	{
  		while(_token != _SC('}') && _token != TK_DEFAULT && _token != TK_CASE) {
  			Statement();
  			if(_lex._prevtoken != _SC('}') && _lex._prevtoken != _SC(';')) OptionalSemicolon();
  		}
  	}
  	void Statement(bool closeframe = true)
  	{
  		_fs->AddLineInfos(_lex._currentline, _lineinfo);
  		switch(_token){
  		case _SC(';'):	Lex();					break;
  		case TK_IF:		IfStatement();			break;
  		case TK_WHILE:		WhileStatement();		break;
  		case TK_DO:		DoWhileStatement();		break;
  		case TK_FOR:		ForStatement();			break;
  		case TK_FOREACH:	ForEachStatement();		break;
  		case TK_SWITCH:	SwitchStatement();		break;
  		case TK_LOCAL:		LocalDeclStatement();	break;
  		case TK_RETURN:
  		case TK_YIELD: {
  			SQOpcode op;
  			if(_token == TK_RETURN) {
  				op = _OP_RETURN;
  			}
  			else {
  				op = _OP_YIELD;
  				_fs->_bgenerator = true;
  			}
  			Lex();
  			if(!IsEndOfStatement()) {
  				SQInteger retexp = _fs->GetCurrentPos()+1;
  				CommaExpr();
  				if(op == _OP_RETURN && _fs->_traps > 0)
  					_fs->AddInstruction(_OP_POPTRAP, _fs->_traps, 0);
  				_fs->_returnexp = retexp;
  				_fs->AddInstruction(op, 1, _fs->PopTarget(),_fs->GetStackSize());
  			}
  			else{ 
  				if(op == _OP_RETURN && _fs->_traps > 0)
  					_fs->AddInstruction(_OP_POPTRAP, _fs->_traps ,0);
  				_fs->_returnexp = -1;
  				_fs->AddInstruction(op, 0xFF,0,_fs->GetStackSize()); 
  			}
  			break;}
  		case TK_BREAK:
  			if(_fs->_breaktargets.size() <= 0)Error(_SC("'break' has to be in a loop block"));
  			if(_fs->_breaktargets.top() > 0){
  				_fs->AddInstruction(_OP_POPTRAP, _fs->_breaktargets.top(), 0);
  			}
  			RESOLVE_OUTERS();
  			_fs->AddInstruction(_OP_JMP, 0, -1234);
  			_fs->_unresolvedbreaks.push_back(_fs->GetCurrentPos());
  			Lex();
  			break;
  		case TK_CONTINUE:
  			if(_fs->_continuetargets.size() <= 0)Error(_SC("'continue' has to be in a loop block"));
  			if(_fs->_continuetargets.top() > 0) {
  				_fs->AddInstruction(_OP_POPTRAP, _fs->_continuetargets.top(), 0);
  			}
  			RESOLVE_OUTERS();
  			_fs->AddInstruction(_OP_JMP, 0, -1234);
  			_fs->_unresolvedcontinues.push_back(_fs->GetCurrentPos());
  			Lex();
  			break;
  		case TK_FUNCTION:
  			FunctionStatement();
  			break;
  		case TK_CLASS:
  			ClassStatement();
  			break;
  		case TK_ENUM:
  			EnumStatement();
  			break;
  		case _SC('{'):{
  				BEGIN_SCOPE();
  				Lex();
  				Statements();
  				Expect(_SC('}'));
  				if(closeframe) {
  					END_SCOPE();
  				}
  				else {
  					END_SCOPE_NO_CLOSE();
  				}
  			}
  			break;
  		case TK_TRY:
  			TryCatchStatement();
  			break;
  		case TK_THROW:
  			Lex();
  			CommaExpr();
  			_fs->AddInstruction(_OP_THROW, _fs->PopTarget());
  			break;
  		case TK_CONST:
  			{
  			Lex();
  			SQObject id = Expect(TK_IDENTIFIER);
  			Expect('=');
  			SQObject val = ExpectScalar();
  			OptionalSemicolon();
  			SQTable *enums = _table(_ss(_vm)->_consts);
  			SQObjectPtr strongid = id; 
  			enums->NewSlot(strongid,SQObjectPtr(val));
  			strongid.Null();
  			}
  			break;
  		default:
  			CommaExpr();
  			_fs->DiscardTarget();
  			//_fs->PopTarget();
  			break;
  		}
  		_fs->SnoozeOpt();
  	}
  	void EmitDerefOp(SQOpcode op)
  	{
  		SQInteger val = _fs->PopTarget();
  		SQInteger key = _fs->PopTarget();
  		SQInteger src = _fs->PopTarget();
          _fs->AddInstruction(op,_fs->PushTarget(),src,key,val);
  	}
  	void Emit2ArgsOP(SQOpcode op, SQInteger p3 = 0)
  	{
  		SQInteger p2 = _fs->PopTarget(); //src in OP_GET
  		SQInteger p1 = _fs->PopTarget(); //key in OP_GET
  		_fs->AddInstruction(op,_fs->PushTarget(), p1, p2, p3);
  	}
  	void EmitCompoundArith(SQInteger tok, SQInteger etype, SQInteger pos)
  	{
  		/* Generate code depending on the expression type */
  		switch(etype) {
  		case LOCAL:{
  			SQInteger p2 = _fs->PopTarget(); //src in OP_GET
  			SQInteger p1 = _fs->PopTarget(); //key in OP_GET
  			_fs->PushTarget(p1);
  			//EmitCompArithLocal(tok, p1, p1, p2);
  			_fs->AddInstruction(ChooseArithOpByToken(tok),p1, p2, p1, 0);
  				   }
  			break;
  		case OBJECT:
  		case BASE:
  			{
  				SQInteger val = _fs->PopTarget();
  				SQInteger key = _fs->PopTarget();
  				SQInteger src = _fs->PopTarget();
  				/* _OP_COMPARITH mixes dest obj and source val in the arg1 */
  				_fs->AddInstruction(_OP_COMPARITH, _fs->PushTarget(), (src<<16)|val, key, ChooseCompArithCharByToken(tok));
  			}
  			break;
  		case OUTER:
  			{
  				SQInteger val = _fs->TopTarget();
  				SQInteger tmp = _fs->PushTarget();
  				_fs->AddInstruction(_OP_GETOUTER,   tmp, pos);
  				_fs->AddInstruction(ChooseArithOpByToken(tok), tmp, val, tmp, 0);
  				_fs->AddInstruction(_OP_SETOUTER, tmp, pos, tmp);
  			}
  			break;
  		}
  	}
  	void CommaExpr()
  	{
  		for(Expression();_token == ',';_fs->PopTarget(), Lex(), CommaExpr());
  	}
  	void Expression()
  	{
  		 SQExpState es = _es;
  		_es.etype     = EXPR;
  		_es.epos      = -1;
  		_es.donot_get = false;
  		LogicalOrExp();
  		switch(_token)  {
  		case _SC('='):
  		case TK_NEWSLOT:
  		case TK_MINUSEQ:
  		case TK_PLUSEQ:
  		case TK_MULEQ:
  		case TK_DIVEQ:
  		case TK_MODEQ:{
  			SQInteger op = _token;
  			SQInteger ds = _es.etype;
  			SQInteger pos = _es.epos;
  			if(ds == EXPR) Error(_SC("can't assign expression"));
  			Lex(); Expression();
  
  			switch(op){
  			case TK_NEWSLOT:
  				if(ds == OBJECT || ds == BASE)
  					EmitDerefOp(_OP_NEWSLOT);
  				else //if _derefstate != DEREF_NO_DEREF && DEREF_FIELD so is the index of a local
  					Error(_SC("can't 'create' a local slot"));
  				break;
  			case _SC('='): //ASSIGN
  				switch(ds) {
  				case LOCAL:
  					{
  						SQInteger src = _fs->PopTarget();
  						SQInteger dst = _fs->TopTarget();
  						_fs->AddInstruction(_OP_MOVE, dst, src);
  					}
  					break;
  				case OBJECT:
  				case BASE:
  					EmitDerefOp(_OP_SET);
  					break;
  				case OUTER:
  					{
  						SQInteger src = _fs->PopTarget();
  						SQInteger dst = _fs->PushTarget();
  						_fs->AddInstruction(_OP_SETOUTER, dst, pos, src);
  					}
  				}
  				break;
  			case TK_MINUSEQ:
  			case TK_PLUSEQ:
  			case TK_MULEQ:
  			case TK_DIVEQ:
  			case TK_MODEQ:
  				EmitCompoundArith(op, ds, pos);
  				break;
  			}
  			}
  			break;
  		case _SC('?'): {
  			Lex();
  			_fs->AddInstruction(_OP_JZ, _fs->PopTarget());
  			SQInteger jzpos = _fs->GetCurrentPos();
  			SQInteger trg = _fs->PushTarget();
  			Expression();
  			SQInteger first_exp = _fs->PopTarget();
  			if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp);
  			SQInteger endfirstexp = _fs->GetCurrentPos();
  			_fs->AddInstruction(_OP_JMP, 0, 0);
  			Expect(_SC(':'));
  			SQInteger jmppos = _fs->GetCurrentPos();
  			Expression();
  			SQInteger second_exp = _fs->PopTarget();
  			if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp);
  			_fs->SetIntructionParam(jmppos, 1, _fs->GetCurrentPos() - jmppos);
  			_fs->SetIntructionParam(jzpos, 1, endfirstexp - jzpos + 1);
  			_fs->SnoozeOpt();
  			}
  			break;
  		}
  		_es = es;
  	}
  	template<typename T> void BIN_EXP(SQOpcode op, T f,SQInteger op3 = 0)
  	{
  		Lex(); (this->*f)();
  		SQInteger op1 = _fs->PopTarget();SQInteger op2 = _fs->PopTarget();
  		_fs->AddInstruction(op, _fs->PushTarget(), op1, op2, op3);
  	}
  	void LogicalOrExp()
  	{
  		LogicalAndExp();
  		for(;;) if(_token == TK_OR) {
  			SQInteger first_exp = _fs->PopTarget();
  			SQInteger trg = _fs->PushTarget();
  			_fs->AddInstruction(_OP_OR, trg, 0, first_exp, 0);
  			SQInteger jpos = _fs->GetCurrentPos();
  			if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp);
  			Lex(); LogicalOrExp();
  			_fs->SnoozeOpt();
  			SQInteger second_exp = _fs->PopTarget();
  			if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp);
  			_fs->SnoozeOpt();
  			_fs->SetIntructionParam(jpos, 1, (_fs->GetCurrentPos() - jpos));
  			break;
  		}else return;
  	}
  	void LogicalAndExp()
  	{
  		BitwiseOrExp();
  		for(;;) switch(_token) {
  		case TK_AND: {
  			SQInteger first_exp = _fs->PopTarget();
  			SQInteger trg = _fs->PushTarget();
  			_fs->AddInstruction(_OP_AND, trg, 0, first_exp, 0);
  			SQInteger jpos = _fs->GetCurrentPos();
  			if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp);
  			Lex(); LogicalAndExp();
  			_fs->SnoozeOpt();
  			SQInteger second_exp = _fs->PopTarget();
  			if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp);
  			_fs->SnoozeOpt();
  			_fs->SetIntructionParam(jpos, 1, (_fs->GetCurrentPos() - jpos));
  			break;
  			}
  		case TK_IN: BIN_EXP(_OP_EXISTS, &SQCompiler::BitwiseOrExp); break;
  		case TK_INSTANCEOF: BIN_EXP(_OP_INSTANCEOF, &SQCompiler::BitwiseOrExp); break;
  		default:
  			return;
  		}
  	}
  	void BitwiseOrExp()
  	{
  		BitwiseXorExp();
  		for(;;) if(_token == _SC('|'))
  		{BIN_EXP(_OP_BITW, &SQCompiler::BitwiseXorExp,BW_OR);
  		}else return;
  	}
  	void BitwiseXorExp()
  	{
  		BitwiseAndExp();
  		for(;;) if(_token == _SC('^'))
  		{BIN_EXP(_OP_BITW, &SQCompiler::BitwiseAndExp,BW_XOR);
  		}else return;
  	}
  	void BitwiseAndExp()
  	{
  		EqExp();
  		for(;;) if(_token == _SC('&'))
  		{BIN_EXP(_OP_BITW, &SQCompiler::EqExp,BW_AND);
  		}else return;
  	}
  	void EqExp()
  	{
  		CompExp();
  		for(;;) switch(_token) {
  		case TK_EQ: BIN_EXP(_OP_EQ, &SQCompiler::CompExp); break;
  		case TK_NE: BIN_EXP(_OP_NE, &SQCompiler::CompExp); break;
  		case TK_3WAYSCMP: BIN_EXP(_OP_CMP, &SQCompiler::CompExp,CMP_3W); break;
  		default: return;	
  		}
  	}
  	void CompExp()
  	{
  		ShiftExp();
  		for(;;) switch(_token) {
  		case _SC('>'): BIN_EXP(_OP_CMP, &SQCompiler::ShiftExp,CMP_G); break;
  		case _SC('<'): BIN_EXP(_OP_CMP, &SQCompiler::ShiftExp,CMP_L); break;
  		case TK_GE: BIN_EXP(_OP_CMP, &SQCompiler::ShiftExp,CMP_GE); break;
  		case TK_LE: BIN_EXP(_OP_CMP, &SQCompiler::ShiftExp,CMP_LE); break;
  		default: return;	
  		}
  	}
  	void ShiftExp()
  	{
  		PlusExp();
  		for(;;) switch(_token) {
  		case TK_USHIFTR: BIN_EXP(_OP_BITW, &SQCompiler::PlusExp,BW_USHIFTR); break;
  		case TK_SHIFTL: BIN_EXP(_OP_BITW, &SQCompiler::PlusExp,BW_SHIFTL); break;
  		case TK_SHIFTR: BIN_EXP(_OP_BITW, &SQCompiler::PlusExp,BW_SHIFTR); break;
  		default: return;	
  		}
  	}
  	SQOpcode ChooseArithOpByToken(SQInteger tok)
  	{
  		switch(tok) {
  			case TK_PLUSEQ: case '+': return _OP_ADD;
  			case TK_MINUSEQ: case '-': return _OP_SUB;
  			case TK_MULEQ: case '*': return _OP_MUL;
  			case TK_DIVEQ: case '/': return _OP_DIV;
  			case TK_MODEQ: case '%': return _OP_MOD;
  			default: assert(0);
  		}
  		return _OP_ADD;
  	}
  	SQInteger ChooseCompArithCharByToken(SQInteger tok)
  	{
  		SQInteger oper;
  		switch(tok){
  		case TK_MINUSEQ: oper = '-'; break;
  		case TK_PLUSEQ: oper = '+'; break;
  		case TK_MULEQ: oper = '*'; break;
  		case TK_DIVEQ: oper = '/'; break;
  		case TK_MODEQ: oper = '%'; break;
  		default: oper = 0; //shut up compiler
  			assert(0); break;
  		};
  		return oper;
  	}
  	void PlusExp()
  	{
  		MultExp();
  		for(;;) switch(_token) {
  		case _SC('+'): case _SC('-'):
  			BIN_EXP(ChooseArithOpByToken(_token), &SQCompiler::MultExp); break;
  		default: return;
  		}
  	}
  	
  	void MultExp()
  	{
  		PrefixedExpr();
  		for(;;) switch(_token) {
  		case _SC('*'): case _SC('/'): case _SC('%'):
  			BIN_EXP(ChooseArithOpByToken(_token), &SQCompiler::PrefixedExpr); break;
  		default: return;
  		}
  	}
  	//if 'pos' != -1 the previous variable is a local variable
  	void PrefixedExpr()
  	{
  		SQInteger pos = Factor();
  		for(;;) {
  			switch(_token) {
  			case _SC('.'):
  				pos = -1;
  				Lex(); 
  
  				_fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(Expect(TK_IDENTIFIER)));
  				if(_es.etype==BASE) {
  					Emit2ArgsOP(_OP_GET);
  					pos = _fs->TopTarget();
  					_es.etype = EXPR;
  					_es.epos   = pos;
  				}
  				else {
  					if(NeedGet()) {
  						Emit2ArgsOP(_OP_GET);
  					}
  					_es.etype = OBJECT;
  				}
  				break;
  			case _SC('['):
  				if(_lex._prevtoken == _SC('\n')) Error(_SC("cannot brake deref/or comma needed after [exp]=exp slot declaration"));
  				Lex(); Expression(); Expect(_SC(']')); 
  				pos = -1;
  				if(_es.etype==BASE) {
  					Emit2ArgsOP(_OP_GET);
  					pos = _fs->TopTarget();
  					_es.etype = EXPR;
  					_es.epos   = pos;
  				}
  				else {
  					if(NeedGet()) {
  						Emit2ArgsOP(_OP_GET);
  					}
  					_es.etype = OBJECT;
  				}
  				break;
  			case TK_MINUSMINUS:
  			case TK_PLUSPLUS:
  				{
  					if(IsEndOfStatement()) return;
  					SQInteger diff = (_token==TK_MINUSMINUS) ? -1 : 1;
  					Lex();
  					switch(_es.etype)
  					{
  						case EXPR: Error(_SC("can't '++' or '--' an expression")); break;
  						case OBJECT:
  						case BASE:
  							Emit2ArgsOP(_OP_PINC, diff);
  							break;
  						case LOCAL: {
  							SQInteger src = _fs->PopTarget();
  							_fs->AddInstruction(_OP_PINCL, _fs->PushTarget(), src, 0, diff);
  									}
  							break;
  						case OUTER: {
  							SQInteger tmp1 = _fs->PushTarget();
  							SQInteger tmp2 = _fs->PushTarget();
  							_fs->AddInstruction(_OP_GETOUTER, tmp2, _es.epos);
  							_fs->AddInstruction(_OP_PINCL,    tmp1, tmp2, 0, diff);
  							_fs->AddInstruction(_OP_SETOUTER, tmp2, _es.epos, tmp2);
  							_fs->PopTarget();
  						}
  					}
  				}
  				return;
  				break;	
  			case _SC('('): 
  				switch(_es.etype) {
  					case OBJECT: {
  						SQInteger key     = _fs->PopTarget();  /* location of the key */
  						SQInteger table   = _fs->PopTarget();  /* location of the object */
  						SQInteger closure = _fs->PushTarget(); /* location for the closure */
  						SQInteger ttarget = _fs->PushTarget(); /* location for 'this' pointer */
  						_fs->AddInstruction(_OP_PREPCALL, closure, key, table, ttarget);
  						}
  						break;
  					case BASE:
  						//Emit2ArgsOP(_OP_GET);
  						_fs->AddInstruction(_OP_MOVE, _fs->PushTarget(), 0);
  						break;
  					case OUTER:
  						_fs->AddInstruction(_OP_GETOUTER, _fs->PushTarget(), _es.epos);
  						_fs->AddInstruction(_OP_MOVE,     _fs->PushTarget(), 0);
  						break;
  					default:
  						_fs->AddInstruction(_OP_MOVE, _fs->PushTarget(), 0);
  				}
  				_es.etype = EXPR;
  				Lex();
  				FunctionCallArgs();
  				break;
  			default: return;
  			}
  		}
  	}
  	SQInteger Factor()
  	{
  		_es.etype = EXPR;
  		switch(_token)
  		{
  		case TK_STRING_LITERAL:
  			_fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(_fs->CreateString(_lex._svalue,_lex._longstr.size()-1)));
  			Lex(); 
  			break;
  		case TK_BASE:
  			Lex();
  			_fs->AddInstruction(_OP_GETBASE, _fs->PushTarget());
  			_es.etype  = BASE;
  			_es.epos   = _fs->TopTarget();
  			return (_es.epos);
  			break;
  		case TK_IDENTIFIER:
  		case TK_CONSTRUCTOR:
  		case TK_THIS:{
  				SQObject id;
  				SQObject constant;
  
  				switch(_token) {
  					case TK_IDENTIFIER:  id = _fs->CreateString(_lex._svalue);       break;
  					case TK_THIS:        id = _fs->CreateString(_SC("this"));        break;
  					case TK_CONSTRUCTOR: id = _fs->CreateString(_SC("constructor")); break;
  				}
  
  				SQInteger pos = -1;
  				Lex();
  				if((pos = _fs->GetLocalVariable(id)) != -1) {
  					/* Handle a local variable (includes 'this') */
  					_fs->PushTarget(pos);
  					_es.etype  = LOCAL;
  					_es.epos   = pos;
  				}
  
  				else if((pos = _fs->GetOuterVariable(id)) != -1) {
  					/* Handle a free var */
  					if(NeedGet()) {
  						_es.epos  = _fs->PushTarget();
  						_fs->AddInstruction(_OP_GETOUTER, _es.epos, pos);	
  						/* _es.etype = EXPR; already default value */
  					}
  					else {
  						_es.etype = OUTER;
  						_es.epos  = pos;
  					}
  				}
  
  				else if(_fs->IsConstant(id, constant)) {
  					/* Handle named constant */
  					SQObjectPtr constval;
  					SQObject    constid;
  					if(type(constant) == OT_TABLE) {
  						Expect('.');
  						constid = Expect(TK_IDENTIFIER);
  						if(!_table(constant)->Get(constid, constval)) {
  							constval.Null();
  							Error(_SC("invalid constant [%s.%s]"), _stringval(id), _stringval(constid));
  						}
  					}
  					else {
  						constval = constant;
  					}
  					_es.epos = _fs->PushTarget();
  
  					/* generate direct or literal function depending on size */
  					SQObjectType ctype = type(constval);
  					switch(ctype) {
  						case OT_INTEGER: EmitLoadConstInt(_integer(constval),_es.epos); break;
  						case OT_FLOAT: EmitLoadConstFloat(_float(constval),_es.epos); break;
  						default: _fs->AddInstruction(_OP_LOAD,_es.epos,_fs->GetConstant(constval)); break;
  					}
  					_es.etype = EXPR;
  				}
  				else {
  					/* Handle a non-local variable, aka a field. Push the 'this' pointer on
  					* the virtual stack (always found in offset 0, so no instruction needs to
  					* be generated), and push the key next. Generate an _OP_LOAD instruction
  					* for the latter. If we are not using the variable as a dref expr, generate
  					* the _OP_GET instruction.
  					*/
  					_fs->PushTarget(0);
  					_fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(id));
  					if(NeedGet()) {
  						Emit2ArgsOP(_OP_GET);
  					}
  					_es.etype = OBJECT;
  				}
  				return _es.epos;
  			}
  			break;
  		case TK_DOUBLE_COLON:  // "::"
  			_fs->AddInstruction(_OP_LOADROOT, _fs->PushTarget());
  			_es.etype = OBJECT;
  			_token = _SC('.'); /* hack: drop into PrefixExpr, case '.'*/
  			_es.epos = -1;
  			return _es.epos;
  			break;
  		case TK_NULL: 
  			_fs->AddInstruction(_OP_LOADNULLS, _fs->PushTarget(),1);
  			Lex();
  			break;
  		case TK_INTEGER: EmitLoadConstInt(_lex._nvalue,-1); Lex();	break;
  		case TK_FLOAT: EmitLoadConstFloat(_lex._fvalue,-1); Lex(); break;
  		case TK_TRUE: case TK_FALSE:
  			_fs->AddInstruction(_OP_LOADBOOL, _fs->PushTarget(),_token == TK_TRUE?1:0);
  			Lex();
  			break;
  		case _SC('['): {
  				_fs->AddInstruction(_OP_NEWOBJ, _fs->PushTarget(),0,0,NOT_ARRAY);
  				SQInteger apos = _fs->GetCurrentPos(),key = 0;
  				Lex();
  				while(_token != _SC(']')) {
                      Expression(); 
  					if(_token == _SC(',')) Lex();
  					SQInteger val = _fs->PopTarget();
  					SQInteger array = _fs->TopTarget();
  					_fs->AddInstruction(_OP_APPENDARRAY, array, val, AAT_STACK);
  					key++;
  				}
  				_fs->SetIntructionParam(apos, 1, key);
  				Lex();
  			}
  			break;
  		case _SC('{'):
  			_fs->AddInstruction(_OP_NEWOBJ, _fs->PushTarget(),0,NOT_TABLE);
  			Lex();ParseTableOrClass(_SC(','),_SC('}'));
  			break;
  		case TK_FUNCTION: FunctionExp(_token);break;
  		case _SC('@'): FunctionExp(_token,true);break;
  		case TK_CLASS: Lex(); ClassExp();break;
  		case _SC('-'): 
  			Lex(); 
  			switch(_token) {
  			case TK_INTEGER: EmitLoadConstInt(-_lex._nvalue,-1); Lex(); break;
  			case TK_FLOAT: EmitLoadConstFloat(-_lex._fvalue,-1); Lex(); break;
  			default: UnaryOP(_OP_NEG);
  			}
  			break;
  		case _SC('!'): Lex(); UnaryOP(_OP_NOT); break;
  		case _SC('~'): 
  			Lex(); 
  			if(_token == TK_INTEGER)  { EmitLoadConstInt(~_lex._nvalue,-1); Lex(); break; }
  			UnaryOP(_OP_BWNOT); 
  			break;
  		case TK_TYPEOF : Lex() ;UnaryOP(_OP_TYPEOF); break;
  		case TK_RESUME : Lex(); UnaryOP(_OP_RESUME); break;
  		case TK_CLONE : Lex(); UnaryOP(_OP_CLONE); break;
  		case TK_MINUSMINUS : 
  		case TK_PLUSPLUS :PrefixIncDec(_token); break;
  		case TK_DELETE : DeleteExpr(); break;
  		case _SC('('): Lex(); CommaExpr(); Expect(_SC(')'));
  			break;
  		default: Error(_SC("expression expected"));
  		}
  		return -1;
  	}
  	void EmitLoadConstInt(SQInteger value,SQInteger target)
  	{
  		if(target < 0) {
  			target = _fs->PushTarget();
  		}
  		if((value & (~((SQInteger)0xFFFFFFFF))) == 0) { //does it fit in 32 bits?
  			_fs->AddInstruction(_OP_LOADINT, target,value);
  		}
  		else {
  			_fs->AddInstruction(_OP_LOAD, target, _fs->GetNumericConstant(value));
  		}
  	}
  	void EmitLoadConstFloat(SQFloat value,SQInteger target)
  	{
  		if(target < 0) {
  			target = _fs->PushTarget();
  		}
  		if(sizeof(SQFloat) == sizeof(SQInt32)) {
  			_fs->AddInstruction(_OP_LOADFLOAT, target,*((SQInt32 *)&value));
  		}
  		else {
  			_fs->AddInstruction(_OP_LOAD, target, _fs->GetNumericConstant(value));
  		}
  	}
  	void UnaryOP(SQOpcode op)
  	{
  		PrefixedExpr();
  		SQInteger src = _fs->PopTarget();
  		_fs->AddInstruction(op, _fs->PushTarget(), src);
  	}
  	bool NeedGet()
  	{
  		switch(_token) {
  		case _SC('='): case _SC('('): case TK_NEWSLOT: case TK_MODEQ: case TK_MULEQ:
  	    case TK_DIVEQ: case TK_MINUSEQ: case TK_PLUSEQ: case TK_PLUSPLUS: case TK_MINUSMINUS:
  			return false;
  		}
  		return (!_es.donot_get || ( _es.donot_get && (_token == _SC('.') || _token == _SC('['))));
  	}
  	void FunctionCallArgs()
  	{
  		SQInteger nargs = 1;//this
  		 while(_token != _SC(')')) {
  			 Expression();
  			 MoveIfCurrentTargetIsLocal();
  			 nargs++; 
  			 if(_token == _SC(',')){ 
  				 Lex(); 
  				 if(_token == ')') Error(_SC("expression expected, found ')'"));
  			 }
  		 }
  		 Lex();
  		 for(SQInteger i = 0; i < (nargs - 1); i++) _fs->PopTarget();
  		 SQInteger stackbase = _fs->PopTarget();
  		 SQInteger closure = _fs->PopTarget();
           _fs->AddInstruction(_OP_CALL, _fs->PushTarget(), closure, stackbase, nargs);
  	}
  	void ParseTableOrClass(SQInteger separator,SQInteger terminator)
  	{
  		SQInteger tpos = _fs->GetCurrentPos(),nkeys = 0;
  		while(_token != terminator) {
  			bool hasattrs = false;
  			bool isstatic = false;
  			//check if is an attribute
  			if(separator == ';') {
  				if(_token == TK_ATTR_OPEN) {
  					_fs->AddInstruction(_OP_NEWOBJ, _fs->PushTarget(),0,NOT_TABLE); Lex();
  					ParseTableOrClass(',',TK_ATTR_CLOSE);
  					hasattrs = true;
  				}
  				if(_token == TK_STATIC) {
  					isstatic = true;
  					Lex();
  				}
  			}
  			switch(_token) {
  			case TK_FUNCTION:
  			case TK_CONSTRUCTOR:{
  				SQInteger tk = _token;
  				Lex();
  				SQObject id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->CreateString(_SC("constructor"));
  				Expect(_SC('('));
  				_fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(id));
  				CreateFunction(id);
  				_fs->AddInstruction(_OP_CLOSURE, _fs->PushTarget(), _fs->_functions.size() - 1, 0);
  								}
  								break;
  			case _SC('['):
  				Lex(); CommaExpr(); Expect(_SC(']'));
  				Expect(_SC('=')); Expression();
  				break;
  			case TK_STRING_LITERAL: //JSON
  				if(separator == ',') { //only works for tables
  					_fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(Expect(TK_STRING_LITERAL)));
  					Expect(_SC(':')); Expression();
  					break;
  				}
  			default :
  				_fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(Expect(TK_IDENTIFIER)));
  				Expect(_SC('=')); Expression();
  			}
  			if(_token == separator) Lex();//optional comma/semicolon
  			nkeys++;
  			SQInteger val = _fs->PopTarget();
  			SQInteger key = _fs->PopTarget();
  			SQInteger attrs = hasattrs ? _fs->PopTarget():-1;
  			assert((hasattrs && (attrs == key-1)) || !hasattrs);
  			unsigned char flags = (hasattrs?NEW_SLOT_ATTRIBUTES_FLAG:0)|(isstatic?NEW_SLOT_STATIC_FLAG:0);
  			SQInteger table = _fs->TopTarget(); //<<BECAUSE OF THIS NO COMMON EMIT FUNC IS POSSIBLE
  			if(separator == _SC(',')) { //hack recognizes a table from the separator
  				_fs->AddInstruction(_OP_NEWSLOT, 0xFF, table, key, val);
  			}
  			else {
  				_fs->AddInstruction(_OP_NEWSLOTA, flags, table, key, val); //this for classes only as it invokes _newmember
  			}
  		}
  		if(separator == _SC(',')) //hack recognizes a table from the separator
  			_fs->SetIntructionParam(tpos, 1, nkeys);
  		Lex();
  	}
  	void LocalDeclStatement()
  	{
  		SQObject varname;
  		Lex();
  		if( _token == TK_FUNCTION) {
  			Lex();
  			varname = Expect(TK_IDENTIFIER);
  			Expect(_SC('('));
  			CreateFunction(varname,false);
  			_fs->AddInstruction(_OP_CLOSURE, _fs->PushTarget(), _fs->_functions.size() - 1, 0);
  			_fs->PopTarget();
  			_fs->PushLocalVariable(varname);
  			return;
  		}
  
  		do {
  			varname = Expect(TK_IDENTIFIER);
  			if(_token == _SC('=')) {
  				Lex(); Expression();
  				SQInteger src = _fs->PopTarget();
  				SQInteger dest = _fs->PushTarget();
  				if(dest != src) _fs->AddInstruction(_OP_MOVE, dest, src);
  			}
  			else{
  				_fs->AddInstruction(_OP_LOADNULLS, _fs->PushTarget(),1);
  			}
  			_fs->PopTarget();
  			_fs->PushLocalVariable(varname);
  			if(_token == _SC(',')) Lex(); else break;
  		} while(1);
  	}
  	void IfStatement()
  	{
  		SQInteger jmppos;
  		bool haselse = false;
  		Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
  		_fs->AddInstruction(_OP_JZ, _fs->PopTarget());
  		SQInteger jnepos = _fs->GetCurrentPos();
  		BEGIN_SCOPE();
  		
  		Statement();
  		//
  		if(_token != _SC('}') && _token != TK_ELSE) OptionalSemicolon();
  		
  		END_SCOPE();
  		SQInteger endifblock = _fs->GetCurrentPos();
  		if(_token == TK_ELSE){
  			haselse = true;
  			BEGIN_SCOPE();
  			_fs->AddInstruction(_OP_JMP);
  			jmppos = _fs->GetCurrentPos();
  			Lex();
  			Statement(); OptionalSemicolon();
  			END_SCOPE();
  			_fs->SetIntructionParam(jmppos, 1, _fs->GetCurrentPos() - jmppos);
  		}
  		_fs->SetIntructionParam(jnepos, 1, endifblock - jnepos + (haselse?1:0));
  	}
  	void WhileStatement()
  	{
  		SQInteger jzpos, jmppos;
  		jmppos = _fs->GetCurrentPos();
  		Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
  		
  		BEGIN_BREAKBLE_BLOCK();
  		_fs->AddInstruction(_OP_JZ, _fs->PopTarget());
  		jzpos = _fs->GetCurrentPos();
  		BEGIN_SCOPE();
  		
  		Statement();
  		
  		END_SCOPE();
  		_fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->GetCurrentPos() - 1);
  		_fs->SetIntructionParam(jzpos, 1, _fs->GetCurrentPos() - jzpos);
  		
  		END_BREAKBLE_BLOCK(jmppos);
  	}
  	void DoWhileStatement()
  	{
  		Lex();
  		SQInteger jmptrg = _fs->GetCurrentPos();
  		BEGIN_BREAKBLE_BLOCK()
  		BEGIN_SCOPE();
  		Statement();
  		END_SCOPE();
  		Expect(TK_WHILE);
  		SQInteger continuetrg = _fs->GetCurrentPos();
  		Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
  		_fs->AddInstruction(_OP_JZ, _fs->PopTarget(), 1);
  		_fs->AddInstruction(_OP_JMP, 0, jmptrg - _fs->GetCurrentPos() - 1);
  		END_BREAKBLE_BLOCK(continuetrg);
  	}
  	void ForStatement()
  	{
  		Lex();
  		BEGIN_SCOPE();
  		Expect(_SC('('));
  		if(_token == TK_LOCAL) LocalDeclStatement();
  		else if(_token != _SC(';')){
  			CommaExpr();
  			_fs->PopTarget();
  		}
  		Expect(_SC(';'));
  		_fs->SnoozeOpt();
  		SQInteger jmppos = _fs->GetCurrentPos();
  		SQInteger jzpos = -1;
  		if(_token != _SC(';')) { CommaExpr(); _fs->AddInstruction(_OP_JZ, _fs->PopTarget()); jzpos = _fs->GetCurrentPos(); }
  		Expect(_SC(';'));
  		_fs->SnoozeOpt();
  		SQInteger expstart = _fs->GetCurrentPos() + 1;
  		if(_token != _SC(')')) {
  			CommaExpr();
  			_fs->PopTarget();
  		}
  		Expect(_SC(')'));
  		_fs->SnoozeOpt();
  		SQInteger expend = _fs->GetCurrentPos();
  		SQInteger expsize = (expend - expstart) + 1;
  		SQInstructionVec exp;
  		if(expsize > 0) {
  			for(SQInteger i = 0; i < expsize; i++)
  				exp.push_back(_fs->GetInstruction(expstart + i));
  			_fs->PopInstructions(expsize);
  		}
  		BEGIN_BREAKBLE_BLOCK()
  		Statement();
  		SQInteger continuetrg = _fs->GetCurrentPos();
  		if(expsize > 0) {
  			for(SQInteger i = 0; i < expsize; i++)
  				_fs->AddInstruction(exp[i]);
  		}
  		_fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->GetCurrentPos() - 1, 0);
  		if(jzpos>  0) _fs->SetIntructionParam(jzpos, 1, _fs->GetCurrentPos() - jzpos);
  		END_SCOPE();
  		
  		END_BREAKBLE_BLOCK(continuetrg);
  	}
  	void ForEachStatement()
  	{
  		SQObject idxname, valname;
  		Lex(); Expect(_SC('(')); valname = Expect(TK_IDENTIFIER);
  		if(_token == _SC(',')) {
  			idxname = valname;
  			Lex(); valname = Expect(TK_IDENTIFIER);
  		}
  		else{
  			idxname = _fs->CreateString(_SC("@INDEX@"));
  		}
  		Expect(TK_IN);
  		
  		//save the stack size
  		BEGIN_SCOPE();
  		//put the table in the stack(evaluate the table expression)
  		Expression(); Expect(_SC(')'));
  		SQInteger container = _fs->TopTarget();
  		//push the index local var
  		SQInteger indexpos = _fs->PushLocalVariable(idxname);
  		_fs->AddInstruction(_OP_LOADNULLS, indexpos,1);
  		//push the value local var
  		SQInteger valuepos = _fs->PushLocalVariable(valname);
  		_fs->AddInstruction(_OP_LOADNULLS, valuepos,1);
  		//push reference index
  		SQInteger itrpos = _fs->PushLocalVariable(_fs->CreateString(_SC("@ITERATOR@"))); //use invalid id to make it inaccessible
  		_fs->AddInstruction(_OP_LOADNULLS, itrpos,1);
  		SQInteger jmppos = _fs->GetCurrentPos();
  		_fs->AddInstruction(_OP_FOREACH, container, 0, indexpos);
  		SQInteger foreachpos = _fs->GetCurrentPos();
  		_fs->AddInstruction(_OP_POSTFOREACH, container, 0, indexpos);
  		//generate the statement code
  		BEGIN_BREAKBLE_BLOCK()
  		Statement();
  		_fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->GetCurrentPos() - 1);
  		_fs->SetIntructionParam(foreachpos, 1, _fs->GetCurrentPos() - foreachpos);
  		_fs->SetIntructionParam(foreachpos + 1, 1, _fs->GetCurrentPos() - foreachpos);
  		END_BREAKBLE_BLOCK(foreachpos - 1);
  		//restore the local variable stack(remove index,val and ref idx)
  		_fs->PopTarget();
  		END_SCOPE();
  	}
  	void SwitchStatement()
  	{
  		Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
  		Expect(_SC('{'));
  		SQInteger expr = _fs->TopTarget();
  		bool bfirst = true;
  		SQInteger tonextcondjmp = -1;
  		SQInteger skipcondjmp = -1;
  		SQInteger __nbreaks__ = _fs->_unresolvedbreaks.size();
  		_fs->_breaktargets.push_back(0);
  		while(_token == TK_CASE) {
  			if(!bfirst) {
  				_fs->AddInstruction(_OP_JMP, 0, 0);
  				skipcondjmp = _fs->GetCurrentPos();
  				_fs->SetIntructionParam(tonextcondjmp, 1, _fs->GetCurrentPos() - tonextcondjmp);
  			}
  			//condition
  			Lex(); Expression(); Expect(_SC(':'));
  			SQInteger trg = _fs->PopTarget();
  			_fs->AddInstruction(_OP_EQ, trg, trg, expr);
  			_fs->AddInstruction(_OP_JZ, trg, 0);
  			//end condition
  			if(skipcondjmp != -1) {
  				_fs->SetIntructionParam(skipcondjmp, 1, (_fs->GetCurrentPos() - skipcondjmp));
  			}
  			tonextcondjmp = _fs->GetCurrentPos();
  			BEGIN_SCOPE();
  			Statements();
  			END_SCOPE();
  			bfirst = false;
  		}
  		if(tonextcondjmp != -1)
  			_fs->SetIntructionParam(tonextcondjmp, 1, _fs->GetCurrentPos() - tonextcondjmp);
  		if(_token == TK_DEFAULT) {
  			Lex(); Expect(_SC(':'));
  			BEGIN_SCOPE();
  			Statements();
  			END_SCOPE();
  		}
  		Expect(_SC('}'));
  		_fs->PopTarget();
  		__nbreaks__ = _fs->_unresolvedbreaks.size() - __nbreaks__;
  		if(__nbreaks__ > 0)ResolveBreaks(_fs, __nbreaks__);
  		_fs->_breaktargets.pop_back();
  	}
  	void FunctionStatement()
  	{
  		SQObject id;
  		Lex(); id = Expect(TK_IDENTIFIER);
  		_fs->PushTarget(0);
  		_fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(id));
  		if(_token == TK_DOUBLE_COLON) Emit2ArgsOP(_OP_GET);
  		
  		while(_token == TK_DOUBLE_COLON) {
  			Lex();
  			id = Expect(TK_IDENTIFIER);
  			_fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(id));
  			if(_token == TK_DOUBLE_COLON) Emit2ArgsOP(_OP_GET);
  		}
  		Expect(_SC('('));
  		CreateFunction(id);
  		_fs->AddInstruction(_OP_CLOSURE, _fs->PushTarget(), _fs->_functions.size() - 1, 0);
  		EmitDerefOp(_OP_NEWSLOT);
  		_fs->PopTarget();
  	}
  	void ClassStatement()
  	{
  		SQExpState es;
  		Lex();
  		es = _es;
  		_es.donot_get = true;
  		PrefixedExpr();
  		if(_es.etype == EXPR) {
  			Error(_SC("invalid class name"));
  		}
  		else if(_es.etype == OBJECT || _es.etype == BASE) {
  			ClassExp();
  			EmitDerefOp(_OP_NEWSLOT);
  			_fs->PopTarget();
  		}
  		else {
  			Error(_SC("cannot create a class in a local with the syntax(class <local>)"));
  		}
  		_es = es;
  	}
  	SQObject ExpectScalar()
  	{
  		SQObject val;
  		val._type = OT_NULL; val._unVal.nInteger = 0; //shut up GCC 4.x
  		switch(_token) {
  			case TK_INTEGER:
  				val._type = OT_INTEGER;
  				val._unVal.nInteger = _lex._nvalue;
  				break;
  			case TK_FLOAT:
  				val._type = OT_FLOAT;
  				val._unVal.fFloat = _lex._fvalue;
  				break;
  			case TK_STRING_LITERAL:
  				val = _fs->CreateString(_lex._svalue,_lex._longstr.size()-1);
  				break;
  			case '-':
  				Lex();
  				switch(_token)
  				{
  				case TK_INTEGER:
  					val._type = OT_INTEGER;
  					val._unVal.nInteger = -_lex._nvalue;
  				break;
  				case TK_FLOAT:
  					val._type = OT_FLOAT;
  					val._unVal.fFloat = -_lex._fvalue;
  				break;
  				default:
  					Error(_SC("scalar expected : integer,float"));
  				}
  				break;
  			default:
  				Error(_SC("scalar expected : integer,float or string"));
  		}
  		Lex();
  		return val;
  	}
  	void EnumStatement()
  	{
  		Lex(); 
  		SQObject id = Expect(TK_IDENTIFIER);
  		Expect(_SC('{'));
  		
  		SQObject table = _fs->CreateTable();
  		SQInteger nval = 0;
  		while(_token != _SC('}')) {
  			SQObject key = Expect(TK_IDENTIFIER);
  			SQObject val;
  			if(_token == _SC('=')) {
  				Lex();
  				val = ExpectScalar();
  			}
  			else {
  				val._type = OT_INTEGER;
  				val._unVal.nInteger = nval++;
  			}
  			_table(table)->NewSlot(SQObjectPtr(key),SQObjectPtr(val));
  			if(_token == ',') Lex();
  		}
  		SQTable *enums = _table(_ss(_vm)->_consts);
  		SQObjectPtr strongid = id; 
  		enums->NewSlot(SQObjectPtr(strongid),SQObjectPtr(table));
  		strongid.Null();
  		Lex();
  	}
  	void TryCatchStatement()
  	{
  		SQObject exid;
  		Lex();
  		_fs->AddInstruction(_OP_PUSHTRAP,0,0);
  		_fs->_traps++;
  		if(_fs->_breaktargets.size()) _fs->_breaktargets.top()++;
  		if(_fs->_continuetargets.size()) _fs->_continuetargets.top()++;
  		SQInteger trappos = _fs->GetCurrentPos();
  		{
  			BEGIN_SCOPE();
  			Statement();
  			END_SCOPE();
  		}
  		_fs->_traps--;
  		_fs->AddInstruction(_OP_POPTRAP, 1, 0);
  		if(_fs->_breaktargets.size()) _fs->_breaktargets.top()--;
  		if(_fs->_continuetargets.size()) _fs->_continuetargets.top()--;
  		_fs->AddInstruction(_OP_JMP, 0, 0);
  		SQInteger jmppos = _fs->GetCurrentPos();
  		_fs->SetIntructionParam(trappos, 1, (_fs->GetCurrentPos() - trappos));
  		Expect(TK_CATCH); Expect(_SC('(')); exid = Expect(TK_IDENTIFIER); Expect(_SC(')'));
  		{
  			BEGIN_SCOPE();
  			SQInteger ex_target = _fs->PushLocalVariable(exid);
  			_fs->SetIntructionParam(trappos, 0, ex_target);
  			Statement();
  			_fs->SetIntructionParams(jmppos, 0, (_fs->GetCurrentPos() - jmppos), 0);
  			END_SCOPE();
  		}
  	}
  	void FunctionExp(SQInteger ftype,bool lambda = false)
  	{
  		Lex(); Expect(_SC('('));
  		SQObjectPtr dummy;
  		CreateFunction(dummy,lambda);
  		_fs->AddInstruction(_OP_CLOSURE, _fs->PushTarget(), _fs->_functions.size() - 1, ftype == TK_FUNCTION?0:1);
  	}
  	void ClassExp()
  	{
  		SQInteger base = -1;
  		SQInteger attrs = -1;
  		if(_token == TK_EXTENDS) {
  			Lex(); Expression();
  			base = _fs->TopTarget();
  		}
  		if(_token == TK_ATTR_OPEN) {
  			Lex();
  			_fs->AddInstruction(_OP_NEWOBJ, _fs->PushTarget(),0,NOT_TABLE);
  			ParseTableOrClass(_SC(','),TK_ATTR_CLOSE);
  			attrs = _fs->TopTarget();
  		}
  		Expect(_SC('{'));
  		if(attrs != -1) _fs->PopTarget();
  		if(base != -1) _fs->PopTarget();
  		_fs->AddInstruction(_OP_NEWOBJ, _fs->PushTarget(), base, attrs,NOT_CLASS);
  		ParseTableOrClass(_SC(';'),_SC('}'));
  	}
  	void DeleteExpr()
  	{
  		SQExpState es;
  		Lex();
  		es = _es;
  		_es.donot_get = true;
  		PrefixedExpr();
  		if(_es.etype==EXPR) Error(_SC("can't delete an expression"));
  		if(_es.etype==OBJECT || _es.etype==BASE) {
  			Emit2ArgsOP(_OP_DELETE);
  		}
  		else {
  			Error(_SC("cannot delete an (outer) local"));
  		}
  		_es = es;
  	}
  	void PrefixIncDec(SQInteger token)
  	{
  		SQExpState  es;
  		SQInteger diff = (token==TK_MINUSMINUS) ? -1 : 1;
  		Lex();
  		es = _es;
  		_es.donot_get = true;
  		PrefixedExpr();
  		if(_es.etype==EXPR) {
  			Error(_SC("can't '++' or '--' an expression"));
  		}
  		else if(_es.etype==OBJECT || _es.etype==BASE) {
  			Emit2ArgsOP(_OP_INC, diff);
  		}
  		else if(_es.etype==LOCAL) {
  			SQInteger src = _fs->TopTarget();
  			_fs->AddInstruction(_OP_INCL, src, src, 0, diff);
  			
  		}
  		else if(_es.etype==OUTER) {
  			SQInteger tmp = _fs->PushTarget();
  			_fs->AddInstruction(_OP_GETOUTER, tmp, _es.epos);
  			_fs->AddInstruction(_OP_INCL,     tmp, tmp, 0, diff);
  			_fs->AddInstruction(_OP_SETOUTER, tmp, _es.epos, tmp);
  		}
  		_es = es;
  	}
  	void CreateFunction(SQObject &name,bool lambda = false)
  	{
  		SQFuncState *funcstate = _fs->PushChildState(_ss(_vm));
  		funcstate->_name = name;
  		SQObject paramname;
  		funcstate->AddParameter(_fs->CreateString(_SC("this")));
  		funcstate->_sourcename = _sourcename;
  		SQInteger defparams = 0;
  		while(_token!=_SC(')')) {
  			if(_token == TK_VARPARAMS) {
  				if(defparams > 0) Error(_SC("function with default parameters cannot have variable number of parameters"));
  				funcstate->AddParameter(_fs->CreateString(_SC("vargv")));
  				funcstate->_varparams = true;
  				Lex();
  				if(_token != _SC(')')) Error(_SC("expected ')'"));
  				break;
  			}
  			else {
  				paramname = Expect(TK_IDENTIFIER);
  				funcstate->AddParameter(paramname);
  				if(_token == _SC('=')) { 
  					Lex();
  					Expression();
  					funcstate->AddDefaultParam(_fs->TopTarget());
  					defparams++;
  				}
  				else {
  					if(defparams > 0) Error(_SC("expected '='"));
  				}
  				if(_token == _SC(',')) Lex();
  				else if(_token != _SC(')')) Error(_SC("expected ')' or ','"));
  			}
  		}
  		Expect(_SC(')'));
  		for(SQInteger n = 0; n < defparams; n++) {
  			_fs->PopTarget();
  		}
  				
  		SQFuncState *currchunk = _fs;
  		_fs = funcstate;
  		if(lambda) { 
  			Expression(); 
  			_fs->AddInstruction(_OP_RETURN, 1, _fs->PopTarget());}
  		else { 
  			Statement(false); 
  		}
  		funcstate->AddLineInfos(_lex._prevtoken == _SC('\n')?_lex._lasttokenline:_lex._currentline, _lineinfo, true);
          funcstate->AddInstruction(_OP_RETURN, -1);
  		funcstate->SetStackSize(0);
  
  		SQFunctionProto *func = funcstate->BuildProto();
  #ifdef _DEBUG_DUMP
  		funcstate->Dump(func);
  #endif
  		_fs = currchunk;
  		_fs->_functions.push_back(func);
  		_fs->PopChildState();
  	}
  	void ResolveBreaks(SQFuncState *funcstate, SQInteger ntoresolve)
  	{
  		while(ntoresolve > 0) {
  			SQInteger pos = funcstate->_unresolvedbreaks.back();
  			funcstate->_unresolvedbreaks.pop_back();
  			//set the jmp instruction
  			funcstate->SetIntructionParams(pos, 0, funcstate->GetCurrentPos() - pos, 0);
  			ntoresolve--;
  		}
  	}
  	void ResolveContinues(SQFuncState *funcstate, SQInteger ntoresolve, SQInteger targetpos)
  	{
  		while(ntoresolve > 0) {
  			SQInteger pos = funcstate->_unresolvedcontinues.back();
  			funcstate->_unresolvedcontinues.pop_back();
  			//set the jmp instruction
  			funcstate->SetIntructionParams(pos, 0, targetpos - pos, 0);
  			ntoresolve--;
  		}
  	}
  private:
  	SQInteger _token;
  	SQFuncState *_fs;
  	SQObjectPtr _sourcename;
  	SQLexer _lex;
  	bool _lineinfo;
  	bool _raiseerror;
  	SQInteger _debugline;
  	SQInteger _debugop;
  	SQExpState   _es;
  	SQScope _scope;
  	SQChar *compilererror;
  	jmp_buf _errorjmp;
  	SQVM *_vm;
  };
  
  bool Compile(SQVM *vm,SQLEXREADFUNC rg, SQUserPointer up, const SQChar *sourcename, SQObjectPtr &out, bool raiseerror, bool lineinfo)
  {
  	SQCompiler p(vm, rg, up, sourcename, raiseerror, lineinfo);
  	return p.Compile(out);
  }
  
  #endif
  