HeeroYui-deprecated/rabbit
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] remote _table()

Browse Source
This commit is contained in:
Edouard DUPIN 2018-07-03 21:57:37 +02:00
parent 7a589d9a98
commit 04cdeeac1a
11 changed files with 112 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rabbit/Closure.cpp
View File

@ -137,7 +137,7 @@ bool rabbit::Closure::load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQRE
rabbit::ObjectPtr func;
_CHECK_IO(rabbit::FunctionProto::load(v,up,read,func));
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL));
ret = rabbit::Closure::create(_get_shared_state(v),_funcproto(func),_table(v->_roottable)->getWeakRef(rabbit::OT_TABLE));
ret = rabbit::Closure::create(_get_shared_state(v),_funcproto(func),v->_roottable.toTable()->getWeakRef(rabbit::OT_TABLE));
//FIXME: load an root for this closure
return true;
}

8
rabbit/Compiler.cpp
View File

@ -320,7 +320,7 @@ public:
Expect('=');
rabbit::Object val = ExpectScalar();
OptionalSemicolon();
rabbit::Table *enums = _table(_get_shared_state(_vm)->_consts);
rabbit::Table *enums = _get_shared_state(_vm)->_consts.toTable();
rabbit::ObjectPtr strongid = id;
enums->newSlot(strongid,rabbit::ObjectPtr(val));
strongid.Null();
@ -787,7 +787,7 @@ public:
if(sq_type(constant) == rabbit::OT_TABLE) {
Expect('.');
constid = Expect(TK_IDENTIFIER);
if(!_table(constant)->get(constid, constval)) {
if(!constant.toTable()->get(constid, constval)) {
constval.Null();
error("invalid constant [%s.%s]", _stringval(id), _stringval(constid));
}
@ -1400,10 +1400,10 @@ public:
val._type = rabbit::OT_INTEGER;
val._unVal.nInteger = nval++;
}
_table(table)->newSlot(rabbit::ObjectPtr(key),rabbit::ObjectPtr(val));
table.toTable()->newSlot(rabbit::ObjectPtr(key),rabbit::ObjectPtr(val));
if(_token == ',') Lex();
}
rabbit::Table *enums = _table(_get_shared_state(_vm)->_consts);
rabbit::Table *enums = _get_shared_state(_vm)->_consts.toTable();
rabbit::ObjectPtr strongid = id;
enums->newSlot(rabbit::ObjectPtr(strongid),rabbit::ObjectPtr(table));
strongid.Null();

18
rabbit/FuncState.cpp
View File

@ -148,7 +148,7 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
int64_t idx;
etk::Vector<rabbit::ObjectPtr> templiterals;
templiterals.resize(_nliterals);
while((idx=_table(_literals)->next(false,refidx,key,val))!=-1) {
while((idx=_literals.toTable()->next(false,refidx,key,val))!=-1) {
refidx=idx;
templiterals[val.toInteger()]=key;
}
@ -193,7 +193,7 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
else {
int64_t refidx;
rabbit::ObjectPtr val,key,refo;
while(((refidx=_table(_literals)->next(false,refo,key,val))!= -1) && (val.toInteger() != lidx)) {
while(((refidx=_literals.toTable()->next(false,refo,key,val))!= -1) && (val.toInteger() != lidx)) {
refo = refidx;
}
dumpLiteral(key);
@ -209,7 +209,7 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
else {
int64_t refidx;
rabbit::ObjectPtr val,key,refo;
while(((refidx=_table(_literals)->next(false,refo,key,val))!= -1) && (val.toInteger() != lidx)) {
while(((refidx=_literals.toTable()->next(false,refo,key,val))!= -1) && (val.toInteger() != lidx)) {
refo = refidx;
}
dumpLiteral(key);
@ -247,10 +247,10 @@ int64_t rabbit::FuncState::getNumericConstant(const float_t cons)
int64_t rabbit::FuncState::getConstant(const rabbit::Object &cons)
{
rabbit::ObjectPtr val;
if(!_table(_literals)->get(cons,val))
if(!_literals.toTable()->get(cons,val))
{
val = _nliterals;
_table(_literals)->newSlot(cons,val);
_literals.toTable()->newSlot(cons,val);
_nliterals++;
if(_nliterals > MAX_LITERALS) {
val.Null();
@ -358,7 +358,7 @@ void rabbit::FuncState::setStacksize(int64_t n)
bool rabbit::FuncState::isConstant(const rabbit::Object &name,rabbit::Object &e)
{
rabbit::ObjectPtr val;
if(_table(_sharedstate->_consts)->get(name,val)) {
if(_sharedstate->_consts.toTable()->get(name,val)) {
e = val;
return true;
}
@ -601,14 +601,14 @@ void rabbit::FuncState::addInstruction(rabbit::Instruction &i)
rabbit::Object rabbit::FuncState::createString(const char *s,int64_t len)
{
rabbit::ObjectPtr ns(rabbit::String::create(_sharedstate,s,len));
_table(_strings)->newSlot(ns,(int64_t)1);
_strings.toTable()->newSlot(ns,(int64_t)1);
return ns;
}
rabbit::Object rabbit::FuncState::createTable()
{
rabbit::ObjectPtr nt(rabbit::Table::create(_sharedstate,0));
_table(_strings)->newSlot(nt,(int64_t)1);
_strings.toTable()->newSlot(nt,(int64_t)1);
return nt;
}
@ -625,7 +625,7 @@ rabbit::FunctionProto* rabbit::FuncState::buildProto() {
f->_bgenerator = _bgenerator;
f->_name = _name;
while((idx=_table(_literals)->next(false,refidx,key,val))!=-1) {
while((idx=_literals.toTable()->next(false,refidx,key,val))!=-1) {
f->_literals[val.toInteger()]=key;
refidx=idx;
}

1
rabbit/Object.hpp
View File

@ -149,7 +149,6 @@ namespace rabbit {
#define is_delegable(t) (sq_type(t)&SQOBJECT_DELEGABLE)
#define raw_type(obj) _RAW_TYPE((obj)._type)
#define _table(obj) ((obj)._unVal.pTable)
#define _closure(obj) ((obj)._unVal.pClosure)
#define _generator(obj) ((obj)._unVal.pGenerator)
#define _nativeclosure(obj) ((obj)._unVal.pNativeClosure)

10
rabbit/SharedState.cpp
View File

@ -48,7 +48,7 @@ rabbit::SharedState::SharedState()
#define newmetamethod(s) { \
_metamethods->pushBack(rabbit::String::create(this,s)); \
_table(_metamethodsmap)->newSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \
_metamethodsmap.toTable()->newSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \
}
bool rabbit::compileTypemask(etk::Vector<int64_t> &res,const char *typemask)
@ -162,9 +162,9 @@ rabbit::SharedState::~SharedState()
_releasehook = NULL;
}
_constructoridx.Null();
_table(_registry)->finalize();
_table(_consts)->finalize();
_table(_metamethodsmap)->finalize();
_registry.toTable()->finalize();
_consts.toTable()->finalize();
_metamethodsmap.toTable()->finalize();
_registry.Null();
_consts.Null();
_metamethodsmap.Null();
@ -199,7 +199,7 @@ int64_t rabbit::SharedState::getMetaMethodIdxByName(const rabbit::ObjectPtr &nam
return -1;
}
rabbit::ObjectPtr ret;
if(_table(_metamethodsmap)->get(name,ret)) {
if(_metamethodsmap.toTable()->get(name,ret)) {
return ret.toInteger();
}
return -1;

20
rabbit/SharedState.hpp
View File

@ -70,16 +70,16 @@ namespace rabbit {
#define _sp(s) (_sharedstate->getScratchPad(s))
#define _spval (_sharedstate->getScratchPad(-1))
#define _table_ddel _table(_sharedstate->_table_default_delegate)
#define _array_ddel _table(_sharedstate->_array_default_delegate)
#define _string_ddel _table(_sharedstate->_string_default_delegate)
#define _number_ddel _table(_sharedstate->_number_default_delegate)
#define _generator_ddel _table(_sharedstate->_generator_default_delegate)
#define _closure_ddel _table(_sharedstate->_closure_default_delegate)
#define _thread_ddel _table(_sharedstate->_thread_default_delegate)
#define _class_ddel _table(_sharedstate->_class_default_delegate)
#define _instance_ddel _table(_sharedstate->_instance_default_delegate)
#define _weakref_ddel _table(_sharedstate->_weakref_default_delegate)
#define _table_ddel _sharedstate->_table_default_delegate.toTable()
#define _array_ddel _sharedstate->_array_default_delegate.toTable()
#define _string_ddel _sharedstate->_string_default_delegate.toTable()
#define _number_ddel _sharedstate->_number_default_delegate.toTable()
#define _generator_ddel _sharedstate->_generator_default_delegate.toTable()
#define _closure_ddel _sharedstate->_closure_default_delegate.toTable()
#define _thread_ddel _sharedstate->_thread_default_delegate.toTable()
#define _class_ddel _sharedstate->_class_default_delegate.toTable()
#define _instance_ddel _sharedstate->_instance_default_delegate.toTable()
#define _weakref_ddel _sharedstate->_weakref_default_delegate.toTable()
bool compileTypemask(etk::Vector<int64_t> &res,const char *typemask);

26
rabbit/Table.cpp
View File

@ -35,7 +35,7 @@ rabbit::Table::Table(rabbit::SharedState *ss,int64_t ninitialsize) {
_delegate = NULL;
}
void rabbit::Table::remove(const rabbit::ObjectPtr &key) {
void rabbit::Table::remove(const rabbit::ObjectPtr &key) const {
_HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1));
if (n) {
n->val.Null();
@ -45,7 +45,7 @@ void rabbit::Table::remove(const rabbit::ObjectPtr &key) {
}
}
void rabbit::Table::allocNodes(int64_t nsize)
void rabbit::Table::allocNodes(int64_t nsize) const
{
_HashNode *nodes=(_HashNode *)SQ_MALLOC(sizeof(_HashNode)*nsize);
for(int64_t i=0;i<nsize;i++){
@ -58,7 +58,7 @@ void rabbit::Table::allocNodes(int64_t nsize)
_firstfree=&_nodes[_numofnodes-1];
}
void rabbit::Table::Rehash(bool force)
void rabbit::Table::Rehash(bool force) const
{
int64_t oldsize=_numofnodes;
//prevent problems with the integer division
@ -85,7 +85,7 @@ void rabbit::Table::Rehash(bool force)
SQ_FREE(nold,oldsize*sizeof(_HashNode));
}
rabbit::Table *rabbit::Table::clone()
rabbit::Table *rabbit::Table::clone() const
{
rabbit::Table *nt=create(NULL,_numofnodes);
#ifdef _FAST_CLONE
@ -120,7 +120,7 @@ rabbit::Table *rabbit::Table::clone()
return nt;
}
bool rabbit::Table::get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val)
bool rabbit::Table::get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val) const
{
if(sq_type(key) == rabbit::OT_NULL)
return false;
@ -131,7 +131,7 @@ bool rabbit::Table::get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val)
}
return false;
}
bool rabbit::Table::newSlot(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val)
bool rabbit::Table::newSlot(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val) const
{
assert(sq_type(key) != rabbit::OT_NULL);
rabbit::Hash h = HashObj(key) & (_numofnodes - 1);
@ -188,7 +188,7 @@ bool rabbit::Table::newSlot(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr
return newSlot(key, val);
}
int64_t rabbit::Table::next(bool getweakrefs,const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval)
int64_t rabbit::Table::next(bool getweakrefs,const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval) const
{
int64_t idx = (int64_t)translateIndex(refpos);
while (idx < _numofnodes) {
@ -207,7 +207,7 @@ int64_t rabbit::Table::next(bool getweakrefs,const rabbit::ObjectPtr &refpos, ra
}
bool rabbit::Table::set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val)
bool rabbit::Table::set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val) const
{
_HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1));
if (n) {
@ -217,7 +217,7 @@ bool rabbit::Table::set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &v
return false;
}
void rabbit::Table::_clearNodes()
void rabbit::Table::_clearNodes() const
{
for(int64_t i = 0;i < _numofnodes; i++) { _HashNode &n = _nodes[i]; n.key.Null(); n.val.Null(); }
}
@ -228,7 +228,7 @@ void rabbit::Table::finalize()
setDelegate(NULL);
}
void rabbit::Table::clear()
void rabbit::Table::clear() const
{
_clearNodes();
_usednodes = 0;
@ -250,7 +250,7 @@ rabbit::Table::~Table() {
SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode));
}
rabbit::Table::_HashNode* rabbit::Table::_get(const rabbit::ObjectPtr &key,rabbit::Hash hash) {
rabbit::Table::_HashNode* rabbit::Table::_get(const rabbit::ObjectPtr &key,rabbit::Hash hash) const{
_HashNode *n = &_nodes[hash];
do {
if( _rawval(n->key) == _rawval(key)
@ -262,7 +262,7 @@ rabbit::Table::_HashNode* rabbit::Table::_get(const rabbit::ObjectPtr &key,rabbi
}
//for compiler use
bool rabbit::Table::getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val) {
bool rabbit::Table::getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val) const{
rabbit::Hash hash = _hashstr(key,keylen);
_HashNode *n = &_nodes[hash & (_numofnodes - 1)];
_HashNode *res = NULL;
@ -279,7 +279,7 @@ bool rabbit::Table::getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val
return false;
}
int64_t rabbit::Table::countUsed() {
int64_t rabbit::Table::countUsed() const {
return _usednodes;
}

34
rabbit/Table.hpp
View File

@ -25,30 +25,30 @@ namespace rabbit {
rabbit::ObjectPtr key;
_HashNode *next;
};
_HashNode *_firstfree;
_HashNode *_nodes;
int64_t _numofnodes;
int64_t _usednodes;
void allocNodes(int64_t nsize);
void Rehash(bool force);
mutable _HashNode *_firstfree;
mutable _HashNode *_nodes;
mutable int64_t _numofnodes;
mutable int64_t _usednodes;
void allocNodes(int64_t nsize) const;
void Rehash(bool force) const;
Table(rabbit::SharedState *ss, int64_t ninitialsize);
void _clearNodes();
void _clearNodes() const;
public:
static rabbit::Table* create(rabbit::SharedState *ss,int64_t ninitialsize);
void finalize();
Table *clone();
Table *clone() const;
~Table();
_HashNode *_get(const rabbit::ObjectPtr &key,rabbit::Hash hash);
_HashNode *_get(const rabbit::ObjectPtr &key,rabbit::Hash hash) const;
//for compiler use
bool getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val);
bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val);
void remove(const rabbit::ObjectPtr &key);
bool set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val);
bool getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val) const;
bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val) const ;
void remove(const rabbit::ObjectPtr &key) const;
bool set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val) const ;
//returns true if a new slot has been created false if it was already present
bool newSlot(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val);
int64_t next(bool getweakrefs,const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval);
int64_t countUsed();
void clear();
bool newSlot(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val) const;
int64_t next(bool getweakrefs,const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval) const;
int64_t countUsed() const;
void clear() const;
void release();
};
}

37
rabbit/VirtualMachine.cpp
View File

@ -540,7 +540,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr
int64_t nrefidx;
switch(sq_type(o1)) {
case rabbit::OT_TABLE:
if((nrefidx = _table(o1)->next(false,o4, o2, o3)) == -1) _FINISH(exitpos);
if((nrefidx = o1.toTable()->next(false,o4, o2, o3)) == -1) _FINISH(exitpos);
o4 = (int64_t)nrefidx; _FINISH(1);
case rabbit::OT_ARRAY:
if((nrefidx = o1.toArray()->next(o4, o2, o3)) == -1) _FINISH(exitpos);
@ -603,7 +603,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr
bool rabbit::VirtualMachine::CLOSURE_OP(rabbit::ObjectPtr &target, rabbit::FunctionProto *func)
{
int64_t nouters;
rabbit::Closure *closure = rabbit::Closure::create(_get_shared_state(this), func,_table(_roottable)->getWeakRef(rabbit::OT_TABLE));
rabbit::Closure *closure = rabbit::Closure::create(_get_shared_state(this), func,_roottable.toTable()->getWeakRef(rabbit::OT_TABLE));
if((nouters = func->_noutervalues)) {
for(int64_t i = 0; i<nouters; i++) {
rabbit::OuterVar &v = func->_outervalues[i];
@ -1244,7 +1244,7 @@ bool rabbit::VirtualMachine::tailcall(rabbit::Closure *closure, int64_t parambas
bool rabbit::VirtualMachine::get(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, rabbit::ObjectPtr &dest, uint64_t getflags, int64_t selfidx) {
switch(sq_type(self)){
case rabbit::OT_TABLE:
if(_table(self)->get(key,dest)) {
if(self.toTable()->get(key,dest)) {
return true;
}
break;
@ -1374,7 +1374,7 @@ bool rabbit::VirtualMachine::set(const rabbit::ObjectPtr &self,const rabbit::Obj
{
switch(sq_type(self)){
case rabbit::OT_TABLE:
if(_table(self)->set(key,val)) return true;
if(self.toTable()->set(key,val)) return true;
break;
case rabbit::OT_INSTANCE:
if(_instance(self)->set(key,val)) return true;
@ -1398,7 +1398,7 @@ bool rabbit::VirtualMachine::set(const rabbit::ObjectPtr &self,const rabbit::Obj
case FALLBACK_ERROR: return false; // the metamethod failed
}
if(selfidx == 0) {
if(_table(_roottable)->set(key,val))
if(_roottable.toTable()->set(key,val))
return true;
}
raise_Idxerror(key);
@ -1409,8 +1409,8 @@ int64_t rabbit::VirtualMachine::fallBackSet(const rabbit::ObjectPtr &self,const
{
switch(sq_type(self)) {
case rabbit::OT_TABLE:
if(_table(self)->_delegate) {
if(set(_table(self)->_delegate,key,val,DONT_FALL_BACK)) return FALLBACK_OK;
if(self.toTable()->_delegate) {
if(set(self.toTable()->_delegate,key,val,DONT_FALL_BACK)) return FALLBACK_OK;
}
//keps on going
case rabbit::OT_INSTANCE:
@ -1446,7 +1446,7 @@ bool rabbit::VirtualMachine::clone(const rabbit::ObjectPtr &self,rabbit::ObjectP
rabbit::ObjectPtr newobj;
switch(sq_type(self)){
case rabbit::OT_TABLE:
newobj = _table(self)->clone();
newobj = self.toTable()->clone();
goto cloned_mt;
case rabbit::OT_INSTANCE: {
newobj = _instance(self)->clone(_get_shared_state(this));
@ -1498,11 +1498,12 @@ bool rabbit::VirtualMachine::newSlot(const rabbit::ObjectPtr &self,const rabbit:
{
if(sq_type(key) == rabbit::OT_NULL) { raise_error("null cannot be used as index"); return false; }
switch(sq_type(self)) {
case rabbit::OT_TABLE: {
case rabbit::OT_TABLE:
{
bool rawcall = true;
if(_table(self)->_delegate) {
if(self.toTable()->_delegate) {
rabbit::ObjectPtr res;
if(!_table(self)->get(key,res)) {
if(!self.toTable()->get(key,res)) {
rabbit::ObjectPtr closure;
if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_NEWSLOT,closure)) {
push(self);push(key);push(val);
@ -1516,9 +1517,11 @@ bool rabbit::VirtualMachine::newSlot(const rabbit::ObjectPtr &self,const rabbit:
}
}
}
if(rawcall) _table(self)->newSlot(key,val); //cannot fail
break;}
if(rawcall) {
self.toTable()->newSlot(key,val); //cannot fail
}
break;
}
case rabbit::OT_INSTANCE: {
rabbit::ObjectPtr res;
rabbit::ObjectPtr closure;
@ -1570,8 +1573,8 @@ bool rabbit::VirtualMachine::deleteSlot(const rabbit::ObjectPtr &self,const rabb
}
else {
if(sq_type(self) == rabbit::OT_TABLE) {
if(_table(self)->get(key,t)) {
_table(self)->remove(key);
if(self.toTable()->get(key,t)) {
self.toTable()->remove(key);
}
else {
raise_Idxerror((const rabbit::Object &)key);
@ -1786,7 +1789,7 @@ void rabbit::VirtualMachine::dumpstack(int64_t stackbase,bool dumpall)
case rabbit::OT_BOOL: printf("BOOL %s",obj.toInteger()?"true":"false");break;
case rabbit::OT_STRING: printf("STRING %s",_stringval(obj));break;
case rabbit::OT_NULL: printf("NULL"); break;
case rabbit::OT_TABLE: printf("TABLE %p[%p]",_table(obj),_table(obj)->_delegate);break;
case rabbit::OT_TABLE: printf("TABLE %p[%p]",obj.toTable(),obj.toTable()->_delegate);break;
case rabbit::OT_ARRAY: printf("ARRAY %p",obj.toArray());break;
case rabbit::OT_CLOSURE: printf("CLOSURE [%p]",_closure(obj));break;
case rabbit::OT_NATIVECLOSURE: printf("NATIVECLOSURE");break;

28
rabbit/sqapi.cpp
View File

@ -149,7 +149,7 @@ rabbit::Result rabbit::sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,r
rabbit::ObjectPtr o;
#ifndef NO_COMPILER
if(compile(v, read, p, sourcename, o, raiseerror?true:false, _get_shared_state(v)->_debuginfo)) {
v->push(rabbit::Closure::create(_get_shared_state(v), _funcproto(o), _table(v->_roottable)->getWeakRef(rabbit::OT_TABLE)));
v->push(rabbit::Closure::create(_get_shared_state(v), _funcproto(o), v->_roottable.toTable()->getWeakRef(rabbit::OT_TABLE)));
return SQ_OK;
}
return SQ_ERROR;
@ -518,7 +518,7 @@ rabbit::Result rabbit::sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx)
rabbit::Object o = stack_get(v, -1);
if(!sq_isclosure(c)) return sq_throwerror(v, "closure expected");
if(sq_istable(o)) {
_closure(c)->setRoot(_table(o)->getWeakRef(rabbit::OT_TABLE));
_closure(c)->setRoot(o.toTable()->getWeakRef(rabbit::OT_TABLE));
v->pop();
return SQ_OK;
}
@ -537,7 +537,7 @@ rabbit::Result rabbit::sq_clear(rabbit::VirtualMachine* v,int64_t idx)
{
rabbit::Object &o=stack_get(v,idx);
switch(sq_type(o)) {
case rabbit::OT_TABLE: _table(o)->clear(); break;
case rabbit::OT_TABLE: o.toTable()->clear(); break;
case rabbit::OT_ARRAY: o.toArray()->resize(0); break;
default:
return sq_throwerror(v, "clear only works on table and array");
@ -738,7 +738,7 @@ int64_t rabbit::sq_getsize(rabbit::VirtualMachine* v, int64_t idx)
rabbit::ObjectType type = sq_type(o);
switch(type) {
case rabbit::OT_STRING: return o.toString()->_len;
case rabbit::OT_TABLE: return _table(o)->countUsed();
case rabbit::OT_TABLE: return o.toTable()->countUsed();
case rabbit::OT_ARRAY: return o.toArray()->size();
case rabbit::OT_USERDATA: return _userdata(o)->getsize();
case rabbit::OT_INSTANCE: return _instance(o)->_class->_udsize;
@ -932,7 +932,7 @@ rabbit::Result rabbit::sq_rawset(rabbit::VirtualMachine* v,int64_t idx)
}
switch(sq_type(self)) {
case rabbit::OT_TABLE:
_table(self)->newSlot(key, v->getUp(-1));
self.toTable()->newSlot(key, v->getUp(-1));
v->pop(2);
return SQ_OK;
break;
@ -996,18 +996,18 @@ rabbit::Result rabbit::sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx)
switch(type) {
case rabbit::OT_TABLE:
if(sq_type(mt) == rabbit::OT_TABLE) {
if(!_table(self)->setDelegate(_table(mt))) {
if(!self.toTable()->setDelegate(mt.toTable())) {
return sq_throwerror(v, "delagate cycle");
}
v->pop();
}
else if(sq_type(mt)==rabbit::OT_NULL) {
_table(self)->setDelegate(NULL); v->pop(); }
self.toTable()->setDelegate(NULL); v->pop(); }
else return sq_aux_invalidtype(v,type);
break;
case rabbit::OT_USERDATA:
if(sq_type(mt)==rabbit::OT_TABLE) {
_userdata(self)->setDelegate(_table(mt)); v->pop(); }
_userdata(self)->setDelegate(mt.toTable()); v->pop(); }
else if(sq_type(mt)==rabbit::OT_NULL) {
_userdata(self)->setDelegate(NULL); v->pop(); }
else return sq_aux_invalidtype(v, type);
@ -1026,8 +1026,8 @@ rabbit::Result rabbit::sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,ra
_GETSAFE_OBJ(v, idx, rabbit::OT_TABLE,self);
rabbit::ObjectPtr &key = v->getUp(-1);
rabbit::ObjectPtr t;
if(_table(*self)->get(key,t)) {
_table(*self)->remove(key);
if(self->toTable()->get(key,t)) {
self->toTable()->remove(key);
}
if(pushval != 0)
v->getUp(-1) = t;
@ -1070,7 +1070,7 @@ rabbit::Result rabbit::sq_rawget(rabbit::VirtualMachine* v,int64_t idx)
rabbit::ObjectPtr &obj = v->getUp(-1);
switch(sq_type(self)) {
case rabbit::OT_TABLE:
if(_table(self)->get(obj,obj))
if(self.toTable()->get(obj,obj))
return SQ_OK;
break;
case rabbit::OT_CLASS:
@ -1081,13 +1081,13 @@ rabbit::Result rabbit::sq_rawget(rabbit::VirtualMachine* v,int64_t idx)
if(_instance(self)->get(obj,obj))
return SQ_OK;
break;
case rabbit::OT_ARRAY:{
case rabbit::OT_ARRAY:
{
if(sq_isnumeric(obj)){
if(self.toArray()->get(tointeger(obj),obj)) {
return SQ_OK;
}
}
else {
} else {
v->pop();
return sq_throwerror(v,"invalid index type for an array");
}

4
rabbit/sqbaselib.cpp
View File

@ -473,7 +473,7 @@ static int64_t table_getdelegate(rabbit::VirtualMachine* v)
static int64_t table_filter(rabbit::VirtualMachine* v)
{
rabbit::Object &o = stack_get(v,1);
rabbit::Table *tbl = _table(o);
rabbit::Table *tbl = o.toTable();
rabbit::ObjectPtr ret = rabbit::Table::create(_get_shared_state(v),0);
rabbit::ObjectPtr itr, key, val;
@ -488,7 +488,7 @@ static int64_t table_filter(rabbit::VirtualMachine* v)
return SQ_ERROR;
}
if(!rabbit::VirtualMachine::IsFalse(v->getUp(-1))) {
_table(ret)->newSlot(key, val);
ret.toTable()->newSlot(key, val);
}
v->pop();
}