/* Print every character, or rather try to. */
static void verb_chars(winid_t win)
{
int ix;
char buf[16];
glk_set_window(win);
for (ix=0; ix<256; ix++) {
num_to_str(buf, ix);
glk_put_string(buf);
glk_put_string(": ");
glk_put_char(ix);
glk_put_char('\n');
}
}
glui32 automap_draw_callback(winid_t win, glui32 width, glui32 height)
{
if(win == NULL)
return automap_size;
mymap_init(width, height);
automap_set_locations(automap_location);
glk_stream_set_current(glk_window_get_stream(win));
mymap_draw();
if(selected_room_number) {
offset short_name_off = object_name(selected_room_number);
glk_window_move_cursor(win, 0, 0);
if(short_name_off)
decodezscii(short_name_off, w_glk_put_char);
else
w_glk_put_string("<nameless>");
w_glk_put_string(" (");
g_print_number(selected_room_number);
glk_put_char(')');
}
return automap_size;
}
static void verb_yada(winid_t win)
{
/* This is a goofy (and overly ornate) way to print a long paragraph.
It just shows off line wrapping in the Glk implementation. */
#define NUMWORDS (13)
static char *wordcaplist[NUMWORDS] = {
"Ga", "Bo", "Wa", "Mu", "Bi", "Fo", "Za", "Mo", "Ra", "Po",
"Ha", "Ni", "Na"
};
static char *wordlist[NUMWORDS] = {
"figgle", "wob", "shim", "fleb", "moobosh", "fonk", "wabble",
"gazoon", "ting", "floo", "zonk", "loof", "lob",
};
static int wcount1 = 0;
static int wcount2 = 0;
static int wstep = 1;
static int jx = 0;
int ix;
int first = TRUE;
glk_set_window(win);
for (ix=0; ix<85; ix++) {
if (ix > 0) {
glk_put_string(" ");
}
if (first) {
glk_put_string(wordcaplist[(ix / 17) % NUMWORDS]);
first = FALSE;
}
glk_put_string(wordlist[jx]);
jx = (jx + wstep) % NUMWORDS;
wcount1++;
if (wcount1 >= NUMWORDS) {
wcount1 = 0;
wstep++;
wcount2++;
if (wcount2 >= NUMWORDS-2) {
wcount2 = 0;
wstep = 1;
}
}
if ((ix % 17) == 16) {
glk_put_string(".");
first = TRUE;
}
}
glk_put_char('\n');
}
/* Print thirty lines. */
static void verb_page(winid_t win)
{
int ix;
char buf[32];
glk_set_window(win);
for (ix=0; ix<30; ix++) {
num_to_str(buf, ix);
glk_put_string(buf);
glk_put_char('\n');
}
}
void center_text(winid_t win, char *text)
{
glui32 width, height;
glk_window_get_size(win, &width, &height);
glk_set_window(win);
glk_window_clear(win);
if(glk_window_get_type(win) == wintype_TextGrid) {
glk_window_move_cursor(win, width / 2 - strlen(text) / 2, height / 2);
glk_put_string(text);
} else if(glk_window_get_type(win) == wintype_TextBuffer) {
int count;
for(count = 0; count < height / 2; count++)
glk_put_char('\n');
for(count = 0;
count < (int)(SPACE_FACTOR * (width / 2 - strlen(text) / 2));
count++)
glk_put_char(' ');
glk_put_string(text);
}
}
/* This draws some corner decorations in *every* key window -- the
one created at startup, and any later ones. It finds them all
with glk_window_iterate. */
static void draw_keywins(void)
{
winid_t win;
glui32 rock;
glui32 width, height;
for (win = glk_window_iterate(NULL, &rock);
win;
win = glk_window_iterate(win, &rock)) {
if (rock == KEYWINROCK) {
glk_set_window(win);
glk_window_clear(win);
glk_window_get_size(win, &width, &height);
glk_window_move_cursor(win, 0, 0);
glk_put_char('O');
glk_window_move_cursor(win, width-1, 0);
glk_put_char('O');
glk_window_move_cursor(win, 0, height-1);
glk_put_char('O');
glk_window_move_cursor(win, width-1, height-1);
glk_put_char('O');
}
}
}
static void mymap_draw(void)
{
int x, y;
int firsty, firstx, lasty, lastx;
int height, width;
firsty = mapheight; firstx = mapwidth;
lasty = 0; lastx = 0;
for(y = 0; y < mapheight; y++) {
for(x = 0; x < mapwidth; x++)
if(mymap[x + y * mapwidth] != ' ') {
if(y < firsty)
firsty = y;
if(y > lasty)
lasty = y;
if(x < firstx)
firstx = x;
if(x > lastx)
lastx = x;
}
}
height = lasty - firsty; width = lastx - firstx;
xoffset = firstx + (width - mapwidth/2) / 2;
yoffset = firsty + (height - mapheight/2) / 2;
if(yoffset >= mapheight/2)
yoffset = mapheight/2 - 1;
if(yoffset <= 1)
yoffset = 2;
if(xoffset >= mapwidth/2)
xoffset = mapwidth/2 - 1;
if(xoffset <= 1)
xoffset = 2;
for(y = 0; y < mapheight/2; y++) {
for(x = 0; x < mapwidth/2; x++)
glk_put_char(mymap[x+xoffset + (y+yoffset) * mapwidth]);
}
}
void glk_main(void)
{
/* Open the main window. */
mainwin = glk_window_open(0, 0, 0, wintype_TextBuffer, 1);
if (!mainwin) {
/* It's possible that the main window failed to open. There's
nothing we can do without it, so exit. */
return;
}
glui32 buffer[1024];
int i;
for(i = 0; i < 512; i++) {
buffer[i * 2] = i + 33;
buffer[i * 2 + 1] = 32;
}
/* frefid_t f = glk_fileref_create_temp(fileusage_BinaryMode, 0);
if(f)
{
strid_t s = glk_stream_open_file(f, filemode_ReadWrite, 0);*/
glui32 membuf[512];
strid_t s = glk_stream_open_memory_uni(membuf, 512, filemode_ReadWrite, 0);
glk_stream_set_current(s);
glk_put_char_uni('X');
glk_put_string("Philip en Marijn zijn vet goed.\n");
glk_put_buffer_uni(buffer, 1024);
glk_stream_set_position(s, 0, seekmode_Start);
glk_set_window(mainwin);
glk_put_char_uni( glk_get_char_stream_uni(s) );
glk_put_char('\n');
printf("Line read: %d\n", glk_get_line_stream_uni(s, buffer, 1024) );
printf("string[5] = %X\n", buffer[5]);
glk_put_string_uni(buffer);
int count = glk_get_buffer_stream_uni(s, buffer, 1024);
printf("Buffer read: %d\n", count);
glk_put_string("\n---SOME CHARACTERS---\n");
glk_put_buffer_uni(buffer, count);
glk_put_string("\n---THE SAME CHARACTERS IN UPPERCASE---\n");
int newcount = glk_buffer_to_upper_case_uni(buffer, 1024, 1024);
glk_put_buffer_uni(buffer, newcount);
stream_result_t result;
glk_stream_close(s, &result);
fprintf(stderr, "Read count: %d\nWrite count: %d\n", result.readcount, result.writecount);
/* glk_fileref_destroy(f);
}*/
glk_set_interrupt_handler(&sayit);
event_t ev;
while(1) {
glk_put_string("\nprompt> ");
glk_request_line_event_uni(mainwin, buffer, 1024, 0);
glk_select(&ev);
switch(ev.type) {
default:
printf("Received event:\n");
printf("Type: %d\n", ev.type);
printf("Win: %d\n", glk_window_get_rock(ev.win) );
printf("Var1: %d\n", ev.val1);
printf("Var2: %d\n", ev.val2);
}
}
/* Bye bye */
glk_exit();
}
git_sint32 saveToFile (git_sint32 * base, git_sint32 * sp, git_sint32 id)
{
git_uint32 n, zeroCount;
glui32 fileSize, fileSizePos;
glui32 memSize, memSizePos;
glui32 heapSize;
glui32* heap;
strid_t file, oldFile;
// Find out what stream they want to use, and make sure it's valid.
file = git_find_stream_by_id (id);
if (file == 0)
return 1;
// Get the state of the heap.
if (heap_get_summary (&heapSize, &heap))
fatalError ("Couldn't get heap summary");
// Make the given stream the default.
oldFile = glk_stream_get_current ();
glk_stream_set_current (file);
// Write Quetzal header.
glk_put_string ("FORM");
fileSizePos = glk_stream_get_position (file);
writeWord (0);
glk_put_string ("IFZS");
// Header chunk.
glk_put_string ("IFhd");
writeWord (128);
glk_put_buffer ((char *) gRom, 128);
// Stack chunk.
glk_put_string ("Stks");
writeWord ((sp - base) * 4);
for (n = 0 ; n < (git_uint32) (sp - base) ; ++n)
writeWord (base [n]);
// Heap chunk.
if (heap != 0)
{
glk_put_string ("MAll");
writeWord (heapSize * 4);
for (n = 0 ; n < heapSize ; ++n)
writeWord (heap [n]);
free(heap);
}
// Memory chunk.
glk_put_string ("CMem");
memSizePos = glk_stream_get_position (file);
writeWord (0);
writeWord (gEndMem);
for (zeroCount = 0, n = gRamStart ; n < gEndMem ; ++n)
{
unsigned char romC = (n < gExtStart) ? gRom[n] : 0;
unsigned char c = ((git_uint32) romC) ^ ((git_uint32) gRam[n]);
if (c == 0)
++zeroCount;
else
{
for ( ; zeroCount > 256 ; zeroCount -= 256)
{
glk_put_char (0);
glk_put_char (0xff);
}
if (zeroCount > 0)
{
glk_put_char (0);
glk_put_char ((char) (zeroCount - 1));
zeroCount = 0;
}
glk_put_char (c);
}
}
// Note: we don't bother writing out any remaining zeroes,
// because the memory is padded out with zeroes on restore.
memSize = glk_stream_get_position (file) - memSizePos - 4;
if (memSize & 1)
glk_put_char (0);
// Back up and fill in the lengths.
fileSize = glk_stream_get_position (file) - fileSizePos - 4;
glk_stream_set_position (file, fileSizePos, seekmode_Start);
writeWord (fileSize);
glk_stream_set_position (file, memSizePos, seekmode_Start);
writeWord (memSize);
// Restore the previous default stream.
glk_stream_set_current (oldFile);
// And we're done.
return 0;
}
uint Glulxe::perform_glk(uint funcnum, uint numargs, uint *arglist) {
uint retval = 0;
switch (funcnum) {
/* To speed life up, we implement commonly-used Glk functions
directly -- instead of bothering with the whole prototype
mess. */
case 0x0047: /* stream_set_current */
if (numargs != 1)
goto WrongArgNum;
glk_stream_set_current(find_stream_by_id(arglist[0]));
break;
case 0x0048: /* stream_get_current */
if (numargs != 0)
goto WrongArgNum;
retval = find_id_for_stream(glk_stream_get_current());
break;
case 0x0080: /* put_char */
if (numargs != 1)
goto WrongArgNum;
glk_put_char(arglist[0] & 0xFF);
break;
case 0x0081: /* put_char_stream */
if (numargs != 2)
goto WrongArgNum;
glk_put_char_stream(find_stream_by_id(arglist[0]), arglist[1] & 0xFF);
break;
case 0x00C0: /* select */
/* call a library hook on every glk_select() */
if (library_select_hook)
library_select_hook(arglist[0]);
/* but then fall through to full dispatcher, because there's no real
need for speed here */
goto FullDispatcher;
case 0x00A0: /* char_to_lower */
if (numargs != 1)
goto WrongArgNum;
retval = glk_char_to_lower(arglist[0] & 0xFF);
break;
case 0x00A1: /* char_to_upper */
if (numargs != 1)
goto WrongArgNum;
retval = glk_char_to_upper(arglist[0] & 0xFF);
break;
case 0x0128: /* put_char_uni */
if (numargs != 1)
goto WrongArgNum;
glk_put_char_uni(arglist[0]);
break;
case 0x012B: /* put_char_stream_uni */
if (numargs != 2)
goto WrongArgNum;
glk_put_char_stream_uni(find_stream_by_id(arglist[0]), arglist[1]);
break;
WrongArgNum:
error("Wrong number of arguments to Glk function.");
break;
FullDispatcher:
default: {
/* Go through the full dispatcher prototype foo. */
const char *proto, *cx;
dispatch_splot_t splot;
int argnum, argnum2;
/* Grab the string. */
proto = gidispatch_prototype(funcnum);
if (!proto)
error("Unknown Glk function.");
splot.varglist = arglist;
splot.numvargs = numargs;
splot.retval = &retval;
/* The work goes in four phases. First, we figure out how many
arguments we want, and allocate space for the Glk argument
list. Then we go through the Glulxe arguments and load them
into the Glk list. Then we call. Then we go through the
arguments again, unloading the data back into Glulx memory. */
/* Phase 0. */
prepare_glk_args(proto, &splot);
/* Phase 1. */
argnum = 0;
cx = proto;
parse_glk_args(&splot, &cx, 0, &argnum, 0, 0);
/* Phase 2. */
gidispatch_call(funcnum, argnum, splot.garglist);
/* Phase 3. */
argnum2 = 0;
cx = proto;
unparse_glk_args(&splot, &cx, 0, &argnum2, 0, 0);
if (argnum != argnum2)
error("Argument counts did not match.");
break;
}
}
return retval;
}
static void accel_error(char *msg)
{
glk_put_char('\n');
glk_put_string(msg);
glk_put_char('\n');
}
/*======================================================================*/
void statusline(void)
{
#ifdef HAVE_GLK
glui32 glkWidth;
char line[100];
int pcol = col;
if (!statusLineOption) return;
if (glkStatusWin == NULL)
return;
glk_set_window(glkStatusWin);
glk_window_clear(glkStatusWin);
glk_window_get_size(glkStatusWin, &glkWidth, NULL);
#ifdef HAVE_GARGLK
int i;
glk_set_style(style_User1);
for (i = 0; i < glkWidth; i++)
glk_put_char(' ');
#endif
onStatusLine = TRUE;
col = 1;
glk_window_move_cursor(glkStatusWin, 1, 0);
sayInstance(where(HERO, TRUE));
// TODO Add status message1 & 2 as author customizable messages
if (header->maximumScore > 0)
sprintf(line, "Score %d(%d)/%d moves", current.score, (int)header->maximumScore, current.tick);
else
sprintf(line, "%d moves", current.tick);
glk_window_move_cursor(glkStatusWin, glkWidth-strlen(line)-1, 0);
glk_put_string(line);
needSpace = FALSE;
col = pcol;
onStatusLine = FALSE;
glk_set_window(glkMainWin);
#else
#ifdef HAVE_ANSI
char line[100];
int i;
int pcol = col;
if (!statusLineOption) return;
/* ansi_position(1,1); ansi_bold_on(); */
printf("\x1b[1;1H");
printf("\x1b[7m");
onStatusLine = TRUE;
col = 1;
sayInstance(where(HERO, FALSE));
if (header->maximumScore > 0)
sprintf(line, "Score %d(%d)/%d moves", current.score, header->maximumScore, current.tick);
else
sprintf(line, "%ld moves", (long)current.tick);
for (i=0; i < pageWidth - col - strlen(line); i++) putchar(' ');
printf(line);
printf("\x1b[m");
printf("\x1b[%d;1H", pageLength);
needSpace = FALSE;
capitalize = TRUE;
onStatusLine = FALSE;
col = pcol;
#endif
#endif
}
static zword smart_tokeniser(zword dictionarytable,
const char *text, unsigned length, BOOL is_begin)
{
zword word_num = 0;
unsigned tlength = (length < 12) ? length : 12;
char tbuffer[13];
/* Letter replacements are tried in this order - */
const char fixmeletters[] = "abcdefghijklmnopqrstuvwxyz";
/* char fixmeletters[] = "etaonrishdlfcmugpywbvkxjqz"; */
word_num = find_word(dictionarytable, text, length);
/* Some game files don't contain abbreviations for common commands */
if(!word_num && do_expand && length == 1 && is_begin) {
const char * const abbrevs[26] = {
"a", "b", "close", "down",
"east", "f", "again", "h",
"inventory", "j", "attack", "look",
"m", "north", "oops", "open",
"quit", "drop", "south", "take",
"up", "v", "west", "examine",
"yes", "wait"
};
if('a' <= text[0] && text[0] <= 'z') {
strcpy(tbuffer, abbrevs[text[0] - 'a']);
tlength = strlen(tbuffer);
word_num = find_word(dictionarytable, tbuffer, tlength);
}
}
/* Check for various typing errors */
/* Don't attempt typo correction in very short words */
if(do_spell_correct && length >= 3) {
if(!word_num) { /* Check for transposes */
/* To fix, try all possible transposes */
unsigned position;
for(position = 1; position < tlength; position++) {
unsigned s;
for(s = 0; s < tlength; s++)
tbuffer[s] = text[s];
tbuffer[position - 1] = text[position];
tbuffer[position] = text[position - 1];
word_num = find_word(dictionarytable, tbuffer, tlength);
if(word_num)
break;
}
}
if(!word_num) { /* Check for deletions */
/* To fix, try all possible insertions */
unsigned position;
for(position = 0; position <= tlength; position++) {
unsigned s;
for(s = 0; s < position; s++) /* letters before the insertion */
tbuffer[s] = text[s];
for(s = position; s < tlength; s++) /* after the insertion */
tbuffer[s + 1] = text[s];
/* try each letter */
for(s = 0; s < sizeof(fixmeletters); s++) {
tbuffer[position] = fixmeletters[s];
word_num = find_word(dictionarytable, tbuffer, tlength + 1);
if(word_num)
break;
}
if(word_num) {
tlength++;
break;
}
}
}
if(!word_num) { /* Check for insertions */
/* To fix, try all possible deletions */
unsigned position;
for(position = 0; position < tlength; position++) {
unsigned s;
for(s = 0; s < position; s++) /* letters before the deletion */
tbuffer[s] = text[s];
for(s = position + 1; s < tlength; s++) /* after the deletion */
tbuffer[s - 1] = text[s];
word_num = find_word(dictionarytable, tbuffer, tlength - 1);
if(word_num) {
tlength--;
break;
}
}
}
if(!word_num) { /* Check for substitutions */
/* To fix, try all possible substitutions */
unsigned position;
for(position = 0; position < tlength; position++) {
unsigned s;
for(s = 0; s < tlength; s++)
tbuffer[s] = text[s];
/* try each letter */
for(s = 0; s < sizeof(fixmeletters); s++) {
tbuffer[position] = fixmeletters[s];
word_num = find_word(dictionarytable, tbuffer, tlength);
if(word_num)
break;
}
if(word_num)
break;
}
}
}
/* Report any corrections made */
if(word_num) {
struct Typocorrection *p;
char original[13], changedto[13];
n_strncpy(original, text, 13);
n_strncpy(changedto, tbuffer, 13);
if(length < 13)
original[length] = 0;
if(tlength < 13)
changedto[tlength] = 0;
LEsearch(recent_corrections, p, ((n_strncmp(p->original, original, 13) == 0) &&
(n_strncmp(p->changedto, changedto, 13) == 0)));
/* Only print a correction if it hasn't yet been reported this turn */
if(!p) {
struct Typocorrection newcorrection;
n_strncpy(newcorrection.original, original, 13);
n_strncpy(newcorrection.changedto, changedto, 13);
LEadd(recent_corrections, newcorrection);
set_glk_stream_current();
if(allow_output) {
glk_put_char('[');
w_glk_put_buffer(text, length);
w_glk_put_string(" -> ");
w_glk_put_buffer(tbuffer, tlength);
glk_put_char(']');
glk_put_char(10);
}
}
}
return word_num;
}
void glk_put_buffer(char *buf, glui32 len) {
for (int i=0; i<len; i++) {
glk_put_char(buf[i]);
}
}
/* React to character input in a key window. */
static void perform_key(winid_t win, glui32 key)
{
glui32 width, height, len;
int ix;
char buf[128], keyname[64];
if (key == 'h' || key == 'v') {
winid_t newwin;
glui32 loc;
/* Open a new keywindow. */
if (key == 'h')
loc = winmethod_Right | winmethod_Proportional;
else
loc = winmethod_Below | winmethod_Proportional;
newwin = glk_window_open(win,
loc, 50, wintype_TextGrid, KEYWINROCK);
/* Since the new window has rock value KEYWINROCK, the
draw_keywins() routine will redraw it. */
if (newwin) {
/* Request character input. In this program, only keywins
get char input, so the CharInput events always call
perform_key() -- and so the new window will respond
to keys just as this one does. */
glk_request_char_event(newwin);
/* We now have to redraw the keywins, because any or all of
them could have changed size when we opened newwin.
glk_window_open() does not generate Arrange events; we
have to do the redrawing manually. */
draw_keywins();
}
/* Re-request character input for this window, so that future
keys are accepted. */
glk_request_char_event(win);
return;
}
else if (key == 'c') {
/* Close this keywindow. */
glk_window_close(win, NULL);
/* Again, any key windows could have changed size. Also the
status window could have (if this was the last key window). */
draw_keywins();
draw_statuswin();
return;
}
/* Print a string naming the key that was just hit. */
switch (key) {
case ' ':
str_cpy(keyname, "space");
break;
case keycode_Left:
str_cpy(keyname, "left");
break;
case keycode_Right:
str_cpy(keyname, "right");
break;
case keycode_Up:
str_cpy(keyname, "up");
break;
case keycode_Down:
str_cpy(keyname, "down");
break;
case keycode_Return:
str_cpy(keyname, "return");
break;
case keycode_Delete:
str_cpy(keyname, "delete");
break;
case keycode_Escape:
str_cpy(keyname, "escape");
break;
case keycode_Tab:
str_cpy(keyname, "tab");
break;
case keycode_PageUp:
str_cpy(keyname, "page up");
break;
case keycode_PageDown:
str_cpy(keyname, "page down");
break;
case keycode_Home:
str_cpy(keyname, "home");
break;
case keycode_End:
str_cpy(keyname, "end");
break;
default:
if (key <= keycode_Func1 && key >= keycode_Func12) {
str_cpy(keyname, "function key");
}
else if (key < 32) {
str_cpy(keyname, "ctrl-");
keyname[5] = '@' + key;
keyname[6] = '\0';
}
else if (key <= 255) {
keyname[0] = key;
keyname[1] = '\0';
}
else {
str_cpy(keyname, "unknown key");
}
break;
}
str_cpy(buf, "Key: ");
str_cat(buf, keyname);
len = str_len(buf);
/* Print the string centered in this window. */
glk_set_window(win);
glk_window_get_size(win, &width, &height);
glk_window_move_cursor(win, 0, height/2);
for (ix=0; ix<width; ix++)
glk_put_char(' ');
width = width/2;
len = len/2;
if (width > len)
width = width-len;
else
width = 0;
glk_window_move_cursor(win, width, height/2);
glk_put_string(buf);
/* Re-request character input for this window, so that future
keys are accepted. */
glk_request_char_event(win);
}
void gidispatch_call(glui32 funcnum, glui32 numargs, gluniversal_t *arglist)
{
gidispatch_function_t *gidispatch_function;
char *prototype;
int argument = 0;
int slot = 0;
gidispatch_function = gidispatch_get_function_by_id(funcnum);
prototype = gidispatch_prototype(funcnum);
printf("DEBUG: dispatch call name=%s, prototype=%s, numargs=%u -- ", gidispatch_function->name, prototype, (unsigned int)numargs);
if (strcmp(prototype, "4IuIuIuIs") == 0) {
printf("%u, %u, %u, %d\n", arglist[0].uint, arglist[1].uint, arglist[2].uint, arglist[3].sint);
} else if (strcmp(prototype, "3IuIu:Iu") == 0) {
printf("%u, %u, returning a glui32\n", arglist[0].uint, arglist[1].uint);
} else if (strcmp(prototype, "3Qa<Iu:Qa") == 0) {
printf("win at %p, outref to a glui32, returning a winid_t\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "3Qc<Iu:Qc") == 0) {
printf("fileref at %p, outref to a glui32, returning a frefid_t\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "1Qa:") == 0) {
printf("win at %p\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "6QaIuIuIuIu:Qa") == 0) {
printf("win at %p, %u, %u, %u, %u, returning a winid_t\n", arglist[0].opaqueref, arglist[1].uint, arglist[2].uint, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "4IuIuIuIs:") == 0) {
printf("%u, %u, %u, %d\n", arglist[0].uint, arglist[1].uint, arglist[2].uint, arglist[3].sint);
} else if (strcmp(prototype, "1Qb:") == 0) {
printf("stream at %p\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "1Iu:") == 0) {
printf("%u\n", arglist[0].uint);
} else if (strcmp(prototype, "2Qb<[2IuIu]:") == 0) {
printf("stream at %p, some struct stuff here\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "3IuIuIu:") == 0) {
printf("%u, %u, %u\n", arglist[0].uint, arglist[1].uint, arglist[2].uint);
} else if (strcmp(prototype, "1:Qb") == 0) {
printf("returning a strid_t\n");
} else if (strcmp(prototype, "4&+#!IuIuIu:Qb") == 0) {
printf("retained, nonnull, array of glui32 at %p for length %u, %u, %u, returning a strid_t\n", arglist[1].array, arglist[2].uint, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "2Qc:Iu") == 0) {
printf("fileref at %p, returning a glui32\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "1<+[4IuQaIuIu]:") == 0) {
printf("some struct stuff here, nonnull\n");
} else if (strcmp(prototype, "1:Qb") == 0) {
printf("returning a strid_t\n");
} else if (strcmp(prototype, "2Qb:Is") == 0) {
printf("stream at %p, returning a glsi32\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "2Qc:Iu") == 0) {
printf("fileref at %p, returning a glui32\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "3Qa&+#!CnIu:") == 0) {
printf("win at %p, retained, nonnull, array of char at %p for length %u, %u\n", arglist[0].opaqueref, arglist[2].array, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "3Qb<Iu:Qb") == 0) {
printf("stream at %p, outref to a glui32, returning a strid_t\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "4&+#!CnIuIu:Qb") == 0) {
printf("retained, nonnull, array of char at %p for length %u, %u, %u, returning a strid_t\n", arglist[1].array, arglist[2].uint, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "4&+#!IuIuIu:Qb") == 0) {
printf("retained, nonnull, array of glui32 at %p for length %u, %u, %u, returning a strid_t\n", arglist[1].array, arglist[2].uint, arglist[3].uint, arglist[4].uint);
} else if (strcmp(prototype, "4IuSIu:Qc") == 0) {
printf("%u, %s, %u, returning a frefid_t\n", arglist[0].uint, arglist[1].charstr, arglist[2].uint);
} else if (strcmp(prototype, "4QcIuIu:Qb") == 0) {
printf("fileref at %p, %u, %u, returning a strid_t\n", arglist[0].opaqueref, arglist[1].uint, arglist[2].uint);
} else if (strcmp(prototype, "3Qa<Iu<Iu:") == 0) {
printf("win at %p, outref to a glui32, outref to a glui32\n", arglist[0].opaqueref);
} else if (strcmp(prototype, "6QaIuIsIsIuIu:") == 0) {
printf("win at %p, %u, %d, %d, %u, %u\n", arglist[0].opaqueref, arglist[1].uint, arglist[2].sint, arglist[3].sint, arglist[4].uint, arglist[5].uint);
} else if (strcmp(prototype, "4Iu<Iu<Iu:Iu") == 0) {
printf("%u, outref to a glui32, outref to a glui32, returning a glui32\n", arglist[0].uint);
} else {
printf("unhandled prototype\n");
}
switch (funcnum) {
case 0x0004: /* gestalt */
arglist[3].uint = glk_gestalt(arglist[0].uint, arglist[1].uint);
break;
case 0x0005: /* gestalt_ext */
if (arglist[2].ptrflag) {
arglist[6].uint = glk_gestalt_ext(arglist[0].uint, arglist[1].uint,
arglist[3].array, arglist[4].uint);
}
else {
arglist[4].uint = glk_gestalt_ext(arglist[0].uint, arglist[1].uint,
NULL, 0);
}
break;
case 0x0020: /* window_iterate */
if (arglist[1].ptrflag)
arglist[4].opaqueref = glk_window_iterate(arglist[0].opaqueref, &arglist[2].uint);
else
arglist[3].opaqueref = glk_window_iterate(arglist[0].opaqueref, NULL);
break;
case 0x0023: /* window_open */
arglist[6].opaqueref = glk_window_open(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint, arglist[3].uint, arglist[4].uint);
break;
case 0x0025: /* window_get_size */
{
int ix = 1;
glui32 *ptr1, *ptr2;
if (!arglist[ix].ptrflag) {
ptr1 = NULL;
}
else {
ix++;
ptr1 = &(arglist[ix].uint);
}
ix++;
if (!arglist[ix].ptrflag) {
ptr2 = NULL;
}
else {
ix++;
ptr2 = &(arglist[ix].uint);
}
ix++;
glk_window_get_size(arglist[0].opaqueref, ptr1, ptr2);
}
break;
case 0x0028: /* window_get_type */
arglist[2].uint = glk_window_get_type(arglist[0].opaqueref);
break;
case 0x002A: /* window_clear */
glk_window_clear(arglist[0].opaqueref);
break;
case 0x002B: /* window_move_cursor */
glk_window_move_cursor(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint);
break;
case 0x002F: /* set_window */
glk_set_window(arglist[0].opaqueref);
break;
case 0x0040: /* stream_iterate */
if (arglist[1].ptrflag)
arglist[4].opaqueref = glk_stream_iterate(arglist[0].opaqueref, &arglist[2].uint);
else
arglist[3].opaqueref = glk_stream_iterate(arglist[0].opaqueref, NULL);
break;
case 0x0042: /* stream_open_file */
arglist[4].opaqueref = glk_stream_open_file(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint);
break;
case 0x0043: /* stream_open_memory */
if (arglist[0].ptrflag)
arglist[6].opaqueref = glk_stream_open_memory(arglist[1].array,
arglist[2].uint, arglist[3].uint, arglist[4].uint);
else
arglist[4].opaqueref = glk_stream_open_memory(NULL,
0, arglist[1].uint, arglist[2].uint);
break;
case 0x0044: /* stream_close */
if (arglist[1].ptrflag) {
stream_result_t dat;
glk_stream_close(arglist[0].opaqueref, &dat);
arglist[2].uint = dat.readcount;
arglist[3].uint = dat.writecount;
}
else {
glk_stream_close(arglist[0].opaqueref, NULL);
}
break;
case 0x0047: /* stream_set_current */
glk_stream_set_current(arglist[0].opaqueref);
break;
case 0x0048: /* stream_get_current */
arglist[1].opaqueref = glk_stream_get_current();
break;
case 0x0061: /* fileref_create_by_name */
arglist[4].opaqueref = glk_fileref_create_by_name(arglist[0].uint,
arglist[1].charstr, arglist[2].uint);
break;
case 0x0062: /* fileref_create_by_prompt */
arglist[4].opaqueref = glk_fileref_create_by_prompt(arglist[0].uint,
arglist[1].uint, arglist[2].uint);
break;
case 0x0067: /* fileref_does_file_exist */
arglist[2].uint = glk_fileref_does_file_exist(arglist[0].opaqueref);
break;
case 0x0086: /* set_style */
glk_set_style(arglist[0].uint);
break;
case 0x0087: /* set_style_stream */
glk_set_style_stream(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x0090: /* get_char_stream */
arglist[2].sint = glk_get_char_stream(arglist[0].opaqueref);
break;
case 0x00B0: /* stylehint_set */
glk_stylehint_set(arglist[0].uint, arglist[1].uint,
arglist[2].uint, arglist[3].sint);
break;
case 0x00C0: /* select */
if (arglist[0].ptrflag) {
event_t dat;
glk_select(&dat);
arglist[1].uint = dat.type;
arglist[2].opaqueref = dat.win;
arglist[3].uint = dat.val1;
arglist[4].uint = dat.val2;
}
else {
glk_select(NULL);
}
break;
case 0x00D0: /* request_line_event */
if (arglist[1].ptrflag)
glk_request_line_event(arglist[0].opaqueref, arglist[2].array,
arglist[3].uint, arglist[4].uint);
else
glk_request_line_event(arglist[0].opaqueref, NULL,
0, arglist[2].uint);
break;
case 0x00D2: /* request_char_event */
glk_request_char_event(arglist[0].opaqueref);
break;
case 0x00E0: /* image_get_info */
{
int ix = 1;
glui32 *ptr1, *ptr2;
if (!arglist[ix].ptrflag) {
ptr1 = NULL;
}
else {
ix++;
ptr1 = &(arglist[ix].uint);
}
ix++;
if (!arglist[ix].ptrflag) {
ptr2 = NULL;
}
else {
ix++;
ptr2 = &(arglist[ix].uint);
}
ix++;
ix++;
arglist[ix].uint = glk_image_get_info(arglist[0].uint, ptr1, ptr2);
}
break;
case 0x00E1: /* image_draw */
arglist[5].uint = glk_image_draw(arglist[0].opaqueref,
arglist[1].uint,
arglist[2].sint, arglist[3].sint);
break;
case 0x00E2: /* image_draw_scaled */
arglist[7].uint = glk_image_draw_scaled(arglist[0].opaqueref,
arglist[1].uint,
arglist[2].sint, arglist[3].sint,
arglist[4].uint, arglist[5].uint);
break;
case 0x00EA: /* window_fill_rect */
glk_window_fill_rect(arglist[0].opaqueref, arglist[1].uint,
arglist[2].sint, arglist[3].sint,
arglist[4].uint, arglist[5].uint);
break;
case 0x0128: /* put_char_uni */
glk_put_char_uni(arglist[0].uint);
break;
case 0x0139: /* stream_open_memory_uni */
if (arglist[0].ptrflag)
arglist[6].opaqueref = glk_stream_open_memory_uni(arglist[1].array,
arglist[2].uint, arglist[3].uint, arglist[4].uint);
else
arglist[4].opaqueref = glk_stream_open_memory_uni(NULL,
0, arglist[1].uint, arglist[2].uint);
break;
default:
printf("Unhandled call to %s via dispatch\n", gidispatch_function->name);
#if 0
case 0x0001: /* exit */
glk_exit();
break;
case 0x0002: /* set_interrupt_handler */
/* cannot be invoked through dispatch layer */
break;
case 0x0003: /* tick */
glk_tick();
break;
case 0x0021: /* window_get_rock */
arglist[2].uint = glk_window_get_rock(arglist[0].opaqueref);
break;
case 0x0022: /* window_get_root */
arglist[1].opaqueref = glk_window_get_root();
break;
case 0x0024: /* window_close */
if (arglist[1].ptrflag) {
stream_result_t dat;
glk_window_close(arglist[0].opaqueref, &dat);
arglist[2].uint = dat.readcount;
arglist[3].uint = dat.writecount;
}
else {
glk_window_close(arglist[0].opaqueref, NULL);
}
break;
case 0x0026: /* window_set_arrangement */
glk_window_set_arrangement(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint, arglist[3].opaqueref);
break;
case 0x0027: /* window_get_arrangement */
{
int ix = 1;
glui32 *ptr1, *ptr2;
winid_t *ptr3;
if (!arglist[ix].ptrflag) {
ptr1 = NULL;
}
else {
ix++;
ptr1 = &(arglist[ix].uint);
}
ix++;
if (!arglist[ix].ptrflag) {
ptr2 = NULL;
}
else {
ix++;
ptr2 = &(arglist[ix].uint);
}
ix++;
if (!arglist[ix].ptrflag) {
ptr3 = NULL;
}
else {
ix++;
ptr3 = (winid_t *)(&(arglist[ix].opaqueref));
}
ix++;
glk_window_get_arrangement(arglist[0].opaqueref, ptr1, ptr2, ptr3);
}
break;
case 0x0029: /* window_get_parent */
arglist[2].opaqueref = glk_window_get_parent(arglist[0].opaqueref);
break;
case 0x002C: /* window_get_stream */
arglist[2].opaqueref = glk_window_get_stream(arglist[0].opaqueref);
break;
case 0x002D: /* window_set_echo_stream */
glk_window_set_echo_stream(arglist[0].opaqueref, arglist[1].opaqueref);
break;
case 0x002E: /* window_get_echo_stream */
arglist[2].opaqueref = glk_window_get_echo_stream(arglist[0].opaqueref);
break;
case 0x0030: /* window_get_sibling */
arglist[2].opaqueref = glk_window_get_sibling(arglist[0].opaqueref);
break;
case 0x0041: /* stream_get_rock */
arglist[2].uint = glk_stream_get_rock(arglist[0].opaqueref);
break;
case 0x0045: /* stream_set_position */
glk_stream_set_position(arglist[0].opaqueref, arglist[1].sint,
arglist[2].uint);
break;
case 0x0046: /* stream_get_position */
arglist[2].uint = glk_stream_get_position(arglist[0].opaqueref);
break;
case 0x0048: /* stream_get_current */
arglist[1].opaqueref = glk_stream_get_current();
break;
case 0x0060: /* fileref_create_temp */
arglist[3].opaqueref = glk_fileref_create_temp(arglist[0].uint,
arglist[1].uint);
break;
case 0x0063: /* fileref_destroy */
glk_fileref_destroy(arglist[0].opaqueref);
break;
case 0x0064: /* fileref_iterate */
if (arglist[1].ptrflag)
arglist[4].opaqueref = glk_fileref_iterate(arglist[0].opaqueref, &arglist[2].uint);
else
arglist[3].opaqueref = glk_fileref_iterate(arglist[0].opaqueref, NULL);
break;
case 0x0065: /* fileref_get_rock */
arglist[2].uint = glk_fileref_get_rock(arglist[0].opaqueref);
break;
case 0x0066: /* fileref_delete_file */
glk_fileref_delete_file(arglist[0].opaqueref);
break;
case 0x0068: /* fileref_create_from_fileref */
arglist[4].opaqueref = glk_fileref_create_from_fileref(arglist[0].uint,
arglist[1].opaqueref, arglist[2].uint);
break;
case 0x0080: /* put_char */
glk_put_char(arglist[0].uch);
break;
case 0x0081: /* put_char_stream */
glk_put_char_stream(arglist[0].opaqueref, arglist[1].uch);
break;
case 0x0082: /* put_string */
glk_put_string(arglist[0].charstr);
break;
case 0x0083: /* put_string_stream */
glk_put_string_stream(arglist[0].opaqueref, arglist[1].charstr);
break;
case 0x0084: /* put_buffer */
if (arglist[0].ptrflag)
glk_put_buffer(arglist[1].array, arglist[2].uint);
else
glk_put_buffer(NULL, 0);
break;
case 0x0085: /* put_buffer_stream */
if (arglist[1].ptrflag)
glk_put_buffer_stream(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
glk_put_buffer_stream(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0091: /* get_line_stream */
if (arglist[1].ptrflag)
arglist[5].uint = glk_get_line_stream(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
arglist[3].uint = glk_get_line_stream(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0092: /* get_buffer_stream */
if (arglist[1].ptrflag)
arglist[5].uint = glk_get_buffer_stream(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
arglist[3].uint = glk_get_buffer_stream(arglist[0].opaqueref,
NULL, 0);
break;
case 0x00A0: /* char_to_lower */
arglist[2].uch = glk_char_to_lower(arglist[0].uch);
break;
case 0x00A1: /* char_to_upper */
arglist[2].uch = glk_char_to_upper(arglist[0].uch);
break;
case 0x00B1: /* stylehint_clear */
glk_stylehint_clear(arglist[0].uint, arglist[1].uint,
arglist[2].uint);
break;
case 0x00B2: /* style_distinguish */
arglist[4].uint = glk_style_distinguish(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint);
break;
case 0x00B3: /* style_measure */
if (arglist[3].ptrflag)
arglist[6].uint = glk_style_measure(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint, &(arglist[4].uint));
else
arglist[5].uint = glk_style_measure(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint, NULL);
break;
case 0x00C1: /* select_poll */
if (arglist[0].ptrflag) {
event_t dat;
glk_select_poll(&dat);
arglist[1].uint = dat.type;
arglist[2].opaqueref = dat.win;
arglist[3].uint = dat.val1;
arglist[4].uint = dat.val2;
}
else {
glk_select_poll(NULL);
}
break;
case 0x00D1: /* cancel_line_event */
if (arglist[1].ptrflag) {
event_t dat;
glk_cancel_line_event(arglist[0].opaqueref, &dat);
arglist[2].uint = dat.type;
arglist[3].opaqueref = dat.win;
arglist[4].uint = dat.val1;
arglist[5].uint = dat.val2;
}
else {
glk_cancel_line_event(arglist[0].opaqueref, NULL);
}
break;
case 0x00D3: /* cancel_char_event */
glk_cancel_char_event(arglist[0].opaqueref);
break;
case 0x00D4: /* request_mouse_event */
glk_request_mouse_event(arglist[0].opaqueref);
break;
case 0x00D5: /* cancel_mouse_event */
glk_cancel_mouse_event(arglist[0].opaqueref);
break;
case 0x00D6: /* request_timer_events */
glk_request_timer_events(arglist[0].uint);
break;
#ifdef GLK_MODULE_IMAGE
case 0x00E8: /* window_flow_break */
glk_window_flow_break(arglist[0].opaqueref);
break;
case 0x00E9: /* window_erase_rect */
glk_window_erase_rect(arglist[0].opaqueref,
arglist[1].sint, arglist[2].sint,
arglist[3].uint, arglist[4].uint);
break;
case 0x00EB: /* window_set_background_color */
glk_window_set_background_color(arglist[0].opaqueref, arglist[1].uint);
break;
#endif /* GLK_MODULE_IMAGE */
#ifdef GLK_MODULE_SOUND
case 0x00F0: /* schannel_iterate */
if (arglist[1].ptrflag)
arglist[4].opaqueref = glk_schannel_iterate(arglist[0].opaqueref, &arglist[2].uint);
else
arglist[3].opaqueref = glk_schannel_iterate(arglist[0].opaqueref, NULL);
break;
case 0x00F1: /* schannel_get_rock */
arglist[2].uint = glk_schannel_get_rock(arglist[0].opaqueref);
break;
case 0x00F2: /* schannel_create */
arglist[2].opaqueref = glk_schannel_create(arglist[0].uint);
break;
case 0x00F3: /* schannel_destroy */
glk_schannel_destroy(arglist[0].opaqueref);
break;
case 0x00F8: /* schannel_play */
arglist[3].uint = glk_schannel_play(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x00F9: /* schannel_play_ext */
arglist[5].uint = glk_schannel_play_ext(arglist[0].opaqueref,
arglist[1].uint, arglist[2].uint, arglist[3].uint);
break;
case 0x00FA: /* schannel_stop */
glk_schannel_stop(arglist[0].opaqueref);
break;
case 0x00FB: /* schannel_set_volume */
glk_schannel_set_volume(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x00FC: /* sound_load_hint */
glk_sound_load_hint(arglist[0].uint, arglist[1].uint);
break;
#endif /* GLK_MODULE_SOUND */
#ifdef GLK_MODULE_HYPERLINKS
case 0x0100: /* set_hyperlink */
glk_set_hyperlink(arglist[0].uint);
break;
case 0x0101: /* set_hyperlink_stream */
glk_set_hyperlink_stream(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x0102: /* request_hyperlink_event */
glk_request_hyperlink_event(arglist[0].opaqueref);
break;
case 0x0103: /* cancel_hyperlink_event */
glk_cancel_hyperlink_event(arglist[0].opaqueref);
break;
#endif /* GLK_MODULE_HYPERLINKS */
#ifdef GLK_MODULE_UNICODE
case 0x0120: /* buffer_to_lower_case_uni */
if (arglist[0].ptrflag)
arglist[5].uint = glk_buffer_to_lower_case_uni(arglist[1].array, arglist[2].uint, arglist[3].uint);
else
arglist[3].uint = glk_buffer_to_lower_case_uni(NULL, 0, arglist[1].uint);
break;
case 0x0121: /* buffer_to_upper_case_uni */
if (arglist[0].ptrflag)
arglist[5].uint = glk_buffer_to_upper_case_uni(arglist[1].array, arglist[2].uint, arglist[3].uint);
else
arglist[3].uint = glk_buffer_to_upper_case_uni(NULL, 0, arglist[1].uint);
break;
case 0x0122: /* buffer_to_title_case_uni */
if (arglist[0].ptrflag)
arglist[6].uint = glk_buffer_to_title_case_uni(arglist[1].array, arglist[2].uint, arglist[3].uint, arglist[4].uint);
else
arglist[4].uint = glk_buffer_to_title_case_uni(NULL, 0, arglist[1].uint, arglist[2].uint);
break;
case 0x0129: /* put_string_uni */
glk_put_string_uni(arglist[0].unicharstr);
break;
case 0x012A: /* put_buffer_uni */
if (arglist[0].ptrflag)
glk_put_buffer_uni(arglist[1].array, arglist[2].uint);
else
glk_put_buffer_uni(NULL, 0);
break;
case 0x012B: /* put_char_stream_uni */
glk_put_char_stream_uni(arglist[0].opaqueref, arglist[1].uint);
break;
case 0x012C: /* put_string_stream_uni */
glk_put_string_stream_uni(arglist[0].opaqueref, arglist[1].unicharstr);
break;
case 0x012D: /* put_buffer_stream_uni */
if (arglist[1].ptrflag)
glk_put_buffer_stream_uni(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
glk_put_buffer_stream_uni(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0130: /* get_char_stream_uni */
arglist[2].sint = glk_get_char_stream_uni(arglist[0].opaqueref);
break;
case 0x0131: /* get_buffer_stream_uni */
if (arglist[1].ptrflag)
arglist[5].uint = glk_get_buffer_stream_uni(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
arglist[3].uint = glk_get_buffer_stream_uni(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0132: /* get_line_stream_uni */
if (arglist[1].ptrflag)
arglist[5].uint = glk_get_line_stream_uni(arglist[0].opaqueref,
arglist[2].array, arglist[3].uint);
else
arglist[3].uint = glk_get_line_stream_uni(arglist[0].opaqueref,
NULL, 0);
break;
case 0x0138: /* stream_open_file_uni */
arglist[4].opaqueref = glk_stream_open_file_uni(arglist[0].opaqueref, arglist[1].uint,
arglist[2].uint);
break;
case 0x0140: /* request_char_event_uni */
glk_request_char_event_uni(arglist[0].opaqueref);
break;
case 0x0141: /* request_line_event_uni */
if (arglist[1].ptrflag)
glk_request_line_event_uni(arglist[0].opaqueref, arglist[2].array,
arglist[3].uint, arglist[4].uint);
else
glk_request_line_event_uni(arglist[0].opaqueref, NULL,
0, arglist[2].uint);
break;
#endif /* GLK_MODULE_UNICODE */
#endif /* 0 */
}
}
