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 DELEGATE static 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")); }