Diff: squirrel/sqfuncstate.cpp

Revision:

0:97a4f8cc534c

diff -r 000000000000 -r 97a4f8cc534c squirrel/sqfuncstate.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/squirrel/sqfuncstate.cpp	Tue Dec 16 10:20:34 2014 +0000
@@ -0,0 +1,653 @@
+/*
+	see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+#ifndef NO_COMPILER
+#include "sqcompiler.h"
+#include "sqstring.h"
+#include "sqfuncproto.h"
+#include "sqtable.h"
+#include "sqopcodes.h"
+#include "sqfuncstate.h"
+
+#ifdef _DEBUG_DUMP
+SQInstructionDesc g_InstrDesc[]={
+	{_SC("_OP_LINE")},
+	{_SC("_OP_LOAD")},
+	{_SC("_OP_LOADINT")},
+	{_SC("_OP_LOADFLOAT")},
+	{_SC("_OP_DLOAD")},
+	{_SC("_OP_TAILCALL")},
+	{_SC("_OP_CALL")},
+	{_SC("_OP_PREPCALL")},
+	{_SC("_OP_PREPCALLK")},
+	{_SC("_OP_GETK")},
+	{_SC("_OP_MOVE")},
+	{_SC("_OP_NEWSLOT")},
+	{_SC("_OP_DELETE")},
+	{_SC("_OP_SET")},
+	{_SC("_OP_GET")},
+	{_SC("_OP_EQ")},
+	{_SC("_OP_NE")},
+	{_SC("_OP_ADD")},
+	{_SC("_OP_SUB")},
+	{_SC("_OP_MUL")},
+	{_SC("_OP_DIV")},
+	{_SC("_OP_MOD")},
+	{_SC("_OP_BITW")},
+	{_SC("_OP_RETURN")},
+	{_SC("_OP_LOADNULLS")},
+	{_SC("_OP_LOADROOT")},
+	{_SC("_OP_LOADBOOL")},
+	{_SC("_OP_DMOVE")},
+	{_SC("_OP_JMP")},
+	{_SC("_OP_JCMP")},
+	{_SC("_OP_JZ")},
+	{_SC("_OP_SETOUTER")},
+	{_SC("_OP_GETOUTER")},
+	{_SC("_OP_NEWOBJ")},
+	{_SC("_OP_APPENDARRAY")},
+	{_SC("_OP_COMPARITH")},
+	{_SC("_OP_INC")},
+	{_SC("_OP_INCL")},
+	{_SC("_OP_PINC")},
+	{_SC("_OP_PINCL")},
+	{_SC("_OP_CMP")},
+	{_SC("_OP_EXISTS")},
+	{_SC("_OP_INSTANCEOF")},
+	{_SC("_OP_AND")},
+	{_SC("_OP_OR")},
+	{_SC("_OP_NEG")},
+	{_SC("_OP_NOT")},
+	{_SC("_OP_BWNOT")},
+	{_SC("_OP_CLOSURE")},
+	{_SC("_OP_YIELD")},
+	{_SC("_OP_RESUME")},
+	{_SC("_OP_FOREACH")},
+	{_SC("_OP_POSTFOREACH")},
+	{_SC("_OP_CLONE")},
+	{_SC("_OP_TYPEOF")},
+	{_SC("_OP_PUSHTRAP")},
+	{_SC("_OP_POPTRAP")},
+	{_SC("_OP_THROW")},
+	{_SC("_OP_NEWSLOTA")},
+	{_SC("_OP_GETBASE")},
+	{_SC("_OP_CLOSE")},
+	{_SC("_OP_JCMP")}
+};
+#endif
+void DumpLiteral(SQObjectPtr &o)
+{
+	switch(type(o)){
+		case OT_STRING:	scprintf(_SC("\"%s\""),_stringval(o));break;
+		case OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break;
+		case OT_INTEGER: scprintf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break;
+		case OT_BOOL: scprintf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break;
+		default: scprintf(_SC("(%s %p)"),GetTypeName(o),(void*)_rawval(o));break; break; //shut up compiler
+	}
+}
+
+SQFuncState::SQFuncState(SQSharedState *ss,SQFuncState *parent,CompilerErrorFunc efunc,void *ed)
+{
+		_nliterals = 0;
+		_literals = SQTable::Create(ss,0);
+		_strings =  SQTable::Create(ss,0);
+		_sharedstate = ss;
+		_lastline = 0;
+		_optimization = true;
+		_parent = parent;
+		_stacksize = 0;
+		_traps = 0;
+		_returnexp = 0;
+		_varparams = false;
+		_errfunc = efunc;
+		_errtarget = ed;
+		_bgenerator = false;
+		_outers = 0;
+		_ss = ss;
+
+}
+
+void SQFuncState::Error(const SQChar *err)
+{
+	_errfunc(_errtarget,err);
+}
+
+#ifdef _DEBUG_DUMP
+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"));
+}
+#endif
+
+SQInteger SQFuncState::GetNumericConstant(const SQInteger cons)
+{
+	return GetConstant(SQObjectPtr(cons));
+}
+
+SQInteger SQFuncState::GetNumericConstant(const SQFloat cons)
+{
+	return GetConstant(SQObjectPtr(cons));
+}
+
+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);
+}
+
+void SQFuncState::SetIntructionParams(SQInteger pos,SQInteger arg0,SQInteger arg1,SQInteger arg2,SQInteger arg3)
+{
+	_instructions[pos]._arg0=(unsigned char)*((SQUnsignedInteger *)&arg0);
+	_instructions[pos]._arg1=(SQInt32)*((SQUnsignedInteger *)&arg1);
+	_instructions[pos]._arg2=(unsigned char)*((SQUnsignedInteger *)&arg2);
+	_instructions[pos]._arg3=(unsigned char)*((SQUnsignedInteger *)&arg3);
+}
+
+void SQFuncState::SetIntructionParam(SQInteger pos,SQInteger arg,SQInteger val)
+{
+	switch(arg){
+		case 0:_instructions[pos]._arg0=(unsigned char)*((SQUnsignedInteger *)&val);break;
+		case 1:case 4:_instructions[pos]._arg1=(SQInt32)*((SQUnsignedInteger *)&val);break;
+		case 2:_instructions[pos]._arg2=(unsigned char)*((SQUnsignedInteger *)&val);break;
+		case 3:_instructions[pos]._arg3=(unsigned char)*((SQUnsignedInteger *)&val);break;
+	};
+}
+
+SQInteger SQFuncState::AllocStackPos()
+{
+	SQInteger npos=_vlocals.size();
+	_vlocals.push_back(SQLocalVarInfo());
+	if(_vlocals.size()>((SQUnsignedInteger)_stacksize)) {
+		if(_stacksize>MAX_FUNC_STACKSIZE) Error(_SC("internal compiler error: too many locals"));
+		_stacksize=_vlocals.size();
+	}
+	return npos;
+}
+
+SQInteger SQFuncState::PushTarget(SQInteger n)
+{
+	if(n!=-1){
+		_targetstack.push_back(n);
+		return n;
+	}
+	n=AllocStackPos();
+	_targetstack.push_back(n);
+	return n;
+}
+
+SQInteger SQFuncState::GetUpTarget(SQInteger n){
+	return _targetstack[((_targetstack.size()-1)-n)];
+}
+
+SQInteger SQFuncState::TopTarget(){
+	return _targetstack.back();
+}
+SQInteger SQFuncState::PopTarget()
+{
+	SQUnsignedInteger npos=_targetstack.back();
+	assert(npos < _vlocals.size());
+	SQLocalVarInfo &t = _vlocals[npos];
+	if(type(t._name)==OT_NULL){
+		_vlocals.pop_back();
+	}
+	_targetstack.pop_back();
+	return npos;
+}
+
+SQInteger SQFuncState::GetStackSize()
+{
+	return _vlocals.size();
+}
+
+SQInteger SQFuncState::CountOuters(SQInteger stacksize)
+{
+	SQInteger outers = 0;
+	SQInteger k = _vlocals.size() - 1;
+	while(k >= stacksize) {
+		SQLocalVarInfo &lvi = _vlocals[k];
+		k--;
+		if(lvi._end_op == UINT_MINUS_ONE) { //this means is an outer
+			outers++;
+		}
+	}
+	return outers;
+}
+
+void SQFuncState::SetStackSize(SQInteger n)
+{
+	SQInteger size=_vlocals.size();
+	while(size>n){
+		size--;
+		SQLocalVarInfo lvi = _vlocals.back();
+		if(type(lvi._name)!=OT_NULL){
+			if(lvi._end_op == UINT_MINUS_ONE) { //this means is an outer
+				_outers--;
+			}
+			lvi._end_op = GetCurrentPos();
+			_localvarinfos.push_back(lvi);
+		}
+		_vlocals.pop_back();
+	}
+}
+
+bool SQFuncState::IsConstant(const SQObject &name,SQObject &e)
+{
+	SQObjectPtr val;
+	if(_table(_sharedstate->_consts)->Get(name,val)) {
+		e = val;
+		return true;
+	}
+	return false;
+}
+
+bool SQFuncState::IsLocal(SQUnsignedInteger stkpos)
+{
+	if(stkpos>=_vlocals.size())return false;
+	else if(type(_vlocals[stkpos]._name)!=OT_NULL)return true;
+	return false;
+}
+
+SQInteger SQFuncState::PushLocalVariable(const SQObject &name)
+{
+	SQInteger pos=_vlocals.size();
+	SQLocalVarInfo lvi;
+	lvi._name=name;
+	lvi._start_op=GetCurrentPos()+1;
+	lvi._pos=_vlocals.size();
+	_vlocals.push_back(lvi);
+	if(_vlocals.size()>((SQUnsignedInteger)_stacksize))_stacksize=_vlocals.size();
+	return pos;
+}
+
+
+
+SQInteger SQFuncState::GetLocalVariable(const SQObject &name)
+{
+	SQInteger locals=_vlocals.size();
+	while(locals>=1){
+		SQLocalVarInfo &lvi = _vlocals[locals-1];
+		if(type(lvi._name)==OT_STRING && _string(lvi._name)==_string(name)){
+			return locals-1;
+		}
+		locals--;
+	}
+	return -1;
+}
+
+void SQFuncState::MarkLocalAsOuter(SQInteger pos)
+{
+	SQLocalVarInfo &lvi = _vlocals[pos];
+	lvi._end_op = UINT_MINUS_ONE;
+	_outers++;
+}
+
+SQInteger SQFuncState::GetOuterVariable(const SQObject &name)
+{
+	SQInteger outers = _outervalues.size();
+	for(SQInteger i = 0; i<outers; i++) {
+		if(_string(_outervalues[i]._name) == _string(name))
+			return i;
+	}
+	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 _outervalues.size() - 1;	
+			}
+		}
+		else {
+			_parent->MarkLocalAsOuter(pos);
+			_outervalues.push_back(SQOuterVar(name,SQObjectPtr(SQInteger(pos)),otLOCAL)); //local
+			return _outervalues.size() - 1;
+			
+			
+		}
+	}
+	return -1;
+}
+
+void SQFuncState::AddParameter(const SQObject &name)
+{
+	PushLocalVariable(name);
+	_parameters.push_back(name);
+}
+
+void SQFuncState::AddLineInfos(SQInteger line,bool lineop,bool force)
+{
+	if(_lastline!=line || force){
+		SQLineInfo li;
+		li._line=line;li._op=(GetCurrentPos()+1);
+		if(lineop)AddInstruction(_OP_LINE,0,line);
+		if(_lastline!=line) {
+			_lineinfos.push_back(li);
+		}
+		_lastline=line;
+	}
+}
+
+void SQFuncState::DiscardTarget()
+{
+	SQInteger discardedtarget = PopTarget();
+	SQInteger size = _instructions.size();
+	if(size > 0 && _optimization){
+		SQInstruction &pi = _instructions[size-1];//previous instruction
+		switch(pi.op) {
+		case _OP_SET:case _OP_NEWSLOT:case _OP_SETOUTER:case _OP_CALL:
+			if(pi._arg0 == discardedtarget) {
+				pi._arg0 = 0xFF;
+			}
+		}
+	}
+}
+
+void SQFuncState::AddInstruction(SQInstruction &i)
+{
+	SQInteger size = _instructions.size();
+	if(size > 0 && _optimization){ //simple optimizer
+		SQInstruction &pi = _instructions[size-1];//previous instruction
+		switch(i.op) {
+		case _OP_JZ:
+			if( pi.op == _OP_CMP && pi._arg1 < 0xFF) {
+				pi.op = _OP_JCMP;
+				pi._arg0 = (unsigned char)pi._arg1;
+				pi._arg1 = i._arg1;
+				return;
+			}
+		case _OP_SET:
+		case _OP_NEWSLOT:
+			if(i._arg0 == i._arg3) {
+				i._arg0 = 0xFF;
+			}
+			break;
+		case _OP_SETOUTER:
+			if(i._arg0 == i._arg2) {
+				i._arg0 = 0xFF;
+			}
+			break;
+		case _OP_RETURN:
+			if( _parent && i._arg0 != MAX_FUNC_STACKSIZE && pi.op == _OP_CALL && _returnexp < size-1) {
+				pi.op = _OP_TAILCALL;
+			} else if(pi.op == _OP_CLOSE){
+				pi = i;
+				return;
+			}
+		break;
+		case _OP_GET:
+			if( pi.op == _OP_LOAD && pi._arg0 == i._arg2 && (!IsLocal(pi._arg0))){
+				pi._arg1 = pi._arg1;
+				pi._arg2 = (unsigned char)i._arg1;
+				pi.op = _OP_GETK;
+				pi._arg0 = i._arg0;
+				
+				return;
+			}
+		break;
+		case _OP_PREPCALL:
+			if( pi.op == _OP_LOAD  && pi._arg0 == i._arg1 && (!IsLocal(pi._arg0))){
+				pi.op = _OP_PREPCALLK;
+				pi._arg0 = i._arg0;
+				pi._arg1 = pi._arg1;
+				pi._arg2 = i._arg2;
+				pi._arg3 = i._arg3;
+				return;
+			}
+			break;
+		case _OP_APPENDARRAY: {
+			SQInteger aat = -1;
+			switch(pi.op) {
+			case _OP_LOAD: aat = AAT_LITERAL; break;
+			case _OP_LOADINT: aat = AAT_INT; break;
+			case _OP_LOADBOOL: aat = AAT_BOOL; break;
+			case _OP_LOADFLOAT: aat = AAT_FLOAT; break;
+			default: break;
+			}
+			if(aat != -1 && pi._arg0 == i._arg1 && (!IsLocal(pi._arg0))){
+				pi.op = _OP_APPENDARRAY;
+				pi._arg0 = i._arg0;
+				pi._arg1 = pi._arg1;
+				pi._arg2 = (unsigned char)aat;
+				pi._arg3 = MAX_FUNC_STACKSIZE;
+				return;
+			}
+							  }
+			break;
+		case _OP_MOVE:
+			switch(pi.op) {
+			case _OP_GET: case _OP_ADD: case _OP_SUB: case _OP_MUL: case _OP_DIV: case _OP_MOD: case _OP_BITW:
+			case _OP_LOADINT: case _OP_LOADFLOAT: case _OP_LOADBOOL: case _OP_LOAD:
+
+				if(pi._arg0 == i._arg1)
+				{
+					pi._arg0 = i._arg0;
+					_optimization = false;
+					//_result_elimination = false;
+					return;
+				}
+			}
+
+			if(pi.op == _OP_MOVE)
+			{
+				pi.op = _OP_DMOVE;
+				pi._arg2 = i._arg0;
+				pi._arg3 = (unsigned char)i._arg1;
+				return;
+			}
+			break;
+		case _OP_LOAD:
+			if(pi.op == _OP_LOAD && i._arg1 < 256) {
+				pi.op = _OP_DLOAD;
+				pi._arg2 = i._arg0;
+				pi._arg3 = (unsigned char)i._arg1;
+				return;
+			}
+			break;
+		case _OP_EQ:case _OP_NE:
+			if(pi.op == _OP_LOAD && pi._arg0 == i._arg1 && (!IsLocal(pi._arg0) ))
+			{
+				pi.op = i.op;
+				pi._arg0 = i._arg0;
+				pi._arg1 = pi._arg1;
+				pi._arg2 = i._arg2;
+				pi._arg3 = MAX_FUNC_STACKSIZE;
+				return;
+			}
+			break;
+		case _OP_LOADNULLS:
+			if((pi.op == _OP_LOADNULLS && pi._arg0+pi._arg1 == i._arg0)) {
+				
+				pi._arg1 = pi._arg1 + 1;
+				pi.op = _OP_LOADNULLS;
+				return;
+			}
+            break;
+		case _OP_LINE:
+			if(pi.op == _OP_LINE) {
+				_instructions.pop_back();
+				_lineinfos.pop_back();
+			}
+			break;
+		}
+	}
+	_optimization = true;
+	_instructions.push_back(i);
+}
+
+SQObject SQFuncState::CreateString(const SQChar *s,SQInteger len)
+{
+	SQObjectPtr ns(SQString::Create(_sharedstate,s,len));
+	_table(_strings)->NewSlot(ns,(SQInteger)1);
+	return ns;
+}
+
+SQObject SQFuncState::CreateTable()
+{
+	SQObjectPtr nt(SQTable::Create(_sharedstate,0));
+	_table(_strings)->NewSlot(nt,(SQInteger)1);
+	return nt;
+}
+
+SQFunctionProto *SQFuncState::BuildProto()
+{
+	
+	SQFunctionProto *f=SQFunctionProto::Create(_ss,_instructions.size(),
+		_nliterals,_parameters.size(),_functions.size(),_outervalues.size(),
+		_lineinfos.size(),_localvarinfos.size(),_defaultparams.size());
+
+	SQObjectPtr refidx,key,val;
+	SQInteger idx;
+
+	f->_stacksize = _stacksize;
+	f->_sourcename = _sourcename;
+	f->_bgenerator = _bgenerator;
+	f->_name = _name;
+
+	while((idx=_table(_literals)->Next(false,refidx,key,val))!=-1) {
+		f->_literals[_integer(val)]=key;
+		refidx=idx;
+	}
+
+	for(SQUnsignedInteger nf = 0; nf < _functions.size(); nf++) f->_functions[nf] = _functions[nf];
+	for(SQUnsignedInteger np = 0; np < _parameters.size(); np++) f->_parameters[np] = _parameters[np];
+	for(SQUnsignedInteger no = 0; no < _outervalues.size(); no++) f->_outervalues[no] = _outervalues[no];
+	for(SQUnsignedInteger nl = 0; nl < _localvarinfos.size(); nl++) f->_localvarinfos[nl] = _localvarinfos[nl];
+	for(SQUnsignedInteger ni = 0; ni < _lineinfos.size(); ni++) f->_lineinfos[ni] = _lineinfos[ni];
+	for(SQUnsignedInteger nd = 0; nd < _defaultparams.size(); nd++) f->_defaultparams[nd] = _defaultparams[nd];
+
+	memcpy(f->_instructions,&_instructions[0],_instructions.size()*sizeof(SQInstruction));
+
+	f->_varparams = _varparams;
+
+	return f;
+}
+
+SQFuncState *SQFuncState::PushChildState(SQSharedState *ss)
+{
+	SQFuncState *child = (SQFuncState *)sq_malloc(sizeof(SQFuncState));
+	new (child) SQFuncState(ss,this,_errfunc,_errtarget);
+	_childstates.push_back(child);
+	return child;
+}
+
+void SQFuncState::PopChildState()
+{
+	SQFuncState *child = _childstates.back();
+	sq_delete(child,SQFuncState);
+	_childstates.pop_back();
+}
+
+SQFuncState::~SQFuncState()
+{
+	while(_childstates.size() > 0)
+	{
+		PopChildState();
+	}
+}
+
+#endif