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; rabbit::ObjectPtr func;
_CHECK_IO(rabbit::FunctionProto::load(v,up,read,func)); _CHECK_IO(rabbit::FunctionProto::load(v,up,read,func));
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL)); _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 //FIXME: load an root for this closure
return true; return true;
} }

8
rabbit/Compiler.cpp
View File

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

18
rabbit/FuncState.cpp
View File

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

1
rabbit/Object.hpp
View File

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

10
rabbit/SharedState.cpp
View File

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

20
rabbit/SharedState.hpp
View File

@ -70,16 +70,16 @@ namespace rabbit {
#define _sp(s) (_sharedstate->getScratchPad(s)) #define _sp(s) (_sharedstate->getScratchPad(s))
#define _spval (_sharedstate->getScratchPad(-1)) #define _spval (_sharedstate->getScratchPad(-1))
#define _table_ddel _table(_sharedstate->_table_default_delegate) #define _table_ddel _sharedstate->_table_default_delegate.toTable()
#define _array_ddel _table(_sharedstate->_array_default_delegate) #define _array_ddel _sharedstate->_array_default_delegate.toTable()
#define _string_ddel _table(_sharedstate->_string_default_delegate) #define _string_ddel _sharedstate->_string_default_delegate.toTable()
#define _number_ddel _table(_sharedstate->_number_default_delegate) #define _number_ddel _sharedstate->_number_default_delegate.toTable()
#define _generator_ddel _table(_sharedstate->_generator_default_delegate) #define _generator_ddel _sharedstate->_generator_default_delegate.toTable()
#define _closure_ddel _table(_sharedstate->_closure_default_delegate) #define _closure_ddel _sharedstate->_closure_default_delegate.toTable()
#define _thread_ddel _table(_sharedstate->_thread_default_delegate) #define _thread_ddel _sharedstate->_thread_default_delegate.toTable()
#define _class_ddel _table(_sharedstate->_class_default_delegate) #define _class_ddel _sharedstate->_class_default_delegate.toTable()
#define _instance_ddel _table(_sharedstate->_instance_default_delegate) #define _instance_ddel _sharedstate->_instance_default_delegate.toTable()
#define _weakref_ddel _table(_sharedstate->_weakref_default_delegate) #define _weakref_ddel _sharedstate->_weakref_default_delegate.toTable()
bool compileTypemask(etk::Vector<int64_t> &res,const char *typemask); 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; _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)); _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1));
if (n) { if (n) {
n->val.Null(); 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); _HashNode *nodes=(_HashNode *)SQ_MALLOC(sizeof(_HashNode)*nsize);
for(int64_t i=0;i<nsize;i++){ for(int64_t i=0;i<nsize;i++){
@ -58,7 +58,7 @@ void rabbit::Table::allocNodes(int64_t nsize)
_firstfree=&_nodes[_numofnodes-1]; _firstfree=&_nodes[_numofnodes-1];
} }
void rabbit::Table::Rehash(bool force) void rabbit::Table::Rehash(bool force) const
{ {
int64_t oldsize=_numofnodes; int64_t oldsize=_numofnodes;
//prevent problems with the integer division //prevent problems with the integer division
@ -85,7 +85,7 @@ void rabbit::Table::Rehash(bool force)
SQ_FREE(nold,oldsize*sizeof(_HashNode)); SQ_FREE(nold,oldsize*sizeof(_HashNode));
} }
rabbit::Table *rabbit::Table::clone() rabbit::Table *rabbit::Table::clone() const
{ {
rabbit::Table *nt=create(NULL,_numofnodes); rabbit::Table *nt=create(NULL,_numofnodes);
#ifdef _FAST_CLONE #ifdef _FAST_CLONE
@ -120,7 +120,7 @@ rabbit::Table *rabbit::Table::clone()
return nt; 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) if(sq_type(key) == rabbit::OT_NULL)
return false; return false;
@ -131,7 +131,7 @@ bool rabbit::Table::get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val)
} }
return false; 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); assert(sq_type(key) != rabbit::OT_NULL);
rabbit::Hash h = HashObj(key) & (_numofnodes - 1); 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); 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); int64_t idx = (int64_t)translateIndex(refpos);
while (idx < _numofnodes) { 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)); _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1));
if (n) { if (n) {
@ -217,7 +217,7 @@ bool rabbit::Table::set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &v
return false; 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(); } 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); setDelegate(NULL);
} }
void rabbit::Table::clear() void rabbit::Table::clear() const
{ {
_clearNodes(); _clearNodes();
_usednodes = 0; _usednodes = 0;
@ -250,7 +250,7 @@ rabbit::Table::~Table() {
SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode)); 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]; _HashNode *n = &_nodes[hash];
do { do {
if( _rawval(n->key) == _rawval(key) if( _rawval(n->key) == _rawval(key)
@ -262,7 +262,7 @@ rabbit::Table::_HashNode* rabbit::Table::_get(const rabbit::ObjectPtr &key,rabbi
} }
//for compiler use //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); rabbit::Hash hash = _hashstr(key,keylen);
_HashNode *n = &_nodes[hash & (_numofnodes - 1)]; _HashNode *n = &_nodes[hash & (_numofnodes - 1)];
_HashNode *res = NULL; _HashNode *res = NULL;
@ -279,7 +279,7 @@ bool rabbit::Table::getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val
return false; return false;
} }
int64_t rabbit::Table::countUsed() { int64_t rabbit::Table::countUsed() const {
return _usednodes; return _usednodes;
} }

34
rabbit/Table.hpp
View File

@ -25,30 +25,30 @@ namespace rabbit {
rabbit::ObjectPtr key; rabbit::ObjectPtr key;
_HashNode *next; _HashNode *next;
}; };
_HashNode *_firstfree; mutable _HashNode *_firstfree;
_HashNode *_nodes; mutable _HashNode *_nodes;
int64_t _numofnodes; mutable int64_t _numofnodes;
int64_t _usednodes; mutable int64_t _usednodes;
void allocNodes(int64_t nsize); void allocNodes(int64_t nsize) const;
void Rehash(bool force); void Rehash(bool force) const;
Table(rabbit::SharedState *ss, int64_t ninitialsize); Table(rabbit::SharedState *ss, int64_t ninitialsize);
void _clearNodes(); void _clearNodes() const;
public: public:
static rabbit::Table* create(rabbit::SharedState *ss,int64_t ninitialsize); static rabbit::Table* create(rabbit::SharedState *ss,int64_t ninitialsize);
void finalize(); void finalize();
Table *clone(); Table *clone() const;
~Table(); ~Table();
_HashNode *_get(const rabbit::ObjectPtr &key,rabbit::Hash hash); _HashNode *_get(const rabbit::ObjectPtr &key,rabbit::Hash hash) const;
//for compiler use //for compiler use
bool getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val); bool getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val) const;
bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val); bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val) const ;
void remove(const rabbit::ObjectPtr &key); void remove(const rabbit::ObjectPtr &key) const;
bool set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val); 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 //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); 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); int64_t next(bool getweakrefs,const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval) const;
int64_t countUsed(); int64_t countUsed() const;
void clear(); void clear() const;
void release(); 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; int64_t nrefidx;
switch(sq_type(o1)) { switch(sq_type(o1)) {
case rabbit::OT_TABLE: 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); o4 = (int64_t)nrefidx; _FINISH(1);
case rabbit::OT_ARRAY: case rabbit::OT_ARRAY:
if((nrefidx = o1.toArray()->next(o4, o2, o3)) == -1) _FINISH(exitpos); 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) bool rabbit::VirtualMachine::CLOSURE_OP(rabbit::ObjectPtr &target, rabbit::FunctionProto *func)
{ {
int64_t nouters; 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)) { if((nouters = func->_noutervalues)) {
for(int64_t i = 0; i<nouters; i++) { for(int64_t i = 0; i<nouters; i++) {
rabbit::OuterVar &v = func->_outervalues[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) { 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)){ switch(sq_type(self)){
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
if(_table(self)->get(key,dest)) { if(self.toTable()->get(key,dest)) {
return true; return true;
} }
break; break;
@ -1374,7 +1374,7 @@ bool rabbit::VirtualMachine::set(const rabbit::ObjectPtr &self,const rabbit::Obj
{ {
switch(sq_type(self)){ switch(sq_type(self)){
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
if(_table(self)->set(key,val)) return true; if(self.toTable()->set(key,val)) return true;
break; break;
case rabbit::OT_INSTANCE: case rabbit::OT_INSTANCE:
if(_instance(self)->set(key,val)) return true; 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 case FALLBACK_ERROR: return false; // the metamethod failed
} }
if(selfidx == 0) { if(selfidx == 0) {
if(_table(_roottable)->set(key,val)) if(_roottable.toTable()->set(key,val))
return true; return true;
} }
raise_Idxerror(key); raise_Idxerror(key);
@ -1409,8 +1409,8 @@ int64_t rabbit::VirtualMachine::fallBackSet(const rabbit::ObjectPtr &self,const
{ {
switch(sq_type(self)) { switch(sq_type(self)) {
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
if(_table(self)->_delegate) { if(self.toTable()->_delegate) {
if(set(_table(self)->_delegate,key,val,DONT_FALL_BACK)) return FALLBACK_OK; if(set(self.toTable()->_delegate,key,val,DONT_FALL_BACK)) return FALLBACK_OK;
} }
//keps on going //keps on going
case rabbit::OT_INSTANCE: case rabbit::OT_INSTANCE:
@ -1446,7 +1446,7 @@ bool rabbit::VirtualMachine::clone(const rabbit::ObjectPtr &self,rabbit::ObjectP
rabbit::ObjectPtr newobj; rabbit::ObjectPtr newobj;
switch(sq_type(self)){ switch(sq_type(self)){
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
newobj = _table(self)->clone(); newobj = self.toTable()->clone();
goto cloned_mt; goto cloned_mt;
case rabbit::OT_INSTANCE: { case rabbit::OT_INSTANCE: {
newobj = _instance(self)->clone(_get_shared_state(this)); 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; } if(sq_type(key) == rabbit::OT_NULL) { raise_error("null cannot be used as index"); return false; }
switch(sq_type(self)) { switch(sq_type(self)) {
case rabbit::OT_TABLE: { case rabbit::OT_TABLE:
{
bool rawcall = true; bool rawcall = true;
if(_table(self)->_delegate) { if(self.toTable()->_delegate) {
rabbit::ObjectPtr res; rabbit::ObjectPtr res;
if(!_table(self)->get(key,res)) { if(!self.toTable()->get(key,res)) {
rabbit::ObjectPtr closure; rabbit::ObjectPtr closure;
if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_NEWSLOT,closure)) { if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_NEWSLOT,closure)) {
push(self);push(key);push(val); 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 if(rawcall) {
self.toTable()->newSlot(key,val); //cannot fail
break;} }
break;
}
case rabbit::OT_INSTANCE: { case rabbit::OT_INSTANCE: {
rabbit::ObjectPtr res; rabbit::ObjectPtr res;
rabbit::ObjectPtr closure; rabbit::ObjectPtr closure;
@ -1570,8 +1573,8 @@ bool rabbit::VirtualMachine::deleteSlot(const rabbit::ObjectPtr &self,const rabb
} }
else { else {
if(sq_type(self) == rabbit::OT_TABLE) { if(sq_type(self) == rabbit::OT_TABLE) {
if(_table(self)->get(key,t)) { if(self.toTable()->get(key,t)) {
_table(self)->remove(key); self.toTable()->remove(key);
} }
else { else {
raise_Idxerror((const rabbit::Object &)key); 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_BOOL: printf("BOOL %s",obj.toInteger()?"true":"false");break;
case rabbit::OT_STRING: printf("STRING %s",_stringval(obj));break; case rabbit::OT_STRING: printf("STRING %s",_stringval(obj));break;
case rabbit::OT_NULL: printf("NULL"); 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_ARRAY: printf("ARRAY %p",obj.toArray());break;
case rabbit::OT_CLOSURE: printf("CLOSURE [%p]",_closure(obj));break; case rabbit::OT_CLOSURE: printf("CLOSURE [%p]",_closure(obj));break;
case rabbit::OT_NATIVECLOSURE: printf("NATIVECLOSURE");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; rabbit::ObjectPtr o;
#ifndef NO_COMPILER #ifndef NO_COMPILER
if(compile(v, read, p, sourcename, o, raiseerror?true:false, _get_shared_state(v)->_debuginfo)) { 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_OK;
} }
return SQ_ERROR; 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); rabbit::Object o = stack_get(v, -1);
if(!sq_isclosure(c)) return sq_throwerror(v, "closure expected"); if(!sq_isclosure(c)) return sq_throwerror(v, "closure expected");
if(sq_istable(o)) { if(sq_istable(o)) {
_closure(c)->setRoot(_table(o)->getWeakRef(rabbit::OT_TABLE)); _closure(c)->setRoot(o.toTable()->getWeakRef(rabbit::OT_TABLE));
v->pop(); v->pop();
return SQ_OK; 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); rabbit::Object &o=stack_get(v,idx);
switch(sq_type(o)) { 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; case rabbit::OT_ARRAY: o.toArray()->resize(0); break;
default: default:
return sq_throwerror(v, "clear only works on table and array"); 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); rabbit::ObjectType type = sq_type(o);
switch(type) { switch(type) {
case rabbit::OT_STRING: return o.toString()->_len; 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_ARRAY: return o.toArray()->size();
case rabbit::OT_USERDATA: return _userdata(o)->getsize(); case rabbit::OT_USERDATA: return _userdata(o)->getsize();
case rabbit::OT_INSTANCE: return _instance(o)->_class->_udsize; 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)) { switch(sq_type(self)) {
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
_table(self)->newSlot(key, v->getUp(-1)); self.toTable()->newSlot(key, v->getUp(-1));
v->pop(2); v->pop(2);
return SQ_OK; return SQ_OK;
break; break;
@ -996,18 +996,18 @@ rabbit::Result rabbit::sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx)
switch(type) { switch(type) {
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
if(sq_type(mt) == 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"); return sq_throwerror(v, "delagate cycle");
} }
v->pop(); v->pop();
} }
else if(sq_type(mt)==rabbit::OT_NULL) { 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); else return sq_aux_invalidtype(v,type);
break; break;
case rabbit::OT_USERDATA: case rabbit::OT_USERDATA:
if(sq_type(mt)==rabbit::OT_TABLE) { 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) { else if(sq_type(mt)==rabbit::OT_NULL) {
_userdata(self)->setDelegate(NULL); v->pop(); } _userdata(self)->setDelegate(NULL); v->pop(); }
else return sq_aux_invalidtype(v, type); 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); _GETSAFE_OBJ(v, idx, rabbit::OT_TABLE,self);
rabbit::ObjectPtr &key = v->getUp(-1); rabbit::ObjectPtr &key = v->getUp(-1);
rabbit::ObjectPtr t; rabbit::ObjectPtr t;
if(_table(*self)->get(key,t)) { if(self->toTable()->get(key,t)) {
_table(*self)->remove(key); self->toTable()->remove(key);
} }
if(pushval != 0) if(pushval != 0)
v->getUp(-1) = t; 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); rabbit::ObjectPtr &obj = v->getUp(-1);
switch(sq_type(self)) { switch(sq_type(self)) {
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
if(_table(self)->get(obj,obj)) if(self.toTable()->get(obj,obj))
return SQ_OK; return SQ_OK;
break; break;
case rabbit::OT_CLASS: 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)) if(_instance(self)->get(obj,obj))
return SQ_OK; return SQ_OK;
break; break;
case rabbit::OT_ARRAY:{ case rabbit::OT_ARRAY:
{
if(sq_isnumeric(obj)){ if(sq_isnumeric(obj)){
if(self.toArray()->get(tointeger(obj),obj)) { if(self.toArray()->get(tointeger(obj),obj)) {
return SQ_OK; return SQ_OK;
} }
} } else {
else {
v->pop(); v->pop();
return sq_throwerror(v,"invalid index type for an array"); 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) static int64_t table_filter(rabbit::VirtualMachine* v)
{ {
rabbit::Object &o = stack_get(v,1); 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 ret = rabbit::Table::create(_get_shared_state(v),0);
rabbit::ObjectPtr itr, key, val; rabbit::ObjectPtr itr, key, val;
@ -488,7 +488,7 @@ static int64_t table_filter(rabbit::VirtualMachine* v)
return SQ_ERROR; return SQ_ERROR;
} }
if(!rabbit::VirtualMachine::IsFalse(v->getUp(-1))) { if(!rabbit::VirtualMachine::IsFalse(v->getUp(-1))) {
_table(ret)->newSlot(key, val); ret.toTable()->newSlot(key, val);
} }
v->pop(); v->pop();
} }