////////////////////////////////////////////////////////////////////////////////
// register the script plugin framework
////////////////////////////////////////////////////////////////////////////////
void Register_ScriptPlugin()
{
SqPlus::RegisterGlobal(&ScriptPluginWrapper::ExecutePlugin, "ExecutePlugin");
SquirrelVM::CreateFunctionGlobal(&ScriptPluginWrapper::GetPlugin, "GetPlugin", "*");
SquirrelVM::CreateFunctionGlobal(&ScriptPluginWrapper::RegisterPlugin, "RegisterPlugin", "*");
// load base script plugin
// WARNING: we CANNOT use ScriptingManager::LoadBuffer() because we have reached here
// by a call from inside ScriptingManager's constructor. This would cause an infinite
// loop and the app would die with a stack overflow. We got to load the script manually...
// we also have to disable the printfunc for a while
SQPRINTFUNCTION oldPrintFunc = sq_getprintfunc(SquirrelVM::GetVMPtr());
sq_setprintfunc(SquirrelVM::GetVMPtr(), 0);
// compile and run script
SquirrelObject script;
try
{
script = SquirrelVM::CompileBuffer(s_cbScriptPlugin, "cbScriptPlugin");
SquirrelVM::RunScript(script);
}
catch (SquirrelError e)
{
cbMessageBox(wxString::Format(_("Failed to register script plugins framework.\n\n%s"),
cbC2U(e.desc).c_str()),
_("Script compile error"), wxICON_ERROR);
}
// restore the printfunc
sq_setprintfunc(SquirrelVM::GetVMPtr(), oldPrintFunc);
}
int sqlang_sr_init_child(void)
{
memset(&_sr_J_env, 0, sizeof(sr_sqlang_env_t));
_sr_J_env.J = sq_open(1024);
if(_sr_J_env.J==NULL) {
LM_ERR("cannot create SQlang context (exec)\n");
return -1;
}
sq_pushroottable(_sr_J_env.J);
/*sets the print functions*/
sq_setprintfunc(_sr_J_env.J, sqlang_printfunc, sqlang_errorfunc);
//sq_setnativedebughook(_sr_J_env.J, sqlang_debughook);
sq_enabledebuginfo(_sr_J_env.J, 1);
sqstd_register_bloblib(_sr_J_env.J);
sqstd_register_iolib(_sr_J_env.J);
sqstd_register_systemlib(_sr_J_env.J);
sqstd_register_mathlib(_sr_J_env.J);
sqstd_register_stringlib(_sr_J_env.J);
sqstd_seterrorhandlers(_sr_J_env.J);
sqlang_sr_kemi_register_libs(_sr_J_env.J);
if(_sr_sqlang_load_file.s != NULL && _sr_sqlang_load_file.len>0) {
_sr_J_env.JJ = sq_open(1024);
if(_sr_J_env.JJ==NULL) {
LM_ERR("cannot create load SQLang context (load)\n");
return -1;
}
sq_pushroottable(_sr_J_env.JJ);
LM_DBG("*** sqlang top index now is: %d\n", (int)sqlang_gettop(_sr_J_env.JJ));
/*sets the print functions*/
sq_setprintfunc(_sr_J_env.JJ, sqlang_printfunc, sqlang_errorfunc);
//sq_setnativedebughook(_sr_J_env.JJ, sqlang_debughook);
sq_enabledebuginfo(_sr_J_env.JJ, 1);
sqstd_register_bloblib(_sr_J_env.JJ);
sqstd_register_iolib(_sr_J_env.JJ);
sqstd_register_systemlib(_sr_J_env.JJ);
sqstd_register_mathlib(_sr_J_env.JJ);
sqstd_register_stringlib(_sr_J_env.JJ);
sqstd_seterrorhandlers(_sr_J_env.JJ);
sqlang_sr_kemi_register_libs(_sr_J_env.JJ);
LM_DBG("loading sqlang script file: %.*s\n",
_sr_sqlang_load_file.len, _sr_sqlang_load_file.s);
if(sqlang_kemi_load_script()<0) {
return -1;
}
}
LM_DBG("JS initialized!\n");
return 0;
}
wxString ScriptingManager::LoadBufferRedirectOutput(const wxString& buffer)
{
// wxCriticalSectionLocker c(cs);
s_ScriptErrors.Clear();
::capture.Clear();
sq_setprintfunc(SquirrelVM::GetVMPtr(), CaptureScriptOutput);
bool res = LoadBuffer(buffer);
sq_setprintfunc(SquirrelVM::GetVMPtr(), ScriptsPrintFunc);
return res ? ::capture : (wxString) wxEmptyString;
}
void SqEnv::_init(size_t sz)
{
// AutoLock a(&_m);
__vm = sq_open(sz);
_vm= &__vm;
assert( *_vm );
Sqrat::DefaultVM::Set(*_vm);
sq_setprintfunc(*_vm, SqEnv::print_func, SqEnv::print_func);
sq_newclosure(*_vm, SqEnv::error_handler,0);
sq_seterrorhandler(*_vm);
//sq
sq_pushroottable(*_vm);
sqstd_register_iolib(*_vm);
sqstd_register_bloblib(*_vm);
sqstd_register_mathlib(*_vm);
sqstd_register_stringlib(*_vm);
sqstd_register_systemlib(*_vm);
sqstd_seterrorhandlers(*_vm);
sqstd_printcallstack(*_vm);
// setnativedebughook(_vmsys,debug_hook);
sq_notifyallexceptions(*_vm, true);
}
int main(int argc, char** argv)
{
HSQUIRRELVM vm=sq_open(SQUIRREL_STACK_SIZE);
sq_setprintfunc(vm, squirrel_print_function, NULL);
register_global_func(vm,ShowVersion,"ShowVersion");
register_global_func(vm,Multiply,"Multiply");
if(SQ_FAILED(sqstd_dofile(vm,"test.nut",SQFalse,SQFalse)))
return 1;
/*const SQChar *program = "::print(\"Hello World!\\n\");";
if (SQ_FAILED(sq_compilebuffer(vm, program,
sizeof(SQChar) * strlen(program),
"program", SQFalse))) {
return 1;
}*/
sq_pushroottable(vm);
if (SQ_FAILED(sq_call(vm, 1, SQFalse, SQFalse))) {
//squirrel_print_last_error(sqvm);
return 1;
}
sq_close(vm);
return 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;
}
int main(int argc, char *argv[])
{
setbuf(stdout, NULL);
if (argc < 2) {
scprintf(_SC("SQDBG error : no file specified"));
return -1;
}
HSQUIRRELVM v = sq_open(1024);
sqstd_seterrorhandlers(v);
//!! INITIALIZES THE DEBUGGER ON THE TCP PORT 1234
//!! ENABLES AUTOUPDATE
HSQREMOTEDBG rdbg = sq_rdbg_init(v, 1234, SQTrue);
if (rdbg) {
//!! ENABLES DEBUG INFO GENERATION(for the compiler)
sq_enabledebuginfo(v, SQTrue);
sq_setprintfunc(v, printfunc, errorfunc);
//!! SUSPENDS THE APP UNTIL THE DEBUGGER CLIENT CONNECTS
if (SQ_SUCCEEDED(sq_rdbg_waitforconnections(rdbg))) {
scprintf(_SC("connected\n"));
const SQChar *fname = NULL;
#ifdef _UNICODE
SQChar sTemp[256];
mbstowcs(sTemp,argv[1],(int)strlen(argv[1])+1);
fname=sTemp;
#else
fname = argv[1];
#endif
//!!REGISTERS STANDARDS LIBS
sq_pushroottable(v);
sqstd_register_bloblib(v);
sqstd_register_iolib(v);
//!!EXECUTE A SCTIPT
if (SQ_FAILED(sqstd_dofile(v, fname, SQFalse, SQTrue))) {
PrintError(v);
#if defined(_WIN32) || defined(_WIN64)
_getch();
#else
getch();
#endif
}
}
//!! CLEANUP
sq_rdbg_shutdown(rdbg);
}
else {
PrintError(v);
}
sq_close(v);
return 0;
}
ScriptConsole::ScriptConsole(wxWindow* parent,wxWindowID id)
{
//(*Initialize(ScriptConsole)
wxBoxSizer* BoxSizer2;
wxBoxSizer* BoxSizer1;
Create(parent, id, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL, _T("id"));
BoxSizer1 = new wxBoxSizer(wxVERTICAL);
txtConsole = new wxTextCtrl(this, ID_TEXTCTRL1, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_AUTO_SCROLL|wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL, wxDefaultValidator, _T("ID_TEXTCTRL1"));
wxFont txtConsoleFont(10,wxMODERN,wxFONTSTYLE_NORMAL,wxNORMAL,false,wxEmptyString,wxFONTENCODING_DEFAULT);
txtConsole->SetFont(txtConsoleFont);
BoxSizer1->Add(txtConsole, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
Panel1 = new wxPanel(this, ID_PANEL1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL, _T("ID_PANEL1"));
Panel1->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
BoxSizer2 = new wxBoxSizer(wxHORIZONTAL);
lblCommand = new wxStaticText(Panel1, ID_STATICTEXT1, _("Command:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT1"));
BoxSizer2->Add(lblCommand, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
txtCommand = new wxComboBox(Panel1, ID_COMBOBOX1, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_DROPDOWN|wxTE_PROCESS_ENTER, wxDefaultValidator, _T("ID_COMBOBOX1"));
wxFont txtCommandFont(10,wxMODERN,wxFONTSTYLE_NORMAL,wxNORMAL,false,wxEmptyString,wxFONTENCODING_DEFAULT);
txtCommand->SetFont(txtCommandFont);
BoxSizer2->Add(txtCommand, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
btnExecute = new wxBitmapButton(Panel1, ID_BITMAPBUTTON1, wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_EXECUTABLE_FILE")),wxART_BUTTON), wxDefaultPosition, wxDefaultSize, wxBU_AUTODRAW, wxDefaultValidator, _T("ID_BITMAPBUTTON1"));
btnExecute->SetToolTip(_("Execute current command"));
BoxSizer2->Add(btnExecute, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
btnLoad = new wxBitmapButton(Panel1, ID_BITMAPBUTTON2, wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FILE_OPEN")),wxART_BUTTON), wxDefaultPosition, wxDefaultSize, wxBU_AUTODRAW, wxDefaultValidator, _T("ID_BITMAPBUTTON2"));
btnLoad->SetDefault();
btnLoad->SetToolTip(_("Load from file"));
BoxSizer2->Add(btnLoad, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
btnClear = new wxBitmapButton(Panel1, ID_BITMAPBUTTON3, wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_DELETE")),wxART_BUTTON), wxDefaultPosition, wxDefaultSize, wxBU_AUTODRAW, wxDefaultValidator, _T("ID_BITMAPBUTTON3"));
btnClear->SetDefault();
btnClear->SetToolTip(_("Clear output window"));
BoxSizer2->Add(btnClear, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
Panel1->SetSizer(BoxSizer2);
BoxSizer2->Fit(Panel1);
BoxSizer2->SetSizeHints(Panel1);
BoxSizer1->Add(Panel1, 0, wxALL|wxEXPAND|wxALIGN_LEFT|wxALIGN_TOP, 0);
SetSizer(BoxSizer1);
BoxSizer1->Fit(this);
BoxSizer1->SetSizeHints(this);
Connect(ID_COMBOBOX1,wxEVT_COMMAND_TEXT_ENTER,(wxObjectEventFunction)&ScriptConsole::OnbtnExecuteClick);
Connect(ID_BITMAPBUTTON1,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&ScriptConsole::OnbtnExecuteClick);
Connect(ID_BITMAPBUTTON2,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&ScriptConsole::OnbtnLoadClick);
Connect(ID_BITMAPBUTTON3,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&ScriptConsole::OnbtnClearClick);
//*)
txtCommand->Append(wxEmptyString);
if (!s_Console)
{
s_Console = this;
s_OldPrintFunc = sq_getprintfunc(SquirrelVM::GetVMPtr());
sq_setprintfunc(SquirrelVM::GetVMPtr(), ScriptConsolePrintFunc);
}
Log(_("Welcome to the script console!"));
}
ScriptConsole::~ScriptConsole()
{
if (s_Console == this)
{
s_Console = 0;
if (SquirrelVM::GetVMPtr())
sq_setprintfunc(SquirrelVM::GetVMPtr(), s_OldPrintFunc);
}
//(*Destroy(ScriptConsole)
//*)
}
/*
* Initialize Squirrel VM
*/
void initSQVM(HSQUIRRELVM v) {
sqstd_seterrorhandlers(v);
sq_setprintfunc(v, sq_printfunc, sq_errorfunc);
sq_pushroottable(v);
sqstd_register_systemlib(v);
#ifndef EMO_WITH_SANDBOX
sqstd_register_iolib(v);
#endif
sqstd_register_bloblib(v);
sqstd_register_mathlib(v);
sqstd_register_stringlib(v);
}
int sqrl_main(int argc, char* argv[])
{
HSQUIRRELVM v;
SQInteger retval = 0;
const SQChar *filename=NULL;
#if defined(_MSC_VER) && defined(_DEBUG)
_CrtSetAllocHook(MemAllocHook);
#endif
v=sq_open(1024);
sq_setprintfunc(v,printfunc,errorfunc);
sq_pushroottable(v);
sqstd_register_bloblib(v);
sqstd_register_iolib(v);
sqstd_register_mathlib(v);
/*
* TODO: system and string library should be implemented for nuttx
* they need 'longjmp' and 'setjmp'.
*/
//sqstd_register_stringlib(v);
//sqstd_register_systemlib(v);
//aux library
//sets error handlers
sqstd_seterrorhandlers(v);
//gets arguments
switch(getargs(v,argc,argv,&retval))
{
case _INTERACTIVE:
Interactive(v);
break;
case _DONE:
case _ERROR:
default:
break;
}
sq_close(v);
#if defined(_MSC_VER) && defined(_DEBUG)
_getch();
_CrtMemDumpAllObjectsSince( NULL );
#endif
return retval;
return 0;
}
void Squirrel::RunError(HSQUIRRELVM vm, const SQChar *error)
{
/* Set the print function to something that prints to stderr */
SQPRINTFUNCTION pf = sq_getprintfunc(vm);
sq_setprintfunc(vm, &Squirrel::ErrorPrintFunc);
/* Check if we have a custom print function */
SQChar buf[1024];
scsnprintf(buf, lengthof(buf), _SC("Your script made an error: %s\n"), error);
Squirrel *engine = (Squirrel *)sq_getforeignptr(vm);
SQPrintFunc *func = engine->print_func;
if (func == NULL) {
scfprintf(stderr, _SC("%s"), buf);
} else {
(*func)(true, buf);
}
/* Print below the error the stack, so the users knows what is happening */
sqstd_printcallstack(vm);
/* Reset the old print function */
sq_setprintfunc(vm, pf);
}
CSquirrel::CSquirrel(CResource* pResource)
{
m_pResource = pResource;
// Create the VM
m_pVM = sq_open(DEFAULT_STACK_SIZE);
// Was the VM created successfully?
if( m_pVM )
{
// Push the root table onto the stack
sq_pushroottable(m_pVM);
// Register the default error handles
sqstd_seterrorhandlers(m_pVM);
// Set the print and error functions
sq_setprintfunc(m_pVM, printfunc, errorfunc);
// Register the blob library
sqstd_register_bloblib(m_pVM);
// Register the input/out library
sqstd_register_iolib(m_pVM);
// Register the math library
sqstd_register_mathlib(m_pVM);
// Register the string library
sqstd_register_stringlib(m_pVM);
// Register the system library
sqstd_register_systemlib(m_pVM);
// Register our shared functions
// Register our own functions
#ifdef _SERVER
CPlayerNatives::Register(this);
CVehicleNatives::Register(this);
C3DLabelNatives::Register(this);
CActorNatives::Register(this);
CCheckpointNatives::Register(this);
CObjectNatives::Register(this);
CServerNatives::Register(this);
CBlipNatives::Register(this);
#endif
}
}
int main(int argc, char* argv[])
{
HSQUIRRELVM v;
const SQChar *filename=NULL;
#if defined(_MSC_VER) && defined(_DEBUG)
_CrtSetAllocHook(MemAllocHook);
#endif
//v= sq_open(1024);
v= sqobject::init();
sq_setprintfunc(v,printfunc);
sq_pushroottable(v);
sqstd_register_bloblib(v);
sqstd_register_iolib(v);
sqstd_register_systemlib(v);
// sqstd_register_mathlib(v);
// sqstd_register_stringlib(v);
//aux library
//sets error handlers
// sqstd_seterrorhandlers(v);
sqobject::Object::registerClass();
//gets arguments
int ret;
switch((ret = getargs(v,argc,argv)))
{
case _INTERACTIVE:
Interactive(v);
break;
case _DONE:
default:
break;
}
//sq_close(v);
sqobject::done();
#if defined(_MSC_VER) && defined(_DEBUG)
_getch();
_CrtMemDumpAllObjectsSince( NULL );
#endif
return ret == _ERROR ? -1 : 0;
}
void SquirrelVM::Init()
{
_CallState = -1;
_VM = sq_open(1024);
sq_setprintfunc(_VM,SquirrelVM::PrintFunc,SquirrelVM::ErrorFunc);
sq_pushroottable(_VM);
//sqstd_register_iolib(_VM);
//sqstd_register_bloblib(_VM);
sqstd_register_mathlib(_VM);
sqstd_register_stringlib(_VM);
sqstd_seterrorhandlers(_VM);
_root = new SquirrelObject(_VM);
_root->AttachToStackObject(-1);
sq_pop(_VM,1);
//TODO error handler compier error handler
}
bool CSquirrel::Load(String strName, String strPath)
{
// Check if the script exists
if(!SharedUtility::Exists(strPath.Get()))
return false;
// Set the script name
m_strName = strName;
// Set the script path
m_strPath = strPath;
// Create a squirrel VM with an initial stack size of 1024 bytes (stack will resize as needed)
m_pVM = sq_open(1024);
// Register the default error handlers
sqstd_seterrorhandlers(m_pVM);
// Set the print function and error function
sq_setprintfunc(m_pVM, PrintFunction, PrintFunction);
// Set the compiler error function
sq_setcompilererrorhandler(m_pVM, CompilerErrorFunction);
// Set our error handler
sq_newclosure(m_pVM, PrintErrorFunction, 0);
sq_seterrorhandler(m_pVM);
// Push the root table onto the stack
sq_pushroottable(m_pVM);
#ifdef _SERVER
// Register the input/output library
sqstd_register_iolib(m_pVM);
#endif
// Register the blob library
sqstd_register_bloblib(m_pVM);
// Register the math library
sqstd_register_mathlib(m_pVM);
// Register the string library
sqstd_register_stringlib(m_pVM);
return true;
}
HSQUIRRELVM Sq_Open(const char *File) {
HSQUIRRELVM v;
v = sq_open(1024);
sqstd_seterrorhandlers(v);
sq_setprintfunc(v, Sq_PrintFunc,Sq_ErrorFunc);
sq_pushroottable(v);
sqstd_register_mathlib(v);
sqstd_register_stringlib(v);
sq_pop(v,1);
sq_pushroottable(v);
sq_pushstring(v, "api", -1);
sq_newtable(v);
sq_newslot(v,-3,SQFalse);
sq_pushstring(v, "api", -1);
sq_get(v, -2);
Sq_RegisterFunc(v, Sq_StrToL, "Num", 2, "si");
Sq_RegisterFunc(v, Sq_MessageBox, "MessageBox", 1, "s");
Sq_RegisterFunc(v, Sq_AskForInput, "AskForInput", 1, "s");
Sq_RegisterFunc(v, Sq_GetLevelJSON, "GetLevelJSON", 1, "si.");
Sq_RegisterFunc(v, Sq_SetLevelJSON, "SetLevelJSON", 2, "s.");
Sq_RegisterFunc(v, Sq_GetLayerRects, "GetLayerRects", 2, "s");
Sq_RegisterFunc(v, Sq_SetLayerRects, "SetLayerRects", 2, "sa");
Sq_RegisterFunc(v, Sq_GetLayerMap, "GetLayerMap", -1, "siiii");
Sq_RegisterFunc(v, Sq_SetLayerMap, "SetLayerMap", -2, "saiiii");
Sq_RegisterFunc(v, Sq_RegisterExport, "RegisterExport", 2, "cs");
Sq_RegisterFunc(v, Sq_RegisterMenu, "RegisterMenu", 2, "cs");
Sq_RegisterFunc(v, Sq_ExportOpen, "ExportOpen", 1, "s");
Sq_RegisterFunc(v, Sq_ExportWrite, "ExportWrite", 2, "is");
Sq_RegisterFunc(v, Sq_ExportClose, "ExportClose", 1, "i");
Sq_RegisterFunc(v, Sq_GetInfo, "GetInfo", 1, "s");
Sq_RegisterFunc(v, Sq_GetLevelInt, "GetLevelInt", 2, "is");
Sq_RegisterFunc(v, Sq_GetLevelStr, "GetLevelStr", 2, "ss");
Sq_RegisterFunc(v, Sq_GetLevelTbl, "GetLevelTbl", 1, "s");
Sq_RegisterFunc(v, Sq_DecodeJSON, "DecodeJSON", 1, "s");
Sq_RegisterFunc(v, Sq_Interpolate, "Interpolate", 3, "ssa");
sq_pop(v,1); // pop api table
Sq_DoFile(v, "data/common.nut");
if(File) Sq_DoFile(v, File);
return v;
}
int main()
{
HSQUIRRELVM vm = sq_open(1024);
sq_setprintfunc(vm, PrintFunc, PrintFunc);
sq_setcompilererrorhandler(vm, CompileErrorHandler);
//FILE* fp = fopen("../../../test/test.nut", "r");
//if(!fp)
//{
// goto _CLEANUP;
//}
//fseek(fp, 0, SEEK_END);
//long len = ftell(fp);
//fseek(fp, 0, SEEK_SET);
//char* buf = new char[len + 1];
//memset(buf, 0, len + 1);
//fread(buf, 1, len, fp);
//fclose(fp);
//SQChar* source = new SQChar[len + 2];
//memset(source, 0, sizeof(SQChar) * (len + 2));
//mbstowcs(source, buf, len + 1);
//delete[] buf;
//if(SQ_FAILED(sq_compilebuffer(vm, source, _tcslen(source), _SC("test.nut"), SQTrue)))
//{
// delete[] source;
// goto _CLEANUP;
//}
//delete[] source;
SQChar* apSrc[] = {
_SC("../../../test/test.nut"),
};
sq_compilestatic(vm, OpenSrcFunc, CloseSrcFunc, 1, apSrc, _SC("testproj"), SQTrue);
sq_pushroottable(vm);
if(SQ_SUCCEEDED(sq_call(vm, 1, SQFalse, SQTrue)))
{
printf("Run script succeeded.");
}
_CLEANUP:
sq_close(vm);
system("pause");
return 0;
}
int main(int argc, char* argv[])
{
HSQUIRRELVM v;
SQInteger retval = 0;
#if defined(_MSC_VER) && defined(_DEBUG)
_CrtSetAllocHook(MemAllocHook);
#endif
v=sq_open(1024);
sq_setprintfunc(v,printfunc,errorfunc);
sq_pushroottable(v);
sqstd_register_bloblib(v);
sqstd_register_iolib(v);
sqstd_register_systemlib(v);
sqstd_register_mathlib(v);
sqstd_register_stringlib(v);
//aux library
//sets error handlers
sqstd_seterrorhandlers(v);
//gets arguments
switch(getargs(v,argc,argv,&retval))
{
case _INTERACTIVE:
Interactive(v);
break;
case _DONE:
case _ERROR:
default:
break;
}
sq_close(v);
#if defined(_MSC_VER) && defined(_DEBUG)
_getch();
_CrtMemDumpAllObjectsSince( NULL );
#endif
return retval;
}
void Context::initialize()
{
sq_setforeignptr(vm_, this);
sq_setprintfunc(vm_, Detail::print, Detail::printError);
sq_pushroottable(vm_);
sqstd_register_mathlib(vm_);
sqstd_register_stringlib(vm_);
sqstd_register_bloblib(vm_);
sq_setcompilererrorhandler(vm_, Detail::handleCompilerError);
sq_newclosure(vm_, Detail::handleError, 0);
sq_seterrorhandler(vm_);
sq_pop(vm_, 1);
Table::create(*this, _SC("__sqrew_classes"), TableDomain::Registry);
}
ScriptingManager::ScriptingManager()
: m_AttachedToMainWindow(false),
m_MenuItemsManager(false) // not auto-clear
{
//ctor
// initialize but don't load the IO lib
SquirrelVM::Init((SquirrelInitFlags)(sqifAll & ~sqifIO));
if (!SquirrelVM::GetVMPtr())
cbThrow(_T("Can't create scripting engine!"));
sq_setprintfunc(SquirrelVM::GetVMPtr(), ScriptsPrintFunc);
sqstd_register_stringlib(SquirrelVM::GetVMPtr());
RefreshTrusts();
// register types
ScriptBindings::RegisterBindings();
}
CSquirrelVM::CSquirrelVM(CResource * pResource)
: IScriptVM(pResource),
m_iStackIndex(2)
{
m_pVM = sq_open(1024);
// Register the default error handlers
sqstd_seterrorhandlers(m_pVM);
// Push the root table onto the stack
sq_pushroottable(m_pVM);
sqstd_register_stringlib(m_pVM);
sqstd_register_mathlib(m_pVM);
sqstd_register_systemlib(m_pVM);
sq_setprintfunc(m_pVM, PrintFunction, PrintFunction);
}
Squirrel::Squirrel()
{
this->vm = sq_open(1024);
this->print_func = NULL;
this->global_pointer = NULL;
this->crashed = false;
/* Handle compile-errors ourself, so we can display it nicely */
sq_setcompilererrorhandler(this->vm, &Squirrel::CompileError);
sq_notifyallexceptions(this->vm, SQTrue);
/* Set a good print-function */
sq_setprintfunc(this->vm, &Squirrel::PrintFunc);
/* Handle runtime-errors ourself, so we can display it nicely */
sq_newclosure(this->vm, &Squirrel::_RunError, 0);
sq_seterrorhandler(this->vm);
/* Set the foreigh pointer, so we can always find this instance from within the VM */
sq_setforeignptr(this->vm, this);
sq_pushroottable(this->vm);
squirrel_register_global_std(this);
}
SquirrelScriptContext* SquirrelScriptContext::CreateContext(int stackSize)
{
SquirrelScriptContext* context = new SquirrelScriptContext();
HSQUIRRELVM vm = sq_open(stackSize);
vm->user_data = context;
sq_setprintfunc(vm, SquirrelPrintCallback);
sqstd_seterrorhandlers(vm);
// Push root table so stdlibs can register themselves to it
sq_pushroottable(vm);
// Register stdlibs
sqstd_register_iolib(vm);
sqstd_register_mathlib(vm);
sqstd_register_stringlib(vm);
sqstd_register_systemlib(vm);
context->m_vm = vm;
return context;
}
/*
** Creates a new SQuirrel vm.
*/
static SQRESULT sq_slave_vm_constructor (HSQUIRRELVM v)
{
SQ_FUNC_VARS(v);
SQ_OPT_INTEGER(v, 2, stack_size, 1024);
HSQUIRRELVM self = sq_open(stack_size);
/* Initialize environment */
sq_setprintfunc(self,sq_getprintfunc(v),sq_geterrorfunc(v));
/* load base libraries */
sq_pushroottable(self);
sqstd_register_bloblib(self);
sqstd_register_iolib(self);
sqstd_register_systemlib(self);
sqstd_register_mathlib(self);
sqstd_register_stringlib(self);
sq_poptop(self); //remove root table
sq_setinstanceup(v, 1, self);
sq_setreleasehook(v, 1, sq_slave_vm_release_hook);
return 1;
}
void MTR_ScriptsInit(void)
{
#ifdef MTR_MOD_PLUGIN
int i;
int j;
#endif
MTR_LogWrite("Initializing script subsystem", 0, MTR_LMT_INFO);
MTR_LogWrite_s("Reporting Squirrel compile-time version:", 1, MTR_LMT_INFO,
SQUIRREL_VERSION);
MTR_LogWrite_i("Reporting Squirrel linked version:", 1, MTR_LMT_INFO,
sq_getversion());
mtrVm = sq_open(1024);
sq_setprintfunc(mtrVm, MTR_ScriptPrintFunc, MTR_ScriptErrorFunc); //sets the print function
sq_pushroottable(mtrVm);
sqstd_register_bloblib(mtrVm);
sqstd_register_iolib(mtrVm);
sqstd_register_systemlib(mtrVm);
sqstd_register_mathlib(mtrVm);
sqstd_register_stringlib(mtrVm);
sqstd_seterrorhandlers(mtrVm); //registers the default error handlers
MTR_LogWrite("Squirrel VM created", 1, MTR_LMT_INFO);
/* Registering functions and constants from all binding plugins */
MTR_LogWrite("Registering functions and constants of engine", 1,
MTR_LMT_INFO);
MTR_ScriptsRegisterAll();
MTR_LogWrite("Script functions and constants of engine registered",
1, MTR_LMT_INFO);
/* Registering functions and constants from all binding plugins */
MTR_LogWrite("Registering functions and constants of bindings", 1,
MTR_LMT_INFO);
#ifdef MTR_MOD_PLUGIN
for (i = 0; i < mtrPluginsCount; i++)
{
for (j = 0; j < mtrPluginData[i].report->prereqsCount; j++)
{
if (strcmp(mtrPluginData[i].report->prereqs[j], "Script_Squirrel") == 0)
{
MTR_LogWrite_s("Binding found:", 2, MTR_LMT_INFO,
mtrPluginData[i].report->moduleID);
MTR_PluginInit = (mtrPluginInitFunc)MTR_FindFunction(
mtrPluginData[i].report->moduleID, "MTR_PluginInit");
if (MTR_PluginInit != NULL)
MTR_PluginInit();
else
MTR_Notify("Library not contain MTR_PluginInit function", 3,
MTR_LMT_ERROR);
}
}
}
#else
MTR_BifInitAll();
#endif
MTR_LogWrite("Script functions and constants of bindings registered",
1, MTR_LMT_INFO);
MTR_LogWrite("Script subsystem initialized", 0, MTR_LMT_INFO);
}
int main(int argc, char *argv[])
{
if(argc < 2){
scprintf(_SC("SQDBG error : no file specified"));
return -1;
}
// RVF +
int debuggerPort = 0;
for (int i = 1; i < argc; i++) {
const char* arg = argv[i];
if (!strncmp(arg, "-d", 2))
debuggerPort = std::atoi(arg + 2);
}
if (!debuggerPort) {
scprintf(_SC("SQDBG error : Debugger port not specified. Use the -d<PORT> parameter"));
return EXIT_FAILURE;
}
// RVF -
HSQUIRRELVM v = sq_open(1024);
sqstd_seterrorhandlers(v);
//!! INITIALIZES THE DEBUGGER ON THE TCP PORT 1234
//!! ENABLES AUTOUPDATE
HSQREMOTEDBG rdbg = sq_rdbg_init(v,debuggerPort,SQTrue);
if(rdbg) {
//!! ENABLES DEBUG INFO GENERATION(for the compiler)
sq_enabledebuginfo(v,SQTrue);
sq_setprintfunc(v,printfunc,errorfunc);
//!! SUSPENDS THE APP UNTIL THE DEBUGGER CLIENT CONNECTS
if(SQ_SUCCEEDED(sq_rdbg_waitforconnections(rdbg))) {
scprintf(_SC("connected\n"));
const SQChar *fname=NULL;
#ifdef _UNICODE
SQChar sTemp[256];
mbstowcs(sTemp,argv[argc-1],(int)strlen(argv[1])+1);
fname=sTemp;
#else
fname=argv[argc-1];
#endif
//!!REGISTERS STANDARDS LIBS
sq_pushroottable(v);
sqstd_register_bloblib(v);
sqstd_register_iolib(v);
sqstd_register_systemlib(v);
sqstd_register_mathlib(v);
sqstd_register_stringlib(v);
//!!EXECUTE A SCTIPT
if(SQ_FAILED(sqstd_dofile(v,fname,SQFalse,SQTrue))) {
PrintError(v);
_getch();
}
}
//!! CLEANUP
sq_rdbg_shutdown(rdbg);
}
else {
PrintError(v);
}
sq_close(v);
return 0;
}
SqWrap::SqWrap() {
vm = sq_open(1024);
sqstd_seterrorhandlers(vm);
sq_setprintfunc(vm, printfunc, errorfunc);
}
UIManager::UIManager(UIPreference *Setting, pfc::string8 *Script) : m_Setting(Setting), m_Script(Script)
{
SquirrelVM::Init();
SquirrelVM::GetVMSys(m_vmSys);
sq_setprintfunc(m_vmSys, &UIManager::ScriptDebugLog, &UIManager::ScriptDebugLog);
UICanvas::RegisterCanvas();
SquirrelObject InitScript = SquirrelVM::CompileBuffer(TEXT("function Init() { }"));
SquirrelVM::RunScript(InitScript);
SqPlus::RegisterGlobal(&UIManager::IsHighlightedLine, TEXT("IsHighlightedLine"));
SquirrelObject DrawScript = SquirrelVM::CompileBuffer(
TEXT("function Draw(canvas, lines) { \n")
TEXT("local normalfont = WndSetting.GetNormalFont();\n")
TEXT("local highlightfont = WndSetting.GetHighlightFont();\n")
TEXT("local h = 0; foreach(i,v in lines) {\n")
TEXT("local sz;\n")
TEXT("if(IsHighlightedLine(v))\n")
TEXT("sz = canvas.EstimateText(highlightfont, v);\n")
TEXT("else\n")
TEXT("sz = canvas.EstimateText(normalfont, v);\n")
TEXT("h += sz.height * WndSetting.GetLineMargin() / 100.0 + WndSetting.GetOutlineSize() / 2}\n")
TEXT("local sz = canvas.GetCanvasSize();\n")
TEXT("if(WndSetting.GetBgType() == 0)\n")
TEXT("canvas.Fill(0, 0, sz.width, sz.height, WndSetting.GetBackColor());\n")
TEXT("else if(WndSetting.GetBgType() == 1) canvas.DrawImage(0, 0, sz.width, sz.height, WndSetting.GetBackImage());\n")
TEXT("else if(WndSetting.GetBgType() == 2) canvas.SetTransparent();\n")
TEXT("local starty = 0;\n")
TEXT("if(WndSetting.GetVAlign() == 2)\n")
TEXT("starty = (sz.height - h) / 2;\n")
TEXT("else if(WndSetting.GetVAlign() == 3) starty = sz.height - h;\n")
TEXT("if(starty < 0) starty = 0;")
TEXT("canvas.SetDrawTextOrigin(UIPoint(0, starty));\n")
TEXT("foreach(i, v in lines) {\n")
TEXT("if(IsHighlightedLine(v))\n")
TEXT("canvas.DrawText(highlightfont, v, WndSetting.GetHAlign(), WndSetting.GetLineMargin() / 100.0, WndSetting.GetFontTransparency(), WndSetting.GetOutlineColor(), WndSetting.GetOutlineSize());\n")
TEXT("else\n")
TEXT("canvas.DrawText(normalfont, v, WndSetting.GetHAlign(), WndSetting.GetLineMargin() / 100.0, WndSetting.GetFontTransparency(), WndSetting.GetOutlineColor(), WndSetting.GetOutlineSize());}}\n")
);
SquirrelVM::RunScript(DrawScript);
SqPlus::SQClassDefNoConstructor<UIPreference>(TEXT("UIPreference")).
func(&UIPreference::GetBkColor, TEXT("GetBackColor")).
func(&UIPreference::GetBgImagePath, TEXT("GetBackImage")).
func(&UIPreference::GetBgType, TEXT("GetBgType")).
func(&UIPreference::GetHorizentalAlign, TEXT("GetHAlign")).
func(&UIPreference::GetVerticalAlign, TEXT("GetVAlign")).
func(&UIPreference::GetLineMargin, TEXT("GetLineMargin")).
func(&UIPreference::GetHighlightFont, TEXT("GetHighlightFont")).
func(&UIPreference::GetNormalFont, TEXT("GetNormalFont")).
func(&UIPreference::GetFontTransparency, TEXT("GetFontTransparency")).
func(&UIPreference::GetOutlineColor, TEXT("GetOutlineColor")).
func(&UIPreference::GetOutlineSize, TEXT("GetOutlineSize"));
SqPlus::BindVariable(m_Setting, TEXT("WndSetting"));
m_RootTable = SquirrelVM::GetRootTable();
SqPlus::SquirrelFunction<void>(m_RootTable, TEXT("Init"))();
InitializeCriticalSection(&m_DrawCrit);
}
CResourceScript::CResourceScript ( CString strFile, int ScriptType, CResource *pResource )
{
// Warp some varibles.
m_pResource = pResource;
m_iScriptType = ScriptType;
// Format script localization.
m_strFile.Format("%s\\%s\\%s", m_pResource->GetDirectory().Get(), m_pResource->GetName().Get(), strFile.Get());
// Check if file exists.
if(!Exists(m_strFile.Get()))
{
CLog::Printf( "[Resources] Script %s not found!", m_strFile.Get() );
return;
}
// Check script type - default server.
if ( ScriptType == SCRIPT_CLIENT )
{
/*
TODO:
- Warp to code WebServ,
- Create class for client resources,
- ..
*/
} else {
// Create root stack for script.
m_pVM = sq_open(1024);
//Register error and print functions.
sqstd_seterrorhandlers(m_pVM);
sq_setprintfunc(m_pVM, PrintFunction, ErrorFunction);
sq_setcompilererrorhandler(m_pVM, CompilerErrorFunction);
// Push root vm table.
sq_pushroottable(m_pVM);
// Register basic systems.
sqstd_register_systemlib(m_pVM);
sqstd_register_iolib(m_pVM);
sqstd_register_bloblib(m_pVM);
sqstd_register_mathlib(m_pVM);
sqstd_register_stringlib(m_pVM);
// Register Squirrel Classes
m_pResource->RegisterClass(this);
// Register all functions.
// Event functions.
CEventNatives::Register(this);
// Funkcje gracza.
CPlayerNatives::Register(this);
if ( SQ_FAILED ( sqstd_dofile(m_pVM, m_strFile.Get(), SQFalse, SQTrue) ) )
{
// cannot compile script file.
return;
}
// Define basic varibles.
CSquirrelArguments pArgs;
pArgs.push(MAX_PLAYERS);
RegisterVarible ( "MAX_PLAYERS", &pArgs );
pArgs.clear();
}
}
