示例#1
0
SquirrelObject SquirrelObject::GetValue(const SQChar *key)/*const*/
{
	SquirrelObject ret;
	if(GetSlot(key)) {
		ret.AttachToStackObject(-1);
		sq_pop(m_Vm.GetVMPtr(),1);
	}
	sq_pop(m_Vm.GetVMPtr(),1);
	return ret;
}
示例#2
0
float SquirrelObject::GetFloat(const SQChar *key) /*const*/
{
	float ret = 0.0f;
	if(GetSlot(key)) {
		sq_getfloat(m_Vm.GetVMPtr(),-1,&ret);
		sq_pop(m_Vm.GetVMPtr(),1);
	}
	sq_pop(m_Vm.GetVMPtr(),1);
	return ret;
}
示例#3
0
const SQChar *SquirrelObject::GetString(int key) /*const*/
{
	const SQChar *ret = NULL;
	if(GetSlot(key)) {
		sq_getstring(m_Vm.GetVMPtr(),-1,&ret);
		sq_pop(m_Vm.GetVMPtr(),1);
	}
	sq_pop(m_Vm.GetVMPtr(),1);
	return ret;
}
示例#4
0
bool SquirrelObject::GetBool(int key) /*const*/
{
	SQBool ret = FALSE;
	if(GetSlot(key)) {
		sq_getbool(m_Vm.GetVMPtr(),-1,&ret);
		sq_pop(m_Vm.GetVMPtr(),1);
	}
	sq_pop(m_Vm.GetVMPtr(),1);
	return ret?true:false;
}
示例#5
0
int SquirrelObject::GetInt(int key) /*const*/
{
	int ret = 0;
	if(GetSlot(key)) {
		sq_getinteger(m_Vm.GetVMPtr(),-1,&ret);
		sq_pop(m_Vm.GetVMPtr(),1);
	}
	sq_pop(m_Vm.GetVMPtr(),1);
	return ret;
}
示例#6
0
SQInteger Sq_Interpolate(HSQUIRRELVM v) {
  const SQChar *Str, *WordString;
  char Out[4096];
  sq_getstring(v, 2, &Str);
  sq_getstring(v, 3, &WordString);
  char *Poke = Out;
  const char *Peek = Str;

  char WordBuff[strlen(Str)+1];
  const char *Word[32];
  const char *WordEol[32];
  XChatTokenize(WordString, WordBuff, Word, WordEol, 32, TOKENIZE_MULTI_WORD);

  while(*Peek) {
    int Span = strcspn(Peek, "%&");
    memcpy(Poke, Peek, Span);
    Poke += Span;
    Peek += Span;
    if(*Peek == '%' || *Peek == '&') {
      char Extra = Peek[1];
      if(Extra == '%')
        *(Poke++) = '%';
      else if(Extra == '&')
        *(Poke++) = '&';
      else {
        if(isdigit(Extra)) {
          int WhichWord = Extra - '1';
          strcpy(Poke, (*Peek=='%')?Word[WhichWord]:WordEol[WhichWord]);
          Poke = strrchr(Poke, 0);
        } else { // look in the list of extra words
          int top = sq_gettop(v);;
          sq_pushnull(v); //null iterator
          while(SQ_SUCCEEDED(sq_next(v,-2))) {
             const SQChar *ThisWord;
             sq_getstring(v, -1, &ThisWord);
             if(ThisWord[0]==Extra) {
               strcpy(Poke, ThisWord+1);
               Poke = strrchr(Poke, 0);
               break;
             }
             sq_pop(v,2);
          }
          sq_pop(v,1); //pops the null iterator
          sq_settop(v, top);
        }
      }
      Peek+= 2;
    }
  }
  *Poke = 0;

  sq_pushstring(v, Out, -1);  
  return 1;
}
bool SQDbgServer::Init()
{
	//creates  an environment table for the debugger
	
	sq_newtable(_v);
	sq_getstackobj(_v,-1,&_debugroot);
	sq_addref(_v,&_debugroot);

	//creates a emptyslot to store the watches
	sq_pushstring(_v,_SC("watches"),-1);
	sq_pushnull(_v);
	sq_createslot(_v,-3);

	sq_pushstring(_v,_SC("beginelement"),-1);
	sq_pushuserpointer(_v,this);
	sq_newclosure(_v,beginelement,1);
	sq_setparamscheck(_v,2,_SC(".s"));
	sq_createslot(_v,-3);

	sq_pushstring(_v,_SC("endelement"),-1);
	sq_pushuserpointer(_v,this);
	sq_newclosure(_v,endelement,1);
	sq_setparamscheck(_v,2,_SC(".s"));
	sq_createslot(_v,-3);

	sq_pushstring(_v,_SC("attribute"),-1);
	sq_pushuserpointer(_v,this);
	sq_newclosure(_v,attribute,1);
	sq_setparamscheck(_v,3,_SC(".ss"));
	sq_createslot(_v,-3);

	sq_pop(_v,1);

	//stores debug hook and error handler in the registry
	sq_pushregistrytable(_v);

	sq_pushstring(_v,SQDBG_DEBUG_HOOK,-1);
	sq_pushuserpointer(_v,this);
	sq_newclosure(_v,debug_hook,1);
	sq_createslot(_v,-3);
	
	sq_pushstring(_v,SQDBG_ERROR_HANDLER,-1);
	sq_pushuserpointer(_v,this);
	sq_newclosure(_v,error_handler,1);
	sq_createslot(_v,-3);

	
	sq_pop(_v,1);

	//sets the error handlers
	SetErrorHandlers();
	return true;
}
示例#8
0
/**
 * TJSオブジェクトのオーバライド処理
 * 引数1 オブジェクト
 * 引数2 名前
 * 引数3 値。省略時は squirrel インスタンスから名前で参照
 */
SQRESULT
TJSObject::tjsOverride(HSQUIRRELVM v)
{
    SQRESULT result;
    tTJSVariant instance;
    if (getVariant(v,1,&instance) && instance.Type() == tvtObject) {
        tTJSVariant value;
        const SQChar *methodName = sqobject::getString(v,2);
        int n = sq_gettop(v);
        if (n >= 3) {
            // 引数で明示指定されている
            if (SQ_FAILED(result = sq_getvariant(v, 3, &value))) {
                return result;
            }
        } else {
            // 自己オブジェクトから名前で検索して登録
            sq_push(v, 1);
            sq_pushstring(v, methodName, -1);
            if (SQ_FAILED(result = sq_get(v, -2))) {
                sq_pop(v, 1); //self
                return result;
            } else {
                SQObjectType type = sq_gettype(v, -1);
                if (type == OT_CLOSURE || type == OT_NATIVECLOSURE) {
                    // クロージャの場合は bindenv しておく
                    sq_push(v, 1);
                    if (SQ_FAILED(result = sq_bindenv(v, -2))) {
                        sq_pop(v, 2); // func, self
                        return result;
                    } else {
                        sq_remove(v, -2); // original func
                    }
                }
                if (SQ_FAILED(result = sq_getvariant(v, -1, &value))) { // value
                    sq_pop(v, 1); //self
                    return result;
                }
                sq_pop(v, 1); // self
            }
        }
        tjs_error error;
        if (TJS_SUCCEEDED(error = instance.AsObjectClosureNoAddRef().PropSet(TJS_MEMBERENSURE, methodName, NULL, &value, NULL))) {
            return SQ_OK;
        } else {
            return  ERROR_KRKR(v, error);
        }
    }
    return ERROR_BADINSTANCE(v);
}
void EventListener::ProcessEvent(Rocket::Core::Event& event)
{
    HSQUIRRELVM vm = Module::instance().getScriptInterface().getSquirrelVM();

    if (!mScript.IsCompiled())
    {

    }

    mScript.Compile(vm, false);

    GlobalUtility gutil(vm, m_pElement->GetOwnerDocument(), m_pElement, &event);

    SQInteger i = sq_gettop(vm);

    SQRESULT sqr;

    gutil.Set();

    Module::instance().getScriptInterface().PushDocumentTable(vm, m_pElement->GetOwnerDocument());
    sqr = sq_bindenv(vm, i);

    ROCKETSQUIRREL_ASSERT(SQ_SUCCEEDED(sqr));

    sq_pushroottable(vm);
    mScript.Run(vm);
    gutil.Restore();

    sq_pop(vm, i);

    return;
}
示例#10
0
/*
 * get instance member value as float
 */
bool getInstanceMemberAsFloat(HSQUIRRELVM v, int idx, const char *name, SQFloat* value) {
	if (sq_gettype(v, idx) == OT_NULL) return false;
	sq_pushstring(v, name, -1);
	if (!SQ_SUCCEEDED(sq_get(v, idx))) {
		sq_pop(v, 1);
		return false;
	}
	if (sq_gettype(v, -1) == OT_NULL) {
		sq_pop(v, 1);
		return false;
	}
	sq_getfloat(v, -1, value);
	sq_pop(v, 1);
	
	return true;
}
示例#11
0
BOOL SbuCreateClass(HSQUIRRELVM v,SquirrelClassDecl *cd)
{
	int n = 0;
	int oldtop = sq_gettop(v);
	sq_pushroottable(v);
	sq_pushstring(v,cd->name,-1);
	if(cd->base) {
		sq_pushstring(v,cd->base,-1);
		if(SQ_FAILED(sq_get(v,-3))) {
			sq_settop(v,oldtop);
			return FALSE;
		}
	}
	if(SQ_FAILED(sq_newclass(v,cd->base?1:0))) {
		sq_settop(v,oldtop);
		return FALSE;
	}
	sq_settypetag(v,-1,(SQUserPointer)cd);
	const ScriptClassMemberDecl *members = cd->members;
	const ScriptClassMemberDecl *m = NULL;
	while(members[n].name) {
		m = &members[n];
		sq_pushstring(v,m->name,-1);
		sq_newclosure(v,m->func,0);
		sq_setparamscheck(v,m->params,m->typemask);
		sq_setnativeclosurename(v,-1,m->name);
		sq_createslot(v,-3);
		n++;
	}
	sq_createslot(v,-3);
	sq_pop(v,1);
	return TRUE;
}
void BindInput()
{
	Sqrat::Class<CInput, Sqrat::NoConstructor> def;

	def.Func("KeyUp", &CInput::KeyUp);
	def.Func("KeyPressed", &CInput::KeyPressed);
	def.Func("KeyHeld", &CInput::KeyHeld);
	def.Func("KeyReleased", &CInput::KeyReleased);
		
	Sqrat::RootTable().Bind("InputSystem", def);
	
	//Sqrat::ConstTable().Const("KEY_LEFT", KEY_LEFT);
	MAKE_KEY( KEY_LEFT );
	MAKE_KEY( KEY_RIGHT );
	MAKE_KEY( KEY_UP );
	MAKE_KEY( KEY_DOWN );
	MAKE_KEY( KEY_Q );
	MAKE_KEY( KEY_W );
	MAKE_KEY( KEY_PAGEUP );
	MAKE_KEY( KEY_PAGEDOWN );
	MAKE_KEY( KEY_HOME );

	// Push the singleton to squirrel
	sq_pushroottable( Sqrat::DefaultVM::Get() );
	sq_pushstring( Sqrat::DefaultVM::Get(), "InputSystem", -1 );
	sq_get(  Sqrat::DefaultVM::Get(), -2 );
	sq_pushstring(  Sqrat::DefaultVM::Get(), "Input", -1 );
	sq_createinstance(  Sqrat::DefaultVM::Get(), -2 );
	sq_setinstanceup(  Sqrat::DefaultVM::Get(), -1, (SQUserPointer)Input() );
	sq_newslot(  Sqrat::DefaultVM::Get(), -4, SQFalse );
	sq_pop(  Sqrat::DefaultVM::Get(), 2 );
}
int SquirrelScriptContext::SquirrelClassToStringMethodCallback(HSQUIRRELVM vm)
{
	// Get class info
	MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER );
	void* userPtr = NULL;
	sq_getuserpointer(vm, -1, &userPtr);
	sq_pop(vm, 1);

	SquirrelClassInfo* classInfo = (SquirrelClassInfo*) userPtr;

	// Get the instance
	MultiScriptAssert( sq_gettype(vm, 1) == OT_INSTANCE );
	sq_getinstanceup(vm, 1, &userPtr, 0);
	SquirrelScriptObject* scriptObject = (SquirrelScriptObject*) userPtr;
	MultiScriptAssert(scriptObject->m_objectPtr);

	// Invoke to-string method
	char buffer[1 << 8];
	if (classInfo->m_desc->m_toStringMethod)
	{
		SquirrelScriptStack stack(classInfo->m_context, false);
		const bool result = classInfo->m_desc->m_toStringMethod(scriptObject, buffer, 1 << 8);
		MultiScriptAssert( result );
		MultiScriptAssert( stack.m_numPushed == 0 );
	}
	else
		MultiScriptSprintf(buffer, 1 << 8, "[%s]", classInfo->m_desc->m_name);

	sq_pushstring(vm, buffer, -1);
	return 1;
}
示例#14
0
文件: sqglm.cpp 项目: jiro-t/sqglm
HSQOBJECT class_init(HSQUIRRELVM v,SQFUNCTION c,const SQChar * p_name)
{	
	HSQOBJECT class_id;
	sq_pushroottable(v);
	sq_pushstring(v,p_name,-1);

	sq_newclass(v,SQFalse);
	sq_getstackobj(v,-1,&class_id);		
	sq_settypetag(v,-1,&class_id);		

	HSQOBJECT string_constructor;
	sq_pushstring(v,_SC("constructor"),-1);
	sq_resetobject(&string_constructor);
	sq_getstackobj(v,-1,&string_constructor);
	sq_newclosure(v,c,0);
	sq_newslot(v,-3,false);
		
	sq_pushstring(v,_SC("_cloned"),-1);
	sq_newclosure(v,clone<T>,0);
	sq_newslot(v,-3,false);
		
	sq_newslot(v,-3,false);
	sq_pop(v,1);

	return class_id;
}
示例#15
0
/** Run the dummy info.nut. */
void Script_CreateDummyInfo(HSQUIRRELVM vm, const char *type, const char *dir)
{
	char dummy_script[4096];
	char *dp = dummy_script;
	dp += seprintf(dp, lastof(dummy_script), "class Dummy%s extends %sInfo {\n", type, type);
	dp += seprintf(dp, lastof(dummy_script), "function GetAuthor()      { return \"OpenTTD Developers Team\"; }\n");
	dp += seprintf(dp, lastof(dummy_script), "function GetName()        { return \"Dummy%s\"; }\n", type);
	dp += seprintf(dp, lastof(dummy_script), "function GetShortName()   { return \"DUMM\"; }\n");
	dp += seprintf(dp, lastof(dummy_script), "function GetDescription() { return \"A Dummy %s that is loaded when your %s/ dir is empty\"; }\n", type, dir);
	dp += seprintf(dp, lastof(dummy_script), "function GetVersion()     { return 1; }\n");
	dp += seprintf(dp, lastof(dummy_script), "function GetDate()        { return \"2008-07-26\"; }\n");
	dp += seprintf(dp, lastof(dummy_script), "function CreateInstance() { return \"Dummy%s\"; }\n", type);
	dp += seprintf(dp, lastof(dummy_script), "} RegisterDummy%s(Dummy%s());\n", type, type);

	const SQChar *sq_dummy_script = dummy_script;

	sq_pushroottable(vm);

	/* Load and run the script */
	if (SQ_SUCCEEDED(sq_compilebuffer(vm, sq_dummy_script, strlen(sq_dummy_script), "dummy", SQTrue))) {
		sq_push(vm, -2);
		if (SQ_SUCCEEDED(sq_call(vm, 1, SQFalse, SQTrue))) {
			sq_pop(vm, 1);
			return;
		}
	}
	NOT_REACHED();
}
示例#16
0
void sq_base_register(HSQUIRRELVM v)
{
	SQInteger i=0;
	sq_pushroottable(v);
	while(base_funcs[i].name!=0) {
		sq_pushstring(v,base_funcs[i].name,-1);
		sq_newclosure(v,base_funcs[i].f,0);
		sq_setnativeclosurename(v,-1,base_funcs[i].name);
		sq_setparamscheck(v,base_funcs[i].nparamscheck,base_funcs[i].typemask);
		sq_createslot(v,-3);
		i++;
	}
	sq_pushstring(v,_SC("_version_"),-1);
	sq_pushstring(v,SQUIRREL_VERSION,-1);
	sq_createslot(v,-3);
	sq_pushstring(v,_SC("_charsize_"),-1);
	sq_pushinteger(v,sizeof(SQChar));
	sq_createslot(v,-3);
	sq_pushstring(v,_SC("_intsize_"),-1);
	sq_pushinteger(v,sizeof(SQInteger));
	sq_createslot(v,-3);
	sq_pushstring(v,_SC("_floatsize_"),-1);
	sq_pushinteger(v,sizeof(SQFloat));
	sq_createslot(v,-3);
	sq_pop(v,1);
}
void SQDbgServer::SerializeState()
{
	sq_pushnull(_v);
	sq_setdebughook(_v);
	sq_pushnull(_v);
	sq_seterrorhandler(_v);
	const SQChar *sz;
	sq_pushobject(_v,_serializefunc);
	sq_pushobject(_v,_debugroot);
	sq_pushstring(_v,_SC("watches"),-1);
	sq_newtable(_v);
	for(WatchSetItor i=_watches.begin(); i!=_watches.end(); ++i)
	{
		sq_pushinteger(_v,i->_id);
		sq_pushstring(_v,i->_exp.c_str(),(int)i->_exp.length());
		sq_createslot(_v,-3);
	}
	sq_rawset(_v,-3);
	if(SQ_SUCCEEDED(sq_call(_v,1,SQTrue,SQTrue))){
		if(SQ_SUCCEEDED(sqstd_getblob(_v,-1,(SQUserPointer*)&sz)))
			SendChunk(sz);
	}
	sq_pop(_v,2);
	
	SetErrorHandlers();
}
示例#18
0
bool has_float(HSQUIRRELVM vm, const char* name)
{
  sq_pushstring(vm, name, -1);
  if (SQ_FAILED(sq_get(vm, -2))) return false;
  sq_pop(vm, 1);
  return true;
}
示例#19
0
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"));
}
示例#20
0
SquirrelObject & SquirrelObject::operator =(int n)
{
	sq_pushinteger(m_Vm.GetVMPtr(),n);
	AttachToStackObject(-1);
	sq_pop(m_Vm.GetVMPtr(),1);
	return *this;
}
ScriptText::ScriptText(HSQUIRRELVM vm) :
	ZeroedMemoryAllocator()
{
	int nparam = sq_gettop(vm) - 1;
	if (nparam < 1) {
		throw sq_throwerror(vm, _SC("You need to pass at least a StringID to the constructor"));
	}

	/* First resolve the StringID. */
	SQInteger sqstring;
	if (SQ_FAILED(sq_getinteger(vm, 2, &sqstring))) {
		throw sq_throwerror(vm, _SC("First argument must be a valid StringID"));
	}
	this->string = sqstring;

	/* The rest of the parameters must be arguments. */
	for (int i = 0; i < nparam - 1; i++) {
		/* Push the parameter to the top of the stack. */
		sq_push(vm, i + 3);

		if (SQ_FAILED(this->_SetParam(i, vm))) {
			this->~ScriptText();
			throw sq_throwerror(vm, _SC("Invalid parameter"));
		}

		/* Pop the parameter again. */
		sq_pop(vm, 1);
	}
}
示例#22
0
void
ThreadQueue::wakeup()
{
  // we traverse the list in reverse orders and use indices. This should be
  // robust for scripts that add new entries to the list while we're traversing
  // it
  size_t i = threads.size() - 1;
  size_t end = static_cast<size_t>(0 - 1);
  size_t size_begin = threads.size();
  while(i != end) {
    HSQOBJECT object = threads[i];

    sq_pushobject(global_vm, object);
    sq_getweakrefval(global_vm, -1);

    HSQUIRRELVM scheduled_vm;
    if(sq_gettype(global_vm, -1) == OT_THREAD &&
       SQ_SUCCEEDED(sq_getthread(global_vm, -1, &scheduled_vm))) {
      if(SQ_FAILED(sq_wakeupvm(scheduled_vm, SQFalse, SQFalse, SQTrue, SQFalse))) {
        log_warning << "Couldn't wakeup scheduled squirrel VM" << std::endl;
      }
    }

    sq_release(global_vm, &object);
    sq_pop(global_vm, 1);
    i--;
  }

  threads.erase(threads.begin(), threads.begin() + size_begin);
}
示例#23
0
文件: sqwrap.cpp 项目: comarius/pizu
void SqEnv::reset()
{
    AutoLock a(&_m);
    sq_pop(*_vm, 1);
	sq_close(*this->_vm);
	this->_init();
}
示例#24
0
/*
 * Register global function.
 * Must be called before loading script files
 */
void register_global_func(HSQUIRRELVM v, SQFUNCTION func, const char *fname) {
    sq_pushroottable(v);
    sq_pushstring(v, fname, -1);
    sq_newclosure(v, func, 0);
    sq_createslot(v, -3);
    sq_pop(v,1);
}
int SquirrelScriptContext::SquirrelClassConstructorCallback(HSQUIRRELVM vm)
{
	MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER );

	// Get class info
	void* userPtr = NULL;
	sq_getuserpointer(vm, -1, &userPtr);
	sq_pop(vm, 1);

	SquirrelClassInfo* classInfo = (SquirrelClassInfo*) userPtr;

	// Construct object
	SquirrelScriptObject* scriptObject = new SquirrelScriptObject();
	scriptObject->m_classInfo = classInfo;

	SquirrelScriptStack stack(classInfo->m_context, false);
	classInfo->m_desc->m_constructor(&stack, scriptObject);
	MultiScriptAssert( scriptObject->m_objectPtr );
	MultiScriptAssert( stack.m_numPushed == 0 );

	// There is already an instance on the stack (pushed automatically when constructor was invoked from script)
	// Attach our object to created instance
	sq_setinstanceup(vm, -1, scriptObject);

	// Set garbage collection callback for this instance
	sq_setreleasehook(vm, -1, SquirrelClassGCCallback);

	return 0;
}
示例#26
0
/*
 * Register new class.
 * Must be called before loading script files
 */
void register_class(HSQUIRRELVM v, const char *cname) {
    sq_pushroottable(v);
    sq_pushstring(v, cname, -1);
    sq_newclass(v, false);
    sq_createslot(v, -3);
    sq_pop(v, 1);
}
示例#27
0
int main(int argc, char* argv[]) 
{ 
	HSQUIRRELVM v; 
	v = sq_open(1024); // creates a VM with initial stack size 1024 

	//REGISTRATION OF STDLIB
	//sq_pushroottable(v); //push the root table where the std function will be registered
	//sqstd_register_iolib(v);  //registers a library
	// ... call here other stdlibs string,math etc...
	//sq_pop(v,1); //pops the root table
	//END REGISTRATION OF STDLIB
	
	sqstd_seterrorhandlers(v); //registers the default error handlers

	sq_setprintfunc(v, printfunc,errorfunc); //sets the print function

	sq_pushroottable(v); //push the root table(were the globals of the script will be stored)
	if(SQ_SUCCEEDED(sqstd_dofile(v, _SC("test.nut"), SQFalse, SQTrue))) // also prints syntax errors if any 
	{
		call_foo(v,1,2.5,_SC("teststring"));
	}

	sq_pop(v,1); //pops the root table
	sq_close(v); 

	return 0; 
} 
示例#28
0
/*
 * Register new table.
 * Must be called before loading script files
 */
void register_table(HSQUIRRELVM v, const char *name) {
    sq_pushroottable(v);
    sq_pushstring(v, name, -1);
    sq_newtable(v);
    sq_createslot(v, -3);
    sq_pop(v, 1);
}
int main(void)
{
  StackQueue* sq = sq_create(10);
  printf("Create: "); sq_print(sq);
  printf("Push: "); sq_push(sq, 5); sq_print(sq);
  printf("Enqueue: "); sq_enqueue(sq, 6); sq_print(sq);
  printf("Push: "); sq_push(sq, 7); sq_print(sq);
  printf("Popped: %u ", sq_pop(sq)); sq_print(sq);
  printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq);

  // Extra
  printf("Push: "); sq_push(sq, 1); sq_print(sq);
  printf("Push: "); sq_push(sq, 2); sq_print(sq);
  printf("Push: "); sq_push(sq, 3); sq_print(sq);
  printf("Push: "); sq_push(sq, 4); sq_print(sq);
  printf("Push: "); sq_push(sq, 5); sq_print(sq);
  printf("Push: "); sq_push(sq, 6); sq_print(sq);
  printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq);
  printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq);
  printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq);
  printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq);
  printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq);
  printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq);
  printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq);

  sq_destroy(sq);

  return EXIT_SUCCESS;
}
示例#30
0
void CSquirrel::RegisterFunction(const char * szFunctionName, SQFUNCTION pfnFunction, int iParameterCount, const char * szFunctionTemplate, bool bPushRootTable)
{
	// Push the root table onto the stack if needed
	if(bPushRootTable)
		sq_pushroottable(m_pVM);

	// Push the function name onto the stack
	sq_pushstring(m_pVM, szFunctionName, -1);

	// Create a new function
	sq_newclosure(m_pVM, pfnFunction, 0);

	// Set the function parameter template and count
	if(iParameterCount != -1)
	{
		char szTemp[128];

		if(szFunctionTemplate)
			sprintf(szTemp, ".%s", szFunctionTemplate);

		sq_setparamscheck(m_pVM, (iParameterCount + 1), (szFunctionTemplate) ? szTemp : NULL);
	}

	// Create a new slot
	sq_createslot(m_pVM, -3);

	// Pop the root table from the stack if needed
	if(bPushRootTable)
		sq_pop(m_pVM, 1);
}