自学教程：C++ stack_get函数代码示例

static SQInteger thread_wakeup(HSQUIRRELVM v){	SQObjectPtr o = stack_get(v,1);	if(type(o) == OT_THREAD) {		SQVM *thread = _thread(o);		SQInteger state = sq_getvmstate(thread);		if(state != SQ_VMSTATE_SUSPENDED) {			switch(state) {			case SQ_VMSTATE_IDLE:				return sq_throwerror(v,_SC("cannot wakeup a idle thread"));				break;			case SQ_VMSTATE_RUNNING:				return sq_throwerror(v,_SC("cannot wakeup a running thread"));				break;			}		}		SQInteger wakeupret = sq_gettop(v)>1?1:0;		if(wakeupret) {			sq_move(thread,v,2);		}		if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,SQTrue,SQTrue,SQFalse))) {			sq_move(v,thread,-1);			sq_pop(thread,1); //pop retval			if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) {				sq_settop(thread,1); //pop roottable			}			return 1;		}		sq_settop(thread,1);		v->_lasterror = thread->_lasterror;		return SQ_ERROR;	}	return sq_throwerror(v,_SC("wrong parameter"));}

static SQInteger array_apply(HSQUIRRELVM v){	SQObject &o = stack_get(v,1);	if(SQ_FAILED(__map_array(_array(o),_array(o),v)))		return SQ_ERROR;	return 0;}

static SQInteger array_reduce(HSQUIRRELVM v){	SQObject &o = stack_get(v,1);	SQArray *a = _array(o);	SQInteger size = a->Size();	if(size == 0) {		return 0;	}	SQObjectPtr res;	a->Get(0,res);	if(size > 1) {		SQObjectPtr other;		for(SQInteger n = 1; n < size; n++) {			a->Get(n,other);			v->Push(o);			v->Push(res);			v->Push(other);			if(SQ_FAILED(sq_call(v,3,SQTrue,SQFalse))) {				return SQ_ERROR;			}			res = v->GetUp(-1);			v->Pop();		}	}	v->Push(res);	return 1;}

static SQInteger number_delegate_tochar(HSQUIRRELVM v){	SQObject &o=stack_get(v,1);	SQChar c = (SQChar)tointeger(o);	v->Push(SQString::Create(_ss(v),(const SQChar *)&c,1));	return 1;}

static SQInteger thread_getstackinfos(HSQUIRRELVM v){	SQObjectPtr o = stack_get(v,1);	if(type(o) == OT_THREAD) {		SQVM *thread = _thread(o);		SQInteger threadtop = sq_gettop(thread);		SQInteger level;		sq_getinteger(v,-1,&level);		SQRESULT res = __getcallstackinfos(thread,level);		if(SQ_FAILED(res))		{			sq_settop(thread,threadtop);			if(type(thread->_lasterror) == OT_STRING) {				sq_throwerror(v,_stringval(thread->_lasterror));			}			else {				sq_throwerror(v,_SC("unknown error"));			}		}		if(res > 0) {			//some result			sq_move(v,thread,-1);			sq_settop(thread,threadtop);			return 1;		}		//no result		sq_settop(thread,threadtop);		return 0;	}	return sq_throwerror(v,_SC("wrong parameter"));}

static SQInteger base_enabledebuginfo(HSQUIRRELVM v){	SQObjectPtr &o=stack_get(v,2);	sq_enabledebuginfo(v,SQVM::IsFalse(o)?SQFalse:SQTrue);	return 0;}

static SQInteger base_assert(HSQUIRRELVM v){    if(v->IsFalse(stack_get(v,2))) {        return sq_throwerror(v,_SC("assertion failed"));    }    return 0;}

/*************************************************************************** * int replace * * fill in the template given by source using the stack and return it into * dest * *************************************************************************/int replace(const char *source, struct strstack *stack, pstring dest, MYSQL *mysql){	char *uname = current_user_info.smb_name;	const char *remote;	enum { COPY, PARAM } state = COPY;	char buffer[6];	int i, cur_parm, bindex = 0;	fstring replaced;	char replaced2[512];	for (i=0; i < strlen(source); i++) {		switch (state) {			case COPY:				if ( source[i] != '$' )					*dest++ = source[i];				else state = PARAM;				break;			case PARAM:				if ( source[i] > '9' || source[i] < '0' ) {					buffer[bindex] = '/0';					if ( buffer[0] == '/0' ) {						switch (source[i]) {							case 'U':		/* user name */								pstrcpy(dest, uname);								dest += strlen(uname);								break;							case 'I':		/* remote host ip address */								pstrcpy(dest, client_name());								dest += strlen(client_name());								break;							case 'N':		/* host name */								remote = get_remote_machine_name();								pstrcpy(dest, remote);								dest += strlen(remote);								break;							default:								*dest++ = source[i];								break;						}					} else {						cur_parm = atoi(buffer);						stack_get(stack, cur_parm, replaced);						mysql_real_escape_string(mysql, replaced2, replaced,								strlen(replaced));						pstrcpy(dest, replaced2);						dest += strlen(replaced2);						*dest++ = source[i];					}					bindex = 0;					state = COPY;				} else					buffer[bindex++] = source[i];				break;		}	}	*dest = '/0';	return 1;}

int main() {  int elt; // element to be pushed and poped  char c;  // 'switch(c)' of the main loop    // display management  const char *prompt = "> ";  int prompt_count = 1;    print_usage();  printf("%i%s", prompt_count++, prompt);      /*---------------------------  Main loop of the test program  ---------------------------*/  while ( (c = getchar()) != 'Q')  {    switch(c)    {      case 'p':  // put        if (scanf("%i", &elt) != 1) goto error_scanf;             stack_put(elt);        printf("%i/n", elt);        break;              case 'g':  // get        elt = stack_get();        printf("%i/n", elt);        break;      case 'r': // retrieve, cannot use p for peek :-(        elt = stack_peek();          printf("%i/n", elt);        break;                      default:        print_usage();        break;    }    while (getchar() != '/n') {} /* skip end of line */    printf("%i%s", prompt_count++, prompt);    continue;  // all is ok, go to the beginning of the main loop    /*----- ERROR TREATMENT -----*/ error_scanf:    while (getchar() != '/n') {} /* skip end of line */    printf("ERROR: wrong scanf argument/n");    printf("%i%s", prompt_count++, prompt);    continue;/*----- END ERROR TREATMENT -----*/       }  /*--------------------------------------  End of the main loop of the test program  --------------------------------------*/  printf("Quit/n");  return 0;}

_MEMBER_FUNCTION_IMPL(timer, constructor){	// Check the param count	CHECK_PARAMS_MIN("timer", 3);	//	if( sq_gettype( pVM, 2 ) != OT_NATIVECLOSURE )		CHECK_TYPE("timer", 1, 2, OT_CLOSURE);	// Check the params	CHECK_TYPE("timer", 2, 3, OT_INTEGER);	CHECK_TYPE("timer", 3, 4, OT_INTEGER);	SQInteger iInterval = 0;	SQInteger iRepeations = 0;	// Get the params	sq_getinteger( pVM, 3, &iInterval );	sq_getinteger( pVM, 4, &iRepeations );	// Invalid repeations?	if( iRepeations < -1 || iRepeations == 0 )	{		sq_pushbool( pVM, false );		return 1;	}	// Get the timer end function	SQObjectPtr pFunction = stack_get( pVM, 2 );	// Create the arguments	CSquirrelArguments * pArguments = new CSquirrelArguments( pVM, 5 );	// Get the current script instance#ifdef _CLIENT	CSquirrel * pScript = pCore->GetClientScriptingManager()->GetScriptingManager()->Get( pVM );#else	CSquirrel * pScript = pCore->GetScriptingManager()->Get( pVM );#endif	// Create the timer instance	CTimer * pTimer = new CTimer( pScript, pFunction, iInterval, iRepeations, pArguments );	// Did it fail to set the timer instance?	if( SQ_FAILED( sq_setinstance( pVM, pTimer) ) )	{		// Delete the timer		SAFE_DELETE( pTimer );		sq_pushbool( pVM, false );		return 1;	}	// Add the timer into the manager	pCore->GetTimerManager()->push_back( pTimer );	sq_pushbool( pVM, true );	return 1;}

static SQInteger array_find(HSQUIRRELVM v){	SQObject &o = stack_get(v,1);	SQObjectPtr &val = stack_get(v,2);	SQArray *a = _array(o);	SQInteger size = a->Size();	SQObjectPtr temp;	for(SQInteger n = 0; n < size; n++) {		bool res = false;		a->Get(n,temp);		if(v->IsEqual(temp,val,res) && res) {			v->Push(n);			return 1;		}	}	return 0;}

static SQInteger base_newthread(HSQUIRRELVM v){	SQObjectPtr &func = stack_get(v,2);	SQInteger stksize = (_funcproto(_closure(func)->_function)->_stacksize << 1) +2;	HSQUIRRELVM newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);	sq_move(newv,v,-2);	return 1;}

void sq_setdebughook(HSQUIRRELVM v){	SQObject o = stack_get(v,-1);	if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) {		v->_debughook = o;		v->Pop();	}}

void sq_seterrorhandler(HSQUIRRELVM v){	SQObject o = stack_get(v, -1);	if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) {		v->_errorhandler = o;		v->Pop();	}}

static SQInteger array_top(HSQUIRRELVM v){	SQObject &o=stack_get(v,1);	if(_array(o)->Size()>0){		v->Push(_array(o)->Top());		return 1;	}	else return sq_throwerror(v,_SC("top() on a empty array"));}

void stk_test_empty(void) {	stack_t* s = stack_init(stk_compare, stk_print, stk_clone, stk_destroy);	stack_print(s, stderr);	CU_ASSERT (stack_get(s) == NULL);	CU_ASSERT (stack_pop(s) == NULL);	CU_ASSERT (stack_destroy(s) == 0);}

static SQInteger array_map(HSQUIRRELVM v){	SQObject &o = stack_get(v,1);	SQInteger size = _array(o)->Size();	SQObjectPtr ret = SQArray::Create(_ss(v),size);	if(SQ_FAILED(__map_array(_array(ret),_array(o),v)))		return SQ_ERROR;	v->Push(ret);	return 1;}

bool sq_aux_gettypedarg(HSQUIRRELVM v,SQInteger idx,SQObjectType type,SQObjectPtr **o){	*o = &stack_get(v,idx);	if(type(**o) != type){		SQObjectPtr oval = v->PrintObjVal(**o);		v->Raise_Error(_SC("wrong argument type, expected '%s' got '%.50s'"),IdType2Name(type),_stringval(oval));		return false;	}	return true;}

// removeEvent(eventname, function)SQInteger CEventNatives::Remove(SQVM * pVM){	const char * szEventName;	SQObjectPtr pFunction;	sq_getstring(pVM, -2, &szEventName);	pFunction = stack_get(pVM, -1);	sq_pushbool(pVM, CEvents::GetInstance()->Remove(szEventName, &CSquirrelEventHandler(pVM, pFunction)));	return 1;}

//GENERATOR DEFAULT DELEGATEstatic SQInteger generator_getstatus(HSQUIRRELVM v){	SQObject &o=stack_get(v,1);	switch(_generator(o)->_state){		case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break;		case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break;		case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break;	}	return 1;}

static SQInteger base_array(HSQUIRRELVM v){	SQArray *a;	SQInteger nInitialSize = tointeger(stack_get(v,2));	SQInteger ret = 1;	if (nInitialSize < 0) {		v->Raise_Error(_SC("can't create/resize array with/to size %d"), nInitialSize);		nInitialSize = 0;		ret = -1;	}	if(sq_gettop(v) > 2) {		a = SQArray::Create(_ss(v),0);		a->Resize(nInitialSize,stack_get(v,3));	}	else {		a = SQArray::Create(_ss(v),nInitialSize);	}	v->Push(a);	return ret;}

void CSquirrelVM::Pop(stScriptFunction& function){	function.ref = -1;	function.function = 0;	function.function = stack_get(m_pVM, m_iStackIndex++);	if (function.function._type != OT_CLOSURE)		function.function = 0;	function.type = eFType::SQUIRREL_FUNCTION;}

SQInteger CEventNatives::AddEventHandler ( SQVM *pVM ){	const char * szEventName;	SQObjectPtr pEventHandler;	sq_getstring ( pVM, 2, &szEventName );	pEventHandler = stack_get(pVM, 3);	bool bReturn = g_pServer->GetResourceManager()->RegisterEvent( CString(szEventName), pEventHandler, pVM );	sq_pushbool(pVM, bReturn);	return 1;}

static SQInteger array_sort(HSQUIRRELVM v){	SQInteger func = -1;	SQObjectPtr &o = stack_get(v,1);	if(_array(o)->Size() > 1) {		if(sq_gettop(v) == 2) func = 2;		if(!_hsort(v, o, 0, _array(o)->Size()-1, func))			return SQ_ERROR;	}	return 0;}

static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o){	SQInteger top = sq_gettop(v);	sidx=0;	eidx=0;	o=stack_get(v,1);	SQObjectPtr &start=stack_get(v,2);	if(type(start)!=OT_NULL && sq_isnumeric(start)){		sidx=tointeger(start);	}	if(top>2){		SQObjectPtr &end=stack_get(v,3);		if(sq_isnumeric(end)){			eidx=tointeger(end);		}	}	else {		eidx = sq_getsize(v,1);	}	return 1;}

void stk_test_get(void) {	stack_t* s = stack_init(stk_compare, stk_print, stk_clone, stk_destroy);		CU_ASSERT (stack_push(s, stk_test_s1) != NULL);;	CU_ASSERT (stack_push(s, stk_test_s2) != NULL);;	CU_ASSERT (stack_push(s, stk_test_s3) != NULL);;	CU_ASSERT (stack_push(s, stk_test_s4) != NULL);;	char* str = stack_get(s);	CU_ASSERT(str == stk_test_s4);	CU_ASSERT (strcmp(str, stk_test_s4) == 0);	str = stack_pop(s);	CU_ASSERT(str != stk_test_s4);	CU_ASSERT (strcmp(str, stk_test_s4) == 0);	free(str);	str = stack_get(s);	CU_ASSERT(str == stk_test_s3);	CU_ASSERT (strcmp(str, stk_test_s3) == 0);	CU_ASSERT (stack_destroy(s) == 0);}

SQRESULT sq_newclass(HSQUIRRELVM v,SQBool hasbase){	SQClass *baseclass = NULL;	if(hasbase) {		SQObjectPtr &base = stack_get(v,-1);		if(type(base) != OT_CLASS)			return sq_throwerror(v,_SC("invalid base type"));		baseclass = _class(base);	}	SQClass *newclass = SQClass::Create(_ss(v), baseclass);	if(baseclass) v->Pop();	v->Push(newclass);		return SQ_OK;}

SQRESULT sq_newclass(HSQUIRRELVM v,SQBool hasbase, const SQChar* name){	SQClass *baseclass = NULL;	if(hasbase) {		SQObjectPtr &base = stack_get(v,-1);		if(sqi_type(base) != OT_CLASS)			return sq_throwerror(v,_SC("invalid base type"));		baseclass = sqi_class(base);	}	SQClass *newclass = SQClass::Create(_ss(v), baseclass);	if (name) newclass->_methods[0].val = SQString::Create(_ss(v), name, -1);	if(baseclass) v->Pop();	v->Push(newclass);		return SQ_OK;}

void signal2_emit(signal2_t *obj, size_t x, size_t y){	uint32_t n_of_slot2s;	slot2_t *slot2_to_be_called = NULL;	PTR_CHECK(obj, "signal2");	n_of_slot2s = stack_size(obj->slot2s_stack);	while(n_of_slot2s--)	{		stack_get(obj->slot2s_stack, (BUFFER_PTR)&slot2_to_be_called, n_of_slot2s);		slot2_call(slot2_to_be_called, x, y);	}}

static SQInteger thread_call(HSQUIRRELVM v){	SQObjectPtr o = stack_get(v,1);	if(type(o) == OT_THREAD) {		SQInteger nparams = sq_gettop(v);		_thread(o)->Push(_thread(o)->_roottable);		for(SQInteger i = 2; i<(nparams+1); i++)			sq_move(_thread(o),v,i);		if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQFalse))) {			sq_move(v,_thread(o),-1);			return 1;		}		return SQ_ERROR;	}	return sq_throwerror(v,_SC("wrong parameter"));}