int main (int argc, char **argv) {
ii_init();
srand((unsigned) time(NULL));
initialize_lua();
lua_set_arguments(argc, argv);
lua_gc(lst, LUA_GCSETSTEPMUL, GARBAGE_STEPMULT);
lua_gc(lst, LUA_GCSETPAUSE, GARBAGE_PAUSE);
ii_control_call(dosomegarbagecollection, NULL, GARBAGE_COLLECT_INTERVAL);
if ( argc == 1 ) {
if ( isatty(fileno(stdout)) )
printf("Lua interpereter loop running.\n");
interpereter_loop();
} else {
if ( luaL_dofile(lst, argv[1]) ) {
fprintf(stderr, "error while executing %s: %s\n", argv[1], luaL_checkstring(lst, lua_gettop(lst)));
exit(1);
}
}
ii_death();
exit(0);
}
enum script_add_result flashScriptPage(const unsigned int page,
const char *data,
const enum script_add_mode mode)
{
if (page >= MAX_SCRIPT_PAGES) {
pr_error("lua: invalid script index\r\n");
return SCRIPT_ADD_RESULT_FAIL;
}
switch (mode) {
case SCRIPT_ADD_MODE_IN_PROGRESS:
case SCRIPT_ADD_MODE_COMPLETE:
/* Valid cases. Carry on */
break;
default:
pr_error_int_msg("lua: Unknown script_add_mode: ", mode);
return SCRIPT_ADD_RESULT_FAIL;
}
static ScriptConfig *g_scriptBuffer;
if (NULL == g_scriptBuffer) {
terminate_lua();
pr_debug("lua: Allocating new script buffer\r\n");
g_scriptBuffer =
(ScriptConfig *) portMalloc(sizeof(ScriptConfig));
memcpy((void *)g_scriptBuffer, (void *)&g_scriptConfig,
sizeof(ScriptConfig));
}
if (NULL == g_scriptBuffer) {
pr_error("lua: Failed to allocate memory for script "
"buffer.\r\n");
return SCRIPT_ADD_RESULT_FAIL;
}
char *pageToAdd = g_scriptBuffer->script + page * SCRIPT_PAGE_SIZE;
strncpy(pageToAdd, data, SCRIPT_PAGE_SIZE);
if (SCRIPT_ADD_MODE_IN_PROGRESS == mode)
return SCRIPT_ADD_RESULT_OK;
pr_info("lua: Completed updating LUA. Flashing... ");
const int rc = memory_flash_region((void*) &g_scriptConfig,
(void*) g_scriptBuffer,
sizeof(ScriptConfig));
portFree(g_scriptBuffer);
g_scriptBuffer = NULL;
if (0 != rc) {
pr_info_int_msg("failed with code ", rc);
return SCRIPT_ADD_RESULT_FAIL;
}
pr_info("win!\r\n");
initialize_lua();
return SCRIPT_ADD_RESULT_OK;
}
struct vox_engine* vox_create_engine (unsigned int width, unsigned int height,
unsigned int flags,
const char *script,
int nargs, char * const arguments[])
{
struct vox_engine *engine;
/* Arguments sanity check */
if (script == NULL) return NULL;
if ((nargs == 0 && arguments != NULL) ||
(nargs != 0 && arguments == NULL))
return NULL;
engine = malloc (sizeof (struct vox_engine));
memset (engine, 0, sizeof (struct vox_engine));
engine->width = width;
engine->height = height;
engine->flags = flags;
initialize_lua (engine);
initialize_arguments (engine, nargs, arguments);
engine_load_script (engine, script);
/* Do not init SDL in debug mode! */
if (!(engine->flags & VOX_ENGINE_DEBUG)) {
// Init SDL
if (SDL_Init (SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0)
{
fprintf (stderr, "Cannot init SDL: %s\n", SDL_GetError());
goto bad;
}
engine->ctx = vox_make_context_and_window (engine->width, engine->height);
if (engine->ctx == NULL)
{
fprintf (stderr, "Cannot create the context: %s\n", SDL_GetError());
goto bad;
}
}
// Create context on top of lua stack
create_lua_context (engine);
execute_init (engine);
return engine;
bad:
vox_destroy_engine (engine);
return NULL;
}
void initialize()
{
virtual_mpq::force_watch("war3map.j", [&](const std::string&, const void**, uint32_t*, uint32_t)->bool {
if (!storm_s::instance().get_mpq_name(tmpMapName, sizeof tmpMapName - 1)) {
return false;
}
if (curMapName[0] && strcmp(curMapName, tmpMapName) == 0) {
return false;
}
strcpy(curMapName, tmpMapName);
initialize_lua();
return false;
});
event_game_reset([&]()
{
if (mainL)
{
lua_close(mainL);
mainL = 0;
}
curMapName[0] = 0;
});
}
int main(int argc, char *args[])
{
GtkApplication *application = gtk_application_new(NULL, 0);
g_application_register(G_APPLICATION(application), NULL, NULL);
struct capplication_handler *application_handler = alloc_application_handler(application);
// Handle option context.
GOptionEntry option_entries[] = {
{ "version",
'v',
0,
G_OPTION_ARG_NONE,
&application_handler->version,
"Show the version of the program.", NULL
},
{ G_OPTION_REMAINING,
'\0',
0,
G_OPTION_ARG_FILENAME_ARRAY,
&application_handler->file_name,
"A file containing a matrix for sequence alignment.", NULL
},
{ "help",
'h',
0,
G_OPTION_ARG_NONE,
&application_handler->help,
"Show this help description.", NULL
},
{NULL}
};
g_option_context_add_main_entries(application_handler->option_context, option_entries, _PROGRAM_NAME_);
g_option_context_set_help_enabled(application_handler->option_context, TRUE);
g_option_context_set_ignore_unknown_options(application_handler->option_context, TRUE);
// Parse options.
GError *error = NULL;
gboolean context_result = FALSE;
context_result = g_option_context_parse(application_handler->option_context,
&argc,
&args,
&error);
if (context_result) {
if (application_handler->version) {
g_printf("%s version %s.\n", _PROGRAM_NAME_, _PROGRAM_VERSION_);
g_printf("Copyright © %s %s. All rights reserved.\n", _PROGRAM_YEAR_, _PROGRAM_AUTHOR_);
}
} else if (error) {
printf("EE Failed to parser arguments.\n");
}
g_option_context_free(application_handler->option_context);
struct cwindow_handler *window_handler = alloc_window_handler(application_handler);
if (gtk_application_prefers_app_menu(GTK_APPLICATION(application_handler->application))) {
//gtk_application_set_app_menu(GTK_APPLICATION(application_handler->application), G_MENU_MODEL(window_handler->menu_model));
}
gtk_application_add_window(GTK_APPLICATION(application_handler->application), GTK_WINDOW(window_handler->window));
gtk_widget_show_all(GTK_WIDGET(window_handler->window));
gtk_window_present(GTK_WINDOW(window_handler->window));
initialize_lua(window_handler, application_handler);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(window_handler->notebook), application_handler->tabs_position);
gtk_widget_set_visible(GTK_WIDGET(window_handler->action_bar), application_handler->show_action_bar);
//gtk_widget_set_visible(window_handler->menu_bar, application_handler->show_menu_bar);
gtk_widget_set_visible(GTK_WIDGET(window_handler->search_and_replace_bar), FALSE);
if (application_handler->file_name) {
gint i = 0;
while (application_handler->file_name[i]) {
g_printf("MM Open file \"%s\".\n", application_handler->file_name[i]);
FILE *file = fopen(application_handler->file_name[i], "r");
fseek(file, 0, SEEK_END);
int size = ftell(file);
char *text = (char *)malloc(sizeof(char) * size + 1);
memset(text, 0, sizeof(char) * size + 1);
fseek(file, 0, SEEK_SET);
fread(text, sizeof(char), size, file);
create_page(window_handler, application_handler->file_name[i], text);
fclose(file);
i++;
}
}
update_editor(window_handler);
gtk_main();
g_printf("MM Closing Lua state.\n");
lua_close(application_handler->lua);
return 0;
}
void ChatLog::initialize(const char* __luafile)
{
initialize_lua(__luafile);
}
