Changeset - r25185:205b0c2c0e50
Parent rev.
Child rev.
[Not reviewed]
master
0 10 0
Rubidium - 3 years ago 2021-04-15 16:47:41
rubidium@openttd.org
Fix #7513: recursive garbage collection caused stack overflow
10 files changed with 142 insertions and 120 deletions:
src/3rdparty/squirrel/squirrel/sqarray.h
1
1
src/3rdparty/squirrel/squirrel/sqclass.h
2
2
src/3rdparty/squirrel/squirrel/sqclosure.h
3
3
src/3rdparty/squirrel/squirrel/sqobject.cpp
57
80
src/3rdparty/squirrel/squirrel/sqobject.h
37
1
src/3rdparty/squirrel/squirrel/sqstate.cpp
37
28
src/3rdparty/squirrel/squirrel/sqstate.h
2
2
src/3rdparty/squirrel/squirrel/sqtable.h
1
1
src/3rdparty/squirrel/squirrel/squserdata.h
1
1
src/3rdparty/squirrel/squirrel/sqvm.h
1
1
0 comments (0 inline, 0 general)
src/3rdparty/squirrel/squirrel/sqarray.h
➞
Show inline comments
 
@@ -14,13 +14,13 @@ public:
 
	static SQArray* Create(SQSharedState *ss,SQInteger nInitialSize){
 
		SQArray *newarray=(SQArray*)SQ_MALLOC(sizeof(SQArray));
 
		new (newarray) SQArray(ss,nInitialSize);
 
		return newarray;
 
	}
 
#ifndef NO_GARBAGE_COLLECTOR
 
	void Mark(SQCollectable **chain);
 
	void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);
 
#endif
 
	void Finalize(){
 
		_values.resize(0);
 
	}
 
	bool Get(const SQInteger nidx,SQObjectPtr &val)
 
	{
src/3rdparty/squirrel/squirrel/sqclass.h
➞
Show inline comments
 
@@ -56,13 +56,13 @@ public:
 
	void Release() {
 
		if (_hook) { _hook(_typetag,0);}
 
		sq_delete(this, SQClass);
 
	}
 
	void Finalize();
 
#ifndef NO_GARBAGE_COLLECTOR
 
	void Mark(SQCollectable ** );
 
	void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);
 
#endif
 
	SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
 
	SQInstance *CreateInstance();
 
	SQTable *_members;
 
	SQClass *_base;
 
	SQClassMemberVec _defaultvalues;
 
@@ -144,13 +144,13 @@ public:
 
		SQInteger size = _memsize;
 
		this->~SQInstance();
 
		SQ_FREE(this, size);
 
	}
 
	void Finalize();
 
#ifndef NO_GARBAGE_COLLECTOR
 
	void Mark(SQCollectable ** );
 
	void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);
 
#endif
 
	bool InstanceOf(SQClass *trg);
 
	bool GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res);
 

			




	
	
	
		
 
	SQClass *_class;

			




	
	
	
		
 
	SQUserPointer _userpointer;

			




        

    


    
    

    

        

                

                    src/3rdparty/squirrel/squirrel/sqclosure.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -29,13 +29,13 @@ public:

			




	
	
	
		
 
	{

			




	
	
	
		
 
		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

			




	
	
	
		
 
	void Mark(SQCollectable **chain);

			




	
	
	
		
 
	void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);

			




	
	
	
		
 
	void Finalize(){_outervalues.resize(0); }

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	SQObjectPtr _env;

			




	
	
	
		
 
	SQObjectPtr _function;

			




	
	
	
		
 
	SQObjectPtrVec _outervalues;

			




	
	
	
		
 
	SQObjectPtrVec _defaultparams;

			




	
	
		
 
@@ -63,13 +63,13 @@ public:

			




	
	
	
		
 
	void Release(){

			




	
	
	
		
 
		sq_delete(this,SQGenerator);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	bool Yield(SQVM *v);

			




	
	
	
		
 
	bool Resume(SQVM *v,SQInteger target);

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 
	void Mark(SQCollectable **chain);

			




	
	
	
		
 
	void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);

			




	
	
	
		
 
	void Finalize(){_stack.resize(0);_closure=_null_;}

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	SQObjectPtr _closure;

			




	
	
	
		
 
	SQObjectPtrVec _stack;

			




	
	
	
		
 
	SQObjectPtrVec _vargsstack;

			




	
	
	
		
 
	SQVM::CallInfo _ci;

			




	
	
		
 
@@ -103,13 +103,13 @@ public:

			




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

			




	
	
	
		
 
	}

			




	
	
	
		
 
	void Release(){

			




	
	
	
		
 
		sq_delete(this,SQNativeClosure);

			




	
	
	
		
 
	}

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 
	void Mark(SQCollectable **chain);

			




	
	
	
		
 
	void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);

			




	
	
	
		
 
	void Finalize(){_outervalues.resize(0);}

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	SQInteger _nparamscheck;

			




	
	
	
		
 
	SQIntVec _typecheck;

			




	
	
	
		
 
	SQObjectPtrVec _outervalues;

			




	
	
	
		
 
	SQObjectPtr _env;

			




        

    


    
    

    

        

                

                    src/3rdparty/squirrel/squirrel/sqobject.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -483,110 +483,87 @@ bool SQFunctionProto::Load(SQVM *v,SQUse

			




	
	
	
		
 
	ret = f;

			




	
	
	
		
 
	return true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 

			




	
	
	
		
 
#define START_MARK() 	if(!(_uiRef&MARK_FLAG)){ \

			




	
	
	
		
 
		_uiRef|=MARK_FLAG;

			




	
	
	
		
 

			




	
	
	
		
 
#define END_MARK() RemoveFromChain(&_sharedstate->_gc_chain, this); \

			




	
	
	
		
 
		AddToChain(chain, this); }

			




	
	
	
		
 

			




	
	
	
		
 
void SQVM::Mark(SQCollectable **chain)

			




	
	
	
		
 
void SQVM::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	START_MARK()

			




	
	
	
		
 
		SQSharedState::MarkObject(_lasterror,chain);

			




	
	
	
		
 
		SQSharedState::MarkObject(_errorhandler,chain);

			




	
	
	
		
 
		SQSharedState::MarkObject(_debughook,chain);

			




	
	
	
		
 
		SQSharedState::MarkObject(_roottable, chain);

			




	
	
	
		
 
		SQSharedState::MarkObject(temp_reg, chain);

			




	
	
	
		
 
		for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::MarkObject(_stack[i], chain);

			




	
	
	
		
 
		for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::MarkObject(_vargsstack[j], chain);

			




	
	
	
		
 
		for(SQInteger k = 0; k < _callsstacksize; k++) SQSharedState::MarkObject(_callsstack[k]._closure, chain);

			




	
	
	
		
 
	END_MARK()

			




	
	
	
		
 
	SQSharedState::EnqueueMarkObject(_lasterror,queue);

			




	
	
	
		
 
	SQSharedState::EnqueueMarkObject(_errorhandler,queue);

			




	
	
	
		
 
	SQSharedState::EnqueueMarkObject(_debughook,queue);

			




	
	
	
		
 
	SQSharedState::EnqueueMarkObject(_roottable, queue);

			




	
	
	
		
 
	SQSharedState::EnqueueMarkObject(temp_reg, queue);

			




	
	
	
		
 
	for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::EnqueueMarkObject(_stack[i], queue);

			




	
	
	
		
 
	for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::EnqueueMarkObject(_vargsstack[j], queue);

			




	
	
	
		
 
	for(SQInteger k = 0; k < _callsstacksize; k++) SQSharedState::EnqueueMarkObject(_callsstack[k]._closure, queue);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQArray::Mark(SQCollectable **chain)

			




	
	
	
		
 
{

			




	
	
	
		
 
	START_MARK()

			




	
	
	
		
 
		SQInteger len = _values.size();

			




	
	
	
		
 
		for(SQInteger i = 0;i < len; i++) SQSharedState::MarkObject(_values[i], chain);

			




	
	
	
		
 
	END_MARK()

			




	
	
	
		
 
}

			




	
	
	
		
 
void SQTable::Mark(SQCollectable **chain)

			




	
	
	
		
 
void SQArray::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	START_MARK()

			




	
	
	
		
 
		if(_delegate) _delegate->Mark(chain);

			




	
	
	
		
 
		SQInteger len = _numofnodes;

			




	
	
	
		
 
		for(SQInteger i = 0; i < len; i++){

			




	
	
	
		
 
			SQSharedState::MarkObject(_nodes[i].key, chain);

			




	
	
	
		
 
			SQSharedState::MarkObject(_nodes[i].val, chain);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	END_MARK()

			




	
	
	
		
 
	SQInteger len = _values.size();

			




	
	
	
		
 
	for(SQInteger i = 0;i < len; i++) SQSharedState::EnqueueMarkObject(_values[i], queue);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQTable::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	if(_delegate) queue.Enqueue(_delegate);

			




	
	
	
		
 
	SQInteger len = _numofnodes;

			




	
	
	
		
 
	for(SQInteger i = 0; i < len; i++){

			




	
	
	
		
 
		SQSharedState::EnqueueMarkObject(_nodes[i].key, queue);

			




	
	
	
		
 
		SQSharedState::EnqueueMarkObject(_nodes[i].val, queue);

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQClass::Mark(SQCollectable **chain)

			




	
	
	
		
 
void SQClass::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	START_MARK()

			




	
	
	
		
 
		_members->Mark(chain);

			




	
	
	
		
 
		if(_base) _base->Mark(chain);

			




	
	
	
		
 
		SQSharedState::MarkObject(_attributes, chain);

			




	
	
	
		
 
		for(SQUnsignedInteger i =0; i< _defaultvalues.size(); i++) {

			




	
	
	
		
 
			SQSharedState::MarkObject(_defaultvalues[i].val, chain);

			




	
	
	
		
 
			SQSharedState::MarkObject(_defaultvalues[i].attrs, chain);

			




	
	
	
		
 
		}

			




	
	
	
		
 
		for(SQUnsignedInteger j =0; j< _methods.size(); j++) {

			




	
	
	
		
 
			SQSharedState::MarkObject(_methods[j].val, chain);

			




	
	
	
		
 
			SQSharedState::MarkObject(_methods[j].attrs, chain);

			




	
	
	
		
 
		}

			




	
	
	
		
 
		for(SQUnsignedInteger k =0; k< _metamethods.size(); k++) {

			




	
	
	
		
 
			SQSharedState::MarkObject(_metamethods[k], chain);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	END_MARK()

			




	
	
	
		
 
	queue.Enqueue(_members);

			




	
	
	
		
 
	if(_base) queue.Enqueue(_base);

			




	
	
	
		
 
	SQSharedState::EnqueueMarkObject(_attributes, queue);

			




	
	
	
		
 
	for(SQUnsignedInteger i =0; i< _defaultvalues.size(); i++) {

			




	
	
	
		
 
		SQSharedState::EnqueueMarkObject(_defaultvalues[i].val, queue);

			




	
	
	
		
 
		SQSharedState::EnqueueMarkObject(_defaultvalues[i].attrs, queue);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	for(SQUnsignedInteger j =0; j< _methods.size(); j++) {

			




	
	
	
		
 
		SQSharedState::EnqueueMarkObject(_methods[j].val, queue);

			




	
	
	
		
 
		SQSharedState::EnqueueMarkObject(_methods[j].attrs, queue);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	for(SQUnsignedInteger k =0; k< _metamethods.size(); k++) {

			




	
	
	
		
 
		SQSharedState::EnqueueMarkObject(_metamethods[k], queue);

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQInstance::Mark(SQCollectable **chain)

			




	
	
	
		
 
void SQInstance::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	START_MARK()

			




	
	
	
		
 
		_class->Mark(chain);

			




	
	
	
		
 
		SQUnsignedInteger nvalues = _class->_defaultvalues.size();

			




	
	
	
		
 
		for(SQUnsignedInteger i =0; i< nvalues; i++) {

			




	
	
	
		
 
			SQSharedState::MarkObject(_values[i], chain);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	END_MARK()

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQGenerator::Mark(SQCollectable **chain)

			




	
	
	
		
 
{

			




	
	
	
		
 
	START_MARK()

			




	
	
	
		
 
		for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::MarkObject(_stack[i], chain);

			




	
	
	
		
 
		for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::MarkObject(_vargsstack[j], chain);

			




	
	
	
		
 
		SQSharedState::MarkObject(_closure, chain);

			




	
	
	
		
 
	END_MARK()

			




	
	
	
		
 
	queue.Enqueue(_class);

			




	
	
	
		
 
	SQUnsignedInteger nvalues = _class->_defaultvalues.size();

			




	
	
	
		
 
	for(SQUnsignedInteger i =0; i< nvalues; i++) {

			




	
	
	
		
 
		SQSharedState::EnqueueMarkObject(_values[i], queue);

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQClosure::Mark(SQCollectable **chain)

			




	
	
	
		
 
void SQGenerator::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	START_MARK()

			




	
	
	
		
 
		for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::MarkObject(_outervalues[i], chain);

			




	
	
	
		
 
		for(SQUnsignedInteger i = 0; i < _defaultparams.size(); i++) SQSharedState::MarkObject(_defaultparams[i], chain);

			




	
	
	
		
 
	END_MARK()

			




	
	
	
		
 
	for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::EnqueueMarkObject(_stack[i], queue);

			




	
	
	
		
 
	for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::EnqueueMarkObject(_vargsstack[j], queue);

			




	
	
	
		
 
	SQSharedState::EnqueueMarkObject(_closure, queue);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQNativeClosure::Mark(SQCollectable **chain)

			




	
	
	
		
 
void SQClosure::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	START_MARK()

			




	
	
	
		
 
		for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::MarkObject(_outervalues[i], chain);

			




	
	
	
		
 
	END_MARK()

			




	
	
	
		
 
	for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::EnqueueMarkObject(_outervalues[i], queue);

			




	
	
	
		
 
	for(SQUnsignedInteger i = 0; i < _defaultparams.size(); i++) SQSharedState::EnqueueMarkObject(_defaultparams[i], queue);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQUserData::Mark(SQCollectable **chain){

			




	
	
	
		
 
	START_MARK()

			




	
	
	
		
 
		if(_delegate) _delegate->Mark(chain);

			




	
	
	
		
 
	END_MARK()

			




	
	
	
		
 
void SQNativeClosure::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::EnqueueMarkObject(_outervalues[i], queue);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQUserData::EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue){

			




	
	
	
		
 
	if(_delegate) queue.Enqueue(_delegate);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQCollectable::UnMark() { _uiRef&=~MARK_FLAG; }

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    src/3rdparty/squirrel/squirrel/sqobject.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*	see copyright notice in squirrel.h */

			




	
	
	
		
 
#ifndef _SQOBJECT_H_

			




	
	
	
		
 
#define _SQOBJECT_H_

			




	
	
	
		
 

			




	
	
	
		
 
#include <forward_list>

			




	
	
	
		
 
#include "squtils.h"

			




	
	
	
		
 

			




	
	
	
		
 
#define SQ_CLOSURESTREAM_HEAD (('S'<<24)|('Q'<<16)|('I'<<8)|('R'))

			




	
	
	
		
 
#define SQ_CLOSURESTREAM_PART (('P'<<24)|('A'<<16)|('R'<<8)|('T'))

			




	
	
	
		
 
#define SQ_CLOSURESTREAM_TAIL (('T'<<24)|('A'<<16)|('I'<<8)|('L'))

			




	
	
	
		
 

			




	
	
		
 
@@ -341,19 +342,54 @@ inline void _Swap(SQObject &a,SQObject &

			




	
	
	
		
 
#define MARK_FLAG 0x80000000

			




	
	
	
		
 
struct SQCollectable : public SQRefCounted {

			




	
	
	
		
 
	SQCollectable *_next;

			




	
	
	
		
 
	SQCollectable *_prev;

			




	
	
	
		
 
	SQSharedState *_sharedstate;

			




	
	
	
		
 
	virtual void Release()=0;

			




	
	
	
		
 
	virtual void Mark(SQCollectable **chain)=0;

			




	
	
	
		
 
	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 container for state to change the garbage collection from a recursive to an iterative approach.

			




	
	
	
		
 
 * The iterative approach provides effectively a depth first search approach.

			




	
	
	
		
 
 */

			




	
	
	
		
 
class SQGCMarkerQueue {

			




	
	
	
		
 
	std::forward_list<SQCollectable*> queue; ///< The queue of elements to still process.

			




	
	
	
		
 
public:

			




	
	
	
		
 
	/** Whether there are any elements left to process. */

			




	
	
	
		
 
	bool IsEmpty() { return this->queue.empty(); }

			




	
	
	
		
 

			




	
	
	
		
 
	/**

			




	
	
	
		
 
	 * Remove the first element from the queue.

			




	
	
	
		
 
	 * Removal when the queue is empty results in undefined behaviour.

			




	
	
	
		
 
	 */

			




	
	
	
		
 
	SQCollectable *Pop()

			




	
	
	
		
 
	{

			




	
	
	
		
 
		SQCollectable *collectable = this->queue.front();

			




	
	
	
		
 
		this->queue.pop_front();

			




	
	
	
		
 
		return collectable;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	/**

			




	
	
	
		
 
	 * Add a collectable to the queue, but only when it has not been marked yet.

			




	
	
	
		
 
	 * When adding it to the queue, the collectable will be marked, so subsequent calls

			




	
	
	
		
 
	 * will not add it again.

			




	
	
	
		
 
	 */

			




	
	
	
		
 
	void Enqueue(SQCollectable *collectable)

			




	
	
	
		
 
	{

			




	
	
	
		
 
		if ((collectable->_uiRef & MARK_FLAG) == 0) {

			




	
	
	
		
 
			collectable->_uiRef |= MARK_FLAG;

			




	
	
	
		
 
			this->queue.push_front(collectable);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#define ADD_TO_CHAIN(chain,obj) AddToChain(chain,obj)

			




	
	
	
		
 
#define REMOVE_FROM_CHAIN(chain,obj) {if(!(_uiRef&MARK_FLAG))RemoveFromChain(chain,obj);}

			




	
	
	
		
 
#define CHAINABLE_OBJ SQCollectable

			




	
	
	
		
 
#define INIT_CHAIN() {_next=NULL;_prev=NULL;_sharedstate=ss;}

			




	
	
	
		
 
#else

			




        

    


    
    

    

        

                

                    src/3rdparty/squirrel/squirrel/sqstate.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -225,53 +225,62 @@ SQInteger SQSharedState::GetMetaMethodId

			




	
	
	
		
 
	}

			




	
	
	
		
 
	return -1;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 

			




	
	
	
		
 
void SQSharedState::MarkObject(SQObjectPtr &o,SQCollectable **chain)

			




	
	
	
		
 
void SQSharedState::EnqueueMarkObject(SQObjectPtr &o,SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	switch(type(o)){

			




	
	
	
		
 
	case OT_TABLE:_table(o)->Mark(chain);break;

			




	
	
	
		
 
	case OT_ARRAY:_array(o)->Mark(chain);break;

			




	
	
	
		
 
	case OT_USERDATA:_userdata(o)->Mark(chain);break;

			




	
	
	
		
 
	case OT_CLOSURE:_closure(o)->Mark(chain);break;

			




	
	
	
		
 
	case OT_NATIVECLOSURE:_nativeclosure(o)->Mark(chain);break;

			




	
	
	
		
 
	case OT_GENERATOR:_generator(o)->Mark(chain);break;

			




	
	
	
		
 
	case OT_THREAD:_thread(o)->Mark(chain);break;

			




	
	
	
		
 
	case OT_CLASS:_class(o)->Mark(chain);break;

			




	
	
	
		
 
	case OT_INSTANCE:_instance(o)->Mark(chain);break;

			




	
	
	
		
 
	case OT_TABLE:queue.Enqueue(_table(o));break;

			




	
	
	
		
 
	case OT_ARRAY:queue.Enqueue(_array(o));break;

			




	
	
	
		
 
	case OT_USERDATA:queue.Enqueue(_userdata(o));break;

			




	
	
	
		
 
	case OT_CLOSURE:queue.Enqueue(_closure(o));break;

			




	
	
	
		
 
	case OT_NATIVECLOSURE:queue.Enqueue(_nativeclosure(o));break;

			




	
	
	
		
 
	case OT_GENERATOR:queue.Enqueue(_generator(o));break;

			




	
	
	
		
 
	case OT_THREAD:queue.Enqueue(_thread(o));break;

			




	
	
	
		
 
	case OT_CLASS:queue.Enqueue(_class(o));break;

			




	
	
	
		
 
	case OT_INSTANCE:queue.Enqueue(_instance(o));break;

			




	
	
	
		
 
	default: break; //shutup compiler

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
SQInteger SQSharedState::CollectGarbage(SQVM *vm)

			




	
	
	
		
 
{

			




	
	
	
		
 
	SQInteger n=0;

			




	
	
	
		
 
	SQCollectable *tchain=NULL;

			




	
	
	
		
 
	SQVM *vms = _thread(_root_vm);

			




	
	
	
		
 

			




	
	
	
		
 
	vms->Mark(&tchain);

			




	
	
	
		
 
	SQGCMarkerQueue queue;

			




	
	
	
		
 
	queue.Enqueue(vms);

			




	
	
	
		
 
#ifdef WITH_ASSERT

			




	
	
	
		
 
	SQInteger x = _table(_thread(_root_vm)->_roottable)->CountUsed();

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	_refs_table.Mark(&tchain);

			




	
	
	
		
 
	MarkObject(_registry,&tchain);

			




	
	
	
		
 
	MarkObject(_consts,&tchain);

			




	
	
	
		
 
	MarkObject(_metamethodsmap,&tchain);

			




	
	
	
		
 
	MarkObject(_table_default_delegate,&tchain);

			




	
	
	
		
 
	MarkObject(_array_default_delegate,&tchain);

			




	
	
	
		
 
	MarkObject(_string_default_delegate,&tchain);

			




	
	
	
		
 
	MarkObject(_number_default_delegate,&tchain);

			




	
	
	
		
 
	MarkObject(_generator_default_delegate,&tchain);

			




	
	
	
		
 
	MarkObject(_thread_default_delegate,&tchain);

			




	
	
	
		
 
	MarkObject(_closure_default_delegate,&tchain);

			




	
	
	
		
 
	MarkObject(_class_default_delegate,&tchain);

			




	
	
	
		
 
	MarkObject(_instance_default_delegate,&tchain);

			




	
	
	
		
 
	MarkObject(_weakref_default_delegate,&tchain);

			




	
	
	
		
 
	_refs_table.EnqueueMarkObject(queue);

			




	
	
	
		
 
	EnqueueMarkObject(_registry,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_consts,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_metamethodsmap,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_table_default_delegate,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_array_default_delegate,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_string_default_delegate,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_number_default_delegate,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_generator_default_delegate,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_thread_default_delegate,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_closure_default_delegate,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_class_default_delegate,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_instance_default_delegate,queue);

			




	
	
	
		
 
	EnqueueMarkObject(_weakref_default_delegate,queue);

			




	
	
	
		
 

			




	
	
	
		
 
	SQCollectable *tchain=NULL;

			




	
	
	
		
 

			




	
	
	
		
 
	while (!queue.IsEmpty()) {

			




	
	
	
		
 
		SQCollectable *q = queue.Pop();

			




	
	
	
		
 
		q->EnqueueMarkObjectForChildren(queue);

			




	
	
	
		
 
		SQCollectable::RemoveFromChain(&_gc_chain, q);

			




	
	
	
		
 
		SQCollectable::AddToChain(&tchain, q);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	SQCollectable *t = _gc_chain;

			




	
	
	
		
 
	SQCollectable *nx = NULL;

			




	
	
	
		
 
	if(t) {

			




	
	
	
		
 
		t->_uiRef++;

			




	
	
	
		
 
		while(t) {

			




	
	
		
 
@@ -354,18 +363,18 @@ void RefTable::Finalize()

			




	
	
	
		
 
RefTable::~RefTable()

			




	
	
	
		
 
{

			




	
	
	
		
 
	SQ_FREE(_buckets,(_numofslots * sizeof(RefNode *)) + (_numofslots * sizeof(RefNode)));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 
void RefTable::Mark(SQCollectable **chain)

			




	
	
	
		
 
void RefTable::EnqueueMarkObject(SQGCMarkerQueue &queue)

			




	
	
	
		
 
{

			




	
	
	
		
 
	RefNode *nodes = (RefNode *)_nodes;

			




	
	
	
		
 
	for(SQUnsignedInteger n = 0; n < _numofslots; n++) {

			




	
	
	
		
 
		if(type(nodes->obj) != OT_NULL) {

			




	
	
	
		
 
			SQSharedState::MarkObject(nodes->obj,chain);

			




	
	
	
		
 
			SQSharedState::EnqueueMarkObject(nodes->obj,queue);

			




	
	
	
		
 
		}

			




	
	
	
		
 
		nodes++;

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    src/3rdparty/squirrel/squirrel/sqstate.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -31,13 +31,13 @@ struct RefTable {

			




	
	
	
		
 
	};

			




	
	
	
		
 
	RefTable();

			




	
	
	
		
 
	~RefTable();

			




	
	
	
		
 
	void AddRef(SQObject &obj);

			




	
	
	
		
 
	SQBool Release(SQObject &obj);

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 
	void Mark(SQCollectable **chain);

			




	
	
	
		
 
	void EnqueueMarkObject(SQGCMarkerQueue &queue);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	void Finalize();

			




	
	
	
		
 
private:

			




	
	
	
		
 
	RefNode *Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add);

			




	
	
	
		
 
	RefNode *Add(SQHash mainpos,SQObject &obj);

			




	
	
	
		
 
	void Resize(SQUnsignedInteger size);

			




	
	
		
 
@@ -60,13 +60,13 @@ struct SQSharedState

			




	
	
	
		
 
	~SQSharedState();

			




	
	
	
		
 
public:

			




	
	
	
		
 
	SQChar* GetScratchPad(SQInteger size);

			




	
	
	
		
 
	SQInteger GetMetaMethodIdxByName(const SQObjectPtr &name);

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 
	SQInteger CollectGarbage(SQVM *vm);

			




	
	
	
		
 
	static void MarkObject(SQObjectPtr &o,SQCollectable **chain);

			




	
	
	
		
 
	static void EnqueueMarkObject(SQObjectPtr &o,SQGCMarkerQueue &queue);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	SQObjectPtrVec *_metamethods;

			




	
	
	
		
 
	SQObjectPtr _metamethodsmap;

			




	
	
	
		
 
	SQObjectPtrVec *_systemstrings;

			




	
	
	
		
 
	SQObjectPtrVec *_types;

			




	
	
	
		
 
	SQStringTable *_stringtable;

			




        

    


    
    

    

        

                

                    src/3rdparty/squirrel/squirrel/sqtable.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -57,13 +57,13 @@ public:

			




	
	
	
		
 
		SetDelegate(NULL);

			




	
	
	
		
 
		REMOVE_FROM_CHAIN(&_sharedstate->_gc_chain, this);

			




	
	
	
		
 
		for (SQInteger i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode();

			




	
	
	
		
 
		SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode));

			




	
	
	
		
 
	}

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 
	void Mark(SQCollectable **chain);

			




	
	
	
		
 
	void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash)

			




	
	
	
		
 
	{

			




	
	
	
		
 
		_HashNode *n = &_nodes[hash];

			




	
	
	
		
 
		do{

			




	
	
	
		
 
			if(_rawval(n->key) == _rawval(key) && type(n->key) == type(key)){

			




        

    


    
    

    

        

                

                    src/3rdparty/squirrel/squirrel/squserdata.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -15,13 +15,13 @@ struct SQUserData : SQDelegable

			




	
	
	
		
 
	{

			




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

			




	
	
	
		
 
		new (ud) SQUserData(ss, size);

			




	
	
	
		
 
		return ud;

			




	
	
	
		
 
	}

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 
	void Mark(SQCollectable **chain);

			




	
	
	
		
 
	void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);

			




	
	
	
		
 
	void Finalize(){SetDelegate(NULL);}

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	void Release() {

			




	
	
	
		
 
		if (_hook) _hook(_val,_size);

			




	
	
	
		
 
		SQInteger tsize = _size - 1;

			




	
	
	
		
 
		this->~SQUserData();

			




        

    


    
    

    

        

                

                    src/3rdparty/squirrel/squirrel/sqvm.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -110,13 +110,13 @@ public:

			




	
	
	
		
 
	void ClearStack(SQInteger last_top);

			




	
	
	
		
 
#ifdef _DEBUG_DUMP

			




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

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef NO_GARBAGE_COLLECTOR

			




	
	
	
		
 
	void Mark(SQCollectable **chain);

			




	
	
	
		
 
	void EnqueueMarkObjectForChildren(SQGCMarkerQueue &queue);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	void Finalize();

			




	
	
	
		
 
	void GrowCallStack() {

			




	
	
	
		
 
		SQInteger newsize = _alloccallsstacksize*2;

			




	
	
	
		
 
		_callstackdata.resize(newsize);

			




	
	
	
		
 
		_callsstack = &_callstackdata[0];

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: code.theleruby.com-48
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2022 by various authors & licensed under GPLv3.
            – Support