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