void wait_for_key(winid_t win) { event_t ev; glk_request_char_event(win); do glk_select(&ev); while(ev.type != evtype_CharInput); }
int hugo_waitforkey(void) { event_t ev; char gotchar = 0; /* Just in case we try to get key input from a Glk-illegal window that hasn't been created, switch as a failsafe to mainwin */ if (currentwin==NULL) glk_set_window(currentwin = mainwin); #if defined (NO_KEYPRESS_CURSOR) if (currentwin!=mainwin) { glk_window_move_cursor(currentwin, currentpos/CHARWIDTH, currentline-1); hugo_print("*"); glk_window_move_cursor(currentwin, currentpos/CHARWIDTH, currentline-1); } #endif glk_request_char_event(currentwin); while (!gotchar) { /* Grab an event */ glk_select(&ev); switch (ev.type) { case evtype_CharInput: /* (Will always be mainwin, but anyway) */ if (ev.win==currentwin) { gotchar = true; } break; } } /* Convert Glk special keycodes: */ switch (ev.val1) { case keycode_Left: ev.val1 = 8; break; case keycode_Right: ev.val1 = 21; break; case keycode_Up: ev.val1 = 11; break; case keycode_Down: ev.val1 = 10; break; case keycode_Return: ev.val1 = 13; break; case keycode_Escape: ev.val1 = 27; break; } #if defined (NO_KEYPRESS_CURSOR) if (currentwin!=mainwin) { glk_window_move_cursor(currentwin, currentpos/CHARWIDTH, currentline-1); hugo_print(" "); glk_window_move_cursor(currentwin, currentpos/CHARWIDTH, currentline-1); } #endif return ev.val1; }
/* The glk_main() function is called by the Glk system; it's the main entry point for your program. */ void glk_main(void) { char commandbuf1[256]; /* For mainwin1 */ char commandbuf2[256]; /* For mainwin2 */ /* Open the main windows. */ mainwin1 = glk_window_open(0, 0, 0, wintype_TextBuffer, 1); if (!mainwin1) { /* It's possible that the main window failed to open. There's nothing we can do without it, so exit. */ return; } /* Open a second window: a text grid, above the main window, five lines high. It is possible that this will fail also, but we accept that. */ statuswin = glk_window_open(mainwin1, winmethod_Above | winmethod_Fixed, 5, wintype_TextGrid, 0); /* And a third window, a second story window below the main one. */ mainwin2 = glk_window_open(mainwin1, winmethod_Below | winmethod_Proportional, 50, wintype_TextBuffer, 0); /* We're going to be switching from one window to another all the time. So we'll be setting the output stream on a case-by-case basis. Every function that prints must set the output stream first. (Contrast model.c, where the output stream is always the main window, and every function that changes that must set it back afterwards.) */ glk_set_window(mainwin1); glk_put_string("Multiwin\nAn Interactive Sample Glk Program\n"); glk_put_string("By Andrew Plotkin.\nRelease 3.\n"); glk_put_string("Type \"help\" for a list of commands.\n"); glk_set_window(mainwin2); glk_put_string("Note that the upper left-hand window accepts character"); glk_put_string(" input. Hit 'h' to split the window horizontally, 'v' to"); glk_put_string(" split the window vertically, 'c' to close a window,"); glk_put_string(" and any other key (including special keys) to display"); glk_put_string(" key codes. All new windows accept these same keys as"); glk_put_string(" well.\n\n"); glk_put_string("This bottom window accepts normal line input.\n"); if (statuswin) { /* For fun, let's open a fourth window now, splitting the status window. */ winid_t keywin; keywin = glk_window_open(statuswin, winmethod_Left | winmethod_Proportional, 66, wintype_TextGrid, KEYWINROCK); if (keywin) { glk_request_char_event(keywin); } } /* Draw the key window now, since we don't draw it every input (as we do the status window. */ draw_keywins(); inputpending1 = FALSE; inputpending2 = FALSE; already1 = 0; already2 = 0; while (1) { char *cx, *cmd; int doneloop, len; winid_t whichwin = NULL; event_t ev; draw_statuswin(); /* We're not redrawing the key windows every command. */ /* Either main window, or both, could already have line input pending. If so, leave that window alone. If there is no input pending on a window, set a line input request, but keep around any characters that were in the buffer already. */ if (mainwin1 && !inputpending1) { glk_set_window(mainwin1); glk_put_string("\n>"); /* We request up to 255 characters. The buffer can hold 256, but we are going to stick a null character at the end, so we have to leave room for that. Note that the Glk library does *not* put on that null character. */ glk_request_line_event(mainwin1, commandbuf1, 255, already1); inputpending1 = TRUE; } if (mainwin2 && !inputpending2) { glk_set_window(mainwin2); glk_put_string("\n>"); /* See above. */ glk_request_line_event(mainwin2, commandbuf2, 255, already2); inputpending2 = TRUE; } doneloop = FALSE; while (!doneloop) { /* Grab an event. */ glk_select(&ev); switch (ev.type) { case evtype_LineInput: /* If the event comes from one main window or the other, we mark that window as no longer having line input pending. We also set commandbuf to point to the appropriate buffer. Then we leave the event loop. */ if (mainwin1 && ev.win == mainwin1) { whichwin = mainwin1; inputpending1 = FALSE; cmd = commandbuf1; doneloop = TRUE; } else if (mainwin2 && ev.win == mainwin2) { whichwin = mainwin2; inputpending2 = FALSE; cmd = commandbuf2; doneloop = TRUE; } break; case evtype_CharInput: /* It's a key event, from one of the keywins. We call a subroutine rather than exiting the event loop (although I could have done it that way too.) */ perform_key(ev.win, ev.val1); break; case evtype_Timer: /* It's a timer event. This does exit from the event loop, since we're going to interrupt input in mainwin1 and then re-print the prompt. */ whichwin = NULL; cmd = NULL; doneloop = TRUE; break; case evtype_Arrange: /* Windows have changed size, so we have to redraw the status window and key window. But we stay in the event loop. */ draw_statuswin(); draw_keywins(); break; } } if (cmd == NULL) { /* It was a timer event. */ perform_timer(); continue; } /* It was a line input event. cmd now points at a line of input from one of the main windows. */ /* The line we have received in commandbuf is not null-terminated. We handle that first. */ len = ev.val1; /* Will be between 0 and 255, inclusive. */ cmd[len] = '\0'; /* Then squash to lower-case. */ for (cx = cmd; *cx; cx++) { *cx = glk_char_to_lower(*cx); } /* Then trim whitespace before and after. */ for (cx = cmd; *cx == ' '; cx++, len--) { }; cmd = cx; for (cx = cmd+len-1; cx >= cmd && *cx == ' '; cx--) { }; *(cx+1) = '\0'; /* cmd now points to a nice null-terminated string. We'll do the simplest possible parsing. */ if (str_eq(cmd, "")) { glk_set_window(whichwin); glk_put_string("Excuse me?\n"); } else if (str_eq(cmd, "help")) { verb_help(whichwin); } else if (str_eq(cmd, "yada")) { verb_yada(whichwin); } else if (str_eq(cmd, "both")) { verb_both(whichwin); } else if (str_eq(cmd, "clear")) { verb_clear(whichwin); } else if (str_eq(cmd, "page")) { verb_page(whichwin); } else if (str_eq(cmd, "pageboth")) { verb_pageboth(whichwin); } else if (str_eq(cmd, "timer")) { verb_timer(whichwin); } else if (str_eq(cmd, "untimer")) { verb_untimer(whichwin); } else if (str_eq(cmd, "chars")) { verb_chars(whichwin); } else if (str_eq(cmd, "jump")) { verb_jump(whichwin); } else if (str_eq(cmd, "quit")) { verb_quit(whichwin); } else { glk_set_window(whichwin); glk_put_string("I don't understand the command \""); glk_put_string(cmd); glk_put_string("\".\n"); } if (whichwin == mainwin1) already1 = 0; else if (whichwin == mainwin2) already2 = 0; } }
/* 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 */ } }