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