val = _realval(o);

			}

			else {

				val = _methods[_member_idx(val)].val;

			}

			return true;

		}

		return false;

	}

	bool SetAttributes(const SQObjectPtr &key,const SQObjectPtr &val);

	bool GetAttributes(const SQObjectPtr &key,SQObjectPtr &outval);

	void Lock() { _locked = true; if(_base) _base->Lock(); }

		if (_hook) { _hook(_typetag,0);}

		sq_delete(this, SQClass);

	}

#ifndef NO_GARBAGE_COLLECTOR

#endif

	SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);

	SQInstance *CreateInstance();

	SQTable *_members;

	SQClass *_base;

	SQClassMemberVec _defaultvalues;

	SQClassMemberVec _methods;

	SQObjectPtrVec _metamethods;

	SQObjectPtr _attributes;

	SQUserPointer _typetag;

	SQRELEASEHOOK _hook;

	bool _locked;

struct SQFunctionProto;

struct SQClosure : public CHAINABLE_OBJ

{

private:

	SQClosure(SQSharedState *ss,SQFunctionProto *func){_function=func; INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);}

public:

	static SQClosure *Create(SQSharedState *ss,SQFunctionProto *func){

		SQClosure *nc=(SQClosure*)SQ_MALLOC(sizeof(SQClosure));

		new (nc) SQClosure(ss,func);

		return nc;

	}

		sq_delete(this,SQClosure);

	}

	SQClosure *Clone()

	{

		SQClosure * ret = SQClosure::Create(_opt_ss(this),_funcproto(_function));

		ret->_env = _env;

		ret->_outervalues.copy(_outervalues);

		ret->_defaultparams.copy(_defaultparams);

		return ret;

	}

	~SQClosure()

	{

		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);

	}

	bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write);

	static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret);

#ifndef NO_GARBAGE_COLLECTOR

#endif

	SQObjectPtr _env;

	SQObjectPtr _function;

	SQObjectPtrVec _outervalues;

	SQObjectPtrVec _defaultparams;

};

//////////////////////////////////////////////

struct SQGenerator : public CHAINABLE_OBJ

{

	enum SQGeneratorState{eRunning,eSuspended,eDead};

private:

	SQGenerator(SQSharedState *ss,SQClosure *closure){_closure=closure;_state=eRunning;_ci._generator=nullptr;INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);}

		SQGenerator *nc=(SQGenerator*)SQ_MALLOC(sizeof(SQGenerator));

		new (nc) SQGenerator(ss,closure);

		return nc;

	}

	~SQGenerator()

	{

		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);

	}

    void Kill(){

		_state=eDead;

		_stack.resize(0);

		_closure=_null_;}

		sq_delete(this,SQGenerator);

	}

	bool Yield(SQVM *v);

	bool Resume(SQVM *v,SQInteger target);

#ifndef NO_GARBAGE_COLLECTOR

#endif

	SQObjectPtr _closure;

	SQObjectPtrVec _stack;

	SQObjectPtrVec _vargsstack;

	SQVM::CallInfo _ci;

	ExceptionsTraps _etraps;

	SQGeneratorState _state;

};

struct SQNativeClosure : public CHAINABLE_OBJ

{

private:

		SQNativeClosure * ret = SQNativeClosure::Create(_opt_ss(this),_function);

		ret->_env = _env;

		ret->_name = _name;

		ret->_outervalues.copy(_outervalues);

		ret->_typecheck.copy(_typecheck);

		ret->_nparamscheck = _nparamscheck;

		return ret;

	}

	~SQNativeClosure()

	{

		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);

	}

		sq_delete(this,SQNativeClosure);

	}

#ifndef NO_GARBAGE_COLLECTOR

#endif

	SQInteger _nparamscheck;

	SQIntVec _typecheck;

	SQObjectPtrVec _outervalues;

	SQObjectPtr _env;

	SQFUNCTION _function;

	SQObjectPtr _name;

};

#endif //_SQCLOSURE_H_

public:

	static SQFunctionProto *Create(SQInteger ninstructions,

		SQInteger nliterals,SQInteger nparameters,

		SQInteger nfunctions,SQInteger noutervalues,

		SQInteger nlineinfos,SQInteger nlocalvarinfos,SQInteger ndefaultparams)

	{

		SQFunctionProto *f;

		//I compact the whole class and members in a single memory allocation

		f = (SQFunctionProto *)sq_vm_malloc(_FUNC_SIZE(ninstructions,nliterals,nparameters,nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams));

		new (f) SQFunctionProto(ninstructions, nliterals, nparameters, nfunctions, noutervalues, nlineinfos, nlocalvarinfos, ndefaultparams);

		return f;

	}

		_DESTRUCT_VECTOR(SQObjectPtr,_nliterals,_literals);

		_DESTRUCT_VECTOR(SQObjectPtr,_nparameters,_parameters);

		_DESTRUCT_VECTOR(SQObjectPtr,_nfunctions,_functions);

		_DESTRUCT_VECTOR(SQOuterVar,_noutervalues,_outervalues);

		//_DESTRUCT_VECTOR(SQLineInfo,_nlineinfos,_lineinfos); //not required are 2 integers

		_DESTRUCT_VECTOR(SQLocalVarInfo,_nlocalvarinfos,_localvarinfos);

		SQInteger size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams);

		this->~SQFunctionProto();

		sq_vm_free(this,size);

	}

	const SQChar* GetLocal(SQVM *v,SQUnsignedInteger stackbase,SQUnsignedInteger nseq,SQUnsignedInteger nop);

	SQInteger GetLine(SQInstruction *curr);

		SQ_FREE(ptr, place->size);

	}

	/* Never used but required. */

	inline void operator delete(void *) { NOT_REACHED(); }

private:

	size_t size;

};

struct SQWeakRef : SQRefCounted

{

	SQObject _obj;

};

#define _realval(o) (type((o)) != OT_WEAKREF?(SQObject)o:_weakref(o)->_obj)

struct SQObjectPtr;

#define __AddRef(type,unval) if(ISREFCOUNTED(type))	\

		{ \

			unval.pRefCounted->_uiRef++; \

		}

	a._type = b._type;

	a._unVal = b._unVal;

	b._type = tOldType;

	b._unVal = unOldVal;

}

/////////////////////////////////////////////////////////////////////////////////////

#ifndef NO_GARBAGE_COLLECTOR

#define MARK_FLAG 0x80000000

struct SQCollectable : public SQRefCounted {

	SQCollectable *_next;

	SQCollectable *_prev;

	SQSharedState *_sharedstate;

	virtual void EnqueueMarkObjectForChildren(class SQGCMarkerQueue &queue)=0;

	void UnMark();

	virtual void Finalize()=0;

	static void AddToChain(SQCollectable **chain,SQCollectable *c);

	static void RemoveFromChain(SQCollectable **chain,SQCollectable *c);

	/**

	 * Helper to perform the final memory freeing of this instance. Since the destructor might

	 * release more objects, this can cause a very deep recursion. As such, the calls to this

	 * are to be done via _sharedstate->DelayFinalFree which ensures the calls to this method

	 * are done in an iterative instead of recursive approach.

	 */

			h = h ^ ((h<<5)+(h>>2)+(unsigned short)*(s++));

		return h;

}

struct SQString : public SQRefCounted

{

	SQString(const SQChar *news, SQInteger len);

	~SQString(){}

public:

	static SQString *Create(SQSharedState *ss, const SQChar *, SQInteger len = -1 );

	static SQString *Create(SQSharedState *ss, const std::string &str) { return Create(ss, str.data(), str.size()); }

	SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);

	SQSharedState *_sharedstate;

	SQString *_next; //chain for the string table

	SQInteger _len;

	SQHash _hash;

	SQChar _val[1];

};

#endif //_SQSTRING_H_

	~SQUserData()

	{

		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain, this);

		SetDelegate(nullptr);

	}

	static SQUserData* Create(SQSharedState *ss, SQInteger size)

	{

		SQUserData* ud = (SQUserData*)SQ_MALLOC(sizeof(SQUserData)+(size-1));

		new (ud) SQUserData(ss, size);

		return ud;

	}

#ifndef NO_GARBAGE_COLLECTOR

#endif

		if (_hook) _hook(_val,_size);

		SQInteger tsize = _size - 1;

		this->~SQUserData();

		SQ_FREE(this, sizeof(SQUserData) + tsize);

	}

	SQInteger _size;

	SQRELEASEHOOK _hook;

	SQUserPointer _typetag;

	SQChar _val[1];

};

	bool FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr &o3,SQObjectPtr &o4,SQInteger arg_2,int exitpos,int &jump);

	bool DELEGATE_OP(SQObjectPtr &trg,SQObjectPtr &o1,SQObjectPtr &o2);

	_INLINE bool LOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr);

	_INLINE bool PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr);

	_INLINE bool DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix);

	void PopVarArgs(VarArgs &vargs);

	void ClearStack(SQInteger last_top);

#ifdef _DEBUG_DUMP

	void dumpstack(SQInteger stackbase=-1, bool dumpall = false);

#endif

#ifndef NO_GARBAGE_COLLECTOR

#endif

	void GrowCallStack() {

		SQInteger newsize = _alloccallsstacksize*2;

		_callstackdata.resize(newsize);

		_callsstack = &_callstackdata[0];

		_alloccallsstacksize = newsize;

	}

////////////////////////////////////////////////////////////////////////////

	//stack functions for the api

	void Remove(SQInteger n);

	bool IsFalse(SQObjectPtr &o);

	void Pop();

	void Pop(SQInteger n);

	void Push(const SQObjectPtr &o);

	SQObjectPtr &Top();

	SQObjectPtr &PopGet();

	SQObjectPtr &GetUp(SQInteger n);