diff --git a/rabbit/Closure.cpp b/rabbit/Closure.cpp
index eace7df..0afe7e2 100644
--- a/rabbit/Closure.cpp
+++ b/rabbit/Closure.cpp
@@ -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;
 }
diff --git a/rabbit/Compiler.cpp b/rabbit/Compiler.cpp
index 3d06f4a..46414cf 100644
--- a/rabbit/Compiler.cpp
+++ b/rabbit/Compiler.cpp
@@ -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();
diff --git a/rabbit/FuncState.cpp b/rabbit/FuncState.cpp
index 1c60a62..6eaa755 100644
--- a/rabbit/FuncState.cpp
+++ b/rabbit/FuncState.cpp
@@ -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;
 	}
diff --git a/rabbit/Object.hpp b/rabbit/Object.hpp
index 7b3d114..f3dd77f 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 _table(obj) ((obj)._unVal.pTable)
 	#define _closure(obj) ((obj)._unVal.pClosure)
 	#define _generator(obj) ((obj)._unVal.pGenerator)
 	#define _nativeclosure(obj) ((obj)._unVal.pNativeClosure)
diff --git a/rabbit/SharedState.cpp b/rabbit/SharedState.cpp
index 1d5751e..59cba43 100644
--- a/rabbit/SharedState.cpp
+++ b/rabbit/SharedState.cpp
@@ -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;
diff --git a/rabbit/SharedState.hpp b/rabbit/SharedState.hpp
index a218212..1dd00b4 100644
--- a/rabbit/SharedState.hpp
+++ b/rabbit/SharedState.hpp
@@ -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);
 	
diff --git a/rabbit/Table.cpp b/rabbit/Table.cpp
index be8411e..78ad1b0 100644
--- a/rabbit/Table.cpp
+++ b/rabbit/Table.cpp
@@ -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;
 }
 
diff --git a/rabbit/Table.hpp b/rabbit/Table.hpp
index 7fc2a55..d87379f 100644
--- a/rabbit/Table.hpp
+++ b/rabbit/Table.hpp
@@ -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();
 	};
 }
diff --git a/rabbit/VirtualMachine.cpp b/rabbit/VirtualMachine.cpp
index 9ad636c..b845e25 100644
--- a/rabbit/VirtualMachine.cpp
+++ b/rabbit/VirtualMachine.cpp
@@ -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,27 +1498,30 @@ 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: {
-		bool rawcall = true;
-		if(_table(self)->_delegate) {
-			rabbit::ObjectPtr res;
-			if(!_table(self)->get(key,res)) {
-				rabbit::ObjectPtr closure;
-				if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_NEWSLOT,closure)) {
-					push(self);push(key);push(val);
-					if(!callMetaMethod(closure,MT_NEWSLOT,3,res)) {
-						return false;
+	case rabbit::OT_TABLE:
+		{
+			bool rawcall = true;
+			if(self.toTable()->_delegate) {
+				rabbit::ObjectPtr 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);
+						if(!callMetaMethod(closure,MT_NEWSLOT,3,res)) {
+							return false;
+						}
+						rawcall = false;
+					}
+					else {
+						rawcall = true;
 					}
-					rawcall = false;
-				}
-				else {
-					rawcall = true;
 				}
 			}
+			if(rawcall) {
+				self.toTable()->newSlot(key,val); //cannot fail
+			}
+			break;
 		}
-		if(rawcall) _table(self)->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;
diff --git a/rabbit/sqapi.cpp b/rabbit/sqapi.cpp
index ebcb856..5d89e76 100644
--- a/rabbit/sqapi.cpp
+++ b/rabbit/sqapi.cpp
@@ -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,17 +1081,17 @@ 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:{
-		if(sq_isnumeric(obj)){
-			if(self.toArray()->get(tointeger(obj),obj)) {
-				return SQ_OK;
+	case rabbit::OT_ARRAY:
+		{
+			if(sq_isnumeric(obj)){
+				if(self.toArray()->get(tointeger(obj),obj)) {
+					return SQ_OK;
+				}
+			} else {
+				v->pop();
+				return sq_throwerror(v,"invalid index type for an array");
 			}
 		}
-		else {
-			v->pop();
-			return sq_throwerror(v,"invalid index type for an array");
-		}
-				  }
 		break;
 	default:
 		v->pop();
diff --git a/rabbit/sqbaselib.cpp b/rabbit/sqbaselib.cpp
index 3f2ade7..388f0f4 100644
--- a/rabbit/sqbaselib.cpp
+++ b/rabbit/sqbaselib.cpp
@@ -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();
 	}