[DEV] remove sqVector and use etk::Vector (safer)

rabbit/Array.hpp

@@ -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

rabbit/sqapi.cpp

@@ -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);

rabbit/sqclass.cpp

@@ -25,8 +25,8 @@ SQClass::SQClass(SQSharedState *ss,SQClass *base)
 	if(_base) {
 		_constructoridx = _base->_constructoridx;
 		_udsize = _base->_udsize;
-		_defaultvalues.copy(base->_defaultvalues);
+		_defaultvalues = base->_defaultvalues;
-		_methods.copy(base->_methods);
+		_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;
 }
 

rabbit/sqclass.hpp

@@ -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

rabbit/sqclosure.hpp

@@ -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;
 	}

rabbit/sqcompiler.cpp

@@ -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){
+			if(_fs->_breaktargets.back() > 0){
-				_fs->addInstruction(_OP_POPTRAP, _fs->_breaktargets.top(), 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) {
+			if(_fs->_continuetargets.back() > 0) {
-				_fs->addInstruction(_OP_POPTRAP, _fs->_continuetargets.top(), 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->_breaktargets.size()) _fs->_breaktargets.back()++;
-		if(_fs->_continuetargets.size()) _fs->_continuetargets.top()++;
+		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->_breaktargets.size()) _fs->_breaktargets.back()--;
-		if(_fs->_continuetargets.size()) _fs->_continuetargets.top()--;
+		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--;

rabbit/sqfuncproto.hpp

@@ -53,9 +53,9 @@ struct SQLocalVarInfo
 
 struct SQLineInfo { int64_t _line;int64_t _op; };
 
-typedef sqvector<SQOuterVar> SQOuterVarVec;
+typedef etk::Vector<SQOuterVar> SQOuterVarVec;
-typedef sqvector<SQLocalVarInfo> SQLocalVarInfoVec;
+typedef etk::Vector<SQLocalVarInfo> SQLocalVarInfoVec;
-typedef sqvector<SQLineInfo> SQLineInfoVec;
+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)) \

rabbit/sqfuncstate.cpp

@@ -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();
+				_instructions.popBack();
-				_lineinfos.pop_back();
+				_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()

rabbit/sqfuncstate.hpp

@@ -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;

rabbit/sqlexer.cpp

@@ -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 APPEND_CHAR(c) { _longstr.pushBack(c);}
-#define TERMINATE_BUFFER() {_longstr.push_back(_SC('\0'));}
+#define TERMINATE_BUFFER() {_longstr.pushBack(_SC('\0'));}
 #define ADD_KEYWORD(key,id) _keywords->newSlot( SQString::create(ss, _SC(#key)) ,int64_t(id))
 
 SQLexer::SQLexer(){}

rabbit/sqlexer.hpp

@@ -52,7 +52,7 @@ public:
 	SQUserPointer _up;
 	LexChar _currdata;
 	SQSharedState *_sharedstate;
-	sqvector<SQChar> _longstr;
+	etk::Vector<SQChar> _longstr;
 	compilererrorFunc _errfunc;
 	void *_errtarget;
 };

rabbit/sqobject.cpp

@@ -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());
+		_etraps.pushBack(v->_etraps.back());
-		v->_etraps.pop_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());
+		v->_etraps.pushBack(_etraps.back());
-		_etraps.pop_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];
+		v->_stack[v->_stackbase+n] = _stack[n];
-		_stack._vals[n].Null();
+		_stack[n].Null();
 	}
 
 	_state=eRunning;

rabbit/sqobject.hpp

@@ -307,8 +307,8 @@ struct SQDelegable : public rabbit::RefCounted {
 };
 
 uint64_t translateIndex(const SQObjectPtr &idx);
-typedef sqvector<SQObjectPtr> SQObjectPtrVec;
+typedef etk::Vector<SQObjectPtr> SQObjectPtrVec;
-typedef sqvector<int64_t> SQIntVec;
+typedef etk::Vector<int64_t> SQIntVec;
 const SQChar *getTypeName(const SQObjectPtr &obj1);
 const SQChar *IdType2Name(SQObjectType type);
 

rabbit/sqopcodes.hpp

@@ -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

rabbit/sqstate.cpp

@@ -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();

rabbit/squtils.hpp

@@ -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
+#include <etk/Vector.hpp>
-{
-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;
-};
 

rabbit/sqvm.cpp

@@ -18,9 +18,9 @@
 #include <rabbit/Array.hpp>
 #include <rabbit/sqclass.hpp>
 
-#define TOP() (_stack._vals[_top-1])
+#define TOP() (_stack[_top-1])
-#define TARGET _stack._vals[_stackbase+arg0]
+#define TARGET _stack[_stackbase+arg0]
-#define STK(a) _stack._vals[_stackbase+(a)]
+#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];
+			(*arr)[n] = _stack[pbase];
-			_stack._vals[pbase].Null();
+			_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; }
+		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._vals[_stackbase + baseclass]);
+		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;
+				_stack[_stackbase + et._extarget] = currerror;
-				_etraps.pop_back(); traps--; ci->_etraps--;
+				_etraps.popBack(); traps--; ci->_etraps--;
-				while(last_top >= _top) _stack._vals[last_top--].Null();
+				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])) {
+			if((tc[i] != -1) && !(sq_type(_stack[newbase+i]) & tc[i])) {
-				raise_ParamTypeerror(i,tc._vals[i], sq_type(_stack._vals[newbase+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;
 	}
 }

rabbit/sqvm.hpp

@@ -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;