int runblorb(char *path, char *game) { char magic[4]; strid_t file; giblorb_result_t res; giblorb_err_t err; giblorb_map_t *map; sprintf(tmp, "Could not load Blorb file:\n%s\n", game); file = glkunix_stream_open_pathname(game, 0, 0); if (!file) { winmsg(tmp); return FALSE; } err = giblorb_create_map(file, &map); if (err) { winmsg(tmp); return FALSE; } err = giblorb_load_resource(map, giblorb_method_FilePos, &res, giblorb_ID_Exec, 0); if (err) { winmsg(tmp); return FALSE; } glk_stream_set_position(file, res.data.startpos, 0); glk_get_buffer_stream(file, magic, 4); switch (res.chunktype) { case ID_ZCOD: if (strlen(terp)) return winterp(path, strcat(exe,terp), flags, game); else if (magic[0] == 6) return winterp(path, strcat(exe,T_ZSIX), flags, game); else return winterp(path, strcat(exe,T_ZCODE), flags, game); break; case ID_GLUL: if (strlen(terp)) return winterp(path, strcat(exe,terp), flags, game); else return winterp(path, strcat(exe,T_GLULX), flags, game); break; default: sprintf(tmp, "Unknown game type in Blorb file:\n%s\n", game); winmsg(tmp); } return FALSE; }
strid_t startup_open(const char *name) { strid_t str; char *s; str = glkunix_stream_open_pathname((char *) name, fileusage_Data | fileusage_BinaryMode, 0); if(str) { set_game_filename(name); #ifdef USE_GARGLK_FEATURES s = strrchr(name, '\\'); if (!s) s = strrchr(name, '/'); garglk_set_story_name(s ? s + 1 : name); #endif } else { char *path = search_path; if(path) { char *p; char *newname = (char *) n_malloc(strlen(path) + strlen(name) + 2); path = n_strdup(path); for(p = n_strtok(path, ":"); p; p = n_strtok(NULL, ":")) { n_strcpy(newname, p); n_strcat(newname, "/"); n_strcat(newname, name); str = glkunix_stream_open_pathname((char *) newname, fileusage_Data | fileusage_BinaryMode, 0); if(str) { set_game_filename(newname); #ifdef USE_GARGLK_FEATURES s = strrchr(newname, '\\'); if (!s) s = strrchr(newname, '/'); garglk_set_story_name(s ? s + 1 : newname); #endif break; } } n_free(path); } } if(!str) fprintf(stderr, "Cannot open '%s'\n", name); return str; }
int glkunix_startup_code(glkunix_startup_t *data) { if (data->argc <= 1) { printf ("usage: git gamefile.ulx\n"); return 0; } gStream = glkunix_stream_open_pathname ((char*) data->argv[1], 0, 0); return 1; }
strid_t startup_findfile(void) { static DIR *dir = NULL; static char *pathstart = NULL; static char *path = NULL; strid_t stream; struct dirent *d; char *name = NULL; if(!pathstart) { char *p = search_path; if(!p) return 0; pathstart = n_strdup(p); if(!(path = n_strtok(pathstart, ":"))) { n_free(pathstart); pathstart = 0; return 0; } } do { if(!dir) { dir = opendir(path); if(!dir) { n_free(pathstart); pathstart = 0; return 0; } } d = readdir(dir); if(!d) { closedir(dir); dir = NULL; if(!(path = n_strtok(NULL, ":"))) { n_free(pathstart); pathstart = 0; return 0; } } } while(!dir); name = (char *) n_malloc(n_strlen(path) + n_strlen(d->d_name) + 2); n_strcpy(name, path); n_strcat(name, "/"); n_strcat(name, d->d_name); stream = glkunix_stream_open_pathname(name, fileusage_Data | fileusage_BinaryMode, 0); if(stream) set_game_filename(name); n_free(name); return stream; }
int glkunix_startup_code_glulxe(glkunix_startup_t *data) { /* It turns out to be more convenient if we return TRUE from here, even when an error occurs, and display an error in glk_main(). */ char *cx; unsigned char buf[12]; int res; if (data->argc <= 1) { ginit_err = "You must supply the name of a game file."; return FALSE; } cx = data->argv[1]; gamefile = glkunix_stream_open_pathname(cx, FALSE, 1); if (!gamefile) { ginit_err = "The game file could not be opened."; ginit_err2 = cx; return TRUE; } /* Now we have to check to see if it's a Blorb file. */ glk_stream_set_position(gamefile, 0, seekmode_Start); res = glk_get_buffer_stream(gamefile, (char *)buf, 12); if (!res) { ginit_err = "The data in this stand-alone game is too short to read."; return TRUE; } if (buf[0] == 'G' && buf[1] == 'l' && buf[2] == 'u' && buf[3] == 'l') { locate_gamefile(FALSE); return TRUE; } else if (buf[0] == 'F' && buf[1] == 'O' && buf[2] == 'R' && buf[3] == 'M' && buf[8] == 'I' && buf[9] == 'F' && buf[10] == 'R' && buf[11] == 'S') { locate_gamefile(TRUE); return TRUE; } else { ginit_err = "This is neither a Glulx game file nor a Blorb file " "which contains one."; return TRUE; } }
int glkunix_startup_code(glkunix_startup_t *data) { /* It turns out to be more convenient if we return TRUE from here, even when an error occurs, and display an error in glk_main(). */ int ix; char *filename = NULL; strid_t gamefile = NULL; fizmo_register_filesys_interface(&glkint_filesys_interface); #ifdef ENABLE_TRACING turn_on_trace(); #endif // ENABLE_TRACING /* Parse out the arguments. They've already been checked for validity, and the library-specific ones stripped out. As usual for Unix, the zeroth argument is the executable name. */ for (ix=1; ix<data->argc; ix++) { if (filename) { init_err = "You must supply exactly one game file."; return TRUE; } filename = data->argv[ix]; } if (!filename) { init_err = "You must supply the name of a game file."; return TRUE; } gamefile = glkunix_stream_open_pathname(filename, FALSE, 1); if (!gamefile) { init_err = "The game file could not be opened."; init_err2 = filename; return TRUE; } gamefilestream = gamefile; gamefilename = filename; return TRUE; }
strid_t intd_filehandle_open(strid_t savefile, glui32 operating_id, glui32 contents_id, glui32 interp_id, glui32 length) { char *name; strid_t str; if(operating_id != 0x554e4958 /* 'UNIX' */) return 0; if(contents_id != 0) return 0; if(interp_id != 0x20202020 /* ' ' */) return 0; name = (char *) n_malloc(length+1); glk_get_buffer_stream(savefile, name, length); name[length] = 0; str = glkunix_stream_open_pathname(name, fileusage_Data | fileusage_BinaryMode, 0); if(str) set_game_filename(name); n_free(name); return str; }
int glkunix_startup_code(glkunix_startup_t *data) { /* It turns out to be more convenient if we return TRUE from here, even when an error occurs, and display an error in glk_main(). */ int ix; char *filename = NULL; char *gameinfofilename = NULL; int gameinfoloaded = FALSE; unsigned char buf[12]; int res; #ifdef GARGLK char *cx; #endif #ifdef GARGLK garglk_set_program_name("Glulxe 0.5.2"); garglk_set_program_info("Glulxe 0.5.2 by Andrew Plotkin"); #endif /* Parse out the arguments. They've already been checked for validity, and the library-specific ones stripped out. As usual for Unix, the zeroth argument is the executable name. */ for (ix=1; ix<data->argc; ix++) { #if VM_PROFILING if (!strcmp(data->argv[ix], "--profile")) { ix++; if (ix<data->argc) { strid_t profstr = glkunix_stream_open_pathname_gen(data->argv[ix], TRUE, FALSE, 1); if (!profstr) { init_err = "Unable to open profile output file."; init_err2 = data->argv[ix]; return TRUE; } setup_profile(profstr, NULL); } continue; } if (!strcmp(data->argv[ix], "--profcalls")) { profile_set_call_counts(TRUE); continue; } #endif /* VM_PROFILING */ #if VM_DEBUGGER if (!strcmp(data->argv[ix], "--gameinfo")) { ix++; if (ix<data->argc) { gameinfofilename = data->argv[ix]; } continue; } if (!strcmp(data->argv[ix], "--cpu")) { debugger_track_cpu(TRUE); continue; } if (!strcmp(data->argv[ix], "--starttrap")) { debugger_set_start_trap(TRUE); continue; } if (!strcmp(data->argv[ix], "--quittrap")) { debugger_set_quit_trap(TRUE); continue; } if (!strcmp(data->argv[ix], "--crashtrap")) { debugger_set_crash_trap(TRUE); continue; } #endif /* VM_DEBUGGER */ if (filename) { init_err = "You must supply exactly one game file."; return TRUE; } filename = data->argv[ix]; } if (!filename) { init_err = "You must supply the name of a game file."; return TRUE; } gamefile = glkunix_stream_open_pathname(filename, FALSE, 1); if (!gamefile) { init_err = "The game file could not be opened."; init_err2 = filename; return TRUE; } #ifdef GARGLK cx = strrchr(data->argv[1], '/'); if (!cx) cx = strrchr(data->argv[1], '\\'); garglk_set_story_name(cx ? cx + 1 : data->argv[1]); #endif #if VM_DEBUGGER if (gameinfofilename) { strid_t debugstr = glkunix_stream_open_pathname_gen(gameinfofilename, FALSE, FALSE, 1); if (!debugstr) { nonfatal_warning("Unable to open gameinfo file for debug data."); } else { int bres = debugger_load_info_stream(debugstr); glk_stream_close(debugstr, NULL); if (!bres) nonfatal_warning("Unable to parse game info."); else gameinfoloaded = TRUE; } } /* Report debugging available, whether a game info file is loaded or not. */ gidebug_debugging_available(debugger_cmd_handler, debugger_cycle_handler); #endif /* VM_DEBUGGER */ /* Now we have to check to see if it's a Blorb file. */ glk_stream_set_position(gamefile, 0, seekmode_Start); res = glk_get_buffer_stream(gamefile, (char *)buf, 12); if (!res) { init_err = "The data in this stand-alone game is too short to read."; return TRUE; } if (buf[0] == 'G' && buf[1] == 'l' && buf[2] == 'u' && buf[3] == 'l') { /* Load game directly from file. */ locate_gamefile(FALSE); return TRUE; } else if (buf[0] == 'F' && buf[1] == 'O' && buf[2] == 'R' && buf[3] == 'M' && buf[8] == 'I' && buf[9] == 'F' && buf[10] == 'R' && buf[11] == 'S') { /* Load game from a chunk in the Blorb file. */ locate_gamefile(TRUE); #if VM_DEBUGGER /* Load the debug info from the Blorb, if it wasn't loaded from a file. */ if (!gameinfoloaded) { glui32 giblorb_ID_Dbug = giblorb_make_id('D', 'b', 'u', 'g'); giblorb_err_t err; giblorb_result_t blorbres; err = giblorb_load_chunk_by_type(giblorb_get_resource_map(), giblorb_method_FilePos, &blorbres, giblorb_ID_Dbug, 0); if (!err) { int bres = debugger_load_info_chunk(gamefile, blorbres.data.startpos, blorbres.length); if (!bres) nonfatal_warning("Unable to parse game info."); else gameinfoloaded = TRUE; } } #endif /* VM_DEBUGGER */ return TRUE; } else { init_err = "This is neither a Glulx game file nor a Blorb file " "which contains one."; return TRUE; } }
int glkunix_startup_code(glkunix_startup_t *data) { /* It turns out to be more convenient if we return TRUE from here, even when an error occurs, and display an error in glk_main(). */ int ix; char *filename = NULL; unsigned char buf[12]; int res; #ifdef GARGLK char *cx; #endif #ifdef GARGLK garglk_set_program_name("Glulxe 0.5.2"); garglk_set_program_info("Glulxe 0.5.2 by Andrew Plotkin"); #endif /* Parse out the arguments. They've already been checked for validity, and the library-specific ones stripped out. As usual for Unix, the zeroth argument is the executable name. */ for (ix=1; ix<data->argc; ix++) { #if VM_PROFILING if (!strcmp(data->argv[ix], "--profile")) { ix++; if (ix<data->argc) { strid_t profstr = glkunix_stream_open_pathname_gen(data->argv[ix], TRUE, FALSE, 1); if (!profstr) { init_err = "Unable to open profile output file."; init_err2 = data->argv[ix]; return TRUE; } setup_profile(profstr, NULL); } continue; } #endif /* VM_PROFILING */ if (filename) { init_err = "You must supply exactly one game file."; return TRUE; } filename = data->argv[ix]; } if (!filename) { init_err = "You must supply the name of a game file."; return TRUE; } gamefile = glkunix_stream_open_pathname(filename, FALSE, 1); if (!gamefile) { init_err = "The game file could not be opened."; init_err2 = filename; return TRUE; } #ifdef GARGLK cx = strrchr(data->argv[1], '/'); if (!cx) cx = strrchr(data->argv[1], '\\'); garglk_set_story_name(cx ? cx + 1 : data->argv[1]); #endif /* Now we have to check to see if it's a Blorb file. */ glk_stream_set_position(gamefile, 0, seekmode_Start); res = glk_get_buffer_stream(gamefile, (char *)buf, 12); if (!res) { init_err = "The data in this stand-alone game is too short to read."; return TRUE; } if (buf[0] == 'G' && buf[1] == 'l' && buf[2] == 'u' && buf[3] == 'l') { locate_gamefile(FALSE); return TRUE; } else if (buf[0] == 'F' && buf[1] == 'O' && buf[2] == 'R' && buf[3] == 'M' && buf[8] == 'I' && buf[9] == 'F' && buf[10] == 'R' && buf[11] == 'S') { locate_gamefile(TRUE); return TRUE; } else { init_err = "This is neither a Glulx game file nor a Blorb file " "which contains one."; return TRUE; } }