[DEV] remove sqVector and use etk::Vector (safer)
This commit is contained in:
parent
5e372fdbfa
commit
5377f4b891
@ -63,7 +63,7 @@ namespace rabbit {
|
||||
}
|
||||
Array* clone() {
|
||||
Array *anew = create(NULL,0);
|
||||
anew->m_data.copy(m_data);
|
||||
anew->m_data = m_data;
|
||||
return anew;
|
||||
}
|
||||
int64_t size() const {
|
||||
@ -82,14 +82,14 @@ namespace rabbit {
|
||||
m_data.reserve(_size);
|
||||
}
|
||||
void append(const SQObject& _o) {
|
||||
m_data.push_back(_o);
|
||||
m_data.pushBack(_o);
|
||||
}
|
||||
void extend(const Array* _a);
|
||||
SQObjectPtr &top(){
|
||||
return m_data.top();
|
||||
return m_data.back();
|
||||
}
|
||||
void pop() {
|
||||
m_data.pop_back();
|
||||
m_data.popBack();
|
||||
shrinkIfNeeded();
|
||||
}
|
||||
bool insert(int64_t _idx,const SQObject& _val) {
|
||||
@ -101,10 +101,13 @@ namespace rabbit {
|
||||
return true;
|
||||
}
|
||||
void shrinkIfNeeded() {
|
||||
// TODO: Check this. No real need with etk ==> automatic ...
|
||||
/*
|
||||
if(m_data.size() <= m_data.capacity()>>2) {
|
||||
//shrink the array
|
||||
m_data.shrinktofit();
|
||||
}
|
||||
*/
|
||||
}
|
||||
bool remove(int64_t _idx) {
|
||||
if( _idx < 0
|
||||
|
||||
@ -431,7 +431,7 @@ SQRESULT sq_setparamscheck(HRABBITVM v,int64_t nparamscheck,const SQChar *typema
|
||||
SQIntVec res;
|
||||
if(!compileTypemask(res, typemask))
|
||||
return sq_throwerror(v, _SC("invalid typemask"));
|
||||
nc->_typecheck.copy(res);
|
||||
nc->_typecheck = res;
|
||||
}
|
||||
else {
|
||||
nc->_typecheck.resize(0);
|
||||
|
||||
@ -25,8 +25,8 @@ SQClass::SQClass(SQSharedState *ss,SQClass *base)
|
||||
if(_base) {
|
||||
_constructoridx = _base->_constructoridx;
|
||||
_udsize = _base->_udsize;
|
||||
_defaultvalues.copy(base->_defaultvalues);
|
||||
_methods.copy(base->_methods);
|
||||
_defaultvalues = base->_defaultvalues;
|
||||
_methods = base->_methods;
|
||||
_COPY_VECTOR(_metamethods,base->_metamethods,MT_LAST);
|
||||
__ObjaddRef(_base);
|
||||
}
|
||||
@ -83,7 +83,7 @@ bool SQClass::newSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr
|
||||
SQClassMember m;
|
||||
m.val = theval;
|
||||
_members->newSlot(key,SQObjectPtr(_make_method_idx(_methods.size())));
|
||||
_methods.push_back(m);
|
||||
_methods.pushBack(m);
|
||||
}
|
||||
else {
|
||||
_methods[_member_idx(temp)].val = theval;
|
||||
@ -94,7 +94,7 @@ bool SQClass::newSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr
|
||||
SQClassMember m;
|
||||
m.val = val;
|
||||
_members->newSlot(key,SQObjectPtr(_make_field_idx(_defaultvalues.size())));
|
||||
_defaultvalues.push_back(m);
|
||||
_defaultvalues.pushBack(m);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@ -18,7 +18,7 @@ struct SQClassMember {
|
||||
}
|
||||
};
|
||||
|
||||
typedef sqvector<SQClassMember> SQClassMemberVec;
|
||||
typedef etk::Vector<SQClassMember> SQClassMemberVec;
|
||||
|
||||
#define MEMBER_TYPE_METHOD 0x01000000
|
||||
#define MEMBER_TYPE_FIELD 0x02000000
|
||||
|
||||
@ -167,7 +167,7 @@ public:
|
||||
if(ret->_env) __ObjaddRef(ret->_env);
|
||||
ret->_name = _name;
|
||||
_COPY_VECTOR(ret->_outervalues,_outervalues,_noutervalues);
|
||||
ret->_typecheck.copy(_typecheck);
|
||||
ret->_typecheck = _typecheck;
|
||||
ret->_nparamscheck = _nparamscheck;
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -65,13 +65,13 @@ struct SQScope {
|
||||
|
||||
#define BEGIN_BREAKBLE_BLOCK() int64_t __nbreaks__=_fs->_unresolvedbreaks.size(); \
|
||||
int64_t __ncontinues__=_fs->_unresolvedcontinues.size(); \
|
||||
_fs->_breaktargets.push_back(0);_fs->_continuetargets.push_back(0);
|
||||
_fs->_breaktargets.pushBack(0);_fs->_continuetargets.pushBack(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();}
|
||||
_fs->_breaktargets.popBack();_fs->_continuetargets.popBack();}
|
||||
|
||||
class SQcompiler
|
||||
{
|
||||
@ -250,22 +250,22 @@ public:
|
||||
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);
|
||||
if(_fs->_breaktargets.back() > 0){
|
||||
_fs->addInstruction(_OP_POPTRAP, _fs->_breaktargets.back(), 0);
|
||||
}
|
||||
RESOLVE_OUTERS();
|
||||
_fs->addInstruction(_OP_JMP, 0, -1234);
|
||||
_fs->_unresolvedbreaks.push_back(_fs->getCurrentPos());
|
||||
_fs->_unresolvedbreaks.pushBack(_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);
|
||||
if(_fs->_continuetargets.back() > 0) {
|
||||
_fs->addInstruction(_OP_POPTRAP, _fs->_continuetargets.back(), 0);
|
||||
}
|
||||
RESOLVE_OUTERS();
|
||||
_fs->addInstruction(_OP_JMP, 0, -1234);
|
||||
_fs->_unresolvedcontinues.push_back(_fs->getCurrentPos());
|
||||
_fs->_unresolvedcontinues.pushBack(_fs->getCurrentPos());
|
||||
Lex();
|
||||
break;
|
||||
case TK_FUNCTION:
|
||||
@ -1163,7 +1163,7 @@ public:
|
||||
SQInstructionVec exp;
|
||||
if(expsize > 0) {
|
||||
for(int64_t i = 0; i < expsize; i++)
|
||||
exp.push_back(_fs->getInstruction(expstart + i));
|
||||
exp.pushBack(_fs->getInstruction(expstart + i));
|
||||
_fs->popInstructions(expsize);
|
||||
}
|
||||
BEGIN_BREAKBLE_BLOCK()
|
||||
@ -1231,7 +1231,7 @@ public:
|
||||
int64_t tonextcondjmp = -1;
|
||||
int64_t skipcondjmp = -1;
|
||||
int64_t __nbreaks__ = _fs->_unresolvedbreaks.size();
|
||||
_fs->_breaktargets.push_back(0);
|
||||
_fs->_breaktargets.pushBack(0);
|
||||
while(_token == TK_CASE) {
|
||||
if(!bfirst) {
|
||||
_fs->addInstruction(_OP_JMP, 0, 0);
|
||||
@ -1274,7 +1274,7 @@ public:
|
||||
_fs->popTarget();
|
||||
__nbreaks__ = _fs->_unresolvedbreaks.size() - __nbreaks__;
|
||||
if(__nbreaks__ > 0)ResolveBreaks(_fs, __nbreaks__);
|
||||
_fs->_breaktargets.pop_back();
|
||||
_fs->_breaktargets.popBack();
|
||||
}
|
||||
void FunctionStatement()
|
||||
{
|
||||
@ -1393,8 +1393,8 @@ public:
|
||||
Lex();
|
||||
_fs->addInstruction(_OP_PUSHTRAP,0,0);
|
||||
_fs->_traps++;
|
||||
if(_fs->_breaktargets.size()) _fs->_breaktargets.top()++;
|
||||
if(_fs->_continuetargets.size()) _fs->_continuetargets.top()++;
|
||||
if(_fs->_breaktargets.size()) _fs->_breaktargets.back()++;
|
||||
if(_fs->_continuetargets.size()) _fs->_continuetargets.back()++;
|
||||
int64_t trappos = _fs->getCurrentPos();
|
||||
{
|
||||
BEGIN_SCOPE();
|
||||
@ -1403,8 +1403,8 @@ public:
|
||||
}
|
||||
_fs->_traps--;
|
||||
_fs->addInstruction(_OP_POPTRAP, 1, 0);
|
||||
if(_fs->_breaktargets.size()) _fs->_breaktargets.top()--;
|
||||
if(_fs->_continuetargets.size()) _fs->_continuetargets.top()--;
|
||||
if(_fs->_breaktargets.size()) _fs->_breaktargets.back()--;
|
||||
if(_fs->_continuetargets.size()) _fs->_continuetargets.back()--;
|
||||
_fs->addInstruction(_OP_JMP, 0, 0);
|
||||
int64_t jmppos = _fs->getCurrentPos();
|
||||
_fs->setIntructionParam(trappos, 1, (_fs->getCurrentPos() - trappos));
|
||||
@ -1543,14 +1543,14 @@ public:
|
||||
funcstate->dump(func);
|
||||
#endif
|
||||
_fs = currchunk;
|
||||
_fs->_functions.push_back(func);
|
||||
_fs->_functions.pushBack(func);
|
||||
_fs->popChildState();
|
||||
}
|
||||
void ResolveBreaks(SQFuncState *funcstate, int64_t ntoresolve)
|
||||
{
|
||||
while(ntoresolve > 0) {
|
||||
int64_t pos = funcstate->_unresolvedbreaks.back();
|
||||
funcstate->_unresolvedbreaks.pop_back();
|
||||
funcstate->_unresolvedbreaks.popBack();
|
||||
//set the jmp instruction
|
||||
funcstate->setIntructionParams(pos, 0, funcstate->getCurrentPos() - pos, 0);
|
||||
ntoresolve--;
|
||||
@ -1560,7 +1560,7 @@ public:
|
||||
{
|
||||
while(ntoresolve > 0) {
|
||||
int64_t pos = funcstate->_unresolvedcontinues.back();
|
||||
funcstate->_unresolvedcontinues.pop_back();
|
||||
funcstate->_unresolvedcontinues.popBack();
|
||||
//set the jmp instruction
|
||||
funcstate->setIntructionParams(pos, 0, targetpos - pos, 0);
|
||||
ntoresolve--;
|
||||
|
||||
@ -53,9 +53,9 @@ struct SQLocalVarInfo
|
||||
|
||||
struct SQLineInfo { int64_t _line;int64_t _op; };
|
||||
|
||||
typedef sqvector<SQOuterVar> SQOuterVarVec;
|
||||
typedef sqvector<SQLocalVarInfo> SQLocalVarInfoVec;
|
||||
typedef sqvector<SQLineInfo> SQLineInfoVec;
|
||||
typedef etk::Vector<SQOuterVar> SQOuterVarVec;
|
||||
typedef etk::Vector<SQLocalVarInfo> SQLocalVarInfoVec;
|
||||
typedef etk::Vector<SQLineInfo> SQLineInfoVec;
|
||||
|
||||
#define _FUNC_SIZE(ni,nl,nparams,nfuncs,nouters,nlineinf,localinf,defparams) (sizeof(SQFunctionProto) \
|
||||
+((ni-1)*sizeof(SQInstruction))+(nl*sizeof(SQObjectPtr)) \
|
||||
|
||||
@ -264,7 +264,7 @@ void SQFuncState::setIntructionParam(int64_t pos,int64_t arg,int64_t val)
|
||||
int64_t SQFuncState::allocStackPos()
|
||||
{
|
||||
int64_t npos=_vlocals.size();
|
||||
_vlocals.push_back(SQLocalVarInfo());
|
||||
_vlocals.pushBack(SQLocalVarInfo());
|
||||
if(_vlocals.size()>((uint64_t)_stacksize)) {
|
||||
if(_stacksize>MAX_FUNC_STACKSIZE) error(_SC("internal compiler error: too many locals"));
|
||||
_stacksize=_vlocals.size();
|
||||
@ -275,11 +275,11 @@ int64_t SQFuncState::allocStackPos()
|
||||
int64_t SQFuncState::pushTarget(int64_t n)
|
||||
{
|
||||
if(n!=-1){
|
||||
_targetstack.push_back(n);
|
||||
_targetstack.pushBack(n);
|
||||
return n;
|
||||
}
|
||||
n=allocStackPos();
|
||||
_targetstack.push_back(n);
|
||||
_targetstack.pushBack(n);
|
||||
return n;
|
||||
}
|
||||
|
||||
@ -296,9 +296,9 @@ int64_t SQFuncState::popTarget()
|
||||
assert(npos < _vlocals.size());
|
||||
SQLocalVarInfo &t = _vlocals[npos];
|
||||
if(sq_type(t._name)==OT_NULL){
|
||||
_vlocals.pop_back();
|
||||
_vlocals.popBack();
|
||||
}
|
||||
_targetstack.pop_back();
|
||||
_targetstack.popBack();
|
||||
return npos;
|
||||
}
|
||||
|
||||
@ -332,9 +332,9 @@ void SQFuncState::setStacksize(int64_t n)
|
||||
_outers--;
|
||||
}
|
||||
lvi._end_op = getCurrentPos();
|
||||
_localvarinfos.push_back(lvi);
|
||||
_localvarinfos.pushBack(lvi);
|
||||
}
|
||||
_vlocals.pop_back();
|
||||
_vlocals.popBack();
|
||||
}
|
||||
}
|
||||
|
||||
@ -362,7 +362,7 @@ int64_t SQFuncState::pushLocalVariable(const SQObject &name)
|
||||
lvi._name=name;
|
||||
lvi._start_op=getCurrentPos()+1;
|
||||
lvi._pos=_vlocals.size();
|
||||
_vlocals.push_back(lvi);
|
||||
_vlocals.pushBack(lvi);
|
||||
if(_vlocals.size()>((uint64_t)_stacksize))_stacksize=_vlocals.size();
|
||||
return pos;
|
||||
}
|
||||
@ -402,13 +402,13 @@ int64_t SQFuncState::getOuterVariable(const SQObject &name)
|
||||
if(pos == -1) {
|
||||
pos = _parent->getOuterVariable(name);
|
||||
if(pos != -1) {
|
||||
_outervalues.push_back(SQOuterVar(name,SQObjectPtr(int64_t(pos)),otOUTER)); //local
|
||||
_outervalues.pushBack(SQOuterVar(name,SQObjectPtr(int64_t(pos)),otOUTER)); //local
|
||||
return _outervalues.size() - 1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
_parent->markLocalAsOuter(pos);
|
||||
_outervalues.push_back(SQOuterVar(name,SQObjectPtr(int64_t(pos)),otLOCAL)); //local
|
||||
_outervalues.pushBack(SQOuterVar(name,SQObjectPtr(int64_t(pos)),otLOCAL)); //local
|
||||
return _outervalues.size() - 1;
|
||||
|
||||
|
||||
@ -420,7 +420,7 @@ int64_t SQFuncState::getOuterVariable(const SQObject &name)
|
||||
void SQFuncState::addParameter(const SQObject &name)
|
||||
{
|
||||
pushLocalVariable(name);
|
||||
_parameters.push_back(name);
|
||||
_parameters.pushBack(name);
|
||||
}
|
||||
|
||||
void SQFuncState::addLineInfos(int64_t line,bool lineop,bool force)
|
||||
@ -430,7 +430,7 @@ void SQFuncState::addLineInfos(int64_t line,bool lineop,bool force)
|
||||
li._line=line;li._op=(getCurrentPos()+1);
|
||||
if(lineop)addInstruction(_OP_LINE,0,line);
|
||||
if(_lastline!=line) {
|
||||
_lineinfos.push_back(li);
|
||||
_lineinfos.pushBack(li);
|
||||
}
|
||||
_lastline=line;
|
||||
}
|
||||
@ -574,14 +574,14 @@ void SQFuncState::addInstruction(SQInstruction &i)
|
||||
break;
|
||||
case _OP_LINE:
|
||||
if(pi.op == _OP_LINE) {
|
||||
_instructions.pop_back();
|
||||
_lineinfos.pop_back();
|
||||
_instructions.popBack();
|
||||
_lineinfos.popBack();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
_optimization = true;
|
||||
_instructions.push_back(i);
|
||||
_instructions.pushBack(i);
|
||||
}
|
||||
|
||||
SQObject SQFuncState::createString(const SQChar *s,int64_t len)
|
||||
@ -636,7 +636,7 @@ SQFuncState *SQFuncState::pushChildState(SQSharedState *ss)
|
||||
{
|
||||
SQFuncState *child = (SQFuncState *)sq_malloc(sizeof(SQFuncState));
|
||||
new (child) SQFuncState(ss,this,_errfunc,_errtarget);
|
||||
_childstates.push_back(child);
|
||||
_childstates.pushBack(child);
|
||||
return child;
|
||||
}
|
||||
|
||||
@ -644,7 +644,7 @@ void SQFuncState::popChildState()
|
||||
{
|
||||
SQFuncState *child = _childstates.back();
|
||||
sq_delete(child,SQFuncState);
|
||||
_childstates.pop_back();
|
||||
_childstates.popBack();
|
||||
}
|
||||
|
||||
SQFuncState::~SQFuncState()
|
||||
|
||||
@ -24,11 +24,11 @@ struct SQFuncState
|
||||
void setIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2=0,int64_t arg3=0);
|
||||
void setIntructionParam(int64_t pos,int64_t arg,int64_t val);
|
||||
SQInstruction &getInstruction(int64_t pos){return _instructions[pos];}
|
||||
void popInstructions(int64_t size){for(int64_t i=0;i<size;i++)_instructions.pop_back();}
|
||||
void popInstructions(int64_t size){for(int64_t i=0;i<size;i++)_instructions.popBack();}
|
||||
void setStacksize(int64_t n);
|
||||
int64_t CountOuters(int64_t stacksize);
|
||||
void snoozeOpt(){_optimization=false;}
|
||||
void addDefaultParam(int64_t trg) { _defaultparams.push_back(trg); }
|
||||
void addDefaultParam(int64_t trg) { _defaultparams.pushBack(trg); }
|
||||
int64_t getDefaultParamCount() { return _defaultparams.size(); }
|
||||
int64_t getCurrentPos(){return _instructions.size()-1;}
|
||||
int64_t getNumericConstant(const int64_t cons);
|
||||
@ -83,7 +83,7 @@ struct SQFuncState
|
||||
int64_t _outers;
|
||||
bool _optimization;
|
||||
SQSharedState *_sharedstate;
|
||||
sqvector<SQFuncState*> _childstates;
|
||||
etk::Vector<SQFuncState*> _childstates;
|
||||
int64_t getConstant(const SQObject &cons);
|
||||
private:
|
||||
compilererrorFunc _errfunc;
|
||||
|
||||
@ -19,8 +19,8 @@
|
||||
#define IS_EOB() (CUR_CHAR <= RABBIT_EOB)
|
||||
#define NEXT() {next();_currentcolumn++;}
|
||||
#define INIT_TEMP_STRING() { _longstr.resize(0);}
|
||||
#define APPEND_CHAR(c) { _longstr.push_back(c);}
|
||||
#define TERMINATE_BUFFER() {_longstr.push_back(_SC('\0'));}
|
||||
#define APPEND_CHAR(c) { _longstr.pushBack(c);}
|
||||
#define TERMINATE_BUFFER() {_longstr.pushBack(_SC('\0'));}
|
||||
#define ADD_KEYWORD(key,id) _keywords->newSlot( SQString::create(ss, _SC(#key)) ,int64_t(id))
|
||||
|
||||
SQLexer::SQLexer(){}
|
||||
|
||||
@ -52,7 +52,7 @@ public:
|
||||
SQUserPointer _up;
|
||||
LexChar _currdata;
|
||||
SQSharedState *_sharedstate;
|
||||
sqvector<SQChar> _longstr;
|
||||
etk::Vector<SQChar> _longstr;
|
||||
compilererrorFunc _errfunc;
|
||||
void *_errtarget;
|
||||
};
|
||||
|
||||
@ -117,9 +117,9 @@ bool SQGenerator::yield(SQVM *v,int64_t target)
|
||||
|
||||
_stack.resize(size);
|
||||
SQObject _this = v->_stack[v->_stackbase];
|
||||
_stack._vals[0] = ISREFCOUNTED(sq_type(_this)) ? SQObjectPtr(_refcounted(_this)->getWeakRef(sq_type(_this))) : _this;
|
||||
_stack[0] = ISREFCOUNTED(sq_type(_this)) ? SQObjectPtr(_refcounted(_this)->getWeakRef(sq_type(_this))) : _this;
|
||||
for(int64_t n =1; n<target; n++) {
|
||||
_stack._vals[n] = v->_stack[v->_stackbase+n];
|
||||
_stack[n] = v->_stack[v->_stackbase+n];
|
||||
}
|
||||
for(int64_t j =0; j < size; j++)
|
||||
{
|
||||
@ -129,8 +129,8 @@ bool SQGenerator::yield(SQVM *v,int64_t target)
|
||||
_ci = *v->ci;
|
||||
_ci._generator=NULL;
|
||||
for(int64_t i=0;i<_ci._etraps;i++) {
|
||||
_etraps.push_back(v->_etraps.top());
|
||||
v->_etraps.pop_back();
|
||||
_etraps.pushBack(v->_etraps.back());
|
||||
v->_etraps.popBack();
|
||||
// store relative stack base and size in case of resume to other _top
|
||||
SQExceptionTrap &et = _etraps.back();
|
||||
et._stackbase -= v->_stackbase;
|
||||
@ -145,7 +145,7 @@ bool SQGenerator::resume(SQVM *v,SQObjectPtr &dest)
|
||||
if(_state==eDead){ v->raise_error(_SC("resuming dead generator")); return false; }
|
||||
if(_state==eRunning){ v->raise_error(_SC("resuming active generator")); return false; }
|
||||
int64_t size = _stack.size();
|
||||
int64_t target = &dest - &(v->_stack._vals[v->_stackbase]);
|
||||
int64_t target = &dest - &(v->_stack[v->_stackbase]);
|
||||
assert(target>=0 && target<=255);
|
||||
int64_t newbase = v->_top;
|
||||
if(!v->enterFrame(v->_top, v->_top + size, false))
|
||||
@ -161,19 +161,19 @@ bool SQGenerator::resume(SQVM *v,SQObjectPtr &dest)
|
||||
|
||||
|
||||
for(int64_t i=0;i<_ci._etraps;i++) {
|
||||
v->_etraps.push_back(_etraps.top());
|
||||
_etraps.pop_back();
|
||||
v->_etraps.pushBack(_etraps.back());
|
||||
_etraps.popBack();
|
||||
SQExceptionTrap &et = v->_etraps.back();
|
||||
// restore absolute stack base and size
|
||||
et._stackbase += newbase;
|
||||
et._stacksize += newbase;
|
||||
}
|
||||
SQObject _this = _stack._vals[0];
|
||||
SQObject _this = _stack[0];
|
||||
v->_stack[v->_stackbase] = sq_type(_this) == OT_WEAKREF ? _weakref(_this)->_obj : _this;
|
||||
|
||||
for(int64_t n = 1; n<size; n++) {
|
||||
v->_stack[v->_stackbase+n] = _stack._vals[n];
|
||||
_stack._vals[n].Null();
|
||||
v->_stack[v->_stackbase+n] = _stack[n];
|
||||
_stack[n].Null();
|
||||
}
|
||||
|
||||
_state=eRunning;
|
||||
|
||||
@ -307,8 +307,8 @@ struct SQDelegable : public rabbit::RefCounted {
|
||||
};
|
||||
|
||||
uint64_t translateIndex(const SQObjectPtr &idx);
|
||||
typedef sqvector<SQObjectPtr> SQObjectPtrVec;
|
||||
typedef sqvector<int64_t> SQIntVec;
|
||||
typedef etk::Vector<SQObjectPtr> SQObjectPtrVec;
|
||||
typedef etk::Vector<int64_t> SQIntVec;
|
||||
const SQChar *getTypeName(const SQObjectPtr &obj1);
|
||||
const SQChar *IdType2Name(SQObjectType type);
|
||||
|
||||
|
||||
@ -129,7 +129,7 @@ struct SQInstruction
|
||||
};
|
||||
|
||||
#include <rabbit/squtils.hpp>
|
||||
typedef sqvector<SQInstruction> SQInstructionVec;
|
||||
typedef etk::Vector<SQInstruction> SQInstructionVec;
|
||||
|
||||
#define NEW_SLOT_ATTRIBUTES_FLAG 0x01
|
||||
#define NEW_SLOT_STATIC_FLAG 0x02
|
||||
|
||||
@ -28,11 +28,11 @@ SQSharedState::SQSharedState()
|
||||
}
|
||||
|
||||
#define newsysstring(s) { \
|
||||
_systemstrings->push_back(SQString::create(this,s)); \
|
||||
_systemstrings->pushBack(SQString::create(this,s)); \
|
||||
}
|
||||
|
||||
#define newmetamethod(s) { \
|
||||
_metamethods->push_back(SQString::create(this,s)); \
|
||||
_metamethods->pushBack(SQString::create(this,s)); \
|
||||
_table(_metamethodsmap)->newSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \
|
||||
}
|
||||
|
||||
@ -58,7 +58,7 @@ bool compileTypemask(SQIntVec &res,const SQChar *typemask)
|
||||
case 'x': mask |= _RT_INSTANCE; break;
|
||||
case 'y': mask |= _RT_CLASS; break;
|
||||
case 'r': mask |= _RT_WEAKREF; break;
|
||||
case '.': mask = -1; res.push_back(mask); i++; mask = 0; continue;
|
||||
case '.': mask = -1; res.pushBack(mask); i++; mask = 0; continue;
|
||||
case ' ': i++; continue; //ignores spaces
|
||||
default:
|
||||
return false;
|
||||
@ -70,7 +70,7 @@ bool compileTypemask(SQIntVec &res,const SQChar *typemask)
|
||||
return false;
|
||||
continue;
|
||||
}
|
||||
res.push_back(mask);
|
||||
res.pushBack(mask);
|
||||
mask = 0;
|
||||
|
||||
}
|
||||
@ -167,7 +167,7 @@ SQSharedState::~SQSharedState()
|
||||
_metamethodsmap.Null();
|
||||
while(!_systemstrings->empty()) {
|
||||
_systemstrings->back().Null();
|
||||
_systemstrings->pop_back();
|
||||
_systemstrings->popBack();
|
||||
}
|
||||
_thread(_root_vm)->finalize();
|
||||
_root_vm.Null();
|
||||
|
||||
@ -20,102 +20,6 @@ void sq_vm_free(void *p,uint64_t size);
|
||||
|
||||
#define sq_aligning(v) (((size_t)(v) + (SQ_ALIGNMENT-1)) & (~(SQ_ALIGNMENT-1)))
|
||||
|
||||
//sqvector mini vector class, supports objects by value
|
||||
template<typename T> class sqvector
|
||||
{
|
||||
public:
|
||||
sqvector()
|
||||
{
|
||||
_vals = NULL;
|
||||
_size = 0;
|
||||
_allocated = 0;
|
||||
}
|
||||
sqvector(const sqvector<T>& v)
|
||||
{
|
||||
copy(v);
|
||||
}
|
||||
void copy(const sqvector<T>& v)
|
||||
{
|
||||
if(_size) {
|
||||
resize(0); //destroys all previous stuff
|
||||
}
|
||||
//resize(v._size);
|
||||
if(v._size > _allocated) {
|
||||
_realloc(v._size);
|
||||
}
|
||||
for(uint64_t i = 0; i < v._size; i++) {
|
||||
new ((void *)&_vals[i]) T(v._vals[i]);
|
||||
}
|
||||
_size = v._size;
|
||||
}
|
||||
~sqvector()
|
||||
{
|
||||
if(_allocated) {
|
||||
for(uint64_t i = 0; i < _size; i++)
|
||||
_vals[i].~T();
|
||||
SQ_FREE(_vals, (_allocated * sizeof(T)));
|
||||
}
|
||||
}
|
||||
void reserve(uint64_t newsize) { _realloc(newsize); }
|
||||
void resize(uint64_t newsize, const T& fill = T())
|
||||
{
|
||||
if(newsize > _allocated)
|
||||
_realloc(newsize);
|
||||
if(newsize > _size) {
|
||||
while(_size < newsize) {
|
||||
new ((void *)&_vals[_size]) T(fill);
|
||||
_size++;
|
||||
}
|
||||
}
|
||||
else{
|
||||
for(uint64_t i = newsize; i < _size; i++) {
|
||||
_vals[i].~T();
|
||||
}
|
||||
_size = newsize;
|
||||
}
|
||||
}
|
||||
void shrinktofit() { if(_size > 4) { _realloc(_size); } }
|
||||
T& top() const { return _vals[_size - 1]; }
|
||||
inline uint64_t size() const { return _size; }
|
||||
bool empty() const { return (_size <= 0); }
|
||||
inline T &push_back(const T& val = T())
|
||||
{
|
||||
if(_allocated <= _size)
|
||||
_realloc(_size * 2);
|
||||
return *(new ((void *)&_vals[_size++]) T(val));
|
||||
}
|
||||
inline void pop_back()
|
||||
{
|
||||
_size--; _vals[_size].~T();
|
||||
}
|
||||
void insert(uint64_t idx, const T& val)
|
||||
{
|
||||
resize(_size + 1);
|
||||
for(uint64_t i = _size - 1; i > idx; i--) {
|
||||
_vals[i] = _vals[i - 1];
|
||||
}
|
||||
_vals[idx] = val;
|
||||
}
|
||||
void remove(uint64_t idx)
|
||||
{
|
||||
_vals[idx].~T();
|
||||
if(idx < (_size - 1)) {
|
||||
memmove(&_vals[idx], &_vals[idx+1], sizeof(T) * (_size - idx - 1));
|
||||
}
|
||||
_size--;
|
||||
}
|
||||
uint64_t capacity() { return _allocated; }
|
||||
inline T &back() const { return _vals[_size - 1]; }
|
||||
inline T& operator[](uint64_t pos) const{ return _vals[pos]; }
|
||||
T* _vals;
|
||||
private:
|
||||
void _realloc(uint64_t newsize)
|
||||
{
|
||||
newsize = (newsize > 0)?newsize:4;
|
||||
_vals = (T*)SQ_REALLOC(_vals, _allocated * sizeof(T), newsize * sizeof(T));
|
||||
_allocated = newsize;
|
||||
}
|
||||
uint64_t _size;
|
||||
uint64_t _allocated;
|
||||
};
|
||||
|
||||
#include <etk/Vector.hpp>
|
||||
|
||||
|
||||
@ -18,9 +18,9 @@
|
||||
#include <rabbit/Array.hpp>
|
||||
#include <rabbit/sqclass.hpp>
|
||||
|
||||
#define TOP() (_stack._vals[_top-1])
|
||||
#define TARGET _stack._vals[_stackbase+arg0]
|
||||
#define STK(a) _stack._vals[_stackbase+(a)]
|
||||
#define TOP() (_stack[_top-1])
|
||||
#define TARGET _stack[_stackbase+arg0]
|
||||
#define STK(a) _stack[_stackbase+(a)]
|
||||
|
||||
bool SQVM::BW_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
|
||||
{
|
||||
@ -134,7 +134,7 @@ SQVM::SQVM(SQSharedState *ss)
|
||||
void SQVM::finalize()
|
||||
{
|
||||
if(_releasehook) { _releasehook(_foreignptr,0); _releasehook = NULL; }
|
||||
if(_openouters) closeOuters(&_stack._vals[0]);
|
||||
if(_openouters) closeOuters(&_stack[0]);
|
||||
_roottable.Null();
|
||||
_lasterror.Null();
|
||||
_errorhandler.Null();
|
||||
@ -395,12 +395,12 @@ bool SQVM::startcall(SQClosure *closure,int64_t target,int64_t args,int64_t stac
|
||||
rabbit::Array *arr = rabbit::Array::create(_ss(this),nvargs);
|
||||
int64_t pbase = stackbase+paramssize;
|
||||
for(int64_t n = 0; n < nvargs; n++) {
|
||||
(*arr)[n] = _stack._vals[pbase];
|
||||
_stack._vals[pbase].Null();
|
||||
(*arr)[n] = _stack[pbase];
|
||||
_stack[pbase].Null();
|
||||
pbase++;
|
||||
|
||||
}
|
||||
_stack._vals[stackbase+paramssize] = arr;
|
||||
_stack[stackbase+paramssize] = arr;
|
||||
//dumpstack(stackbase);
|
||||
}
|
||||
else if (paramssize != nargs) {
|
||||
@ -408,7 +408,7 @@ bool SQVM::startcall(SQClosure *closure,int64_t target,int64_t args,int64_t stac
|
||||
int64_t diff;
|
||||
if(ndef && nargs < paramssize && (diff = paramssize - nargs) <= ndef) {
|
||||
for(int64_t n = ndef - diff; n < ndef; n++) {
|
||||
_stack._vals[stackbase + (nargs++)] = closure->_defaultparams[n];
|
||||
_stack[stackbase + (nargs++)] = closure->_defaultparams[n];
|
||||
}
|
||||
}
|
||||
else {
|
||||
@ -418,7 +418,7 @@ bool SQVM::startcall(SQClosure *closure,int64_t target,int64_t args,int64_t stac
|
||||
}
|
||||
|
||||
if(closure->_env) {
|
||||
_stack._vals[stackbase] = closure->_env->_obj;
|
||||
_stack[stackbase] = closure->_env->_obj;
|
||||
}
|
||||
|
||||
if(!enterFrame(stackbase, newtop, tailcall)) return false;
|
||||
@ -463,16 +463,16 @@ bool SQVM::Return(int64_t _arg0, int64_t _arg1, SQObjectPtr &retval)
|
||||
} else if (ci->_target == -1) {
|
||||
dest = NULL;
|
||||
} else {
|
||||
dest = &_stack._vals[callerbase + ci->_target];
|
||||
dest = &_stack[callerbase + ci->_target];
|
||||
}
|
||||
if (dest) {
|
||||
if(_arg0 != 0xFF) {
|
||||
*dest = _stack._vals[_stackbase+_arg1];
|
||||
*dest = _stack[_stackbase+_arg1];
|
||||
}
|
||||
else {
|
||||
dest->Null();
|
||||
}
|
||||
//*dest = (_arg0 != 0xFF) ? _stack._vals[_stackbase+_arg1] : _null_;
|
||||
//*dest = (_arg0 != 0xFF) ? _stack[_stackbase+_arg1] : _null_;
|
||||
}
|
||||
leaveFrame();
|
||||
return _isroot ? true : false;
|
||||
@ -605,7 +605,7 @@ bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
|
||||
if((ndefparams = func->_ndefaultparams)) {
|
||||
for(int64_t i = 0; i < ndefparams; i++) {
|
||||
int64_t spos = func->_defaultparams[i];
|
||||
closure->_defaultparams[i] = _stack._vals[_stackbase + spos];
|
||||
closure->_defaultparams[i] = _stack[_stackbase + spos];
|
||||
}
|
||||
}
|
||||
target = closure;
|
||||
@ -619,11 +619,11 @@ bool SQVM::CLASS_OP(SQObjectPtr &target,int64_t baseclass,int64_t attributes)
|
||||
SQClass *base = NULL;
|
||||
SQObjectPtr attrs;
|
||||
if(baseclass != -1) {
|
||||
if(sq_type(_stack._vals[_stackbase+baseclass]) != OT_CLASS) { raise_error(_SC("trying to inherit from a %s"),getTypeName(_stack._vals[_stackbase+baseclass])); return false; }
|
||||
base = _class(_stack._vals[_stackbase + baseclass]);
|
||||
if(sq_type(_stack[_stackbase+baseclass]) != OT_CLASS) { raise_error(_SC("trying to inherit from a %s"),getTypeName(_stack[_stackbase+baseclass])); return false; }
|
||||
base = _class(_stack[_stackbase + baseclass]);
|
||||
}
|
||||
if(attributes != MAX_FUNC_STACKSIZE) {
|
||||
attrs = _stack._vals[_stackbase+attributes];
|
||||
attrs = _stack[_stackbase+attributes];
|
||||
}
|
||||
target = SQClass::create(_ss(this),base);
|
||||
if(sq_type(_class(target)->_metamethods[MT_INHERITED]) != OT_NULL) {
|
||||
@ -730,7 +730,7 @@ exception_restore:
|
||||
&& (!_closure(t)->_function->_bgenerator)){
|
||||
SQObjectPtr clo = t;
|
||||
int64_t last_top = _top;
|
||||
if(_openouters) closeOuters(&(_stack._vals[_stackbase]));
|
||||
if(_openouters) closeOuters(&(_stack[_stackbase]));
|
||||
for (int64_t i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);
|
||||
_GUARD(startcall(_closure(clo), ci->_target, arg3, _stackbase, true));
|
||||
if (last_top >= _top) {
|
||||
@ -772,13 +772,13 @@ exception_restore:
|
||||
switch(sq_type(clo)) {
|
||||
case OT_CLOSURE:
|
||||
stkbase = _stackbase+arg2;
|
||||
_stack._vals[stkbase] = inst;
|
||||
_stack[stkbase] = inst;
|
||||
_GUARD(startcall(_closure(clo), -1, arg3, stkbase, false));
|
||||
break;
|
||||
case OT_NATIVECLOSURE:
|
||||
bool dummy;
|
||||
stkbase = _stackbase+arg2;
|
||||
_stack._vals[stkbase] = inst;
|
||||
_stack[stkbase] = inst;
|
||||
_GUARD(callNative(_nativeclosure(clo), arg3, stkbase, clo, -1, dummy, dummy));
|
||||
break;
|
||||
default: break; //shutup GCC 4.x
|
||||
@ -1032,13 +1032,13 @@ exception_restore:
|
||||
case _OP_TYPEOF: _GUARD(typeOf(STK(arg1), TARGET)) continue;
|
||||
case _OP_PUSHTRAP:{
|
||||
SQInstruction *_iv = _closure(ci->_closure)->_function->_instructions;
|
||||
_etraps.push_back(SQExceptionTrap(_top,_stackbase, &_iv[(ci->_ip-_iv)+arg1], arg0)); traps++;
|
||||
_etraps.pushBack(SQExceptionTrap(_top,_stackbase, &_iv[(ci->_ip-_iv)+arg1], arg0)); traps++;
|
||||
ci->_etraps++;
|
||||
}
|
||||
continue;
|
||||
case _OP_POPTRAP: {
|
||||
for(int64_t i = 0; i < arg0; i++) {
|
||||
_etraps.pop_back(); traps--;
|
||||
_etraps.popBack(); traps--;
|
||||
ci->_etraps--;
|
||||
}
|
||||
}
|
||||
@ -1075,13 +1075,13 @@ exception_trap:
|
||||
|
||||
while( ci ) {
|
||||
if(ci->_etraps > 0) {
|
||||
SQExceptionTrap &et = _etraps.top();
|
||||
SQExceptionTrap &et = _etraps.back();
|
||||
ci->_ip = et._ip;
|
||||
_top = et._stacksize;
|
||||
_stackbase = et._stackbase;
|
||||
_stack._vals[_stackbase + et._extarget] = currerror;
|
||||
_etraps.pop_back(); traps--; ci->_etraps--;
|
||||
while(last_top >= _top) _stack._vals[last_top--].Null();
|
||||
_stack[_stackbase + et._extarget] = currerror;
|
||||
_etraps.popBack(); traps--; ci->_etraps--;
|
||||
while(last_top >= _top) _stack[last_top--].Null();
|
||||
goto exception_restore;
|
||||
}
|
||||
else if (_debughook) {
|
||||
@ -1168,8 +1168,8 @@ bool SQVM::callNative(SQNativeClosure *nclosure, int64_t nargs, int64_t newbase,
|
||||
SQIntVec &tc = nclosure->_typecheck;
|
||||
if((tcs = tc.size())) {
|
||||
for(int64_t i = 0; i < nargs && i < tcs; i++) {
|
||||
if((tc._vals[i] != -1) && !(sq_type(_stack._vals[newbase+i]) & tc._vals[i])) {
|
||||
raise_ParamTypeerror(i,tc._vals[i], sq_type(_stack._vals[newbase+i]));
|
||||
if((tc[i] != -1) && !(sq_type(_stack[newbase+i]) & tc[i])) {
|
||||
raise_ParamTypeerror(i,tc[i], sq_type(_stack[newbase+i]));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@ -1181,10 +1181,10 @@ bool SQVM::callNative(SQNativeClosure *nclosure, int64_t nargs, int64_t newbase,
|
||||
|
||||
int64_t outers = nclosure->_noutervalues;
|
||||
for (int64_t i = 0; i < outers; i++) {
|
||||
_stack._vals[newbase+nargs+i] = nclosure->_outervalues[i];
|
||||
_stack[newbase+nargs+i] = nclosure->_outervalues[i];
|
||||
}
|
||||
if(nclosure->_env) {
|
||||
_stack._vals[newbase] = nclosure->_env->_obj;
|
||||
_stack[newbase] = nclosure->_env->_obj;
|
||||
}
|
||||
|
||||
_nnativecalls++;
|
||||
@ -1206,12 +1206,12 @@ bool SQVM::callNative(SQNativeClosure *nclosure, int64_t nargs, int64_t newbase,
|
||||
return false;
|
||||
}
|
||||
if(ret) {
|
||||
retval = _stack._vals[_top-1];
|
||||
retval = _stack[_top-1];
|
||||
}
|
||||
else {
|
||||
retval.Null();
|
||||
}
|
||||
//retval = ret ? _stack._vals[_top-1] : _null_;
|
||||
//retval = ret ? _stack[_top-1] : _null_;
|
||||
leaveFrame();
|
||||
return true;
|
||||
}
|
||||
@ -1641,7 +1641,8 @@ void SQVM::findOuter(SQObjectPtr &target, SQObjectPtr *stackindex)
|
||||
}
|
||||
otr = SQOuter::create(_ss(this), stackindex);
|
||||
otr->_next = *pp;
|
||||
otr->_idx = (stackindex - _stack._vals);
|
||||
// TODO: rework this, this is absolutly not safe...
|
||||
otr->_idx = (stackindex - &_stack[0]);
|
||||
__ObjaddRef(otr);
|
||||
*pp = otr;
|
||||
target = SQObjectPtr(otr);
|
||||
@ -1689,9 +1690,9 @@ void SQVM::leaveFrame() {
|
||||
_top = _stackbase + ci->_prevtop;
|
||||
ci = (css) ? &_callsstack[css-1] : NULL;
|
||||
|
||||
if(_openouters) closeOuters(&(_stack._vals[last_stackbase]));
|
||||
if(_openouters) closeOuters(&(_stack[last_stackbase]));
|
||||
while (last_top >= _top) {
|
||||
_stack._vals[last_top--].Null();
|
||||
_stack[last_top--].Null();
|
||||
}
|
||||
}
|
||||
|
||||
@ -1699,7 +1700,7 @@ void SQVM::relocateOuters()
|
||||
{
|
||||
SQOuter *p = _openouters;
|
||||
while (p) {
|
||||
p->_valptr = _stack._vals + p->_idx;
|
||||
p->_valptr = &_stack[p->_idx];
|
||||
p = p->_next;
|
||||
}
|
||||
}
|
||||
|
||||
@ -35,7 +35,7 @@ struct SQExceptionTrap{
|
||||
|
||||
#define _INLINE
|
||||
|
||||
typedef sqvector<SQExceptionTrap> ExceptionsTraps;
|
||||
typedef etk::Vector<SQExceptionTrap> ExceptionsTraps;
|
||||
|
||||
struct SQVM : public rabbit::RefCounted
|
||||
{
|
||||
@ -53,7 +53,7 @@ struct SQVM : public rabbit::RefCounted
|
||||
SQBool _root;
|
||||
};
|
||||
|
||||
typedef sqvector<callInfo> callInfoVec;
|
||||
typedef etk::Vector<callInfo> callInfoVec;
|
||||
public:
|
||||
void DebugHookProxy(int64_t type, const SQChar * sourcename, int64_t line, const SQChar * funcname);
|
||||
static void _DebugHookProxy(HRABBITVM v, int64_t type, const SQChar * sourcename, int64_t line, const SQChar * funcname);
|
||||
@ -164,7 +164,7 @@ public:
|
||||
callInfo* _callsstack;
|
||||
int64_t _callsstacksize;
|
||||
int64_t _alloccallsstacksize;
|
||||
sqvector<callInfo> _callstackdata;
|
||||
etk::Vector<callInfo> _callstackdata;
|
||||
|
||||
ExceptionsTraps _etraps;
|
||||
callInfo *ci;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user