From 36a162e89d84cc2e1d70bb446166820e6adf075b Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Tue, 3 Jul 2018 22:17:47 +0200 Subject: [PATCH] [DEV] remote _class() --- rabbit/Object.hpp | 1 - rabbit/VirtualMachine.cpp | 26 +++++++++++------------ rabbit/sqapi.cpp | 44 +++++++++++++++++++-------------------- 3 files changed, 35 insertions(+), 36 deletions(-) diff --git a/rabbit/Object.hpp b/rabbit/Object.hpp index 4f6eea0..d653cfb 100644 --- a/rabbit/Object.hpp +++ b/rabbit/Object.hpp @@ -149,7 +149,6 @@ namespace rabbit { #define is_delegable(t) (sq_type(t)&SQOBJECT_DELEGABLE) #define raw_type(obj) _RAW_TYPE((obj)._type) - #define _class(obj) ((obj)._unVal.pClass) #define _instance(obj) ((obj)._unVal.pInstance) #define _delegable(obj) ((rabbit::Delegable *)(obj)._unVal.pDelegable) #define _weakref(obj) ((obj)._unVal.pWeakRef) diff --git a/rabbit/VirtualMachine.cpp b/rabbit/VirtualMachine.cpp index 9ec9e7f..05eeaad 100644 --- a/rabbit/VirtualMachine.cpp +++ b/rabbit/VirtualMachine.cpp @@ -549,7 +549,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr if((nrefidx = o1.toString()->next(o4, o2, o3)) == -1)_FINISH(exitpos); o4 = (int64_t)nrefidx; _FINISH(1); case rabbit::OT_CLASS: - if((nrefidx = _class(o1)->next(o4, o2, o3)) == -1)_FINISH(exitpos); + if((nrefidx = o1.toClass()->next(o4, o2, o3)) == -1)_FINISH(exitpos); o4 = (int64_t)nrefidx; _FINISH(1); case rabbit::OT_USERDATA: case rabbit::OT_INSTANCE: @@ -636,23 +636,23 @@ bool rabbit::VirtualMachine::CLASS_OP(rabbit::ObjectPtr &target,int64_t baseclas rabbit::ObjectPtr attrs; if(baseclass != -1) { if(sq_type(_stack[_stackbase+baseclass]) != rabbit::OT_CLASS) { raise_error("trying to inherit from a %s",getTypeName(_stack[_stackbase+baseclass])); return false; } - base = _class(_stack[_stackbase + baseclass]); + base = _stack[_stackbase + baseclass].toClass(); } if(attributes != MAX_FUNC_STACKSIZE) { attrs = _stack[_stackbase+attributes]; } target = rabbit::Class::create(_get_shared_state(this),base); - if(sq_type(_class(target)->_metamethods[MT_INHERITED]) != rabbit::OT_NULL) { + if(sq_type(target.toClass()->_metamethods[MT_INHERITED]) != rabbit::OT_NULL) { int nparams = 2; rabbit::ObjectPtr ret; push(target); push(attrs); - if(!call(_class(target)->_metamethods[MT_INHERITED],nparams,_top - nparams, ret, false)) { + if(!call(target.toClass()->_metamethods[MT_INHERITED],nparams,_top - nparams, ret, false)) { pop(nparams); return false; } pop(nparams); } - _class(target)->_attributes = attrs; + target.toClass()->_attributes = attrs; return true; } @@ -772,7 +772,7 @@ exception_restore: continue; case rabbit::OT_CLASS:{ rabbit::ObjectPtr inst; - _GUARD(createClassInstance(_class(clo),inst,clo)); + _GUARD(createClassInstance(clo.toClass(),inst,clo)); if(sarg0 != -1) { STK(arg0) = inst; } @@ -972,7 +972,7 @@ exception_restore: case _OP_INSTANCEOF: if(sq_type(STK(arg1)) != rabbit::OT_CLASS) {raise_error("cannot apply instanceof between a %s and a %s",getTypeName(STK(arg1)),getTypeName(STK(arg2))); SQ_THROW();} - TARGET = (sq_type(STK(arg2)) == rabbit::OT_INSTANCE) ? (_instance(STK(arg2))->instanceOf(_class(STK(arg1)))?true:false) : false; + TARGET = (sq_type(STK(arg2)) == rabbit::OT_INSTANCE) ? (_instance(STK(arg2))->instanceOf(STK(arg1).toClass())?true:false) : false; continue; case _OP_AND: if(IsFalse(STK(arg2))) { @@ -1265,7 +1265,7 @@ bool rabbit::VirtualMachine::get(const rabbit::ObjectPtr &self, const rabbit::Ob } break; case rabbit::OT_CLASS: - if(_class(self)->get(key,dest)) { + if(const_cast(self.toClass())->get(key,dest)) { return true; } break; @@ -1476,7 +1476,7 @@ bool rabbit::VirtualMachine::newSlotA(const rabbit::ObjectPtr &self,const rabbit raise_error("object must be a class"); return false; } - rabbit::Class *c = _class(self); + rabbit::Class *c = const_cast(self.toClass()); if(!raw) { rabbit::ObjectPtr &mm = c->_metamethods[MT_NEWMEMBER]; if(sq_type(mm) != rabbit::OT_NULL ) { @@ -1536,8 +1536,8 @@ bool rabbit::VirtualMachine::newSlot(const rabbit::ObjectPtr &self,const rabbit: return false; break;} case rabbit::OT_CLASS: - if(!_class(self)->newSlot(_get_shared_state(this),key,val,bstatic)) { - if(_class(self)->_locked) { + if(!const_cast(self.toClass())->newSlot(_get_shared_state(this),key,val,bstatic)) { + if(self.toClass()->_locked) { raise_error("trying to modify a class that has already been instantiated"); return false; } @@ -1614,7 +1614,7 @@ int64_t prevstackbase = _stackbase; case rabbit::OT_CLASS: { rabbit::ObjectPtr constr; rabbit::ObjectPtr temp; - createClassInstance(_class(closure),outres,constr); + createClassInstance(closure.toClass(),outres,constr); rabbit::ObjectType ctype = sq_type(constr); if (ctype == rabbit::OT_NATIVECLOSURE || ctype == OT_CLOSURE) { _stack[stackbase] = outres; @@ -1797,7 +1797,7 @@ void rabbit::VirtualMachine::dumpstack(int64_t stackbase,bool dumpall) case rabbit::OT_GENERATOR: printf("GENERATOR %p",obj.toGenerator());break; case rabbit::OT_THREAD: printf("THREAD [%p]",obj.toVirtualMachine());break; case rabbit::OT_USERPOINTER: printf("USERPOINTER %p",obj.toUserPointer());break; - case rabbit::OT_CLASS: printf("CLASS %p",_class(obj));break; + case rabbit::OT_CLASS: printf("CLASS %p",obj.toClass());break; case rabbit::OT_INSTANCE: printf("INSTANCE %p",_instance(obj));break; case rabbit::OT_WEAKREF: printf("WEAKERF %p",_weakref(obj));break; default: diff --git a/rabbit/sqapi.cpp b/rabbit/sqapi.cpp index 9ee3e45..badfa86 100644 --- a/rabbit/sqapi.cpp +++ b/rabbit/sqapi.cpp @@ -300,7 +300,7 @@ rabbit::Result rabbit::sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbas rabbit::ObjectPtr &base = stack_get(v,-1); if(sq_type(base) != rabbit::OT_CLASS) return sq_throwerror(v,"invalid base type"); - baseclass = _class(base); + baseclass = base.toClass(); } rabbit::Class *newclass = rabbit::Class::create(_get_shared_state(v), baseclass); if(baseclass) v->pop(); @@ -315,7 +315,7 @@ rabbit::Bool rabbit::sq_instanceof(rabbit::VirtualMachine* v) if( sq_type(inst) != rabbit::OT_INSTANCE || sq_type(cl) != rabbit::OT_CLASS) return sq_throwerror(v,"invalid param type"); - return _instance(inst)->instanceOf(_class(cl))?SQTrue:SQFalse; + return _instance(inst)->instanceOf(cl.toClass())?SQTrue:SQFalse; } rabbit::Result rabbit::sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx) @@ -742,7 +742,7 @@ int64_t rabbit::sq_getsize(rabbit::VirtualMachine* v, int64_t idx) case rabbit::OT_ARRAY: return o.toArray()->size(); case rabbit::OT_USERDATA: return o.toUserData()->getsize(); case rabbit::OT_INSTANCE: return _instance(o)->_class->_udsize; - case rabbit::OT_CLASS: return _class(o)->_udsize; + case rabbit::OT_CLASS: return o.toClass()->_udsize; default: return sq_aux_invalidtype(v, type); } @@ -773,7 +773,7 @@ rabbit::Result rabbit::sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbi o.toUserData()->setTypeTag(typetag); break; case rabbit::OT_CLASS: - _class(o)->_typetag = typetag; + o.toClass()->_typetag = typetag; break; default: return sq_throwerror(v,"invalid object type"); @@ -786,7 +786,7 @@ rabbit::Result rabbit::sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPoin switch(sq_type(*o)) { case rabbit::OT_INSTANCE: *typetag = _instance(*o)->_class->_typetag; break; case rabbit::OT_USERDATA: *typetag = o->toUserData()->getTypeTag(); break; - case rabbit::OT_CLASS: *typetag = _class(*o)->_typetag; break; + case rabbit::OT_CLASS: *typetag = o->toClass()->_typetag; break; default: return SQ_ERROR; } return SQ_OK; @@ -820,8 +820,8 @@ rabbit::Result rabbit::sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, { rabbit::ObjectPtr &o = stack_get(v,idx); if(sq_type(o) != rabbit::OT_CLASS) return sq_throwerror(v,"the object is not a class"); - if(_class(o)->_locked) return sq_throwerror(v,"the class is locked"); - _class(o)->_udsize = udsize; + if(o.toClass()->_locked) return sq_throwerror(v,"the class is locked"); + o.toClass()->_udsize = udsize; return SQ_OK; } @@ -937,7 +937,7 @@ rabbit::Result rabbit::sq_rawset(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; break; case rabbit::OT_CLASS: - _class(self)->newSlot(_get_shared_state(v), key, v->getUp(-1),false); + self.toClass()->newSlot(_get_shared_state(v), key, v->getUp(-1),false); v->pop(2); return SQ_OK; break; @@ -1074,7 +1074,7 @@ rabbit::Result rabbit::sq_rawget(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; break; case rabbit::OT_CLASS: - if(_class(self)->get(obj,obj)) + if(self.toClass()->get(obj,obj)) return SQ_OK; break; case rabbit::OT_INSTANCE: @@ -1270,7 +1270,7 @@ void rabbit::sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHO _instance(ud)->_hook = hook; break; case rabbit::OT_CLASS: - _class(ud)->_hook = hook; + ud.toClass()->_hook = hook; break; default: return; @@ -1288,7 +1288,7 @@ SQRELEASEHOOK rabbit::sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx) return _instance(ud)->_hook; break; case rabbit::OT_CLASS: - return _class(ud)->_hook; + return ud.toClass()->_hook; break; default: return NULL; @@ -1418,13 +1418,13 @@ rabbit::Result rabbit::sq_setattributes(rabbit::VirtualMachine* v,int64_t idx) rabbit::ObjectPtr &val = stack_get(v,-1); rabbit::ObjectPtr attrs; if(sq_type(key) == rabbit::OT_NULL) { - attrs = _class(*o)->_attributes; - _class(*o)->_attributes = val; + attrs = o->toClass()->_attributes; + o->toClass()->_attributes = val; v->pop(2); v->push(attrs); return SQ_OK; - }else if(_class(*o)->getAttributes(key,attrs)) { - _class(*o)->setAttributes(key,val); + }else if(o->toClass()->getAttributes(key,attrs)) { + o->toClass()->setAttributes(key,val); v->pop(2); v->push(attrs); return SQ_OK; @@ -1439,12 +1439,12 @@ rabbit::Result rabbit::sq_getattributes(rabbit::VirtualMachine* v,int64_t idx) rabbit::ObjectPtr &key = stack_get(v,-1); rabbit::ObjectPtr attrs; if(sq_type(key) == rabbit::OT_NULL) { - attrs = _class(*o)->_attributes; + attrs = o->toClass()->_attributes; v->pop(); v->push(attrs); return SQ_OK; } - else if(_class(*o)->getAttributes(key,attrs)) { + else if(o->toClass()->getAttributes(key,attrs)) { v->pop(); v->push(attrs); return SQ_OK; @@ -1457,7 +1457,7 @@ rabbit::Result rabbit::sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx, rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); rabbit::ObjectPtr &key = stack_get(v,-1); - rabbit::Table *m = _class(*o)->_members; + rabbit::Table *m = o->toClass()->_members; rabbit::ObjectPtr val; if(m->get(key,val)) { handle->_static = _isfield(val) ? SQFalse : SQTrue; @@ -1484,7 +1484,7 @@ rabbit::Result _getmemberbyhandle(rabbit::VirtualMachine* v,rabbit::ObjectPtr &s } break; case rabbit::OT_CLASS: { - rabbit::Class *c = _class(self); + rabbit::Class *c = self.toClass(); if(handle->_static) { val = &c->_methods[handle->_index].val; } @@ -1527,8 +1527,8 @@ rabbit::Result rabbit::sq_getbase(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); - if(_class(*o)->_base) - v->push(rabbit::ObjectPtr(_class(*o)->_base)); + if(o->toClass()->_base) + v->push(rabbit::ObjectPtr(o->toClass()->_base)); else v->pushNull(); return SQ_OK; @@ -1546,7 +1546,7 @@ rabbit::Result rabbit::sq_createinstance(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); - v->push(_class(*o)->createInstance()); + v->push(o->toClass()->createInstance()); return SQ_OK; }