From c147d0fda0a9607fe5ecbcaeea87533f84402e71 Mon Sep 17 00:00:00 2001 From: Paul Gilbert Date: Sun, 8 Sep 2019 21:06:52 -0700 Subject: GLK: ADRIFT: Formatting --- engines/glk/adrift/os_glk.cpp | 241 ++++----- engines/glk/adrift/scdebug.cpp | 193 +++----- engines/glk/adrift/scevents.cpp | 45 +- engines/glk/adrift/scexpr.cpp | 94 ++-- engines/glk/adrift/scgamest.cpp | 235 +++------ engines/glk/adrift/scinterf.cpp | 230 +++------ engines/glk/adrift/sclibrar.cpp | 1041 +++++++++++++-------------------------- engines/glk/adrift/sclocale.cpp | 87 ++-- engines/glk/adrift/scmemos.cpp | 73 ++- engines/glk/adrift/scnpcs.cpp | 38 +- engines/glk/adrift/scobjcts.cpp | 98 ++-- engines/glk/adrift/scparser.cpp | 150 ++---- engines/glk/adrift/scprintf.cpp | 112 ++--- engines/glk/adrift/scprops.cpp | 91 ++-- engines/glk/adrift/scprotos.h | 15 +- engines/glk/adrift/scresour.cpp | 27 +- engines/glk/adrift/screstrs.cpp | 83 +--- engines/glk/adrift/scrunner.cpp | 159 +++--- engines/glk/adrift/scserial.cpp | 47 +- engines/glk/adrift/sctaffil.cpp | 69 +-- engines/glk/adrift/sctafpar.cpp | 180 +++---- engines/glk/adrift/sctasks.cpp | 72 +-- engines/glk/adrift/scutils.cpp | 54 +- engines/glk/adrift/scvars.cpp | 133 ++--- engines/glk/adrift/sxfile.cpp | 12 +- engines/glk/adrift/sxglob.cpp | 18 +- engines/glk/adrift/sxscript.cpp | 58 +-- engines/glk/adrift/sxtester.cpp | 3 +- engines/glk/adrift/sxutils.cpp | 18 +- 29 files changed, 1241 insertions(+), 2435 deletions(-) (limited to 'engines') diff --git a/engines/glk/adrift/os_glk.cpp b/engines/glk/adrift/os_glk.cpp index 37ac07f941..cfe61acae6 100644 --- a/engines/glk/adrift/os_glk.cpp +++ b/engines/glk/adrift/os_glk.cpp @@ -62,23 +62,20 @@ namespace Adrift { static const glui32 GSC_PORT_VERSION = 0x00010310; /* Two windows, one for the main text, and one for a status line. */ -static winid_t gsc_main_window = nullptr, - gsc_status_window = nullptr; +static winid_t gsc_main_window = nullptr, gsc_status_window = nullptr; /* * Transcript stream and input log. These are nullptr if there is no current * collection of these strings. */ -static strid_t gsc_transcript_stream = nullptr, - gsc_inputlog_stream = nullptr; +static strid_t gsc_transcript_stream = nullptr, gsc_inputlog_stream = nullptr; /* Input read log stream, for reading back an input log. */ static strid_t gsc_readlog_stream = nullptr; /* Options that may be turned off or set by command line flags. */ -static int gsc_commands_enabled = TRUE, - gsc_abbreviations_enabled = TRUE, - gsc_unicode_enabled = TRUE; +static int gsc_commands_enabled = TRUE, gsc_abbreviations_enabled = TRUE, + gsc_unicode_enabled = TRUE; /* Adrift game to interpret. */ static sc_game gsc_game = nullptr; @@ -86,7 +83,7 @@ static sc_game gsc_game = nullptr; /* Special out-of-band os_confirm() options used locally with os_glk. */ static const sc_int GSC_CONF_SUBTLE_HINT = INT_MAX, GSC_CONF_UNSUBTLE_HINT = INT_MAX - 1, - GSC_CONF_CONTINUE_HINTS = INT_MAX - 2; + GSC_CONF_CONTINUE_HINTS = INT_MAX - 2; /* Forward declaration of event wait functions, and a short delay. */ static void gsc_event_wait_2(glui32 wait_type_1, @@ -105,8 +102,7 @@ static void gsc_short_delay(); * Fatal error handler. The function returns, expecting the caller to * abort() or otherwise handle the error. */ -static void -gsc_fatal(const char *string) { +static void gsc_fatal(const char *string) { /* * If the failure happens too early for us to have a window, print * the message to stderr. @@ -136,8 +132,7 @@ gsc_fatal(const char *string) { * * Non-failing malloc; call gsc_fatal and exit if memory allocation fails. */ -static void * -gsc_malloc(size_t size) { +static void *gsc_malloc(size_t size) { void *pointer; pointer = malloc(size > 0 ? size : 1); @@ -166,20 +161,20 @@ static const glui32 GSC_ISO_8859_EQUIVALENCE = 256; * codepages where they're not (dingbats, for example). */ enum { GSC_TABLE_SIZE = 256 }; -typedef struct { +struct gsc_codepages_t { const glui32 unicode[GSC_TABLE_SIZE]; const sc_char *const ascii[GSC_TABLE_SIZE]; -} gsc_codepages_t; +}; /* * Locale contains a name and a pair of codepage structures, a main one and * an alternate. The latter is intended for monospaced output. */ -typedef struct { +struct gsc_locale_t { const sc_char *const name; const gsc_codepages_t main; const gsc_codepages_t alternate; -} gsc_locale_t; +}; /* @@ -513,8 +508,7 @@ static const gsc_locale_t *const gsc_fallback_locale = &GSC_LATIN1_LOCALE; * * Set a locale explicitly from the name passed in. */ -static void -gsc_set_locale(const sc_char *name) { +static void gsc_set_locale(const sc_char *name) { const gsc_locale_t *matched = nullptr; const gsc_locale_t *const *iterator; assert(name); @@ -544,8 +538,7 @@ gsc_set_locale(const sc_char *name) { * Wrapper around g_vm->glk_put_char_uni(). Handles, inelegantly, the problem of * having to write transcripts as ascii. */ -static void -gsc_put_char_uni(glui32 unicode, const char *ascii) { +static void gsc_put_char_uni(glui32 unicode, const char *ascii) { /* If there is an transcript stream, temporarily disconnect it. */ if (gsc_transcript_stream) g_vm->glk_window_set_echo_stream(gsc_main_window, nullptr); @@ -570,9 +563,7 @@ gsc_put_char_uni(glui32 unicode, const char *ascii) { * Write a single character using the supplied locale. Select either the * main or the alternate codepage depending on the flag passed in. */ -static void -gsc_put_char_locale(sc_char ch, - const gsc_locale_t *locale, sc_bool is_alternate) { +static void gsc_put_char_locale(sc_char ch, const gsc_locale_t *locale, sc_bool is_alternate) { const gsc_codepages_t *codepage; unsigned char character; glui32 unicode; @@ -657,47 +648,40 @@ gsc_put_char_locale(sc_char ch, * * Public functions for writing using the current or fallback locale. */ -static void -gsc_put_char(const sc_char character) { +static void gsc_put_char(const sc_char character) { const gsc_locale_t *locale; locale = gsc_locale ? gsc_locale : gsc_fallback_locale; gsc_put_char_locale(character, locale, FALSE); } -static void -gsc_put_char_alternate(const sc_char character) { +static void gsc_put_char_alternate(const sc_char character) { const gsc_locale_t *locale; locale = gsc_locale ? gsc_locale : gsc_fallback_locale; gsc_put_char_locale(character, locale, TRUE); } -static void -gsc_put_buffer_using(const sc_char *buffer, - sc_int length, void (*putchar_function)(sc_char)) { +static void gsc_put_buffer_using(const sc_char *buffer, sc_int length, void (*putchar_function)(sc_char)) { sc_int index_; for (index_ = 0; index_ < length; index_++) putchar_function(buffer[index_]); } -static void -gsc_put_buffer(const sc_char *buffer, sc_int length) { +static void gsc_put_buffer(const sc_char *buffer, sc_int length) { assert(buffer); gsc_put_buffer_using(buffer, length, gsc_put_char); } -static void -gsc_put_string(const sc_char *string) { +static void gsc_put_string(const sc_char *string) { assert(string); gsc_put_buffer_using(string, strlen(string), gsc_put_char); } -static void -gsc_put_string_alternate(const sc_char *string) { +static void gsc_put_string_alternate(const sc_char *string) { assert(string); gsc_put_buffer_using(string, strlen(string), gsc_put_char_alternate); @@ -712,8 +696,7 @@ gsc_put_string_alternate(const sc_char *string) { * reverse translations in line input. Returns '?' if there is no translation * available. */ -static sc_char -gsc_unicode_to_locale(glui32 unicode, const gsc_locale_t *locale) { +static sc_char gsc_unicode_to_locale(glui32 unicode, const gsc_locale_t *locale) { const gsc_codepages_t *codepage; sc_int character; @@ -733,9 +716,8 @@ gsc_unicode_to_locale(glui32 unicode, const gsc_locale_t *locale) { return character < GSC_TABLE_SIZE ? (sc_char) character : '?'; } -static void -gsc_unicode_buffer_to_locale(const glui32 *unicode, sc_int length, - sc_char *buffer, const gsc_locale_t *locale) { +static void gsc_unicode_buffer_to_locale(const glui32 *unicode, sc_int length, + sc_char *buffer, const gsc_locale_t *locale) { sc_int index_; for (index_ = 0; index_ < length; index_++) @@ -749,9 +731,7 @@ gsc_unicode_buffer_to_locale(const glui32 *unicode, sc_int length, * Read in a line and translate out of the given locale. Returns the count * of characters placed in the buffer. */ -static sc_int -gsc_read_line_locale(sc_char *buffer, - sc_int length, const gsc_locale_t *locale) { +static sc_int gsc_read_line_locale(sc_char *buffer, sc_int length, const gsc_locale_t *locale) { event_t event; /* @@ -791,8 +771,7 @@ gsc_read_line_locale(sc_char *buffer, * * Public function for reading using the current or fallback locale. */ -static sc_int -gsc_read_line(sc_char *buffer, sc_int length) { +static sc_int gsc_read_line(sc_char *buffer, sc_int length) { const gsc_locale_t *locale; locale = gsc_locale ? gsc_locale : gsc_fallback_locale; @@ -824,8 +803,7 @@ static const sc_char *const GSC_WHITESPACE = "\t\n\v\f\r "; * Return TRUE if string is non-null, not zero-length or contains characters * other than whitespace. */ -static sc_bool -gsc_is_string_usable(const sc_char *string) { +static sc_bool gsc_is_string_usable(const sc_char *string) { /* If non-null, scan for any non-space character. */ if (string) { sc_int index_; @@ -847,8 +825,7 @@ gsc_is_string_usable(const sc_char *string) { * Update the status line from the current game state. This is for windowing * Glk libraries. */ -static void -gsc_status_update() { +static void gsc_status_update() { glui32 width, height; uint index; assert(gsc_status_window); @@ -913,8 +890,7 @@ gsc_status_update() { * Helper for gsc_status_print(), concatenates strings only up to the * available length. */ -static void -gsc_status_safe_strcat(char *dest, size_t length, const char *src) { +static void gsc_status_safe_strcat(char *dest, size_t length, const char *src) { size_t available, src_length; /* Append only as many characters as will fit. */ @@ -932,8 +908,7 @@ gsc_status_safe_strcat(char *dest, size_t length, const char *src) { * main window, if it has changed since the last call. This is for non- * windowing Glk libraries. */ -static void -gsc_status_print() { +static void gsc_status_print() { static char current_status[GSC_STATUS_BUFFER_LENGTH + 1]; const sc_char *room; @@ -980,8 +955,7 @@ gsc_status_print() { * Front end function for updating status. Either updates the status window * or prints the status line to the main window. */ -static void -gsc_status_notify() { +static void gsc_status_notify() { if (gsc_status_window) gsc_status_update(); else @@ -996,8 +970,7 @@ gsc_status_notify() { * This function should be called on the appropriate Glk window resize and * arrange events. */ -static void -gsc_status_redraw() { +static void gsc_status_redraw() { if (gsc_status_window) { winid_t parent; @@ -1031,10 +1004,10 @@ static int gsc_help_requested = FALSE, gsc_help_hints_silenced = FALSE; /* Font descriptor type, encapsulating size and monospaced boolean. */ -typedef struct { +struct gsc_font_size_t { sc_bool is_monospaced; sc_int size; -} gsc_font_size_t; +}; /* Font stack and attributes for nesting tags. */ enum { GSC_MAX_STYLE_NESTING = 32 }; @@ -1070,18 +1043,15 @@ static const glui32 GSC_CANCEL_WAIT_1 = ' ', * Register a request for help, and print a note of how to get Glk command * help from the interpreter unless silenced. */ -static void -gsc_output_register_help_request() { +static void gsc_output_register_help_request() { gsc_help_requested = TRUE; } -static void -gsc_output_silence_help_hints() { +static void gsc_output_silence_help_hints() { gsc_help_hints_silenced = TRUE; } -static void -gsc_output_provide_help_hint() { +static void gsc_output_provide_help_hint() { if (gsc_help_requested && !gsc_help_hints_silenced) { g_vm->glk_set_style(style_Emphasized); g_vm->glk_put_string("[Try 'glk help' for help on special interpreter" @@ -1160,8 +1130,7 @@ static void gsc_set_glk_style() { * Push the settings of a font tag onto the font stack, and pop on end of * font tag. Set the appropriate Glk style. */ -static void -gsc_handle_font_tag(const sc_char *argument) { +static void gsc_handle_font_tag(const sc_char *argument) { /* Ignore the call on stack overrun. */ if (gsc_font_index < GSC_MAX_STYLE_NESTING) { sc_char *lower, *face, *size; @@ -1222,8 +1191,7 @@ gsc_handle_font_tag(const sc_char *argument) { } } -static void -gsc_handle_endfont_tag() { +static void gsc_handle_endfont_tag() { /* Unless underrun, pop the font stack and set Glk style. */ if (gsc_font_index > 0) { gsc_font_index--; @@ -1238,8 +1206,7 @@ gsc_handle_endfont_tag() { * Increment the required attribute nesting counter, or decrement on end * tag. Set the appropriate Glk style. */ -static void -gsc_handle_attribute_tag(sc_int tag) { +static void gsc_handle_attribute_tag(sc_int tag) { /* * Increment the required attribute nesting counter, and set Glk style. */ @@ -1262,8 +1229,7 @@ gsc_handle_attribute_tag(sc_int tag) { gsc_set_glk_style(); } -static void -gsc_handle_endattribute_tag(sc_int tag) { +static void gsc_handle_endattribute_tag(sc_int tag) { /* * Decrement the required attribute nesting counter, unless underrun, and * set Glk style. @@ -1356,8 +1322,7 @@ static void gsc_handle_wait_tag(const sc_char *argument) { * Drop all stacked fonts and nested attributes, and return to normal Glk * style. */ -static void -gsc_reset_glk_style() { +static void gsc_reset_glk_style() { /* Reset the font stack and attributes, and set a normal style. */ gsc_font_index = 0; gsc_attribute_bold = 0; @@ -1374,8 +1339,7 @@ gsc_reset_glk_style() { * Interpret selected Adrift output control tags. Not all are implemented * here; several are ignored. */ -void -os_print_tag(sc_int tag, const sc_char *argument) { +void os_print_tag(sc_int tag, const sc_char *argument) { event_t event; assert(argument); @@ -1495,8 +1459,7 @@ void os_print_string(const sc_char *string) { * Debugging output goes to the main Glk window -- no special effects or * dedicated debugging window attempted. */ -void -os_print_string_debug(const sc_char *string) { +void os_print_string_debug(const sc_char *string) { assert(string); assert(g_vm->glk_stream_get_current()); @@ -1516,8 +1479,7 @@ os_print_string_debug(const sc_char *string) { * Convenience functions to print strings in assorted styles. A standout * string is one that hints that it's from the interpreter, not the game. */ -static void -gsc_styled_string(glui32 style, const char *message) { +static void gsc_styled_string(glui32 style, const char *message) { assert(message); g_vm->glk_set_style(style); @@ -1525,8 +1487,7 @@ gsc_styled_string(glui32 style, const char *message) { g_vm->glk_set_style(style_Normal); } -static void -gsc_styled_char(glui32 style, char c) { +static void gsc_styled_char(glui32 style, char c) { char buffer[2]; buffer[0] = c; @@ -1534,28 +1495,23 @@ gsc_styled_char(glui32 style, char c) { gsc_styled_string(style, buffer); } -static void -gsc_standout_string(const char *message) { +static void gsc_standout_string(const char *message) { gsc_styled_string(style_Emphasized, message); } -static void -gsc_standout_char(char c) { +static void gsc_standout_char(char c) { gsc_styled_char(style_Emphasized, c); } -static void -gsc_normal_string(const char *message) { +static void gsc_normal_string(const char *message) { gsc_styled_string(style_Normal, message); } -static void -gsc_normal_char(char c) { +static void gsc_normal_char(char c) { gsc_styled_char(style_Normal, c); } -static void -gsc_header_string(const char *message) { +static void gsc_header_string(const char *message) { gsc_styled_string(style_Header, message); } @@ -1567,8 +1523,7 @@ gsc_header_string(const char *message) { * hints at all, and those that do are usually sparse in what they hint at, so * it's sort of good enough for the moment. */ -void -os_display_hints(sc_game game) { +void os_display_hints(sc_game game) { sc_game_hint hint; sc_int refused; @@ -1628,9 +1583,7 @@ os_display_hints(sc_game game) { * * Stub functions. The unused variables defeat gcc warnings. */ -void -os_play_sound(const sc_char *filepath, - sc_int offset, sc_int length, sc_bool is_looping) { +void os_play_sound(const sc_char *filepath, sc_int offset, sc_int length, sc_bool is_looping) { const sc_char *unused1; sc_int unused2, unused3; sc_bool unused4; @@ -1640,8 +1593,7 @@ os_play_sound(const sc_char *filepath, unused4 = is_looping; } -void -os_stop_sound() { +void os_stop_sound() { } @@ -1659,8 +1611,7 @@ os_stop_sound() { #ifdef LINUX_GRAPHICS static int gsclinux_graphics_enabled = TRUE; static char *gsclinux_game_file = nullptr; -void -os_show_graphic(const sc_char *filepath, sc_int offset, sc_int length) { +void os_show_graphic(const sc_char *filepath, sc_int offset, sc_int length) { const sc_char *unused1; unused1 = filepath; @@ -1687,8 +1638,7 @@ os_show_graphic(const sc_char *filepath, sc_int offset, sc_int length) { } } #else -void -os_show_graphic(const sc_char *filepath, sc_int offset, sc_int length) { +void os_show_graphic(const sc_char *filepath, sc_int offset, sc_int length) { const sc_char *unused1; sc_int unused2, unused3; unused1 = filepath; @@ -1707,8 +1657,7 @@ os_show_graphic(const sc_char *filepath, sc_int offset, sc_int length) { * * Turn game output scripting (logging) on and off. */ -static void -gsc_command_script(const char *argument) { +static void gsc_command_script(const char *argument) { assert(argument); if (sc_strcasecmp(argument, "on") == 0) { @@ -1775,8 +1724,7 @@ gsc_command_script(const char *argument) { * * Turn game input logging on and off. */ -static void -gsc_command_inputlog(const char *argument) { +static void gsc_command_inputlog(const char *argument) { assert(argument); if (sc_strcasecmp(argument, "on") == 0) { @@ -1839,8 +1787,7 @@ gsc_command_inputlog(const char *argument) { * * Set the game input log, to read input from a file. */ -static void -gsc_command_readlog(const char *argument) { +static void gsc_command_readlog(const char *argument) { assert(argument); if (sc_strcasecmp(argument, "on") == 0) { @@ -1908,8 +1855,7 @@ gsc_command_readlog(const char *argument) { * * Turn abbreviation expansions on and off. */ -static void -gsc_command_abbreviations(const char *argument) { +static void gsc_command_abbreviations(const char *argument) { assert(argument); if (sc_strcasecmp(argument, "on") == 0) { @@ -1954,8 +1900,7 @@ gsc_command_abbreviations(const char *argument) { * * Print out the Glk library version number. */ -static void -gsc_command_print_version_number(glui32 version) { +static void gsc_command_print_version_number(glui32 version) { char buffer[64]; sprintf(buffer, "%lu.%lu.%lu", @@ -1965,8 +1910,7 @@ gsc_command_print_version_number(glui32 version) { gsc_normal_string(buffer); } -static void -gsc_command_version(const char *argument) { +static void gsc_command_version(const char *argument) { glui32 version; assert(argument); @@ -1987,8 +1931,7 @@ gsc_command_version(const char *argument) { * Turn command escapes off. Once off, there's no way to turn them back on. * Commands must be on already to enter this function. */ -static void -gsc_command_commands(const char *argument) { +static void gsc_command_commands(const char *argument) { assert(argument); if (sc_strcasecmp(argument, "on") == 0) { @@ -2021,8 +1964,7 @@ gsc_command_commands(const char *argument) { * * Print licensing terms. */ -static void -gsc_command_license(const char *argument) { +static void gsc_command_license(const char *argument) { assert(argument); gsc_normal_string("This program is free software; you can redistribute it" @@ -2052,11 +1994,11 @@ gsc_command_license(const char *argument) { /* Glk subcommands and handler functions. */ -typedef const struct { +struct gsc_command_t { const char *const command; /* Glk subcommand. */ void (* const handler)(const char *argument); /* Subcommand handler. */ const int takes_argument; /* Argument flag. */ -} gsc_command_t; +}; typedef gsc_command_t *gsc_commandref_t; static void gsc_command_summary(const char *argument); @@ -2081,8 +2023,7 @@ static gsc_command_t GSC_COMMAND_TABLE[] = { * * Report all current Glk settings. */ -static void -gsc_command_summary(const char *argument) { +static void gsc_command_summary(const char *argument) { gsc_commandref_t entry; assert(argument); @@ -2106,8 +2047,7 @@ gsc_command_summary(const char *argument) { * * Document the available Glk commands. */ -static void -gsc_command_help(const char *command) { +static void gsc_command_help(const char *command) { gsc_commandref_t entry, matched; assert(command); @@ -2234,8 +2174,7 @@ gsc_command_help(const char *command) { * This function is handed each input line. If the line contains a specific * Glk port command, handle it and return TRUE, otherwise return FALSE. */ -static int -gsc_command_escape(const char *string) { +static int gsc_command_escape(const char *string) { int posn; char *string_copy, *command, *argument; assert(string); @@ -2356,8 +2295,7 @@ static gsc_abbreviation_t GSC_ABBREVIATIONS[] = { * Expand a few common one-character abbreviations commonly found in other * game systems. */ -static void -gsc_expand_abbreviations(char *buffer, int size) { +static void gsc_expand_abbreviations(char *buffer, int size) { char *command, abbreviation; const char *expansion; gsc_abbreviationref_t entry; @@ -2404,8 +2342,7 @@ gsc_expand_abbreviations(char *buffer, int size) { * * Read and return a line of player input. */ -sc_bool -os_read_line(sc_char *buffer, sc_int length) { +sc_bool os_read_line(sc_char *buffer, sc_int length) { sc_int characters; assert(buffer && length > 0); @@ -2520,8 +2457,7 @@ os_read_line(sc_char *buffer, sc_int length) { * window, so this is just a call to the normal readline, with an additional * prompt. */ -sc_bool -os_read_line_debug(sc_char *buffer, sc_int length) { +sc_bool os_read_line_debug(sc_char *buffer, sc_int length) { gsc_output_silence_help_hints(); gsc_reset_glk_style(); g_vm->glk_put_string("[SCARE debug]"); @@ -2534,8 +2470,7 @@ os_read_line_debug(sc_char *buffer, sc_int length) { * * Confirm a game action with a yes/no prompt. */ -sc_bool -os_confirm(sc_int type) { +sc_bool os_confirm(sc_int type) { sc_char response; /* @@ -2625,8 +2560,7 @@ static const glui32 GSC_DELAY_TIMEOUTS_COUNT = 10; * improve the display where 'r', or confirming restart, triggers an otherwise * immediate, and abrupt, restart. */ -static void -gsc_short_delay() { +static void gsc_short_delay() { /* Ignore the call if the Glk doesn't have timers. */ if (g_vm->glk_gestalt(gestalt_Timer, 0)) { glui32 timeout; @@ -2650,8 +2584,7 @@ gsc_short_delay() { * Process Glk events until one of the expected type, or types, arrives. * Return the event of that type. */ -static void -gsc_event_wait_2(glui32 wait_type_1, glui32 wait_type_2, event_t *event) { +static void gsc_event_wait_2(glui32 wait_type_1, glui32 wait_type_2, event_t *event) { assert(event); do { @@ -2671,8 +2604,7 @@ gsc_event_wait_2(glui32 wait_type_1, glui32 wait_type_2, event_t *event) { } while (!(event->type == (EvType)wait_type_1 || event->type == (EvType)wait_type_2)); } -static void -gsc_event_wait(glui32 wait_type, event_t *event) { +static void gsc_event_wait(glui32 wait_type, event_t *event) { assert(event); gsc_event_wait_2(wait_type, evtype_None, event); @@ -2719,16 +2651,14 @@ void *os_open_file(sc_bool is_save) { * * Write/read the given buffered data to/from the open Glk stream. */ -void -os_write_file(void *opaque, const sc_byte *buffer, sc_int length) { +void os_write_file(void *opaque, const sc_byte *buffer, sc_int length) { strid_t stream = (strid_t) opaque; assert(opaque && buffer); g_vm->glk_put_buffer_stream(stream, (char *) buffer, length); } -sc_int -os_read_file(void *opaque, sc_byte *buffer, sc_int length) { +sc_int os_read_file(void *opaque, sc_byte *buffer, sc_int length) { strid_t stream = (strid_t) opaque; assert(opaque && buffer); @@ -2741,8 +2671,7 @@ os_read_file(void *opaque, sc_byte *buffer, sc_int length) { * * Close the opened Glk stream. */ -void -os_close_file(void *opaque) { +void os_close_file(void *opaque) { strid_t stream = (strid_t) opaque; assert(opaque); @@ -2788,8 +2717,7 @@ static sc_int gsc_callback(void *opaque, sc_byte *buffer, sc_int length) { * Offer the option to restart, undo, or quit. Returns the selected game * end option. Called on game completion. */ -static enum gsc_end_option -gsc_get_ending_option() { +static enum gsc_end_option gsc_get_ending_option() { sc_char response; /* Ensure back to normal style, and update status. */ @@ -2858,10 +2786,8 @@ gsc_get_ending_option() { * and generally handle options. The second is called from g_vm->glk_main, and * does the real work of running the game. */ -static int -gsc_startup_code(Common::SeekableReadStream *game_stream, strid_t restore_stream, - sc_uint trace_flags, sc_bool enable_debugger, - sc_bool stable_random, const sc_char *locale) { +static int gsc_startup_code(Common::SeekableReadStream *game_stream, strid_t restore_stream, + sc_uint trace_flags, sc_bool enable_debugger, sc_bool stable_random, const sc_char *locale) { winid_t window; assert(game_stream); @@ -2960,8 +2886,7 @@ gsc_startup_code(Common::SeekableReadStream *game_stream, strid_t restore_stream return TRUE; } -static void -gsc_main() { +static void gsc_main() { sc_bool is_running; /* Ensure SCARE internal types have the right sizes. */ @@ -3100,7 +3025,7 @@ void adrift_main() { /* Glk linkage relevant only to the UNIX platform */ /*---------------------------------------------------------------------*/ -#ifdef UNUSED +#if 0 /* * Glk arguments for UNIX versions of the Glk interpreter. */ diff --git a/engines/glk/adrift/scdebug.cpp b/engines/glk/adrift/scdebug.cpp index 35900c37f4..a752506702 100644 --- a/engines/glk/adrift/scdebug.cpp +++ b/engines/glk/adrift/scdebug.cpp @@ -32,7 +32,7 @@ static const sc_uint DEBUG_MAGIC = 0xc4584d2e; enum { DEBUG_BUFFER_SIZE = 256 }; /* Debugging command and command argument type. */ -typedef enum { +enum sc_command_t { DEBUG_NONE = 0, DEBUG_CONTINUE, DEBUG_STEP, DEBUG_BUFFER, DEBUG_RESOURCES, DEBUG_HELP, DEBUG_GAME, DEBUG_PLAYER, DEBUG_ROOMS, DEBUG_OBJECTS, DEBUG_NPCS, DEBUG_EVENTS, @@ -45,18 +45,15 @@ typedef enum { DEBUG_CLEARTASKS, DEBUG_CLEARVARIABLES, DEBUG_WATCHALL, DEBUG_CLEARALL, DEBUG_RANDOM, DEBUG_QUIT -} -sc_command_t; +}; -typedef enum -{ COMMAND_QUERY = 0, COMMAND_RANGE, COMMAND_ONE, COMMAND_ALL } -sc_command_type_t; +enum sc_command_type_t { COMMAND_QUERY = 0, COMMAND_RANGE, COMMAND_ONE, COMMAND_ALL }; /* Table connecting debugging command strings to commands. */ -typedef struct { +struct sc_strings_t { const sc_char *const command_string; const sc_command_t command; -} sc_strings_t; +}; static const sc_strings_t DEBUG_COMMANDS[] = { {"continue", DEBUG_CONTINUE}, {"step", DEBUG_STEP}, {"buffer", DEBUG_BUFFER}, {"resources", DEBUG_RESOURCES}, {"help", DEBUG_HELP}, {"game", DEBUG_GAME}, @@ -83,7 +80,7 @@ static const sc_strings_t DEBUG_COMMANDS[] = { * added to the game on enabling debug, and removed and destroyed on * disabling debugging. */ -typedef struct sc_debugger_s { +struct sc_debugger_s { sc_uint magic; sc_bool *watch_objects; sc_bool *watch_npcs; @@ -94,7 +91,8 @@ typedef struct sc_debugger_s { sc_bool single_step; sc_bool quit_pending; sc_uint elapsed_seconds; -} sc_debugger_t; +}; +typedef sc_debugger_s sc_debugger_t; /* @@ -102,8 +100,7 @@ typedef struct sc_debugger_s { * * Return TRUE if pointer is a valid debugger, FALSE otherwise. */ -static sc_bool -debug_is_valid(sc_debuggerref_t debug) { +static sc_bool debug_is_valid(sc_debuggerref_t debug) { return debug && debug->magic == DEBUG_MAGIC; } @@ -113,8 +110,7 @@ debug_is_valid(sc_debuggerref_t debug) { * * Return the debugger reference from a game, or NULL if none. */ -static sc_debuggerref_t -debug_get_debugger(sc_gameref_t game) { +static sc_debuggerref_t debug_get_debugger(sc_gameref_t game) { assert(gs_is_game_valid(game)); return game->debugger; @@ -126,8 +122,7 @@ debug_get_debugger(sc_gameref_t game) { * * Common helper to return the count of variables defined in a game. */ -static sc_int -debug_variable_count(sc_gameref_t game) { +static sc_int debug_variable_count(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key; sc_int variable_count; @@ -146,8 +141,7 @@ debug_variable_count(sc_gameref_t game) { * Create a new set of debug control information, and append it to the * game passed in. */ -static void -debug_initialize(sc_gameref_t game) { +static void debug_initialize(sc_gameref_t game) { sc_debuggerref_t debug; /* Create the easy bits of the new debugging set. */ @@ -194,8 +188,7 @@ debug_initialize(sc_gameref_t game) { * Destroy a debug data set, free its heap memory, and remove its reference * from the game. */ -static void -debug_finalize(sc_gameref_t game) { +static void debug_finalize(sc_gameref_t game) { sc_debuggerref_t debug = debug_get_debugger(game); assert(debug_is_valid(debug)); @@ -220,8 +213,7 @@ debug_finalize(sc_gameref_t game) { * * Print debugging help. */ -static void -debug_help(sc_command_t topic) { +static void debug_help(sc_command_t topic) { /* Is help general, or specific? */ if (topic == DEBUG_NONE) { if_print_debug( @@ -539,15 +531,13 @@ debug_help(sc_command_t topic) { * * Low level output helpers. */ -static void -debug_print_quoted(const sc_char *string) { +static void debug_print_quoted(const sc_char *string) { if_print_debug_character('"'); if_print_debug(string); if_print_debug_character('"'); } -static void -debug_print_player(sc_gameref_t game) { +static void debug_print_player(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; const sc_char *playername; @@ -559,8 +549,7 @@ debug_print_player(sc_gameref_t game) { debug_print_quoted(playername); } -static void -debug_print_room(sc_gameref_t game, sc_int room) { +static void debug_print_room(sc_gameref_t game, sc_int room) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_char buffer[32]; @@ -583,8 +572,7 @@ debug_print_room(sc_gameref_t game, sc_int room) { debug_print_quoted(name); } -static void -debug_print_object(sc_gameref_t game, sc_int object) { +static void debug_print_object(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_bool bstatic; @@ -618,8 +606,7 @@ debug_print_object(sc_gameref_t game, sc_int object) { debug_print_quoted(name); } -static void -debug_print_npc(sc_gameref_t game, sc_int npc) { +static void debug_print_npc(sc_gameref_t game, sc_int npc) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_char buffer[32]; @@ -646,8 +633,7 @@ debug_print_npc(sc_gameref_t game, sc_int npc) { debug_print_quoted(name); } -static void -debug_print_event(sc_gameref_t game, sc_int event) { +static void debug_print_event(sc_gameref_t game, sc_int event) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_char buffer[32]; @@ -670,8 +656,7 @@ debug_print_event(sc_gameref_t game, sc_int event) { debug_print_quoted(name); } -static void -debug_print_task(sc_gameref_t game, sc_int task) { +static void debug_print_task(sc_gameref_t game, sc_int task) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; sc_char buffer[32]; @@ -695,8 +680,7 @@ debug_print_task(sc_gameref_t game, sc_int task) { debug_print_quoted(command); } -static void -debug_print_variable(sc_gameref_t game, sc_int variable) { +static void debug_print_variable(sc_gameref_t game, sc_int variable) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[3], vt_rvalue; @@ -742,8 +726,7 @@ debug_print_variable(sc_gameref_t game, sc_int variable) { * * Display overall game details. */ -static void -debug_game(sc_gameref_t game, sc_command_type_t type) { +static void debug_game(sc_gameref_t game, sc_command_type_t type) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_debuggerref_t debug = debug_get_debugger(game); sc_vartype_t vt_key[2]; @@ -890,9 +873,7 @@ debug_game(sc_gameref_t game, sc_command_type_t type) { * * Print a few brief details about the player status. */ -static void -debug_player(sc_gameref_t game, - sc_command_t command, sc_command_type_t type) { +static void debug_player(sc_gameref_t game, sc_command_t command, sc_command_type_t type) { if (type != COMMAND_QUERY) { if_print_debug("The Player command takes no arguments.\n"); return; @@ -948,9 +929,7 @@ debug_player(sc_gameref_t game, * Normalize a set of arguments parsed from a debugger command line, for * debug commands that take ranges. */ -static sc_bool -debug_normalize_arguments(sc_command_type_t type, - sc_int *arg1, sc_int *arg2, sc_int limit) { +static sc_bool debug_normalize_arguments(sc_command_type_t type, sc_int *arg1, sc_int *arg2, sc_int limit) { sc_int low = 0, high = 0; /* Set range low and high depending on the command type. */ @@ -990,13 +969,11 @@ debug_normalize_arguments(sc_command_type_t type, * * Print details of rooms and their direct contents. */ -static sc_bool -debug_filter_room(sc_gameref_t game, sc_int room) { +static sc_bool debug_filter_room(sc_gameref_t game, sc_int room) { return room == gs_playerroom(game); } -static void -debug_dump_room(sc_gameref_t game, sc_int room) { +static void debug_dump_room(sc_gameref_t game, sc_int room) { sc_int object, npc; debug_print_room(game, room); @@ -1037,13 +1014,11 @@ debug_dump_room(sc_gameref_t game, sc_int room) { * * Print the changeable details of game objects. */ -static sc_bool -debug_filter_object(sc_gameref_t game, sc_int object) { +static sc_bool debug_filter_object(sc_gameref_t game, sc_int object) { return obj_indirectly_in_room(game, object, gs_playerroom(game)); } -static void -debug_dump_object(sc_gameref_t game, sc_int object) { +static void debug_dump_object(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int openness; sc_vartype_t vt_key[3]; @@ -1171,13 +1146,11 @@ debug_dump_object(sc_gameref_t game, sc_int object) { * * Print stuff about NPCs. */ -static sc_bool -debug_filter_npc(sc_gameref_t game, sc_int npc) { +static sc_bool debug_filter_npc(sc_gameref_t game, sc_int npc) { return npc_in_room(game, npc, gs_playerroom(game)); } -static void -debug_dump_npc(sc_gameref_t game, sc_int npc) { +static void debug_dump_npc(sc_gameref_t game, sc_int npc) { debug_print_npc(game, npc); if_print_debug_character('\n'); @@ -1239,13 +1212,11 @@ debug_dump_npc(sc_gameref_t game, sc_int npc) { * * Print stuff about events. */ -static sc_bool -debug_filter_event(sc_gameref_t game, sc_int event) { +static sc_bool debug_filter_event(sc_gameref_t game, sc_int event) { return gs_event_state(game, event) == ES_RUNNING; } -static void -debug_dump_event(sc_gameref_t game, sc_int event) { +static void debug_dump_event(sc_gameref_t game, sc_int event) { sc_char buffer[32]; debug_print_event(game, event); @@ -1284,13 +1255,11 @@ debug_dump_event(sc_gameref_t game, sc_int event) { * * Print stuff about tasks. */ -static sc_bool -debug_filter_task(sc_gameref_t game, sc_int task) { +static sc_bool debug_filter_task(sc_gameref_t game, sc_int task) { return task_can_run_task(game, task); } -static void -debug_dump_task(sc_gameref_t game, sc_int task) { +static void debug_dump_task(sc_gameref_t game, sc_int task) { debug_print_task(game, task); if_print_debug_character('\n'); @@ -1314,8 +1283,7 @@ debug_dump_task(sc_gameref_t game, sc_int task) { * * Print stuff about variables. */ -static void -debug_dump_variable(sc_gameref_t game, sc_int variable) { +static void debug_dump_variable(sc_gameref_t game, sc_int variable) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[3], vt_rvalue; @@ -1358,9 +1326,8 @@ debug_dump_variable(sc_gameref_t game, sc_int variable) { * * Common handler for iterating dumps of classes. */ -static void -debug_dump_common(sc_gameref_t game, sc_command_t command, - sc_command_type_t type, sc_int arg1, sc_int arg2) { +static void debug_dump_common(sc_gameref_t game, sc_command_t command, + sc_command_type_t type, sc_int arg1, sc_int arg2) { sc_int low = arg1, high = arg2; sc_int limit, index_; const sc_char *class_; @@ -1492,8 +1459,7 @@ debug_dump_common(sc_gameref_t game, sc_command_t command, * * Print the current raw printfilter contents. */ -static void -debug_buffer(sc_gameref_t game, sc_command_type_t type) { +static void debug_buffer(sc_gameref_t game, sc_command_type_t type) { const sc_filterref_t filter = gs_get_filter(game); const sc_char *buffer; @@ -1515,8 +1481,7 @@ debug_buffer(sc_gameref_t game, sc_command_type_t type) { * * Helper for debug_resources(). */ -static void -debug_print_resource(const sc_resource_t *resource) { +static void debug_print_resource(const sc_resource_t *resource) { sc_char buffer[32]; debug_print_quoted(resource->name); @@ -1534,8 +1499,7 @@ debug_print_resource(const sc_resource_t *resource) { * * Print any active and requested resources. */ -static void -debug_resources(sc_gameref_t game, sc_command_type_t type) { +static void debug_resources(sc_gameref_t game, sc_command_type_t type) { sc_bool printed = FALSE; if (type != COMMAND_QUERY) { @@ -1592,8 +1556,7 @@ debug_resources(sc_gameref_t game, sc_command_type_t type) { * Report the PRNG in use, and seed the random number generator to the * given value. */ -static void -debug_random(sc_command_type_t type, sc_int new_seed) { +static void debug_random(sc_command_type_t type, sc_int new_seed) { const sc_char *random_type; sc_char buffer[32]; @@ -1633,9 +1596,8 @@ debug_random(sc_command_type_t type, sc_int new_seed) { * * Common handler for setting and clearing watchpoints. */ -static void -debug_watchpoint_common(sc_gameref_t game, sc_command_t command, - sc_command_type_t type, sc_int arg1, sc_int arg2) { +static void debug_watchpoint_common(sc_gameref_t game, sc_command_t command, + sc_command_type_t type, sc_int arg1, sc_int arg2) { const sc_debuggerref_t debug = debug_get_debugger(game); sc_int low = arg1, high = arg2; sc_int limit, index_; @@ -1801,9 +1763,7 @@ debug_watchpoint_common(sc_gameref_t game, sc_command_t command, * * Common handler to list out and clear all set watchpoints at a stroke. */ -static void -debug_watchall_common(sc_gameref_t game, - sc_command_t command, sc_command_type_t type) { +static void debug_watchall_common(sc_gameref_t game, sc_command_t command, sc_command_type_t type) { const sc_debuggerref_t debug = debug_get_debugger(game); assert(debug_is_valid(debug)); @@ -1854,8 +1814,7 @@ debug_watchall_common(sc_gameref_t game, * * Compare two objects, and return TRUE if the same. */ -static sc_bool -debug_compare_object(sc_gameref_t from, sc_gameref_t with, sc_int object) { +static sc_bool debug_compare_object(sc_gameref_t from, sc_gameref_t with, sc_int object) { const sc_objectstate_t *from_object = from->objects + object; const sc_objectstate_t *with_object = with->objects + object; @@ -1874,8 +1833,7 @@ debug_compare_object(sc_gameref_t from, sc_gameref_t with, sc_int object) { * * Compare two NPCs, and return TRUE if the same. */ -static sc_bool -debug_compare_npc(sc_gameref_t from, sc_gameref_t with, sc_int npc) { +static sc_bool debug_compare_npc(sc_gameref_t from, sc_gameref_t with, sc_int npc) { const sc_npcstate_t *from_npc = from->npcs + npc; const sc_npcstate_t *with_npc = with->npcs + npc; @@ -1897,8 +1855,7 @@ debug_compare_npc(sc_gameref_t from, sc_gameref_t with, sc_int npc) { * * Compare two events, and return TRUE if the same. */ -static sc_bool -debug_compare_event(sc_gameref_t from, sc_gameref_t with, sc_int event) { +static sc_bool debug_compare_event(sc_gameref_t from, sc_gameref_t with, sc_int event) { const sc_eventstate_t *from_event = from->events + event; const sc_eventstate_t *with_event = with->events + event; @@ -1912,8 +1869,7 @@ debug_compare_event(sc_gameref_t from, sc_gameref_t with, sc_int event) { * * Compare two tasks, and return TRUE if the same. */ -static sc_bool -debug_compare_task(sc_gameref_t from, sc_gameref_t with, sc_int task) { +static sc_bool debug_compare_task(sc_gameref_t from, sc_gameref_t with, sc_int task) { const sc_taskstate_t *from_task = from->tasks + task; const sc_taskstate_t *with_task = with->tasks + task; @@ -1927,8 +1883,7 @@ debug_compare_task(sc_gameref_t from, sc_gameref_t with, sc_int task) { * * Compare two variables, and return TRUE if the same. */ -static sc_bool -debug_compare_variable(sc_gameref_t from, sc_gameref_t with, sc_int variable) { +static sc_bool debug_compare_variable(sc_gameref_t from, sc_gameref_t with, sc_int variable) { const sc_prop_setref_t bundle = from->bundle; const sc_var_setref_t from_var = from->vars; const sc_var_setref_t with_var = with->vars; @@ -1975,12 +1930,9 @@ debug_compare_variable(sc_gameref_t from, sc_gameref_t with, sc_int variable) { * watchpoints flags array. Prints entries that differ, and returns TRUE * if any differed. */ -static sc_bool -debug_check_class(sc_gameref_t from, sc_gameref_t with, - const sc_char *class_, sc_int class_count, - const sc_bool *watchpoints, - sc_bool(*const compare_function) - (sc_gameref_t, sc_gameref_t, sc_int)) { +static sc_bool debug_check_class(sc_gameref_t from, sc_gameref_t with, const sc_char *class_, + sc_int class_count, const sc_bool *watchpoints, + sc_bool(*const compare_function) (sc_gameref_t, sc_gameref_t, sc_int)) { sc_int index_; sc_bool triggered = FALSE; @@ -2020,8 +1972,7 @@ debug_check_class(sc_gameref_t from, sc_gameref_t with, * TRUE if any triggered, FALSE if none (or if the undo game isn't available, * in which case no check is possible). */ -static sc_bool -debug_check_watchpoints(sc_gameref_t game) { +static sc_bool debug_check_watchpoints(sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); const sc_gameref_t undo = game->undo; sc_bool triggered; @@ -2071,10 +2022,8 @@ debug_check_watchpoints(sc_gameref_t game) { * appropriate command and its arguments. Returns DEBUG_NONE if the parse * fails. */ -static sc_command_t -debug_parse_command(const sc_char *command_string, - sc_command_type_t *type, - sc_int *arg1, sc_int *arg2, sc_command_t *help_topic) { +static sc_command_t debug_parse_command(const sc_char *command_string, + sc_command_type_t *type, sc_int *arg1, sc_int *arg2, sc_command_t *help_topic) { sc_command_t return_command; sc_command_type_t return_type; sc_int val1, val2, converted, matches; @@ -2186,10 +2135,8 @@ debug_parse_command(const sc_char *command_string, * * Dispatch a debugging command to the appropriate handler. */ -static void -debug_dispatch(sc_gameref_t game, - sc_command_t command, sc_command_type_t type, - sc_int arg1, sc_int arg2, sc_command_t help_topic) { +static void debug_dispatch(sc_gameref_t game, sc_command_t command, sc_command_type_t type, + sc_int arg1, sc_int arg2, sc_command_t help_topic) { /* Demultiplex debugging command, and call handlers. */ switch (command) { case DEBUG_HELP: @@ -2256,8 +2203,7 @@ debug_dispatch(sc_gameref_t game, * * Create a small debugging dialog with the user. */ -static void -debug_dialog(sc_gameref_t game) { +static void debug_dialog(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_debuggerref_t debug = debug_get_debugger(game); const sc_var_setref_t vars = gs_get_vars(game); @@ -2342,8 +2288,7 @@ debug_dialog(sc_gameref_t game) { * Handle a single debugging command line from the outside world. Returns * TRUE if valid, FALSE if invalid (parse failed, not understood). */ -sc_bool -debug_run_command(sc_gameref_t game, const sc_char *debug_command) { +sc_bool debug_run_command(sc_gameref_t game, const sc_char *debug_command) { const sc_debuggerref_t debug = debug_get_debugger(game); sc_command_t command, help_topic; sc_command_type_t type; @@ -2379,8 +2324,7 @@ debug_run_command(sc_gameref_t game, const sc_char *debug_command) { * a polite refusal if debugging is not enabled, otherwise runs a debugging * dialog. Uses if_print_string() as this isn't debug output. */ -sc_bool -debug_cmd_debugger(sc_gameref_t game) { +sc_bool debug_cmd_debugger(sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); /* If debugging disallowed (not initialized), ignore the call. */ @@ -2410,8 +2354,7 @@ debug_cmd_debugger(sc_gameref_t game) { * The second is called on exit from the game, and may make a final sweep for * watchpoints and offer the debug dialog one last time. */ -void -debug_game_started(sc_gameref_t game) { +void debug_game_started(sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); /* If debugging disallowed (not initialized), ignore the call. */ @@ -2438,8 +2381,7 @@ debug_game_started(sc_gameref_t game) { } } -void -debug_game_ended(sc_gameref_t game) { +void debug_game_ended(sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); /* If debugging disallowed (not initialized), ignore the call. */ @@ -2481,8 +2423,7 @@ debug_game_ended(sc_gameref_t game) { * Called after each turn by the main game loop. Checks for any set * watchpoints, and triggers a debug dialog when any fire. */ -void -debug_turn_update(sc_gameref_t game) { +void debug_turn_update(sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); /* If debugging disallowed (not initialized), ignore the call. */ @@ -2517,8 +2458,7 @@ debug_turn_update(sc_gameref_t game) { * and free'd on disabling; as a result, any set watchpoints are lost on * disabling. */ -void -debug_set_enabled(sc_gameref_t game, sc_bool enable) { +void debug_set_enabled(sc_gameref_t game, sc_bool enable) { const sc_debuggerref_t debug = debug_get_debugger(game); /* @@ -2534,8 +2474,7 @@ debug_set_enabled(sc_gameref_t game, sc_bool enable) { } } -sc_bool -debug_get_enabled(sc_gameref_t game) { +sc_bool debug_get_enabled(sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); return debug != NULL; diff --git a/engines/glk/adrift/scevents.cpp b/engines/glk/adrift/scevents.cpp index 0048cd6dd9..b7cea8b0f6 100644 --- a/engines/glk/adrift/scevents.cpp +++ b/engines/glk/adrift/scevents.cpp @@ -42,8 +42,7 @@ static sc_bool evt_trace = FALSE; * * Return TRUE if any task at all matches the given completion state. */ -static sc_bool -evt_any_task_in_state(sc_gameref_t game, sc_bool state) { +static sc_bool evt_any_task_in_state(sc_gameref_t game, sc_bool state) { sc_int task; /* Scan tasks for any whose completion matches input. */ @@ -62,8 +61,7 @@ evt_any_task_in_state(sc_gameref_t game, sc_bool state) { * * Return TRUE if player is in the right room for event text. */ -sc_bool -evt_can_see_event(sc_gameref_t game, sc_int event) { +sc_bool evt_can_see_event(sc_gameref_t game, sc_int event) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int type; @@ -102,8 +100,7 @@ evt_can_see_event(sc_gameref_t game, sc_int event) { * * Move an object from within an event. */ -static void -evt_move_object(sc_gameref_t game, sc_int object, sc_int destination) { +static void evt_move_object(sc_gameref_t game, sc_int object, sc_int destination) { /* Ignore negative values of object. */ if (object >= 0) { if (evt_trace) { @@ -158,8 +155,7 @@ evt_move_object(sc_gameref_t game, sc_int object, sc_int destination) { * comment. It's arguable if this is a feature or a bug; nevertheless, we * can do the same thing here, though it's ugly. */ -static sc_bool -evt_fixup_v390_v380_immediate_restart(sc_gameref_t game, sc_int event) { +static sc_bool evt_fixup_v390_v380_immediate_restart(sc_gameref_t game, sc_int event) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int version; @@ -195,8 +191,7 @@ evt_fixup_v390_v380_immediate_restart(sc_gameref_t game, sc_int event) { * * Change an event from WAITING to RUNNING. */ -static void -evt_start_event(sc_gameref_t game, sc_int event) { +static void evt_start_event(sc_gameref_t game, sc_int event) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; @@ -253,8 +248,7 @@ evt_start_event(sc_gameref_t game, sc_int event) { * * Return the starter type for an event. */ -static sc_int -evt_get_starter_type(sc_gameref_t game, sc_int event) { +static sc_int evt_get_starter_type(sc_gameref_t game, sc_int event) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int startertype; @@ -273,8 +267,7 @@ evt_get_starter_type(sc_gameref_t game, sc_int event) { * * Move an event to FINISHED, or restart it. */ -static void -evt_finish_event(sc_gameref_t game, sc_int event) { +static void evt_finish_event(sc_gameref_t game, sc_int event) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; @@ -415,16 +408,14 @@ evt_finish_event(sc_gameref_t game, sc_int event) { * * Return the status of start, pause and resume states of an event. */ -static sc_bool -evt_has_starter_task(sc_gameref_t game, sc_int event) { +static sc_bool evt_has_starter_task(sc_gameref_t game, sc_int event) { sc_int startertype; startertype = evt_get_starter_type(game, event); return startertype == 3; } -static sc_bool -evt_starter_task_is_complete(sc_gameref_t game, sc_int event) { +static sc_bool evt_starter_task_is_complete(sc_gameref_t game, sc_int event) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int task; @@ -447,8 +438,7 @@ evt_starter_task_is_complete(sc_gameref_t game, sc_int event) { return start; } -static sc_bool -evt_pauser_task_is_complete(sc_gameref_t game, sc_int event) { +static sc_bool evt_pauser_task_is_complete(sc_gameref_t game, sc_int event) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int pausetask; @@ -474,8 +464,7 @@ evt_pauser_task_is_complete(sc_gameref_t game, sc_int event) { return pause; } -static sc_bool -evt_resumer_task_is_complete(sc_gameref_t game, sc_int event) { +static sc_bool evt_resumer_task_is_complete(sc_gameref_t game, sc_int event) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int resumetask; @@ -508,8 +497,7 @@ evt_resumer_task_is_complete(sc_gameref_t game, sc_int event) { * Print messages and handle resources for the event where we're in mid-event * and getting close to some number of turns from its end. */ -static void -evt_handle_preftime_notifications(sc_gameref_t game, sc_int event) { +static void evt_handle_preftime_notifications(sc_gameref_t game, sc_int event) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; @@ -556,8 +544,7 @@ evt_handle_preftime_notifications(sc_gameref_t game, sc_int event) { * * Attempt to advance an event by one turn. */ -static void -evt_tick_event(sc_gameref_t game, sc_int event) { +static void evt_tick_event(sc_gameref_t game, sc_int event) { if (evt_trace) { sc_trace("Event: ticking event %ld: state %ld, time %ld\n", event, gs_event_state(game, event), gs_event_time(game, event)); @@ -742,8 +729,7 @@ evt_tick_event(sc_gameref_t game, sc_int event) { * * Attempt to advance each event by one turn. */ -void -evt_tick_events(sc_gameref_t game) { +void evt_tick_events(sc_gameref_t game) { sc_int event; /* @@ -778,8 +764,7 @@ evt_tick_events(sc_gameref_t game) { * * Set event tracing on/off. */ -void -evt_debug_trace(sc_bool flag) { +void evt_debug_trace(sc_bool flag) { evt_trace = flag; } diff --git a/engines/glk/adrift/scexpr.cpp b/engines/glk/adrift/scexpr.cpp index a316b7cdec..2375b5e5a7 100644 --- a/engines/glk/adrift/scexpr.cpp +++ b/engines/glk/adrift/scexpr.cpp @@ -71,11 +71,11 @@ enum { * Small tables tying multicharacter tokens strings to tokens. At present, * the string lengths for names are not used. */ -typedef struct { +struct sc_expr_multichar_t { const sc_char *const name; const sc_int length; const sc_int token; -} sc_expr_multichar_t; +}; static const sc_expr_multichar_t FUNCTION_TOKENS[] = { {"either", 6, TOK_EITHER}, @@ -103,8 +103,7 @@ static const sc_expr_multichar_t OPERATOR_TOKENS[] = { * Multicharacter token table search, returns the matching token, or * TOK_NONE if no match. */ -static sc_int -expr_multichar_search(const sc_char *name, const sc_expr_multichar_t *table) { +static sc_int expr_multichar_search(const sc_char *name, const sc_expr_multichar_t *table) { const sc_expr_multichar_t *entry; /* Scan the table for a case-independent full string match. */ @@ -131,8 +130,7 @@ static sc_int expr_current_token = TOK_NONE; * * Start and wrap up expression string tokenization. */ -static void -expr_tokenize_start(const sc_char *expression) { +static void expr_tokenize_start(const sc_char *expression) { static sc_bool initialized = FALSE; /* On first call only, verify the string lengths in the tables. */ @@ -171,8 +169,7 @@ expr_tokenize_start(const sc_char *expression) { expr_current_token = TOK_NONE; } -static void -expr_tokenize_end(void) { +static void expr_tokenize_end(void) { /* Deallocate temporary strings, clear expression. */ sc_free(expr_temporary); expr_temporary = NULL; @@ -189,8 +186,7 @@ expr_tokenize_end(void) { * Return the next token from the current expression. The initial token may * be adjusted into a unary +/- depending on the value of the previous token. */ -static sc_int -expr_next_token_unadjusted(sc_vartype_t *token_value) { +static sc_int expr_next_token_unadjusted(sc_vartype_t *token_value) { sc_int c; assert(expr_expression); @@ -334,8 +330,7 @@ expr_next_token_unadjusted(sc_vartype_t *token_value) { } } -static sc_int -expr_next_token(void) { +static sc_int expr_next_token(void) { sc_int token; sc_vartype_t token_value; @@ -391,8 +386,7 @@ expr_next_token(void) { * Return the token value of the current token. Undefined if the current * token is not numeric, an id, or a variable. */ -static void -expr_current_token_value(sc_vartype_t *value) { +static void expr_current_token_value(sc_vartype_t *value) { /* Quick check that the value is a valid one. */ switch (expr_current_token) { case TOK_INTEGER: @@ -416,10 +410,10 @@ expr_current_token_value(sc_vartype_t *value) { * integers and strings, and flags strings for possible garbage collection * on parse errors. */ -typedef struct { +struct sc_stack_t { sc_bool is_collectible; sc_vartype_t value; -} sc_stack_t; +}; static sc_stack_t expr_eval_stack[MAX_NESTING_DEPTH]; static sc_int expr_eval_stack_index = 0; @@ -432,8 +426,7 @@ static sc_var_setref_t expr_varset = NULL; * Reset the evaluation stack to an empty state, and register the variables * set to use when referencing %...% variables. */ -static void -expr_eval_start(sc_var_setref_t vars) { +static void expr_eval_start(sc_var_setref_t vars) { expr_eval_stack_index = 0; expr_varset = vars; } @@ -445,8 +438,7 @@ expr_eval_start(sc_var_setref_t vars) { * In case of parse error, empty out and free all collectible malloced * strings left in the evaluation array. */ -static void -expr_eval_garbage_collect(void) { +static void expr_eval_garbage_collect(void) { sc_int index_; /* @@ -473,8 +465,7 @@ expr_eval_garbage_collect(void) { * for this case, the input string is assumed to be already malloc'ed, and * the caller should not subsequently free the string. */ -static void -expr_eval_push_integer(sc_int value) { +static void expr_eval_push_integer(sc_int value) { if (expr_eval_stack_index >= MAX_NESTING_DEPTH) sc_fatal("expr_eval_push_integer: stack overflow\n"); @@ -482,8 +473,7 @@ expr_eval_push_integer(sc_int value) { expr_eval_stack[expr_eval_stack_index++].value.integer = value; } -static void -expr_eval_push_string(const sc_char *value) { +static void expr_eval_push_string(const sc_char *value) { sc_char *value_copy; if (expr_eval_stack_index >= MAX_NESTING_DEPTH) @@ -496,8 +486,7 @@ expr_eval_push_string(const sc_char *value) { expr_eval_stack[expr_eval_stack_index++].value.mutable_string = value_copy; } -static void -expr_eval_push_alloced_string(sc_char *value) { +static void expr_eval_push_alloced_string(sc_char *value) { if (expr_eval_stack_index >= MAX_NESTING_DEPTH) sc_fatal("expr_eval_push_alloced_string: stack overflow\n"); @@ -513,8 +502,7 @@ expr_eval_push_alloced_string(sc_char *value) { * Pop values off the values stack. Returned strings are malloc'ed copies, * and the caller is responsible for freeing them. */ -static sc_int -expr_eval_pop_integer(void) { +static sc_int expr_eval_pop_integer(void) { if (expr_eval_stack_index == 0) sc_fatal("expr_eval_pop_integer: stack underflow\n"); @@ -522,8 +510,7 @@ expr_eval_pop_integer(void) { return expr_eval_stack[--expr_eval_stack_index].value.integer; } -static sc_char * -expr_eval_pop_string(void) { +static sc_char *expr_eval_pop_string(void) { if (expr_eval_stack_index == 0) sc_fatal("expr_eval_pop_string: stack underflow\n"); @@ -538,8 +525,7 @@ expr_eval_pop_string(void) { * * Return the top of the values stack as the expression result. */ -static void -expr_eval_result(sc_vartype_t *vt_rvalue) { +static void expr_eval_result(sc_vartype_t *vt_rvalue) { if (expr_eval_stack_index != 1) sc_fatal("expr_eval_result: values stack not completed\n"); @@ -555,8 +541,7 @@ expr_eval_result(sc_vartype_t *vt_rvalue) { * Return the absolute value of the given sc_int. Replacement for labs(), * avoids tying sc_int to long types too closely. */ -static sc_int -expr_eval_abs(sc_int value) { +static sc_int expr_eval_abs(sc_int value) { return value < 0 ? -value : value; } @@ -569,8 +554,7 @@ static jmp_buf expr_parse_error; * * Evaluate the effect of a token into the values stack. */ -static void -expr_eval_action(sc_int token) { +static void expr_eval_action(sc_int token) { sc_vartype_t token_value; switch (token) { @@ -1069,8 +1053,7 @@ static void expr_parse_string_expr(void); * * Match a token to the lookahead, then advance lookahead. */ -static void -expr_parse_match(sc_int token) { +static void expr_parse_match(sc_int token) { if (expr_parse_lookahead == token) expr_parse_lookahead = expr_next_token(); else { @@ -1089,10 +1072,10 @@ expr_parse_match(sc_int token) { * a list with no operators (although in practice we need to put a TOK_NONE * in here since some C compilers won't accept { } as an empty initializer). */ -typedef struct { +struct sc_precedence_entry_t { const sc_int token_count; const sc_int tokens[6]; -} sc_precedence_entry_t; +}; #if 0 /* * Conventional (BASIC, C) precedence table for the parser. Exponentiation @@ -1136,8 +1119,7 @@ static const sc_precedence_entry_t PRECEDENCE_TABLE[] = { * Helper for expr_parse_numeric_element(). Search the token list for the * entry passed in, and return TRUE if it contains the given token. */ -static int -expr_parse_contains_token(const sc_precedence_entry_t *entry, sc_int token) { +static int expr_parse_contains_token(const sc_precedence_entry_t *entry, sc_int token) { sc_bool is_matched; sc_int index_; @@ -1161,8 +1143,7 @@ expr_parse_contains_token(const sc_precedence_entry_t *entry, sc_int token) { * to match tokens, then decide whether, and how, to recurse into itself, or * whether to parse a highest-precedence factor. */ -static void -expr_parse_numeric_element(sc_int precedence) { +static void expr_parse_numeric_element(sc_int precedence) { const sc_precedence_entry_t *entry; /* See if the level passed in has listed tokens. */ @@ -1195,8 +1176,7 @@ expr_parse_numeric_element(sc_int precedence) { * * Parse a complete numeric (sub-)expression. */ -static void -expr_parse_numeric_expr(void) { +static void expr_parse_numeric_expr(void) { /* Call the parser of the lowest precedence operators. */ expr_parse_numeric_element(0); } @@ -1207,8 +1187,7 @@ expr_parse_numeric_expr(void) { * * Parse a numeric expression factor. */ -static void -expr_parse_numeric_factor(void) { +static void expr_parse_numeric_factor(void) { /* Handle factors based on lookahead token. */ switch (expr_parse_lookahead) { /* Handle straightforward factors first. */ @@ -1365,8 +1344,7 @@ expr_parse_numeric_factor(void) { * * Parse a complete string (sub-)expression. */ -static void -expr_parse_string_expr(void) { +static void expr_parse_string_expr(void) { /* * Parse a string factor, then all repeated concatenations. Because the '+' * and '&' are context sensitive, we have to invent/translate them into the @@ -1386,8 +1364,7 @@ expr_parse_string_expr(void) { * * Parse a string expression factor. */ -static void -expr_parse_string_factor(void) { +static void expr_parse_string_factor(void) { /* Handle factors based on lookahead token. */ switch (expr_parse_lookahead) { /* Handle straightforward factors first. */ @@ -1499,9 +1476,8 @@ expr_parse_string_factor(void) { * Parse a string expression into a runtime values stack. Return the * value of the expression. */ -static sc_bool -expr_evaluate_expression(const sc_char *expression, sc_var_setref_t vars, - sc_int assign_type, sc_vartype_t *vt_rvalue) { +static sc_bool expr_evaluate_expression(const sc_char *expression, sc_var_setref_t vars, + sc_int assign_type, sc_vartype_t *vt_rvalue) { assert(assign_type == VAR_INTEGER || assign_type == VAR_STRING); /* Reset values stack and start tokenizer. */ @@ -1540,9 +1516,7 @@ expr_evaluate_expression(const sc_char *expression, sc_var_setref_t vars, * the return value is malloc'ed, and the caller is responsible for freeing * it. */ -sc_bool -expr_eval_numeric_expression(const sc_char *expression, - sc_var_setref_t vars, sc_int *rvalue) { +sc_bool expr_eval_numeric_expression(const sc_char *expression, sc_var_setref_t vars, sc_int *rvalue) { sc_vartype_t vt_rvalue; sc_bool status; assert(expression && vars && rvalue); @@ -1554,9 +1528,7 @@ expr_eval_numeric_expression(const sc_char *expression, return status; } -sc_bool -expr_eval_string_expression(const sc_char *expression, - sc_var_setref_t vars, sc_char **rvalue) { +sc_bool expr_eval_string_expression(const sc_char *expression, sc_var_setref_t vars, sc_char **rvalue) { sc_vartype_t vt_rvalue; sc_bool status; assert(expression && vars && rvalue); diff --git a/engines/glk/adrift/scgamest.cpp b/engines/glk/adrift/scgamest.cpp index f2af6b85d6..84abf6bb9e 100644 --- a/engines/glk/adrift/scgamest.cpp +++ b/engines/glk/adrift/scgamest.cpp @@ -36,8 +36,7 @@ static const sc_uint GAME_MAGIC = 0x35aed26e; * * Move the player to a given room, and check presence in a given room. */ -void -gs_move_player_to_room(sc_gameref_t game, sc_int room) { +void gs_move_player_to_room(sc_gameref_t game, sc_int room) { assert(gs_is_game_valid(game)); if (room < 0) { @@ -53,8 +52,7 @@ gs_move_player_to_room(sc_gameref_t game, sc_int room) { game->playerposition = 0; } -sc_bool -gs_player_in_room(sc_gameref_t game, sc_int room) { +sc_bool gs_player_in_room(sc_gameref_t game, sc_int room) { assert(gs_is_game_valid(game)); return game->playerroom == room; } @@ -65,8 +63,7 @@ gs_player_in_room(sc_gameref_t game, sc_int room) { * * Helper for event, room, object, and npc range assertions. */ -static sc_bool -gs_in_range(sc_int value, sc_int limit) { +static sc_bool gs_in_range(sc_int value, sc_int limit) { return value >= 0 && value < limit; } @@ -76,26 +73,22 @@ gs_in_range(sc_int value, sc_int limit) { * * Game accessors and mutators. */ -sc_var_setref_t -gs_get_vars(sc_gameref_t gs) { +sc_var_setref_t gs_get_vars(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->vars; } -sc_prop_setref_t -gs_get_bundle(sc_gameref_t gs) { +sc_prop_setref_t gs_get_bundle(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->bundle; } -sc_filterref_t -gs_get_filter(sc_gameref_t gs) { +sc_filterref_t gs_get_filter(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->filter; } -sc_memo_setref_t -gs_get_memento(sc_gameref_t gs) { +sc_memo_setref_t gs_get_memento(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->memento; } @@ -104,38 +97,32 @@ gs_get_memento(sc_gameref_t gs) { /* * Game accessors and mutators for the player. */ -void -gs_set_playerroom(sc_gameref_t gs, sc_int room) { +void gs_set_playerroom(sc_gameref_t gs, sc_int room) { assert(gs_is_game_valid(gs)); gs->playerroom = room; } -void -gs_set_playerposition(sc_gameref_t gs, sc_int position) { +void gs_set_playerposition(sc_gameref_t gs, sc_int position) { assert(gs_is_game_valid(gs)); gs->playerposition = position; } -void -gs_set_playerparent(sc_gameref_t gs, sc_int parent) { +void gs_set_playerparent(sc_gameref_t gs, sc_int parent) { assert(gs_is_game_valid(gs)); gs->playerparent = parent; } -sc_int -gs_playerroom(sc_gameref_t gs) { +sc_int gs_playerroom(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->playerroom; } -sc_int -gs_playerposition(sc_gameref_t gs) { +sc_int gs_playerposition(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->playerposition; } -sc_int -gs_playerparent(sc_gameref_t gs) { +sc_int gs_playerparent(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->playerparent; } @@ -144,38 +131,32 @@ gs_playerparent(sc_gameref_t gs) { /* * Game accessors and mutators for events. */ -sc_int -gs_event_count(sc_gameref_t gs) { +sc_int gs_event_count(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->event_count; } -void -gs_set_event_state(sc_gameref_t gs, sc_int event, sc_int state) { +void gs_set_event_state(sc_gameref_t gs, sc_int event, sc_int state) { assert(gs_is_game_valid(gs) && gs_in_range(event, gs->event_count)); gs->events[event].state = state; } -void -gs_set_event_time(sc_gameref_t gs, sc_int event, sc_int etime) { +void gs_set_event_time(sc_gameref_t gs, sc_int event, sc_int etime) { assert(gs_is_game_valid(gs) && gs_in_range(event, gs->event_count)); gs->events[event].time = etime; } -sc_int -gs_event_state(sc_gameref_t gs, sc_int event) { +sc_int gs_event_state(sc_gameref_t gs, sc_int event) { assert(gs_is_game_valid(gs) && gs_in_range(event, gs->event_count)); return gs->events[event].state; } -sc_int -gs_event_time(sc_gameref_t gs, sc_int event) { +sc_int gs_event_time(sc_gameref_t gs, sc_int event) { assert(gs_is_game_valid(gs) && gs_in_range(event, gs->event_count)); return gs->events[event].time; } -void -gs_decrement_event_time(sc_gameref_t gs, sc_int event) { +void gs_decrement_event_time(sc_gameref_t gs, sc_int event) { assert(gs_is_game_valid(gs) && gs_in_range(event, gs->event_count)); gs->events[event].time--; } @@ -184,20 +165,17 @@ gs_decrement_event_time(sc_gameref_t gs, sc_int event) { /* * Game accessors and mutators for rooms. */ -sc_int -gs_room_count(sc_gameref_t gs) { +sc_int gs_room_count(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->room_count; } -void -gs_set_room_seen(sc_gameref_t gs, sc_int room, sc_bool seen) { +void gs_set_room_seen(sc_gameref_t gs, sc_int room, sc_bool seen) { assert(gs_is_game_valid(gs) && gs_in_range(room, gs->room_count)); gs->rooms[room].visited = seen; } -sc_bool -gs_room_seen(sc_gameref_t gs, sc_int room) { +sc_bool gs_room_seen(sc_gameref_t gs, sc_int room) { assert(gs_is_game_valid(gs) && gs_in_range(room, gs->room_count)); return gs->rooms[room].visited; } @@ -206,32 +184,27 @@ gs_room_seen(sc_gameref_t gs, sc_int room) { /* * Game accessors and mutators for tasks. */ -sc_int -gs_task_count(sc_gameref_t gs) { +sc_int gs_task_count(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->task_count; } -void -gs_set_task_done(sc_gameref_t gs, sc_int task, sc_bool done) { +void gs_set_task_done(sc_gameref_t gs, sc_int task, sc_bool done) { assert(gs_is_game_valid(gs) && gs_in_range(task, gs->task_count)); gs->tasks[task].done = done; } -void -gs_set_task_scored(sc_gameref_t gs, sc_int task, sc_bool scored) { +void gs_set_task_scored(sc_gameref_t gs, sc_int task, sc_bool scored) { assert(gs_is_game_valid(gs) && gs_in_range(task, gs->task_count)); gs->tasks[task].scored = scored; } -sc_bool -gs_task_done(sc_gameref_t gs, sc_int task) { +sc_bool gs_task_done(sc_gameref_t gs, sc_int task) { assert(gs_is_game_valid(gs) && gs_in_range(task, gs->task_count)); return gs->tasks[task].done; } -sc_bool -gs_task_scored(sc_gameref_t gs, sc_int task) { +sc_bool gs_task_scored(sc_gameref_t gs, sc_int task) { assert(gs_is_game_valid(gs) && gs_in_range(task, gs->task_count)); return gs->tasks[task].scored; } @@ -240,142 +213,120 @@ gs_task_scored(sc_gameref_t gs, sc_int task) { /* * Game accessors and mutators for objects. */ -sc_int -gs_object_count(sc_gameref_t gs) { +sc_int gs_object_count(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->object_count; } -void -gs_set_object_openness(sc_gameref_t gs, sc_int object, sc_int openness) { +void gs_set_object_openness(sc_gameref_t gs, sc_int object, sc_int openness) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].openness = openness; } -void -gs_set_object_state(sc_gameref_t gs, sc_int object, sc_int state) { +void gs_set_object_state(sc_gameref_t gs, sc_int object, sc_int state) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].state = state; } -void -gs_set_object_seen(sc_gameref_t gs, sc_int object, sc_bool seen) { +void gs_set_object_seen(sc_gameref_t gs, sc_int object, sc_bool seen) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].seen = seen; } -void -gs_set_object_unmoved(sc_gameref_t gs, sc_int object, sc_bool unmoved) { +void gs_set_object_unmoved(sc_gameref_t gs, sc_int object, sc_bool unmoved) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].unmoved = unmoved; } -void -gs_set_object_static_unmoved(sc_gameref_t gs, sc_int object, sc_bool unmoved) { +void gs_set_object_static_unmoved(sc_gameref_t gs, sc_int object, sc_bool unmoved) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].static_unmoved = unmoved; } -sc_int -gs_object_openness(sc_gameref_t gs, sc_int object) { +sc_int gs_object_openness(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); return gs->objects[object].openness; } -sc_int -gs_object_state(sc_gameref_t gs, sc_int object) { +sc_int gs_object_state(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); return gs->objects[object].state; } -sc_bool -gs_object_seen(sc_gameref_t gs, sc_int object) { +sc_bool gs_object_seen(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); return gs->objects[object].seen; } -sc_bool -gs_object_unmoved(sc_gameref_t gs, sc_int object) { +sc_bool gs_object_unmoved(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); return gs->objects[object].unmoved; } -sc_bool -gs_object_static_unmoved(sc_gameref_t gs, sc_int object) { +sc_bool gs_object_static_unmoved(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); return gs->objects[object].static_unmoved; } -sc_int -gs_object_position(sc_gameref_t gs, sc_int object) { +sc_int gs_object_position(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); return gs->objects[object].position; } -sc_int -gs_object_parent(sc_gameref_t gs, sc_int object) { +sc_int gs_object_parent(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); return gs->objects[object].parent; } -static void -gs_object_move_onto_unchecked(sc_gameref_t gs, sc_int object, sc_int onto) { +static void gs_object_move_onto_unchecked(sc_gameref_t gs, sc_int object, sc_int onto) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].position = OBJ_ON_OBJECT; gs->objects[object].parent = onto; } -static void -gs_object_move_into_unchecked(sc_gameref_t gs, sc_int object, sc_int into) { +static void gs_object_move_into_unchecked(sc_gameref_t gs, sc_int object, sc_int into) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].position = OBJ_IN_OBJECT; gs->objects[object].parent = into; } -static void -gs_object_make_hidden_unchecked(sc_gameref_t gs, sc_int object) { +static void gs_object_make_hidden_unchecked(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].position = OBJ_HIDDEN; gs->objects[object].parent = -1; } -static void -gs_object_player_get_unchecked(sc_gameref_t gs, sc_int object) { +static void gs_object_player_get_unchecked(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].position = OBJ_HELD_PLAYER; gs->objects[object].parent = -1; } -static void -gs_object_npc_get_unchecked(sc_gameref_t gs, sc_int object, sc_int npc) { +static void gs_object_npc_get_unchecked(sc_gameref_t gs, sc_int object, sc_int npc) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].position = OBJ_HELD_NPC; gs->objects[object].parent = npc; } -static void -gs_object_player_wear_unchecked(sc_gameref_t gs, sc_int object) { +static void gs_object_player_wear_unchecked(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].position = OBJ_WORN_PLAYER; gs->objects[object].parent = 0; } -static void -gs_object_npc_wear_unchecked(sc_gameref_t gs, sc_int object, sc_int npc) { +static void gs_object_npc_wear_unchecked(sc_gameref_t gs, sc_int object, sc_int npc) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].position = OBJ_WORN_NPC; gs->objects[object].parent = npc; } -static void -gs_object_to_room_unchecked(sc_gameref_t gs, sc_int object, sc_int room) { +static void gs_object_to_room_unchecked(sc_gameref_t gs, sc_int object, sc_int room) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); gs->objects[object].position = room + 1; gs->objects[object].parent = -1; } -void -gs_object_move_onto(sc_gameref_t gs, sc_int object, sc_int onto) { +void gs_object_move_onto(sc_gameref_t gs, sc_int object, sc_int onto) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); if (gs->objects[object].position != OBJ_ON_OBJECT || gs->objects[object].parent != onto) { @@ -384,8 +335,7 @@ gs_object_move_onto(sc_gameref_t gs, sc_int object, sc_int onto) { } } -void -gs_object_move_into(sc_gameref_t gs, sc_int object, sc_int into) { +void gs_object_move_into(sc_gameref_t gs, sc_int object, sc_int into) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); if (gs->objects[object].position != OBJ_IN_OBJECT || gs->objects[object].parent != into) { @@ -394,8 +344,7 @@ gs_object_move_into(sc_gameref_t gs, sc_int object, sc_int into) { } } -void -gs_object_make_hidden(sc_gameref_t gs, sc_int object) { +void gs_object_make_hidden(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); if (gs->objects[object].position != OBJ_HIDDEN) { gs_object_make_hidden_unchecked(gs, object); @@ -403,8 +352,7 @@ gs_object_make_hidden(sc_gameref_t gs, sc_int object) { } } -void -gs_object_player_get(sc_gameref_t gs, sc_int object) { +void gs_object_player_get(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); if (gs->objects[object].position != OBJ_HELD_PLAYER) { gs_object_player_get_unchecked(gs, object); @@ -412,8 +360,7 @@ gs_object_player_get(sc_gameref_t gs, sc_int object) { } } -void -gs_object_npc_get(sc_gameref_t gs, sc_int object, sc_int npc) { +void gs_object_npc_get(sc_gameref_t gs, sc_int object, sc_int npc) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); if (gs->objects[object].position != OBJ_HELD_NPC || gs->objects[object].parent != npc) { @@ -422,8 +369,7 @@ gs_object_npc_get(sc_gameref_t gs, sc_int object, sc_int npc) { } } -void -gs_object_player_wear(sc_gameref_t gs, sc_int object) { +void gs_object_player_wear(sc_gameref_t gs, sc_int object) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); if (gs->objects[object].position != OBJ_WORN_PLAYER) { gs_object_player_wear_unchecked(gs, object); @@ -431,8 +377,7 @@ gs_object_player_wear(sc_gameref_t gs, sc_int object) { } } -void -gs_object_npc_wear(sc_gameref_t gs, sc_int object, sc_int npc) { +void gs_object_npc_wear(sc_gameref_t gs, sc_int object, sc_int npc) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); if (gs->objects[object].position != OBJ_WORN_NPC || gs->objects[object].parent != npc) { @@ -441,8 +386,7 @@ gs_object_npc_wear(sc_gameref_t gs, sc_int object, sc_int npc) { } } -void -gs_object_to_room(sc_gameref_t gs, sc_int object, sc_int room) { +void gs_object_to_room(sc_gameref_t gs, sc_int object, sc_int room) { assert(gs_is_game_valid(gs) && gs_in_range(object, gs->object_count)); if (gs->objects[object].position != room + 1) { gs_object_to_room_unchecked(gs, object, room); @@ -454,83 +398,70 @@ gs_object_to_room(sc_gameref_t gs, sc_int object, sc_int room) { /* * Game accessors and mutators for NPCs. */ -sc_int -gs_npc_count(sc_gameref_t gs) { +sc_int gs_npc_count(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); return gs->npc_count; } -void -gs_set_npc_location(sc_gameref_t gs, sc_int npc, sc_int location) { +void gs_set_npc_location(sc_gameref_t gs, sc_int npc, sc_int location) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count)); gs->npcs[npc].location = location; } -sc_int -gs_npc_location(sc_gameref_t gs, sc_int npc) { +sc_int gs_npc_location(sc_gameref_t gs, sc_int npc) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count)); return gs->npcs[npc].location; } -void -gs_set_npc_position(sc_gameref_t gs, sc_int npc, sc_int position) { +void gs_set_npc_position(sc_gameref_t gs, sc_int npc, sc_int position) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count)); gs->npcs[npc].position = position; } -sc_int -gs_npc_position(sc_gameref_t gs, sc_int npc) { +sc_int gs_npc_position(sc_gameref_t gs, sc_int npc) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count)); return gs->npcs[npc].position; } -void -gs_set_npc_parent(sc_gameref_t gs, sc_int npc, sc_int parent) { +void gs_set_npc_parent(sc_gameref_t gs, sc_int npc, sc_int parent) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count)); gs->npcs[npc].parent = parent; } -sc_int -gs_npc_parent(sc_gameref_t gs, sc_int npc) { +sc_int gs_npc_parent(sc_gameref_t gs, sc_int npc) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count)); return gs->npcs[npc].parent; } -void -gs_set_npc_seen(sc_gameref_t gs, sc_int npc, sc_bool seen) { +void gs_set_npc_seen(sc_gameref_t gs, sc_int npc, sc_bool seen) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count)); gs->npcs[npc].seen = seen; } -sc_bool -gs_npc_seen(sc_gameref_t gs, sc_int npc) { +sc_bool gs_npc_seen(sc_gameref_t gs, sc_int npc) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count)); return gs->npcs[npc].seen; } -sc_int -gs_npc_walkstep_count(sc_gameref_t gs, sc_int npc) { +sc_int gs_npc_walkstep_count(sc_gameref_t gs, sc_int npc) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count)); return gs->npcs[npc].walkstep_count; } -void -gs_set_npc_walkstep(sc_gameref_t gs, +void gs_set_npc_walkstep(sc_gameref_t gs, sc_int npc, sc_int walk, sc_int walkstep) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count) && gs_in_range(walk, gs->npcs[npc].walkstep_count)); gs->npcs[npc].walksteps[walk] = walkstep; } -sc_int -gs_npc_walkstep(sc_gameref_t gs, sc_int npc, sc_int walk) { +sc_int gs_npc_walkstep(sc_gameref_t gs, sc_int npc, sc_int walk) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count) && gs_in_range(walk, gs->npcs[npc].walkstep_count)); return gs->npcs[npc].walksteps[walk]; } -void -gs_decrement_npc_walkstep(sc_gameref_t gs, sc_int npc, sc_int walk) { +void gs_decrement_npc_walkstep(sc_gameref_t gs, sc_int npc, sc_int walk) { assert(gs_is_game_valid(gs) && gs_in_range(npc, gs->npc_count) && gs_in_range(walk, gs->npcs[npc].walkstep_count)); gs->npcs[npc].walksteps[walk]--; @@ -540,29 +471,25 @@ gs_decrement_npc_walkstep(sc_gameref_t gs, sc_int npc, sc_int walk) { /* * Convenience functions for bulk clearance of references. */ -void -gs_clear_npc_references(sc_gameref_t gs) { +void gs_clear_npc_references(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); memset(gs->npc_references, FALSE, gs->npc_count * sizeof(*gs->npc_references)); } -void -gs_clear_object_references(sc_gameref_t gs) { +void gs_clear_object_references(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); memset(gs->object_references, FALSE, gs->object_count * sizeof(*gs->object_references)); } -void -gs_set_multiple_references(sc_gameref_t gs) { +void gs_set_multiple_references(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); memset(gs->multiple_references, TRUE, gs->object_count * sizeof(*gs->multiple_references)); } -void -gs_clear_multiple_references(sc_gameref_t gs) { +void gs_clear_multiple_references(sc_gameref_t gs) { assert(gs_is_game_valid(gs)); memset(gs->multiple_references, FALSE, gs->object_count * sizeof(*gs->multiple_references)); @@ -574,9 +501,7 @@ gs_clear_multiple_references(sc_gameref_t gs) { * * Create and initialize a game state. */ -sc_gameref_t -gs_create(sc_var_setref_t vars, - sc_prop_setref_t bundle, sc_filterref_t filter) { +sc_gameref_t gs_create(sc_var_setref_t vars, sc_prop_setref_t bundle, sc_filterref_t filter) { sc_gameref_t game; sc_vartype_t vt_key[4]; sc_int index_, bytes; @@ -871,8 +796,7 @@ gs_create(sc_var_setref_t vars, * * Return TRUE if pointer is a valid game, FALSE otherwise. */ -sc_bool -gs_is_game_valid(sc_gameref_t game) { +sc_bool gs_is_game_valid(sc_gameref_t game) { return game && game->magic == GAME_MAGIC; } @@ -883,8 +807,7 @@ gs_is_game_valid(sc_gameref_t game) { * Helper for gs_copy(), copies one malloc'ed string to another, or NULL * if from is NULL, taking care not to leak memory. */ -static void -gs_string_copy(sc_char **to_string, const sc_char *from_string) { +static void gs_string_copy(sc_char **to_string, const sc_char *from_string) { /* Free any current contents of to_string. */ sc_free(*to_string); @@ -903,8 +826,7 @@ gs_string_copy(sc_char **to_string, const sc_char *from_string) { * Deep-copy the dynamic parts of a game onto another existing * game structure. */ -void -gs_copy(sc_gameref_t to, sc_gameref_t from) { +void gs_copy(sc_gameref_t to, sc_gameref_t from) { const sc_prop_setref_t bundle = from->bundle; sc_vartype_t vt_key[3]; sc_int var_count, var, npc; @@ -1048,8 +970,7 @@ gs_copy(sc_gameref_t to, sc_gameref_t from) { * * Free all the memory associated with a game state. */ -void -gs_destroy(sc_gameref_t game) { +void gs_destroy(sc_gameref_t game) { sc_int npc; assert(gs_is_game_valid(game)); diff --git a/engines/glk/adrift/scinterf.cpp b/engines/glk/adrift/scinterf.cpp index c5e53e959d..ff7456b120 100644 --- a/engines/glk/adrift/scinterf.cpp +++ b/engines/glk/adrift/scinterf.cpp @@ -45,8 +45,7 @@ static sc_uint if_trace_flags = 0; * First-time runtime checks for the overall interpreter. This function * tries to ensure correct compile options. */ -static void -if_initialize(void) { +static void if_initialize(void) { static sc_bool initialized = FALSE; /* Only do checks on the first call. */ @@ -79,13 +78,11 @@ if_initialize(void) { * Set and retrieve tracing flags. Setting new values propagates the new * tracing setting to all modules that support it. */ -static sc_bool -if_bool(sc_uint flag) { +static sc_bool if_bool(sc_uint flag) { return flag ? TRUE : FALSE; } -void -sc_set_trace_flags(sc_uint trace_flags) { +void sc_set_trace_flags(sc_uint trace_flags) { if_initialize(); /* Save the value for queries. */ @@ -105,8 +102,7 @@ sc_set_trace_flags(sc_uint trace_flags) { pf_debug_trace(if_bool(trace_flags & SC_TRACE_PRINTFILTER)); } -sc_bool -if_get_trace_flag(sc_uint bitmask) { +sc_bool if_get_trace_flag(sc_uint bitmask) { return if_bool(if_trace_flags & bitmask); } @@ -122,28 +118,22 @@ if_get_trace_flag(sc_uint bitmask) { * * Call OS-specific print function for the given arguments. */ -static void -if_print_string_common(const sc_char *string, - void (*print_string_function)(const sc_char *)) { +static void if_print_string_common(const sc_char *string, void (*print_string_function)(const sc_char *)) { assert(string); if (string[0] != NUL) print_string_function(string); } -void -if_print_string(const sc_char *string) { +void if_print_string(const sc_char *string) { if_print_string_common(string, os_print_string); } -void -if_print_debug(const sc_char *string) { +void if_print_debug(const sc_char *string) { if_print_string_common(string, os_print_string_debug); } -static void -if_print_character_common(sc_char character, - void (*print_string_function)(const sc_char *)) { +static void if_print_character_common(sc_char character, void (*print_string_function)(const sc_char *)) { if (character != NUL) { sc_char buffer[2]; @@ -153,18 +143,15 @@ if_print_character_common(sc_char character, } } -void -if_print_character(sc_char character) { +void if_print_character(sc_char character) { if_print_character_common(character, os_print_string); } -void -if_print_debug_character(sc_char character) { +void if_print_debug_character(sc_char character) { if_print_character_common(character, os_print_string_debug); } -void -if_print_tag(sc_int tag, const sc_char *arg) { +void if_print_tag(sc_int tag, const sc_char *arg) { assert(arg); os_print_tag(tag, arg); @@ -179,9 +166,8 @@ if_print_tag(sc_int tag, const sc_char *arg) { * Call OS-specific line read function. Clean up any read data a little * before returning it to the caller. */ -static void -if_read_line_common(sc_char *buffer, sc_int length, - sc_bool(*read_line_function)(sc_char *, sc_int)) { +static void if_read_line_common(sc_char *buffer, sc_int length, + sc_bool(*read_line_function)(sc_char *, sc_int)) { sc_bool is_line_available; sc_int last; assert(buffer && length > 0); @@ -204,13 +190,11 @@ if_read_line_common(sc_char *buffer, sc_int length, buffer[last--] = NUL; } -void -if_read_line(sc_char *buffer, sc_int length) { +void if_read_line(sc_char *buffer, sc_int length) { if_read_line_common(buffer, length, os_read_line); } -void -if_read_debug(sc_char *buffer, sc_int length) { +void if_read_debug(sc_char *buffer, sc_int length) { if_read_line_common(buffer, length, os_read_line_debug); } @@ -220,8 +204,7 @@ if_read_debug(sc_char *buffer, sc_int length) { * * Call OS-specific confirm function. */ -sc_bool -if_confirm(sc_int type) { +sc_bool if_confirm(sc_int type) { return os_confirm(type); } @@ -234,27 +217,23 @@ if_confirm(sc_int type) { * * Call OS-specific functions for saving and restoring games. */ -void * -if_open_saved_game(sc_bool is_save) { +void *if_open_saved_game(sc_bool is_save) { return os_open_file(is_save); } -void -if_write_saved_game(void *opaque, const sc_byte *buffer, sc_int length) { +void if_write_saved_game(void *opaque, const sc_byte *buffer, sc_int length) { assert(buffer); os_write_file(opaque, buffer, length); } -sc_int -if_read_saved_game(void *opaque, sc_byte *buffer, sc_int length) { +sc_int if_read_saved_game(void *opaque, sc_byte *buffer, sc_int length) { assert(buffer); return os_read_file(opaque, buffer, length); } -void -if_close_saved_game(void *opaque) { +void if_close_saved_game(void *opaque) { os_close_file(opaque); } @@ -264,8 +243,7 @@ if_close_saved_game(void *opaque) { * * Call OS-specific hint display function. */ -void -if_display_hints(sc_gameref_t game) { +void if_display_hints(sc_gameref_t game) { assert(gs_is_game_valid(game)); os_display_hints((sc_game) game); @@ -278,18 +256,15 @@ if_display_hints(sc_gameref_t game) { * * Call OS-specific sound and graphic handler functions. */ -void -if_update_sound(const sc_char *filename, - sc_int sound_offset, sc_int sound_length, - sc_bool is_looping) { +void if_update_sound(const sc_char *filename, sc_int sound_offset, sc_int sound_length, + sc_bool is_looping) { if (strlen(filename) > 0) os_play_sound(filename, sound_offset, sound_length, is_looping); else os_stop_sound(); } -void -if_update_graphic(const sc_char *filename, +void if_update_graphic(const sc_char *filename, sc_int graphic_offset, sc_int graphic_length) { os_show_graphic(filename, graphic_offset, graphic_length); } @@ -301,14 +276,12 @@ if_update_graphic(const sc_char *filename, * * Return a version string and Adrift emulation level. */ -const sc_char * -sc_scare_version(void) { +const sc_char *sc_scare_version(void) { if_initialize(); return "SCARE " SCARE_VERSION SCARE_PATCH_LEVEL; } -sc_int -sc_scare_emulation(void) { +sc_int sc_scare_emulation(void) { if_initialize(); return SCARE_EMULATION; } @@ -321,8 +294,7 @@ sc_scare_emulation(void) { * Standard FILE* reader and writer callback for constructing callback-style * calls from filename and stream variants. */ -static sc_int -if_file_read_callback(void *opaque, sc_byte *buffer, sc_int length) { +static sc_int if_file_read_callback(void *opaque, sc_byte *buffer, sc_int length) { Common::SeekableReadStream *stream = (Common::SeekableReadStream *)opaque; sc_int bytes; @@ -350,8 +322,7 @@ static void if_file_write_callback(void *opaque, const sc_byte *buffer, sc_int l * Called by the OS-specific layer to create a run context. The _filename() * and _stream() variants are adapters for run_create(). */ -sc_game -sc_game_from_filename(const sc_char *filename) { +sc_game sc_game_from_filename(const sc_char *filename) { Common::File *stream; sc_game game; @@ -384,9 +355,7 @@ sc_game sc_game_from_stream(Common::SeekableReadStream *stream) { return run_create(if_file_read_callback, stream); } -sc_game -sc_game_from_callback(sc_int(*callback)(void *, sc_byte *, sc_int), - void *opaque) { +sc_game sc_game_from_callback(sc_int(*callback)(void *, sc_byte *, sc_int), void *opaque) { if_initialize(); if (!callback) { sc_error("sc_game_from_callback: nullptr callback\n"); @@ -403,8 +372,7 @@ sc_game_from_callback(sc_int(*callback)(void *, sc_byte *, sc_int), * Common function to verify that the game passed in to functions below * is a valid game. Returns TRUE on game error, FALSE if okay. */ -static sc_bool -if_game_error(sc_gameref_t game, const sc_char *function_name) { +static sc_bool if_game_error(sc_gameref_t game, const sc_char *function_name) { /* Check for invalid game -- null pointer or bad magic. */ if (!gs_is_game_valid(game)) { if (game) @@ -435,8 +403,7 @@ if_game_error(sc_gameref_t game, const sc_char *function_name) { * behaving like sc_restart_game()), but will return if the game could not * be restored. sc_undo_game_turn() behaves like sc_load_game(). */ -void -sc_interpret_game(sc_game game) { +void sc_interpret_game(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_interpret_game")) @@ -445,8 +412,7 @@ sc_interpret_game(sc_game game) { run_interpret(game_); } -void -sc_restart_game(sc_game game) { +void sc_restart_game(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_restart_game")) @@ -455,8 +421,7 @@ sc_restart_game(sc_game game) { run_restart(game_); } -sc_bool -sc_save_game(sc_game game) { +sc_bool sc_save_game(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_save_game")) @@ -465,8 +430,7 @@ sc_save_game(sc_game game) { return run_save_prompted(game_); } -sc_bool -sc_load_game(sc_game game) { +sc_bool sc_load_game(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_load_game")) @@ -475,8 +439,7 @@ sc_load_game(sc_game game) { return run_restore_prompted(game_); } -sc_bool -sc_undo_game_turn(sc_game game) { +sc_bool sc_undo_game_turn(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_undo_game_turn")) @@ -485,8 +448,7 @@ sc_undo_game_turn(sc_game game) { return run_undo(game_); } -void -sc_quit_game(sc_game game) { +void sc_quit_game(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_quit_game")) @@ -510,8 +472,7 @@ sc_quit_game(sc_game game) { * These alternative forms allow the caller to directly specify the data * streams. */ -sc_bool -sc_save_game_to_filename(sc_game game, const sc_char *filename) { +sc_bool sc_save_game_to_filename(sc_game game, const sc_char *filename) { const sc_gameref_t game_ = (const sc_gameref_t)game; Common::OutSaveFile *sf; @@ -536,8 +497,7 @@ sc_save_game_to_filename(sc_game game, const sc_char *filename) { return TRUE; } -void -sc_save_game_to_stream(sc_game game, Common::SeekableReadStream *stream) { +void sc_save_game_to_stream(sc_game game, Common::SeekableReadStream *stream) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_save_game_to_stream")) @@ -551,10 +511,8 @@ sc_save_game_to_stream(sc_game game, Common::SeekableReadStream *stream) { run_save(game_, if_file_write_callback, stream); } -void -sc_save_game_to_callback(sc_game game, - void (*callback)(void *, const sc_byte *, sc_int), - void *opaque) { +void sc_save_game_to_callback(sc_game game, + void (*callback)(void *, const sc_byte *, sc_int), void *opaque) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_save_game_to_callback")) @@ -568,8 +526,7 @@ sc_save_game_to_callback(sc_game game, run_save(game_, callback, opaque); } -sc_bool -sc_load_game_from_filename(sc_game game, const sc_char *filename) { +sc_bool sc_load_game_from_filename(sc_game game, const sc_char *filename) { const sc_gameref_t game_ = (const sc_gameref_t)game; Common::InSaveFile *sf; sc_bool status; @@ -594,8 +551,7 @@ sc_load_game_from_filename(sc_game game, const sc_char *filename) { return status; } -sc_bool -sc_load_game_from_stream(sc_game game, Common::SeekableReadStream *stream) { +sc_bool sc_load_game_from_stream(sc_game game, Common::SeekableReadStream *stream) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_load_game_from_stream")) @@ -609,10 +565,8 @@ sc_load_game_from_stream(sc_game game, Common::SeekableReadStream *stream) { return run_restore(game_, if_file_read_callback, stream); } -sc_bool -sc_load_game_from_callback(sc_game game, - sc_int(*callback)(void *, sc_byte *, sc_int), - void *opaque) { +sc_bool sc_load_game_from_callback(sc_game game, + sc_int(*callback)(void *, sc_byte *, sc_int), void *opaque) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_load_game_from_callback")) @@ -632,8 +586,7 @@ sc_load_game_from_callback(sc_game game, * * Called by the OS-specific layer to free run context memory. */ -void -sc_free_game(sc_game game) { +void sc_free_game(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_free_game")) @@ -662,8 +615,7 @@ sc_free_game(sc_game game) { * * Return a few attributes of a game. */ -sc_bool -sc_is_game_running(sc_game game) { +sc_bool sc_is_game_running(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_is_game_running")) @@ -672,8 +624,7 @@ sc_is_game_running(sc_game game) { return run_is_running(game_); } -const sc_char * -sc_get_game_name(sc_game game) { +const sc_char *sc_get_game_name(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; const sc_char *retval; @@ -700,8 +651,7 @@ sc_get_game_author(sc_game game) { return retval; } -const sc_char * -sc_get_game_compile_date(sc_game game) { +const sc_char *sc_get_game_compile_date(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; const sc_char *retval; @@ -713,8 +663,7 @@ sc_get_game_compile_date(sc_game game) { return retval; } -sc_int -sc_get_game_turns(sc_game game) { +sc_int sc_get_game_turns(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; sc_int retval; @@ -726,8 +675,7 @@ sc_get_game_turns(sc_game game) { return retval; } -sc_int -sc_get_game_score(sc_game game) { +sc_int sc_get_game_score(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; sc_int retval; @@ -739,8 +687,7 @@ sc_get_game_score(sc_game game) { return retval; } -sc_int -sc_get_game_max_score(sc_game game) { +sc_int sc_get_game_max_score(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; sc_int retval; @@ -752,8 +699,7 @@ sc_get_game_max_score(sc_game game) { return retval; } -const sc_char * -sc_get_game_room(sc_game game) { +const sc_char *sc_get_game_room(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; const sc_char *retval; @@ -765,8 +711,7 @@ sc_get_game_room(sc_game game) { return retval; } -const sc_char * -sc_get_game_status_line(sc_game game) { +const sc_char *sc_get_game_status_line(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; const sc_char *retval; @@ -778,8 +723,7 @@ sc_get_game_status_line(sc_game game) { return retval; } -const sc_char * -sc_get_game_preferred_font(sc_game game) { +const sc_char *sc_get_game_preferred_font(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; const sc_char *retval; @@ -791,8 +735,7 @@ sc_get_game_preferred_font(sc_game game) { return retval; } -sc_bool -sc_get_game_bold_room_names(sc_game game) { +sc_bool sc_get_game_bold_room_names(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; sc_bool retval; @@ -804,8 +747,7 @@ sc_get_game_bold_room_names(sc_game game) { return retval; } -sc_bool -sc_get_game_verbose(sc_game game) { +sc_bool sc_get_game_verbose(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; sc_bool retval; @@ -817,8 +759,7 @@ sc_get_game_verbose(sc_game game) { return retval; } -sc_bool -sc_get_game_notify_score_change(sc_game game) { +sc_bool sc_get_game_notify_score_change(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; sc_bool retval; @@ -830,8 +771,7 @@ sc_get_game_notify_score_change(sc_game game) { return retval; } -sc_bool -sc_has_game_completed(sc_game game) { +sc_bool sc_has_game_completed(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_has_game_completed")) @@ -840,8 +780,7 @@ sc_has_game_completed(sc_game game) { return run_has_completed(game_); } -sc_bool -sc_is_game_undo_available(sc_game game) { +sc_bool sc_is_game_undo_available(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_is_game_undo_available")) @@ -858,8 +797,7 @@ sc_is_game_undo_available(sc_game game) { * * Set a few attributes of a game. */ -void -sc_set_game_bold_room_names(sc_game game, sc_bool flag) { +void sc_set_game_bold_room_names(sc_game game, sc_bool flag) { const sc_gameref_t game_ = (const sc_gameref_t)game; sc_bool bold, verbose, notify; @@ -871,8 +809,7 @@ sc_set_game_bold_room_names(sc_game game, sc_bool flag) { run_set_attributes(game_, flag, verbose, notify); } -void -sc_set_game_verbose(sc_game game, sc_bool flag) { +void sc_set_game_verbose(sc_game game, sc_bool flag) { const sc_gameref_t game_ = (const sc_gameref_t)game; sc_bool bold, verbose, notify; @@ -884,8 +821,7 @@ sc_set_game_verbose(sc_game game, sc_bool flag) { run_set_attributes(game_, bold, flag, notify); } -void -sc_set_game_notify_score_change(sc_game game, sc_bool flag) { +void sc_set_game_notify_score_change(sc_game game, sc_bool flag) { const sc_gameref_t game_ = (const sc_gameref_t)game; sc_bool bold, verbose, notify; @@ -904,8 +840,7 @@ sc_set_game_notify_score_change(sc_game game, sc_bool flag) { * * Indicate the game's use of resources. */ -sc_bool -sc_does_game_use_sounds(sc_game game) { +sc_bool sc_does_game_use_sounds(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_does_game_use_sounds")) @@ -914,8 +849,7 @@ sc_does_game_use_sounds(sc_game game) { return res_has_sound(game_); } -sc_bool -sc_does_game_use_graphics(sc_game game) { +sc_bool sc_does_game_use_graphics(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_does_game_use_graphics")) @@ -934,8 +868,7 @@ sc_does_game_use_graphics(sc_game game) { * * Iterate currently available hints, and return strings for a hint. */ -sc_game_hint -sc_get_first_game_hint(sc_game game) { +sc_game_hint sc_get_first_game_hint(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_get_first_game_hint")) @@ -944,8 +877,7 @@ sc_get_first_game_hint(sc_game game) { return run_hint_iterate(game_, nullptr); } -sc_game_hint -sc_get_next_game_hint(sc_game game, sc_game_hint hint) { +sc_game_hint sc_get_next_game_hint(sc_game game, sc_game_hint hint) { const sc_gameref_t game_ = (const sc_gameref_t)game; const sc_hintref_t hint_ = (const sc_hintref_t)hint; @@ -959,8 +891,7 @@ sc_get_next_game_hint(sc_game game, sc_game_hint hint) { return run_hint_iterate(game_, hint_); } -const sc_char * -sc_get_game_hint_question(sc_game game, sc_game_hint hint) { +const sc_char *sc_get_game_hint_question(sc_game game, sc_game_hint hint) { const sc_gameref_t game_ = (const sc_gameref_t)game; const sc_hintref_t hint_ = (const sc_hintref_t)hint; @@ -974,8 +905,7 @@ sc_get_game_hint_question(sc_game game, sc_game_hint hint) { return run_get_hint_question(game_, hint_); } -const sc_char * -sc_get_game_subtle_hint(sc_game game, sc_game_hint hint) { +const sc_char *sc_get_game_subtle_hint(sc_game game, sc_game_hint hint) { const sc_gameref_t game_ = (const sc_gameref_t)game; const sc_hintref_t hint_ = (const sc_hintref_t)hint; @@ -989,8 +919,7 @@ sc_get_game_subtle_hint(sc_game game, sc_game_hint hint) { return run_get_subtle_hint(game_, hint_); } -const sc_char * -sc_get_game_unsubtle_hint(sc_game game, sc_game_hint hint) { +const sc_char *sc_get_game_unsubtle_hint(sc_game game, sc_game_hint hint) { const sc_gameref_t game_ = (const sc_gameref_t)game; const sc_hintref_t hint_ = (const sc_hintref_t)hint; @@ -1012,8 +941,7 @@ sc_get_game_unsubtle_hint(sc_game game, sc_game_hint hint) { * * Enable, disable, and query game debugging, and run a single debug command. */ -void -sc_set_game_debugger_enabled(sc_game game, sc_bool flag) { +void sc_set_game_debugger_enabled(sc_game game, sc_bool flag) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_set_game_debugger_enabled")) @@ -1022,8 +950,7 @@ sc_set_game_debugger_enabled(sc_game game, sc_bool flag) { debug_set_enabled(game_, flag); } -sc_bool -sc_get_game_debugger_enabled(sc_game game) { +sc_bool sc_get_game_debugger_enabled(sc_game game) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_get_game_debugger_enabled")) @@ -1032,8 +959,7 @@ sc_get_game_debugger_enabled(sc_game game) { return debug_get_enabled(game_); } -sc_bool -sc_run_game_debugger_command(sc_game game, const sc_char *debug_command) { +sc_bool sc_run_game_debugger_command(sc_game game, const sc_char *debug_command) { const sc_gameref_t game_ = (const sc_gameref_t)game; if (if_game_error(game_, "sc_run_game_debugger_command")) @@ -1049,8 +975,7 @@ sc_run_game_debugger_command(sc_game game, const sc_char *debug_command) { * * Set the interpreter locale, and get the currently set locale. */ -sc_bool -sc_set_locale(const sc_char *name) { +sc_bool sc_set_locale(const sc_char *name) { if (!name) { sc_error("sc_set_locale: nullptr name\n"); return FALSE; @@ -1059,8 +984,7 @@ sc_set_locale(const sc_char *name) { return loc_set_locale(name); } -const sc_char * -sc_get_locale(void) { +const sc_char *sc_get_locale(void) { return loc_get_locale(); } @@ -1072,16 +996,14 @@ sc_get_locale(void) { * Turn portable random number generation on and off, and supply a new seed * for random number generators. */ -void -sc_set_portable_random(sc_bool flag) { +void sc_set_portable_random(sc_bool flag) { if (flag) sc_set_congruential_random(); else sc_set_platform_random(); } -void -sc_reseed_random_sequence(sc_uint new_seed) { +void sc_reseed_random_sequence(sc_uint new_seed) { if (new_seed == 0) { sc_error("sc_reseed_random_sequence: new_seed may not be 0\n"); return; diff --git a/engines/glk/adrift/sclibrar.cpp b/engines/glk/adrift/sclibrar.cpp index bfa1711aea..51e4224eeb 100644 --- a/engines/glk/adrift/sclibrar.cpp +++ b/engines/glk/adrift/sclibrar.cpp @@ -58,8 +58,7 @@ static sc_bool lib_trace = FALSE; * directly rather than using the printfilter to avoid possible clashes * with ALRs. */ -void -lib_warn_battle_system(void) { +void lib_warn_battle_system(void) { if_print_tag(SC_TAG_FONT, "size=16"); if_print_string("SCARE WARNING"); if_print_tag(SC_TAG_ENDFONT, ""); @@ -85,8 +84,7 @@ lib_warn_battle_system(void) { * * Return a random member of a roomgroup. */ -sc_int -lib_random_roomgroup_member(sc_gameref_t game, sc_int roomgroup) { +sc_int lib_random_roomgroup_member(sc_gameref_t game, sc_int roomgroup) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; sc_int count, room; @@ -119,8 +117,7 @@ lib_random_roomgroup_member(sc_gameref_t game, sc_int roomgroup) { * * Return TRUE if a particular alternate room description should be used. */ -static sc_bool -lib_use_room_alt(sc_gameref_t game, sc_int room, sc_int alt) { +static sc_bool lib_use_room_alt(sc_gameref_t game, sc_int room, sc_int alt) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int type; @@ -247,8 +244,7 @@ lib_use_room_alt(sc_gameref_t game, sc_int room, sc_int alt) { * the alts list when generating room names or descriptions. Returns -1 if * no alt overrides the default room long description. */ -static sc_int -lib_find_starting_alt(sc_gameref_t game, sc_int room) { +static sc_int lib_find_starting_alt(sc_gameref_t game, sc_int room) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int alt_count, alt, retval; @@ -305,8 +301,7 @@ lib_find_starting_alt(sc_gameref_t game, sc_int room) { * * Get/print out the name for a given room. */ -const sc_char * -lib_get_room_name(sc_gameref_t game, sc_int room) { +const sc_char *lib_get_room_name(sc_gameref_t game, sc_int room) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int alt_count, alt, start; @@ -357,8 +352,7 @@ lib_get_room_name(sc_gameref_t game, sc_int room) { return name; } -void -lib_print_room_name(sc_gameref_t game, sc_int room) { +void lib_print_room_name(sc_gameref_t game, sc_int room) { const sc_filterref_t filter = gs_get_filter(game); const sc_char *name; @@ -382,8 +376,7 @@ lib_print_room_name(sc_gameref_t game, sc_int room) { * prefix -- any "a"/"an"/"some" is replaced by "the" -- and with the full * prefix. */ -static void -lib_print_object_np(sc_gameref_t game, sc_int object) { +static void lib_print_object_np(sc_gameref_t game, sc_int object) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -448,8 +441,7 @@ lib_print_object_np(sc_gameref_t game, sc_int object) { pf_buffer_string(filter, name); } -static void -lib_print_object(sc_gameref_t game, sc_int object) { +static void lib_print_object(sc_gameref_t game, sc_int object) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -483,8 +475,7 @@ lib_print_object(sc_gameref_t game, sc_int object) { * Convenience functions to print out an NPC's name, with and without * any prefix. */ -static void -lib_print_npc_np(sc_gameref_t game, sc_int npc) { +static void lib_print_npc_np(sc_gameref_t game, sc_int npc) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -500,8 +491,7 @@ lib_print_npc_np(sc_gameref_t game, sc_int npc) { } #if 0 -static void -lib_print_npc(sc_gameref_t game, sc_int npc) { +static void lib_print_npc(sc_gameref_t game, sc_int npc) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -530,11 +520,8 @@ lib_print_npc(sc_gameref_t game, sc_int npc) { * Convenience functions for multiple handlers. Returns the appropriate * response string for a game, based on perspective or object plurality. */ -static const sc_char * -lib_select_response(sc_gameref_t game, - const sc_char *second_person, - const sc_char *first_person, - const sc_char *third_person) { +static const sc_char *lib_select_response(sc_gameref_t game, + const sc_char *second_person, const sc_char *first_person, const sc_char *third_person) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; sc_int perspective; @@ -564,9 +551,8 @@ lib_select_response(sc_gameref_t game, return response; } -static const sc_char * -lib_select_plurality(sc_gameref_t game, sc_int object, - const sc_char *singular, const sc_char *plural) { +static const sc_char *lib_select_plurality(sc_gameref_t game, sc_int object, + const sc_char *singular, const sc_char *plural) { return obj_appears_plural(game, object) ? plural : singular; } @@ -578,8 +564,7 @@ lib_select_plurality(sc_gameref_t game, sc_int object, * gone walkabout and offers a changed description, return that; otherwise * return the standard inroom text. */ -static const sc_char * -lib_get_npc_inroom_text(sc_gameref_t game, sc_int npc) { +static const sc_char *lib_get_npc_inroom_text(sc_gameref_t game, sc_int npc) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int walk_count, walk; @@ -617,8 +602,7 @@ lib_get_npc_inroom_text(sc_gameref_t game, sc_int npc) { * * Print a list of the contents of a room. */ -static void -lib_print_room_contents(sc_gameref_t game, sc_int room) { +static void lib_print_room_contents(sc_gameref_t game, sc_int room) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; @@ -775,8 +759,7 @@ lib_print_room_contents(sc_gameref_t game, sc_int room) { * * Print out the long description for a given room. */ -void -lib_print_room_description(sc_gameref_t game, sc_int room) { +void lib_print_room_description(sc_gameref_t game, sc_int room) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; @@ -917,8 +900,7 @@ lib_print_room_description(sc_gameref_t game, sc_int room) { * * Return TRUE if the player can move in the given direction. */ -static sc_bool -lib_can_go(sc_gameref_t game, sc_int room, sc_int direction) { +static sc_bool lib_can_go(sc_gameref_t game, sc_int room, sc_int direction) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int restriction; @@ -1036,8 +1018,7 @@ static const sc_char *const DIRNAMES_8[] = { * * Print a list of exits from the player room. */ -sc_bool -lib_cmd_print_room_exits(sc_gameref_t game) { +sc_bool lib_cmd_print_room_exits(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; @@ -1115,8 +1096,7 @@ lib_cmd_print_room_exits(sc_gameref_t game) { * Print out details of the player room, in brief if verbose not set and the * room has already been visited. */ -static void -lib_describe_player_room(sc_gameref_t game, sc_bool force_verbose) { +static void lib_describe_player_room(sc_gameref_t game, sc_bool force_verbose) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; @@ -1149,8 +1129,7 @@ lib_describe_player_room(sc_gameref_t game, sc_bool force_verbose) { * * Command handler for "look" command. */ -sc_bool -lib_cmd_look(sc_gameref_t game) { +sc_bool lib_cmd_look(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_character(filter, '\n'); @@ -1164,8 +1143,7 @@ lib_cmd_look(sc_gameref_t game) { * * Called on "quit". Exits from the game main loop. */ -sc_bool -lib_cmd_quit(sc_gameref_t game) { +sc_bool lib_cmd_quit(sc_gameref_t game) { if (if_confirm(SC_CONF_QUIT)) game->is_running = FALSE; @@ -1180,8 +1158,7 @@ lib_cmd_quit(sc_gameref_t game) { * Called on "restart". Exits from the game main loop with restart * request set. */ -sc_bool -lib_cmd_restart(sc_gameref_t game) { +sc_bool lib_cmd_restart(sc_gameref_t game) { if (if_confirm(SC_CONF_RESTART)) { game->is_running = FALSE; game->do_restart = TRUE; @@ -1197,8 +1174,7 @@ lib_cmd_restart(sc_gameref_t game) { * * Called on "undo". Restores any undo game or memo to the main game. */ -sc_bool -lib_cmd_undo(sc_gameref_t game) { +sc_bool lib_cmd_undo(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_memo_setref_t memento = gs_get_memento(game); @@ -1246,8 +1222,7 @@ lib_cmd_undo(sc_gameref_t game) { * Prints a history of saved commands for the game. Print directly rather * than using the printfilter to avoid possible clashes with ALRs. */ -static sc_bool -lib_cmd_history_common(sc_gameref_t game, sc_int limit) { +static sc_bool lib_cmd_history_common(sc_gameref_t game, sc_int limit) { const sc_var_setref_t vars = gs_get_vars(game); const sc_memo_setref_t memento = gs_get_memento(game); sc_int first, count, timestamp; @@ -1319,8 +1294,7 @@ lib_cmd_history_common(sc_gameref_t game, sc_int limit) { return TRUE; } -sc_bool -lib_cmd_history_number(sc_gameref_t game) { +sc_bool lib_cmd_history_number(sc_gameref_t game) { const sc_var_setref_t vars = gs_get_vars(game); sc_int limit; @@ -1336,8 +1310,7 @@ lib_cmd_history_number(sc_gameref_t game) { return lib_cmd_history_common(game, limit); } -sc_bool -lib_cmd_history(sc_gameref_t game) { +sc_bool lib_cmd_history(sc_gameref_t game) { return lib_cmd_history_common(game, 0); } @@ -1353,8 +1326,7 @@ lib_cmd_history(sc_gameref_t game) { * flag. The others allow the user to select a command from the history list * to re-run. */ -sc_bool -lib_cmd_again(sc_gameref_t game) { +sc_bool lib_cmd_again(sc_gameref_t game) { game->do_again = TRUE; game->redo_sequence = 0; @@ -1362,8 +1334,7 @@ lib_cmd_again(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_redo_number(sc_gameref_t game) { +sc_bool lib_cmd_redo_number(sc_gameref_t game) { const sc_var_setref_t vars = gs_get_vars(game); const sc_memo_setref_t memento = gs_get_memento(game); sc_int sequence; @@ -1398,8 +1369,7 @@ lib_cmd_redo_number(sc_gameref_t game) { return TRUE; } -static sc_bool -lib_cmd_redo_text_last_common(sc_gameref_t game, const sc_char *target) { +static sc_bool lib_cmd_redo_text_last_common(sc_gameref_t game, const sc_char *target) { const sc_memo_setref_t memento = gs_get_memento(game); sc_bool is_do_last, is_contains; sc_int length, matched_sequence; @@ -1486,16 +1456,14 @@ lib_cmd_redo_text_last_common(sc_gameref_t game, const sc_char *target) { return TRUE; } -sc_bool -lib_cmd_redo_text(sc_gameref_t game) { +sc_bool lib_cmd_redo_text(sc_gameref_t game) { const sc_var_setref_t vars = gs_get_vars(game); /* Call the common redo with the referenced text from %text%. */ return lib_cmd_redo_text_last_common(game, var_get_ref_text(vars)); } -sc_bool -lib_cmd_redo_last(sc_gameref_t game) { +sc_bool lib_cmd_redo_last(sc_gameref_t game) { /* Call the common redo with, literally, "!", forming "!!" . */ return lib_cmd_redo_text_last_common(game, "!"); } @@ -1506,8 +1474,7 @@ lib_cmd_redo_last(sc_gameref_t game) { * * Called on "hints". Requests the interface to display any available hints. */ -sc_bool -lib_cmd_hints(sc_gameref_t game) { +sc_bool lib_cmd_hints(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int task; sc_bool game_has_hints; @@ -1550,15 +1517,13 @@ lib_cmd_hints(sc_gameref_t game) { * * Convenience helpers for printing licensing and game information. */ -static void -lib_print_string_bold(const sc_char *string) { +static void lib_print_string_bold(const sc_char *string) { if_print_tag(SC_TAG_BOLD, ""); if_print_string(string); if_print_tag(SC_TAG_ENDBOLD, ""); } -static void -lib_print_string_italics(const sc_char *string) { +static void lib_print_string_italics(const sc_char *string) { if_print_tag(SC_TAG_ITALICS, ""); if_print_string(string); if_print_tag(SC_TAG_ENDITALICS, ""); @@ -1573,8 +1538,7 @@ lib_print_string_italics(const sc_char *string) { * and the GPL licensing. Print directly rather than using the printfilter * to avoid possible clashes with ALRs. */ -sc_bool -lib_cmd_help(sc_gameref_t game) { +sc_bool lib_cmd_help(sc_gameref_t game) { if_print_string( "These are some of the typical commands used in this adventure:\n\n"); @@ -1626,8 +1590,7 @@ lib_cmd_help(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_license(sc_gameref_t game) { +sc_bool lib_cmd_license(sc_gameref_t game) { lib_print_string_bold("SCARE"); if_print_string(" is "); lib_print_string_italics( @@ -1671,8 +1634,7 @@ lib_cmd_license(sc_gameref_t game) { * in real Adrift. Prints directly rather than using the printfilter to * avoid possible clashes with ALRs. */ -sc_bool -lib_cmd_information(sc_gameref_t game) { +sc_bool lib_cmd_information(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[2]; @@ -1718,8 +1680,7 @@ lib_cmd_information(sc_gameref_t game) { * * Clear the main game window (almost). */ -sc_bool -lib_cmd_clear(sc_gameref_t game) { +sc_bool lib_cmd_clear(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_tag(filter, SC_TAG_CLS); @@ -1736,8 +1697,7 @@ lib_cmd_clear(sc_gameref_t game) { * interpreter builds that can't offer a true status line. Prints directly * rather than using the printfilter to avoid possible clashes with ALRs. */ -sc_bool -lib_cmd_statusline(sc_gameref_t game) { +sc_bool lib_cmd_statusline(sc_gameref_t game) { const sc_char *name, *author, *room, *status; sc_int score; @@ -1782,8 +1742,7 @@ lib_cmd_statusline(sc_gameref_t game) { * Display the "Runner version". Prints directly rather than using the * printfilter to avoid possible clashes with ALRs. */ -sc_bool -lib_cmd_version(sc_gameref_t game) { +sc_bool lib_cmd_version(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key; sc_char buffer[64]; @@ -1822,8 +1781,7 @@ lib_cmd_version(sc_gameref_t game) { * the game's setting. The latter prints directly rather than using the * printfilter to avoid possible clashes with ALRs. */ -sc_bool -lib_cmd_wait(sc_gameref_t game) { +sc_bool lib_cmd_wait(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; @@ -1850,8 +1808,7 @@ lib_cmd_wait(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_wait_number(sc_gameref_t game) { +sc_bool lib_cmd_wait_number(sc_gameref_t game) { const sc_var_setref_t vars = gs_get_vars(game); sc_int waitturns; sc_char buffer[32]; @@ -1885,8 +1842,7 @@ lib_cmd_wait_number(sc_gameref_t game) { * Set/clear game verbose flag. Print directly rather than using the * printfilter to avoid possible clashes with ALRs. */ -sc_bool -lib_cmd_verbose(sc_gameref_t game) { +sc_bool lib_cmd_verbose(sc_gameref_t game) { /* Set game verbose flag and return. */ game->verbose = TRUE; if_print_string("The game is now in its "); @@ -1900,8 +1856,7 @@ lib_cmd_verbose(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_brief(sc_gameref_t game) { +sc_bool lib_cmd_brief(sc_gameref_t game) { /* Clear game verbose flag and return. */ game->verbose = FALSE; if_print_string("The game is now in its "); @@ -1923,8 +1878,7 @@ lib_cmd_brief(sc_gameref_t game) { * Set/clear/query game score change notification flag. Print directly * rather than using the printfilter to avoid possible clashes with ALRs. */ -sc_bool -lib_cmd_notify_on_off(sc_gameref_t game) { +sc_bool lib_cmd_notify_on_off(sc_gameref_t game) { const sc_var_setref_t vars = gs_get_vars(game); const sc_char *control; @@ -1957,8 +1911,7 @@ lib_cmd_notify_on_off(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_notify(sc_gameref_t game) { +sc_bool lib_cmd_notify(sc_gameref_t game) { /* Report the current state of notification. */ if_print_string("Game score change notification is "); if_print_tag(SC_TAG_ITALICS, ""); @@ -1986,8 +1939,7 @@ lib_cmd_notify(sc_gameref_t game) { * Runner responds here with the system time and date, but we'll do something * different. */ -sc_bool -lib_cmd_time(sc_gameref_t game) { +sc_bool lib_cmd_time(sc_gameref_t game) { const sc_var_setref_t vars = gs_get_vars(game); sc_uint timestamp; sc_int hr, min, sec; @@ -2012,8 +1964,7 @@ lib_cmd_time(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_date(sc_gameref_t game) { +sc_bool lib_cmd_date(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "Maybe we should just be good friends.\n"); @@ -2038,8 +1989,7 @@ enum { * * Central movement command, called by all movement handlers. */ -static sc_bool -lib_go(sc_gameref_t game, sc_int direction) { +static sc_bool lib_go(sc_gameref_t game, sc_int direction) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5], vt_rvalue; @@ -2164,63 +2114,51 @@ lib_go(sc_gameref_t game, sc_int direction) { * * Direction-specific movement commands. */ -sc_bool -lib_cmd_go_north(sc_gameref_t game) { +sc_bool lib_cmd_go_north(sc_gameref_t game) { return lib_go(game, DIR_NORTH); } -sc_bool -lib_cmd_go_east(sc_gameref_t game) { +sc_bool lib_cmd_go_east(sc_gameref_t game) { return lib_go(game, DIR_EAST); } -sc_bool -lib_cmd_go_south(sc_gameref_t game) { +sc_bool lib_cmd_go_south(sc_gameref_t game) { return lib_go(game, DIR_SOUTH); } -sc_bool -lib_cmd_go_west(sc_gameref_t game) { +sc_bool lib_cmd_go_west(sc_gameref_t game) { return lib_go(game, DIR_WEST); } -sc_bool -lib_cmd_go_up(sc_gameref_t game) { +sc_bool lib_cmd_go_up(sc_gameref_t game) { return lib_go(game, DIR_UP); } -sc_bool -lib_cmd_go_down(sc_gameref_t game) { +sc_bool lib_cmd_go_down(sc_gameref_t game) { return lib_go(game, DIR_DOWN); } -sc_bool -lib_cmd_go_in(sc_gameref_t game) { +sc_bool lib_cmd_go_in(sc_gameref_t game) { return lib_go(game, DIR_IN); } -sc_bool -lib_cmd_go_out(sc_gameref_t game) { +sc_bool lib_cmd_go_out(sc_gameref_t game) { return lib_go(game, DIR_OUT); } -sc_bool -lib_cmd_go_northeast(sc_gameref_t game) { +sc_bool lib_cmd_go_northeast(sc_gameref_t game) { return lib_go(game, DIR_NORTHEAST); } -sc_bool -lib_cmd_go_southeast(sc_gameref_t game) { +sc_bool lib_cmd_go_southeast(sc_gameref_t game) { return lib_go(game, DIR_SOUTHEAST); } -sc_bool -lib_cmd_go_northwest(sc_gameref_t game) { +sc_bool lib_cmd_go_northwest(sc_gameref_t game) { return lib_go(game, DIR_NORTHWEST); } -sc_bool -lib_cmd_go_southwest(sc_gameref_t game) { +sc_bool lib_cmd_go_southwest(sc_gameref_t game) { return lib_go(game, DIR_SOUTHWEST); } @@ -2232,8 +2170,7 @@ lib_cmd_go_southwest(sc_gameref_t game) { * with the string passed in, and return TRUE if they match. The routine * requires that string is filtered, stripped, trimmed and normalized. */ -static sc_bool -lib_compare_rooms(sc_gameref_t game, sc_int room, const sc_char *string) { +static sc_bool lib_compare_rooms(sc_gameref_t game, sc_int room, const sc_char *string) { const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_char *name, *compare_name; @@ -2275,8 +2212,7 @@ lib_compare_rooms(sc_gameref_t game, sc_int room, const sc_char *string) { * text comparisons, for example, two "Manor Grounds" at the start of Humbug, * differentiated within the game with trailing "" components. */ -sc_bool -lib_cmd_go_room(sc_gameref_t game) { +sc_bool lib_cmd_go_room(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); @@ -2386,8 +2322,7 @@ lib_cmd_go_room(sc_gameref_t game) { * * Show the long description of a player. */ -sc_bool -lib_cmd_examine_self(sc_gameref_t game) { +sc_bool lib_cmd_examine_self(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; @@ -2501,9 +2436,7 @@ lib_cmd_examine_self(sc_gameref_t game) { * -1 with *is_ambiguous FALSE if requested, otherwise print a message then * return -1. */ -static sc_int -lib_disambiguate_npc(sc_gameref_t game, - const sc_char *verb, sc_bool *is_ambiguous) { +static sc_int lib_disambiguate_npc(sc_gameref_t game, const sc_char *verb, sc_bool *is_ambiguous) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); sc_int count, index_, npc, listed; @@ -2590,12 +2523,9 @@ lib_disambiguate_npc(sc_gameref_t game, * just one object. The resolver function can normally be the same as the * function used to filter objects for multiple references. */ -static sc_int -lib_disambiguate_object_common(sc_gameref_t game, const sc_char *verb, - sc_bool(*resolver) - (sc_gameref_t, sc_int, sc_int), - sc_int resolver_arg, - sc_bool *is_ambiguous) { +static sc_int lib_disambiguate_object_common(sc_gameref_t game, const sc_char *verb, + sc_bool(*resolver)(sc_gameref_t, sc_int, sc_int), + sc_int resolver_arg, sc_bool *is_ambiguous) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); sc_int count, index_, object, listed; @@ -2712,18 +2642,12 @@ lib_disambiguate_object_common(sc_gameref_t game, const sc_char *verb, return -1; } -static sc_int -lib_disambiguate_object(sc_gameref_t game, - const sc_char *verb, sc_bool *is_ambiguous) { +static sc_int lib_disambiguate_object(sc_gameref_t game, const sc_char *verb, sc_bool *is_ambiguous) { return lib_disambiguate_object_common(game, verb, NULL, -1, is_ambiguous); } -static sc_int -lib_disambiguate_object_extended(sc_gameref_t game, const sc_char *verb, - sc_bool(*resolver) - (sc_gameref_t, sc_int, sc_int), - sc_int resolver_arg, - sc_bool *is_ambiguous) { +static sc_int lib_disambiguate_object_extended(sc_gameref_t game, const sc_char *verb, + sc_bool(*resolver)(sc_gameref_t, sc_int, sc_int), sc_int resolver_arg, sc_bool *is_ambiguous) { return lib_disambiguate_object_common(game, verb, resolver, resolver_arg, is_ambiguous); } @@ -2734,8 +2658,7 @@ lib_disambiguate_object_extended(sc_gameref_t game, const sc_char *verb, * * List objects carried and worn by an NPC. */ -static sc_bool -lib_list_npc_inventory(sc_gameref_t game, sc_int npc, sc_bool is_described) { +static sc_bool lib_list_npc_inventory(sc_gameref_t game, sc_int npc, sc_bool is_described) { const sc_filterref_t filter = gs_get_filter(game); sc_int object, count, trail; sc_bool wearing; @@ -2831,8 +2754,7 @@ lib_list_npc_inventory(sc_gameref_t game, sc_int npc, sc_bool is_described) { * Show the long description of the most recently referenced NPC, and a * list of what they're wearing and carrying. */ -sc_bool -lib_cmd_examine_npc(sc_gameref_t game) { +sc_bool lib_cmd_examine_npc(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; @@ -2888,9 +2810,7 @@ lib_cmd_examine_npc(sc_gameref_t game) { * * List the objects in a given container object, normal format listing. */ -static sc_bool -lib_list_in_object_normal(sc_gameref_t game, - sc_int container, sc_bool is_described) { +static sc_bool lib_list_in_object_normal(sc_gameref_t game, sc_int container, sc_bool is_described) { const sc_filterref_t filter = gs_get_filter(game); sc_int object, count, trail; @@ -2948,9 +2868,7 @@ lib_list_in_object_normal(sc_gameref_t game, * * List the objects in a given container object, alternate format listing. */ -static sc_bool -lib_list_in_object_alternate(sc_gameref_t game, - sc_int container, sc_bool is_described) { +static sc_bool lib_list_in_object_alternate(sc_gameref_t game,sc_int container, sc_bool is_described) { const sc_filterref_t filter = gs_get_filter(game); sc_int object, count, trail; @@ -3014,8 +2932,7 @@ lib_list_in_object_alternate(sc_gameref_t game, * this, and in particular works with the ALR magic in "To Hell in a Hamper", * but it's almost certainly wrong. Or, at minimum, incomplete. */ -static sc_bool -lib_list_in_object(sc_gameref_t game, sc_int container, sc_bool is_described) { +static sc_bool lib_list_in_object(sc_gameref_t game, sc_int container, sc_bool is_described) { sc_bool use_alternate_format = FALSE; /* @@ -3057,8 +2974,7 @@ lib_list_in_object(sc_gameref_t game, sc_int container, sc_bool is_described) { * * List the objects on a given surface object. */ -static sc_bool -lib_list_on_object(sc_gameref_t game, sc_int supporter, sc_bool is_described) { +static sc_bool lib_list_on_object(sc_gameref_t game, sc_int supporter, sc_bool is_described) { const sc_filterref_t filter = gs_get_filter(game); sc_int object, count, trail; @@ -3116,8 +3032,7 @@ lib_list_on_object(sc_gameref_t game, sc_int supporter, sc_bool is_described) { * * Describe the state of a stateful object. */ -static sc_bool -lib_list_object_state(sc_gameref_t game, sc_int object, sc_bool is_described) { +static sc_bool lib_list_object_state(sc_gameref_t game, sc_int object, sc_bool is_described) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -3161,8 +3076,7 @@ lib_list_object_state(sc_gameref_t game, sc_int object, sc_bool is_described) { * * Show the long description of the most recently referenced object. */ -sc_bool -lib_cmd_examine_object(sc_gameref_t game) { +sc_bool lib_cmd_examine_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -3294,8 +3208,7 @@ lib_cmd_examine_object(sc_gameref_t game) { * references uses the buffer passed in if possible, otherwise allocates * its own buffer; testing the return value shows which happened. */ -static sc_bool * -lib_save_object_references(sc_gameref_t game, sc_bool buffer[], sc_int length) { +static sc_bool *lib_save_object_references(sc_gameref_t game, sc_bool buffer[], sc_int length) { sc_int required, available; sc_bool *references; @@ -3312,8 +3225,7 @@ lib_save_object_references(sc_gameref_t game, sc_bool buffer[], sc_int length) { return references; } -static void -lib_restore_object_references(sc_gameref_t game, const sc_bool references[]) { +static void lib_restore_object_references(sc_gameref_t game, const sc_bool references[]) { sc_int bytes; /* Calculate the bytes in the references array, and copy back to the game. */ @@ -3332,13 +3244,9 @@ lib_restore_object_references(sc_gameref_t game, const sc_bool references[]) { * to retry game commands using standard "get " and "drop " commands. This * makes "take/pick up/put down" work with a game's overridden get/drop. */ -static sc_bool -lib_try_game_command_common(sc_gameref_t game, - const sc_char *verb, sc_int object, - const sc_char *preposition, - sc_int associate, - sc_bool is_associate_object, - sc_bool is_associate_npc) { +static sc_bool lib_try_game_command_common(sc_gameref_t game, const sc_char *verb, sc_int object, + const sc_char *preposition, sc_int associate, sc_bool is_associate_object, + sc_bool is_associate_npc) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_char buffer[LIB_ALLOCATION_AVOIDANCE_SIZE]; @@ -3439,26 +3347,18 @@ lib_try_game_command_common(sc_gameref_t game, return status; } -static sc_bool -lib_try_game_command_short(sc_gameref_t game, - const sc_char *verb, sc_int object) { - return lib_try_game_command_common(game, verb, object, - NULL, -1, FALSE, FALSE); +static sc_bool lib_try_game_command_short(sc_gameref_t game, const sc_char *verb, sc_int object) { + return lib_try_game_command_common(game, verb, object, NULL, -1, FALSE, FALSE); } -static sc_bool -lib_try_game_command_with_object(sc_gameref_t game, - const sc_char *verb, sc_int object, - const sc_char *preposition, - sc_int other_object) { +static sc_bool lib_try_game_command_with_object(sc_gameref_t game, const sc_char *verb, + sc_int object, const sc_char *preposition, sc_int other_object) { return lib_try_game_command_common(game, verb, object, preposition, other_object, TRUE, FALSE); } -static sc_bool -lib_try_game_command_with_npc(sc_gameref_t game, - const sc_char *verb, sc_int object, - const sc_char *preposition, sc_int npc) { +static sc_bool lib_try_game_command_with_npc(sc_gameref_t game, const sc_char *verb, + sc_int object, const sc_char *preposition, sc_int npc) { return lib_try_game_command_common(game, verb, object, preposition, npc, FALSE, TRUE); } @@ -3472,12 +3372,9 @@ lib_try_game_command_with_npc(sc_gameref_t game, * using the verb supplied, and sets are_more_objects if we found an object * but there appear to be more following it. */ -static sc_bool -lib_parse_next_object(sc_gameref_t game, const sc_char *verb, - sc_bool(*resolver)(sc_gameref_t, sc_int, sc_int), - sc_int resolver_arg, - sc_int *object, - sc_bool *are_more_objects, sc_bool *is_ambiguous) { +static sc_bool lib_parse_next_object(sc_gameref_t game, const sc_char *verb, + sc_bool(*resolver)(sc_gameref_t, sc_int, sc_int), sc_int resolver_arg, + sc_int *object, sc_bool *are_more_objects, sc_bool *is_ambiguous) { const sc_var_setref_t vars = gs_get_vars(game); const sc_char *list; sc_bool is_matched; @@ -3513,11 +3410,9 @@ lib_parse_next_object(sc_gameref_t game, const sc_char *verb, * Parses object lists such as "object" and "object and object" and returns * the multiple objects in the game's multiple_references. */ -static sc_bool -lib_parse_multiple_objects(sc_gameref_t game, const sc_char *verb, - sc_bool(*resolver)(sc_gameref_t, sc_int, sc_int), - sc_int resolver_arg, - sc_int *count) { +static sc_bool lib_parse_multiple_objects(sc_gameref_t game, const sc_char *verb, + sc_bool(*resolver)(sc_gameref_t, sc_int, sc_int), + sc_int resolver_arg, sc_int *count) { const sc_filterref_t filter = gs_get_filter(game); sc_int count_, object; sc_bool are_more_objects, is_ambiguous; @@ -3612,10 +3507,9 @@ lib_parse_multiple_objects(sc_gameref_t game, const sc_char *verb, * references into standard object references, using the supplied filter. * The first is inclusive, the second exclusive. */ -static sc_int -lib_apply_multiple_filter(sc_gameref_t game, - sc_bool(*filter)(sc_gameref_t, sc_int, sc_int), - sc_int filter_arg, sc_int *references) { +static sc_int lib_apply_multiple_filter(sc_gameref_t game, + sc_bool(*filter)(sc_gameref_t, sc_int, sc_int), + sc_int filter_arg, sc_int *references) { sc_int count, object, references_; /* Clear all object references initially. */ @@ -3645,10 +3539,9 @@ lib_apply_multiple_filter(sc_gameref_t game, return count; } -static sc_int -lib_apply_except_filter(sc_gameref_t game, - sc_bool(*filter)(sc_gameref_t, sc_int, sc_int), - sc_int filter_arg, sc_int *references) { +static sc_int lib_apply_except_filter(sc_gameref_t game, + sc_bool(*filter)(sc_gameref_t, sc_int, sc_int), + sc_int filter_arg, sc_int *references) { sc_int count, object, references_; /* Clear all object references initially. */ @@ -3685,8 +3578,7 @@ lib_apply_except_filter(sc_gameref_t game, * * Display player weight and size limits and amounts currently carried. */ -sc_bool -lib_cmd_count(sc_gameref_t game) { +sc_bool lib_cmd_count(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int index_, size, weight; sc_char buffer[32]; @@ -3734,8 +3626,7 @@ lib_cmd_count(sc_gameref_t game) { * * Return TRUE if the given object is too heavy for the player to carry. */ -static sc_bool -lib_object_too_heavy(sc_gameref_t game, sc_int object, sc_bool *is_portable) { +static sc_bool lib_object_too_heavy(sc_gameref_t game, sc_int object, sc_bool *is_portable) { sc_int player_limit, index_, weight, object_weight; /* Get the player limit and the given object weight. */ @@ -3764,8 +3655,7 @@ lib_object_too_heavy(sc_gameref_t game, sc_int object, sc_bool *is_portable) { * * Return TRUE if the given object is too large for the player to carry. */ -static sc_bool -lib_object_too_large(sc_gameref_t game, sc_int object, sc_bool *is_portable) { +static sc_bool lib_object_too_large(sc_gameref_t game, sc_int object, sc_bool *is_portable) { sc_int player_limit, index_, size, object_size; /* Get the player limit and the given object size. */ @@ -3794,8 +3684,7 @@ lib_object_too_large(sc_gameref_t game, sc_int object, sc_bool *is_portable) { * * Reject attempts to take an npc. */ -sc_bool -lib_cmd_take_npc(sc_gameref_t game) { +sc_bool lib_cmd_take_npc(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int npc; sc_bool is_ambiguous; @@ -3823,9 +3712,8 @@ lib_cmd_take_npc(sc_gameref_t game) { * Objects to action are flagged in object_references; objects requested but * deemed not actionable are flagged in multiple_references. */ -static void -lib_take_backend_common(sc_gameref_t game, sc_int associate, - sc_bool is_associate_object, sc_bool is_associate_npc) { +static void lib_take_backend_common(sc_gameref_t game, sc_int associate, + sc_bool is_associate_object, sc_bool is_associate_npc) { const sc_filterref_t filter = gs_get_filter(game); sc_int object_count, object, count, trail, total, npc; sc_int too_heavy, too_large; @@ -4374,18 +4262,15 @@ lib_take_backend_common(sc_gameref_t game, sc_int associate, * Facets of lib_take_backend_common(). Provide backend handling for either * the plain "take" handlers, or the "take from " handlers. */ -static void -lib_take_backend(sc_gameref_t game) { +static void lib_take_backend(sc_gameref_t game) { lib_take_backend_common(game, -1, FALSE, FALSE); } -static void -lib_take_from_object_backend(sc_gameref_t game, sc_int associate) { +static void lib_take_from_object_backend(sc_gameref_t game, sc_int associate) { lib_take_backend_common(game, associate, TRUE, FALSE); } -static void -lib_take_from_npc_backend(sc_gameref_t game, sc_int associate) { +static void lib_take_from_npc_backend(sc_gameref_t game, sc_int associate) { lib_take_backend_common(game, associate, FALSE, TRUE); } @@ -4397,8 +4282,7 @@ lib_take_from_npc_backend(sc_gameref_t game, sc_int associate) { * Helper functions for deciding if an object may be acquired in this context. * Returns TRUE if an object may be acquired, FALSE otherwise. */ -static sc_bool -lib_take_filter(sc_gameref_t game, sc_int object, sc_int unused) { +static sc_bool lib_take_filter(sc_gameref_t game, sc_int object, sc_int unused) { assert(unused == -1); /* @@ -4413,9 +4297,7 @@ lib_take_filter(sc_gameref_t game, sc_int object, sc_int unused) { || gs_object_position(game, object) == OBJ_WORN_NPC); } -static sc_bool -lib_take_not_associated_filter(sc_gameref_t game, - sc_int object, sc_int unused) { +static sc_bool lib_take_not_associated_filter(sc_gameref_t game, sc_int object, sc_int unused) { assert(unused == -1); /* In addition to other checks, the object may not be in or on an object. */ @@ -4430,8 +4312,7 @@ lib_take_not_associated_filter(sc_gameref_t game, * * Attempt to take all objects currently visible to the player. */ -sc_bool -lib_cmd_take_all(sc_gameref_t game) { +sc_bool lib_cmd_take_all(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects; @@ -4457,8 +4338,7 @@ lib_cmd_take_all(sc_gameref_t game) { * Take all objects currently available to the player, excepting those listed * in %text%. */ -sc_bool -lib_cmd_take_except_multiple(sc_gameref_t game) { +sc_bool lib_cmd_take_except_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects, references; @@ -4493,8 +4373,7 @@ lib_cmd_take_except_multiple(sc_gameref_t game) { * * Take all objects currently available to the player and listed in %text%. */ -sc_bool -lib_cmd_take_multiple(sc_gameref_t game) { +sc_bool lib_cmd_take_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects, references; @@ -4526,8 +4405,7 @@ lib_cmd_take_multiple(sc_gameref_t game) { * Helper function for deciding if an object may be acquired in this context. * Returns TRUE if an object may be acquired, FALSE otherwise. */ -static sc_bool -lib_take_from_filter(sc_gameref_t game, sc_int object, sc_int associate) { +static sc_bool lib_take_from_filter(sc_gameref_t game, sc_int object, sc_int associate) { /* * To be take-able, an object must be either inside or on the specified * object. @@ -4545,8 +4423,7 @@ lib_take_from_filter(sc_gameref_t game, sc_int object, sc_int associate) { * Common error handling for when nothing is taken from a container or * supporter object. */ -static void -lib_take_from_empty(sc_gameref_t game, sc_int associate, sc_bool is_except) { +static void lib_take_from_empty(sc_gameref_t game, sc_int associate, sc_bool is_except) { const sc_filterref_t filter = gs_get_filter(game); if (obj_is_container(game, associate) && obj_is_surface(game, associate)) { @@ -4605,8 +4482,7 @@ lib_take_from_empty(sc_gameref_t game, sc_int associate, sc_bool is_except) { * * Validate the supporter requested in "take from" commands. */ -static sc_bool -lib_take_from_is_valid(sc_gameref_t game, sc_int associate) { +static sc_bool lib_take_from_is_valid(sc_gameref_t game, sc_int associate) { const sc_filterref_t filter = gs_get_filter(game); /* Disallow emptying non-container/non-surface objects. */ @@ -4644,8 +4520,7 @@ lib_take_from_is_valid(sc_gameref_t game, sc_int associate) { * * Attempt to take all objects contained in or supported by a given object. */ -sc_bool -lib_cmd_take_all_from(sc_gameref_t game) { +sc_bool lib_cmd_take_all_from(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int associate, objects; sc_bool is_ambiguous; @@ -4681,8 +4556,7 @@ lib_cmd_take_all_from(sc_gameref_t game) { * Take all objects contained in or supported by a given object, excepting * those listed in %text%. */ -sc_bool -lib_cmd_take_from_except_multiple(sc_gameref_t game) { +sc_bool lib_cmd_take_from_except_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int associate, objects, references; sc_bool is_ambiguous; @@ -4734,8 +4608,7 @@ lib_cmd_take_from_except_multiple(sc_gameref_t game) { * function isn't mandatory -- plain "take " works fine with contain- * ers and surfaces, but it's a standard in Adrift so here it is. */ -sc_bool -lib_cmd_take_from_multiple(sc_gameref_t game) { +sc_bool lib_cmd_take_from_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int associate, objects, references; sc_bool is_ambiguous; @@ -4777,8 +4650,7 @@ lib_cmd_take_from_multiple(sc_gameref_t game) { * Helper function for deciding if an object may be acquired in this context. * Returns TRUE if an object may be acquired, FALSE otherwise. */ -static sc_bool -lib_take_from_npc_filter(sc_gameref_t game, sc_int object, sc_int associate) { +static sc_bool lib_take_from_npc_filter(sc_gameref_t game, sc_int object, sc_int associate) { /* * To be take-able, an object must be either held or worn by the specified * NPC. @@ -4795,8 +4667,7 @@ lib_take_from_npc_filter(sc_gameref_t game, sc_int object, sc_int associate) { * * Attempt to take all objects held or worn by a given NPC. */ -sc_bool -lib_cmd_take_all_from_npc(sc_gameref_t game) { +sc_bool lib_cmd_take_all_from_npc(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int associate, objects; sc_bool is_ambiguous; @@ -4831,8 +4702,7 @@ lib_cmd_take_all_from_npc(sc_gameref_t game) { * Attempt to take all objects held or worn by a given NPC, excepting those * listed in %text%. */ -sc_bool -lib_cmd_take_from_npc_except_multiple(sc_gameref_t game) { +sc_bool lib_cmd_take_from_npc_except_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int associate, objects, references; sc_bool is_ambiguous; @@ -4873,8 +4743,7 @@ lib_cmd_take_from_npc_except_multiple(sc_gameref_t game) { * Attempt to take the objects currently held or worn by an NPC and listed * in %text%. */ -sc_bool -lib_cmd_take_from_npc_multiple(sc_gameref_t game) { +sc_bool lib_cmd_take_from_npc_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int associate, objects, references; sc_bool is_ambiguous; @@ -4919,8 +4788,7 @@ lib_cmd_take_from_npc_multiple(sc_gameref_t game) { * Objects to action are flagged in object_references; objects requested but * deemed not actionable are flagged in multiple_references. */ -static void -lib_drop_backend(sc_gameref_t game) { +static void lib_drop_backend(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object_count, object, count, trail; sc_bool has_printed; @@ -5032,8 +4900,7 @@ lib_drop_backend(sc_gameref_t game) { * Helper function for deciding if an object may be dropped in this context. * Returns TRUE if an object may be dropped, FALSE otherwise. */ -static sc_bool -lib_drop_filter(sc_gameref_t game, sc_int object, sc_int unused) { +static sc_bool lib_drop_filter(sc_gameref_t game, sc_int object, sc_int unused) { assert(unused == -1); return !obj_is_static(game, object) @@ -5046,8 +4913,7 @@ lib_drop_filter(sc_gameref_t game, sc_int object, sc_int unused) { * * Drop all objects currently held by the player. */ -sc_bool -lib_cmd_drop_all(sc_gameref_t game) { +sc_bool lib_cmd_drop_all(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects; @@ -5078,8 +4944,7 @@ lib_cmd_drop_all(sc_gameref_t game) { * Drop all objects currently held by the player, excepting those listed in * %text%. */ -sc_bool -lib_cmd_drop_except_multiple(sc_gameref_t game) { +sc_bool lib_cmd_drop_except_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects, references; @@ -5118,8 +4983,7 @@ lib_cmd_drop_except_multiple(sc_gameref_t game) { * * Drop all objects currently held by the player and listed in %text%. */ -sc_bool -lib_cmd_drop_multiple(sc_gameref_t game) { +sc_bool lib_cmd_drop_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects, references; @@ -5156,8 +5020,7 @@ lib_cmd_drop_multiple(sc_gameref_t game) { * * Attempt to give an object to an NPC. */ -sc_bool -lib_cmd_give_object_npc(sc_gameref_t game) { +sc_bool lib_cmd_give_object_npc(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object, npc; sc_bool is_ambiguous; @@ -5193,8 +5056,7 @@ lib_cmd_give_object_npc(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_give_object(sc_gameref_t game) { +sc_bool lib_cmd_give_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; sc_bool is_ambiguous; @@ -5233,8 +5095,7 @@ lib_cmd_give_object(sc_gameref_t game) { * Objects to action are flagged in object_references; objects requested but * deemed not actionable are flagged in multiple_references. */ -static void -lib_wear_backend(sc_gameref_t game) { +static void lib_wear_backend(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object_count, object, count, trail; sc_bool has_printed; @@ -5434,8 +5295,7 @@ lib_wear_backend(sc_gameref_t game) { * Helper function for deciding if an object may be worn in this context. * Returns TRUE if an object may be worn, FALSE otherwise. */ -static sc_bool -lib_wear_filter(sc_gameref_t game, sc_int object, sc_int unused) { +static sc_bool lib_wear_filter(sc_gameref_t game, sc_int object, sc_int unused) { const sc_prop_setref_t bundle = gs_get_bundle(game); assert(unused == -1); @@ -5464,8 +5324,7 @@ lib_wear_filter(sc_gameref_t game, sc_int object, sc_int unused) { * * Wear all wearable objects currently held by the player. */ -sc_bool -lib_cmd_wear_all(sc_gameref_t game) { +sc_bool lib_cmd_wear_all(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects; @@ -5497,8 +5356,7 @@ lib_cmd_wear_all(sc_gameref_t game) { * Wear all wearable objects currently held by the player, excepting those * listed in %text%. */ -sc_bool -lib_cmd_wear_except_multiple(sc_gameref_t game) { +sc_bool lib_cmd_wear_except_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects, references; @@ -5538,8 +5396,7 @@ lib_cmd_wear_except_multiple(sc_gameref_t game) { * Wear all objects currently held by the player, wearable, and listed * in %text%. */ -sc_bool -lib_cmd_wear_multiple(sc_gameref_t game) { +sc_bool lib_cmd_wear_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects, references; @@ -5580,8 +5437,7 @@ lib_cmd_wear_multiple(sc_gameref_t game) { * Objects to action are flagged in object_references; objects requested but * deemed not actionable are flagged in multiple_references. */ -static void -lib_remove_backend(sc_gameref_t game) { +static void lib_remove_backend(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object_count, object, count, trail; sc_bool has_printed; @@ -5693,8 +5549,7 @@ lib_remove_backend(sc_gameref_t game) { * Helper function for deciding if an object may be removed in this context. * Returns TRUE if an object is currently being worn, FALSE otherwise. */ -static sc_bool -lib_remove_filter(sc_gameref_t game, sc_int object, sc_int unused) { +static sc_bool lib_remove_filter(sc_gameref_t game, sc_int object, sc_int unused) { assert(unused == -1); return !obj_is_static(game, object) @@ -5707,8 +5562,7 @@ lib_remove_filter(sc_gameref_t game, sc_int object, sc_int unused) { * * Remove all objects currently held by the player. */ -sc_bool -lib_cmd_remove_all(sc_gameref_t game) { +sc_bool lib_cmd_remove_all(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects; @@ -5740,8 +5594,7 @@ lib_cmd_remove_all(sc_gameref_t game) { * Remove all objects currently worn by the player, excepting those listed * in %text%. */ -sc_bool -lib_cmd_remove_except_multiple(sc_gameref_t game) { +sc_bool lib_cmd_remove_except_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects, references; @@ -5780,8 +5633,7 @@ lib_cmd_remove_except_multiple(sc_gameref_t game) { * * Remove all objects currently worn by the player, and listed in %text%. */ -sc_bool -lib_cmd_remove_multiple(sc_gameref_t game) { +sc_bool lib_cmd_remove_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int objects, references; @@ -5818,8 +5670,7 @@ lib_cmd_remove_multiple(sc_gameref_t game) { * * List objects carried and worn by the player. */ -sc_bool -lib_cmd_inventory(sc_gameref_t game) { +sc_bool lib_cmd_inventory(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object, count, trail; sc_bool wearing; @@ -5946,8 +5797,7 @@ lib_cmd_inventory(sc_gameref_t game) { * * Attempt to open the referenced object. */ -sc_bool -lib_cmd_open_object(sc_gameref_t game) { +sc_bool lib_cmd_open_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object, openness; sc_bool is_ambiguous; @@ -6017,8 +5867,7 @@ lib_cmd_open_object(sc_gameref_t game) { * * Attempt to close the referenced object. */ -sc_bool -lib_cmd_close_object(sc_gameref_t game) { +sc_bool lib_cmd_close_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object, openness; sc_bool is_ambiguous; @@ -6077,8 +5926,7 @@ lib_cmd_close_object(sc_gameref_t game) { * * Automatically get an object being used as a key, if possible. */ -static void -lib_attempt_key_acquisition(sc_gameref_t game, sc_int object) { +static void lib_attempt_key_acquisition(sc_gameref_t game, sc_int object) { const sc_filterref_t filter = gs_get_filter(game); /* Disallow getting static objects. */ @@ -6139,8 +5987,7 @@ lib_attempt_key_acquisition(sc_gameref_t game, sc_int object) { * * Attempt to unlock the referenced object. */ -sc_bool -lib_cmd_unlock_object_with(sc_gameref_t game) { +sc_bool lib_cmd_unlock_object_with(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); @@ -6246,8 +6093,7 @@ lib_cmd_unlock_object_with(sc_gameref_t game) { * * Attempt to unlock the referenced object, automatically selecting key. */ -sc_bool -lib_cmd_unlock_object(sc_gameref_t game) { +sc_bool lib_cmd_unlock_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int object, openness; @@ -6330,8 +6176,7 @@ lib_cmd_unlock_object(sc_gameref_t game) { * * Attempt to lock the referenced object. */ -sc_bool -lib_cmd_lock_object_with(sc_gameref_t game) { +sc_bool lib_cmd_lock_object_with(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); @@ -6445,8 +6290,7 @@ lib_cmd_lock_object_with(sc_gameref_t game) { * * Attempt to lock the referenced object, automatically selecting key. */ -sc_bool -lib_cmd_lock_object(sc_gameref_t game) { +sc_bool lib_cmd_lock_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int object, openness; @@ -6538,9 +6382,7 @@ lib_cmd_lock_object(sc_gameref_t game) { * * Compare a subject, comma or NUL terminated. Helper for ask. */ -static sc_bool -lib_compare_subject(const sc_char *subject, sc_int posn, - const sc_char *string) { +static sc_bool lib_compare_subject(const sc_char *subject, sc_int posn, const sc_char *string) { sc_int word_posn, string_posn; /* Skip any leading subject spaces. */ @@ -6596,8 +6438,7 @@ lib_compare_subject(const sc_char *subject, sc_int posn, * * Reply for an NPC on a given topic. Helper for ask. */ -static sc_bool -lib_npc_reply_to(sc_gameref_t game, sc_int npc, sc_int topic) { +static sc_bool lib_npc_reply_to(sc_gameref_t game, sc_int npc, sc_int topic) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; @@ -6634,8 +6475,7 @@ lib_npc_reply_to(sc_gameref_t game, sc_int npc, sc_int topic) { * * Converse with NPC. */ -sc_bool -lib_cmd_ask_npc_about(sc_gameref_t game) { +sc_bool lib_cmd_ask_npc_about(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); @@ -6724,9 +6564,8 @@ lib_cmd_ask_npc_about(sc_gameref_t game) { * Checks for infinite recursion when placing an object in an object. Returns * TRUE if no recursion detected. */ -static sc_bool -lib_check_put_in_recursion(sc_gameref_t game, - sc_int object, sc_int container, sc_bool report) { +static sc_bool lib_check_put_in_recursion(sc_gameref_t game, sc_int object, + sc_int container, sc_bool report) { const sc_filterref_t filter = gs_get_filter(game); sc_int check; @@ -6775,8 +6614,7 @@ lib_check_put_in_recursion(sc_gameref_t game, * Objects to action are flagged in object_references; objects requested but * deemed not actionable are flagged in multiple_references. */ -static void -lib_put_in_backend(sc_gameref_t game, sc_int container) { +static void lib_put_in_backend(sc_gameref_t game, sc_int container) { const sc_filterref_t filter = gs_get_filter(game); sc_int object_count, object, count, trail, capacity, maxsize; sc_bool has_printed; @@ -7013,17 +6851,14 @@ lib_put_in_backend(sc_gameref_t game, sc_int container) { * Helper functions for deciding if an object may be put in another this * context. Returns TRUE if an object may be manipulated, FALSE otherwise. */ -static sc_bool -lib_put_in_filter(sc_gameref_t game, sc_int object, sc_int unused) { +static sc_bool lib_put_in_filter(sc_gameref_t game, sc_int object, sc_int unused) { assert(unused == -1); return !obj_is_static(game, object) && gs_object_position(game, object) == OBJ_HELD_PLAYER; } -static sc_bool -lib_put_in_not_container_filter(sc_gameref_t game, - sc_int object, sc_int container) { +static sc_bool lib_put_in_not_container_filter(sc_gameref_t game, sc_int object, sc_int container) { return lib_put_in_filter(game, object, -1) && object != container; } @@ -7033,8 +6868,7 @@ lib_put_in_not_container_filter(sc_gameref_t game, * * Validate the container requested in "put in" commands. */ -static sc_bool -lib_put_in_is_valid(sc_gameref_t game, sc_int container) { +static sc_bool lib_put_in_is_valid(sc_gameref_t game, sc_int container) { const sc_filterref_t filter = gs_get_filter(game); /* Verify that the container object is a container. */ @@ -7072,8 +6906,7 @@ lib_put_in_is_valid(sc_gameref_t game, sc_int container) { * * Put all objects currently held by the player into a container. */ -sc_bool -lib_cmd_put_all_in(sc_gameref_t game) { +sc_bool lib_cmd_put_all_in(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int container, objects; sc_bool is_ambiguous; @@ -7117,8 +6950,7 @@ lib_cmd_put_all_in(sc_gameref_t game) { * Put all objects currently held by the player into an object, excepting * those listed in %text%. */ -sc_bool -lib_cmd_put_in_except_multiple(sc_gameref_t game) { +sc_bool lib_cmd_put_in_except_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int container, objects, references; sc_bool is_ambiguous; @@ -7177,8 +7009,7 @@ lib_cmd_put_in_except_multiple(sc_gameref_t game) { * Put all objects currently held by the player and listed in %text% into an * object. */ -sc_bool -lib_cmd_put_in_multiple(sc_gameref_t game) { +sc_bool lib_cmd_put_in_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int container, objects, references; sc_bool is_ambiguous; @@ -7225,9 +7056,8 @@ lib_cmd_put_in_multiple(sc_gameref_t game) { * Checks for infinite recursion when placing an object on an object. Returns * TRUE if no recursion detected. */ -static sc_bool -lib_check_put_on_recursion(sc_gameref_t game, - sc_int object, sc_int supporter, sc_bool report) { +static sc_bool lib_check_put_on_recursion(sc_gameref_t game, sc_int object, + sc_int supporter, sc_bool report) { const sc_filterref_t filter = gs_get_filter(game); sc_int check; @@ -7276,8 +7106,7 @@ lib_check_put_on_recursion(sc_gameref_t game, * Objects to action are flagged in object_references; objects requested but * deemed not actionable are flagged in multiple_references. */ -static void -lib_put_on_backend(sc_gameref_t game, sc_int supporter) { +static void lib_put_on_backend(sc_gameref_t game, sc_int supporter) { const sc_filterref_t filter = gs_get_filter(game); sc_int object_count, object, count, trail; sc_bool has_printed; @@ -7401,8 +7230,7 @@ lib_put_on_backend(sc_gameref_t game, sc_int supporter) { * Helper functions for deciding if an object may be put on another this * context. Returns TRUE if an object may be manipulated, FALSE otherwise. */ -static sc_bool -lib_put_on_filter(sc_gameref_t game, sc_int object, sc_int unused) { +static sc_bool lib_put_on_filter(sc_gameref_t game, sc_int object, sc_int unused) { assert(unused == -1); return !obj_is_static(game, object) @@ -7421,8 +7249,7 @@ lib_put_on_not_supporter_filter(sc_gameref_t game, * * Validate the supporter requested in "put on" commands. */ -static sc_bool -lib_put_on_is_valid(sc_gameref_t game, sc_int supporter) { +static sc_bool lib_put_on_is_valid(sc_gameref_t game, sc_int supporter) { const sc_filterref_t filter = gs_get_filter(game); /* Verify that the supporter object is a supporter. */ @@ -7447,8 +7274,7 @@ lib_put_on_is_valid(sc_gameref_t game, sc_int supporter) { * * Put all objects currently held by the player onto a supporter. */ -sc_bool -lib_cmd_put_all_on(sc_gameref_t game) { +sc_bool lib_cmd_put_all_on(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int supporter, objects; sc_bool is_ambiguous; @@ -7492,8 +7318,7 @@ lib_cmd_put_all_on(sc_gameref_t game) { * Put all objects currently held by the player onto an object, excepting * those listed in %text%. */ -sc_bool -lib_cmd_put_on_except_multiple(sc_gameref_t game) { +sc_bool lib_cmd_put_on_except_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int supporter, objects, references; sc_bool is_ambiguous; @@ -7552,8 +7377,7 @@ lib_cmd_put_on_except_multiple(sc_gameref_t game) { * Put all objects currently held by the player and listed in %text% onto an * object. */ -sc_bool -lib_cmd_put_on_multiple(sc_gameref_t game) { +sc_bool lib_cmd_put_on_multiple(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int supporter, objects, references; sc_bool is_ambiguous; @@ -7600,8 +7424,7 @@ lib_cmd_put_on_multiple(sc_gameref_t game) { * * Attempt to read the referenced object, or something else. */ -sc_bool -lib_cmd_read_object(sc_gameref_t game) { +sc_bool lib_cmd_read_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -7663,8 +7486,7 @@ lib_cmd_read_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_read_other(sc_gameref_t game) { +sc_bool lib_cmd_read_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); /* Reject the attempt. */ @@ -7683,8 +7505,7 @@ lib_cmd_read_other(sc_gameref_t game) { * * Attempt to attack an NPC, with and without weaponry. */ -sc_bool -lib_cmd_attack_npc(sc_gameref_t game) { +sc_bool lib_cmd_attack_npc(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int npc; sc_bool is_ambiguous; @@ -7705,8 +7526,7 @@ lib_cmd_attack_npc(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_attack_npc_with(sc_gameref_t game) { +sc_bool lib_cmd_attack_npc_with(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int object, npc; @@ -7784,8 +7604,7 @@ lib_cmd_attack_npc_with(sc_gameref_t game) { * * Reject romantic advances in all cases. */ -sc_bool -lib_cmd_kiss_npc(sc_gameref_t game) { +sc_bool lib_cmd_kiss_npc(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -7822,8 +7641,7 @@ lib_cmd_kiss_npc(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_kiss_object(sc_gameref_t game) { +sc_bool lib_cmd_kiss_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; sc_bool is_ambiguous; @@ -7840,8 +7658,7 @@ lib_cmd_kiss_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_kiss_other(sc_gameref_t game) { +sc_bool lib_cmd_kiss_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); /* Reject this attempt. */ @@ -7856,8 +7673,7 @@ lib_cmd_kiss_other(sc_gameref_t game) { * * Standard responses to attempts to buy something. */ -sc_bool -lib_cmd_buy_object(sc_gameref_t game) { +sc_bool lib_cmd_buy_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; sc_bool is_ambiguous; @@ -7876,8 +7692,7 @@ lib_cmd_buy_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_buy_other(sc_gameref_t game) { +sc_bool lib_cmd_buy_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); /* Reject this attempt. */ @@ -7892,8 +7707,7 @@ lib_cmd_buy_other(sc_gameref_t game) { * * Standard responses to attempts to break something. */ -sc_bool -lib_cmd_break_object(sc_gameref_t game) { +sc_bool lib_cmd_break_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; sc_bool is_ambiguous; @@ -7914,8 +7728,7 @@ lib_cmd_break_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_break_other(sc_gameref_t game) { +sc_bool lib_cmd_break_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); /* Reject this attempt. */ @@ -7934,8 +7747,7 @@ lib_cmd_break_other(sc_gameref_t game) { * * Standard responses to attempts to smell something. */ -sc_bool -lib_cmd_smell_object(sc_gameref_t game) { +sc_bool lib_cmd_smell_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; sc_bool is_ambiguous; @@ -7952,8 +7764,7 @@ lib_cmd_smell_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_smell_other(sc_gameref_t game) { +sc_bool lib_cmd_smell_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); /* Reject this attempt. */ @@ -7968,8 +7779,7 @@ lib_cmd_smell_other(sc_gameref_t game) { * * Standard responses to attempts to sell something. */ -sc_bool -lib_cmd_sell_object(sc_gameref_t game) { +sc_bool lib_cmd_sell_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; sc_bool is_ambiguous; @@ -7986,8 +7796,7 @@ lib_cmd_sell_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_sell_other(sc_gameref_t game) { +sc_bool lib_cmd_sell_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "No-one is interested in buying that.\n"); @@ -8000,8 +7809,7 @@ lib_cmd_sell_other(sc_gameref_t game) { * * Consume edible objects. */ -sc_bool -lib_cmd_eat_object(sc_gameref_t game) { +sc_bool lib_cmd_eat_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -8081,8 +7889,7 @@ enum { * * Central handler for stand, sit, and lie commands. */ -static sc_bool -lib_stand_sit_lie(sc_gameref_t game, sc_int movement) { +static sc_bool lib_stand_sit_lie(sc_gameref_t game, sc_int movement) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int object, position; @@ -8295,33 +8102,27 @@ lib_stand_sit_lie(sc_gameref_t game, sc_int movement) { * * Stand, sit, or lie on an object, or on the floor. */ -sc_bool -lib_cmd_stand_on_object(sc_gameref_t game) { +sc_bool lib_cmd_stand_on_object(sc_gameref_t game) { return lib_stand_sit_lie(game, MOVE_STAND); } -sc_bool -lib_cmd_stand_on_floor(sc_gameref_t game) { +sc_bool lib_cmd_stand_on_floor(sc_gameref_t game) { return lib_stand_sit_lie(game, MOVE_STAND_FLOOR); } -sc_bool -lib_cmd_sit_on_object(sc_gameref_t game) { +sc_bool lib_cmd_sit_on_object(sc_gameref_t game) { return lib_stand_sit_lie(game, MOVE_SIT); } -sc_bool -lib_cmd_sit_on_floor(sc_gameref_t game) { +sc_bool lib_cmd_sit_on_floor(sc_gameref_t game) { return lib_stand_sit_lie(game, MOVE_SIT_FLOOR); } -sc_bool -lib_cmd_lie_on_object(sc_gameref_t game) { +sc_bool lib_cmd_lie_on_object(sc_gameref_t game) { return lib_stand_sit_lie(game, MOVE_LIE); } -sc_bool -lib_cmd_lie_on_floor(sc_gameref_t game) { +sc_bool lib_cmd_lie_on_floor(sc_gameref_t game) { return lib_stand_sit_lie(game, MOVE_LIE_FLOOR); } @@ -8332,8 +8133,7 @@ lib_cmd_lie_on_floor(sc_gameref_t game) { * * Get off whatever supporter the player rests on. */ -sc_bool -lib_cmd_get_off_object(sc_gameref_t game) { +sc_bool lib_cmd_get_off_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; sc_bool is_ambiguous; @@ -8369,8 +8169,7 @@ lib_cmd_get_off_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_get_off(sc_gameref_t game) { +sc_bool lib_cmd_get_off(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); /* Reject the attempt if the player is not on anything. */ @@ -8404,8 +8203,7 @@ lib_cmd_get_off(sc_gameref_t game) { * * Save/restore a game. */ -sc_bool -lib_cmd_save(sc_gameref_t game) { +sc_bool lib_cmd_save(sc_gameref_t game) { if (if_confirm(SC_CONF_SAVE)) { if (ser_save_game_prompted(game)) if_print_string("Ok.\n"); @@ -8417,8 +8215,7 @@ lib_cmd_save(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_restore(sc_gameref_t game) { +sc_bool lib_cmd_restore(sc_gameref_t game) { if (if_confirm(SC_CONF_RESTORE)) { if (ser_load_game_prompted(game)) { if_print_string("Ok.\n"); @@ -8439,8 +8236,7 @@ lib_cmd_restore(sc_gameref_t game) { * * Display the location of a selected object, and selected NPC. */ -sc_bool -lib_cmd_locate_object(sc_gameref_t game) { +sc_bool lib_cmd_locate_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); sc_int index_, count, object, room, position, parent; @@ -8612,8 +8408,7 @@ lib_cmd_locate_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_locate_npc(sc_gameref_t game) { +sc_bool lib_cmd_locate_npc(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); sc_int index_, count, npc, room; @@ -8711,8 +8506,7 @@ lib_cmd_locate_npc(sc_gameref_t game) { * * Display turns taken and score so far. */ -sc_bool -lib_cmd_turns(sc_gameref_t game) { +sc_bool lib_cmd_turns(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_char buffer[32]; @@ -8728,8 +8522,7 @@ lib_cmd_turns(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_score(sc_gameref_t game) { +sc_bool lib_cmd_score(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; @@ -8772,8 +8565,7 @@ lib_cmd_score(sc_gameref_t game) { * Standard response commands. These are uninteresting catch-all cases, * but it's good to make then right as game ALRs may look for them. */ -sc_bool -lib_cmd_profanity(sc_gameref_t game) { +sc_bool lib_cmd_profanity(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8782,16 +8574,14 @@ lib_cmd_profanity(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_examine_all(sc_gameref_t game) { +sc_bool lib_cmd_examine_all(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "Please examine one object at a time.\n"); return TRUE; } -sc_bool -lib_cmd_examine_other(sc_gameref_t game) { +sc_bool lib_cmd_examine_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8802,8 +8592,7 @@ lib_cmd_examine_other(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_locate_other(sc_gameref_t game) { +sc_bool lib_cmd_locate_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "I don't know where that is!\n"); @@ -8811,32 +8600,28 @@ lib_cmd_locate_other(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_unix_like(sc_gameref_t game) { +sc_bool lib_cmd_unix_like(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "This isn't Unix you know!\n"); return TRUE; } -sc_bool -lib_cmd_dos_like(sc_gameref_t game) { +sc_bool lib_cmd_dos_like(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "This isn't Dos you know!\n"); return TRUE; } -sc_bool -lib_cmd_cry(sc_gameref_t game) { +sc_bool lib_cmd_cry(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "There's no need for that!\n"); return TRUE; } -sc_bool -lib_cmd_dance(sc_gameref_t game) { +sc_bool lib_cmd_dance(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8847,32 +8632,28 @@ lib_cmd_dance(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_eat_other(sc_gameref_t game) { +sc_bool lib_cmd_eat_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "I don't understand what you are trying to eat.\n"); return TRUE; } -sc_bool -lib_cmd_fight(sc_gameref_t game) { +sc_bool lib_cmd_fight(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "There is nothing worth fighting here.\n"); return TRUE; } -sc_bool -lib_cmd_feed(sc_gameref_t game) { +sc_bool lib_cmd_feed(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "There is nothing worth feeding here.\n"); return TRUE; } -sc_bool -lib_cmd_feel(sc_gameref_t game) { +sc_bool lib_cmd_feel(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8883,8 +8664,7 @@ lib_cmd_feel(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_fly(sc_gameref_t game) { +sc_bool lib_cmd_fly(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8895,8 +8675,7 @@ lib_cmd_fly(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_hint(sc_gameref_t game) { +sc_bool lib_cmd_hint(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8905,8 +8684,7 @@ lib_cmd_hint(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_hum(sc_gameref_t game) { +sc_bool lib_cmd_hum(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8917,16 +8695,14 @@ lib_cmd_hum(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_jump(sc_gameref_t game) { +sc_bool lib_cmd_jump(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "Wheee-boinng.\n"); return TRUE; } -sc_bool -lib_cmd_listen(sc_gameref_t game) { +sc_bool lib_cmd_listen(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8937,8 +8713,7 @@ lib_cmd_listen(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_please(sc_gameref_t game) { +sc_bool lib_cmd_please(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8949,16 +8724,14 @@ lib_cmd_please(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_punch(sc_gameref_t game) { +sc_bool lib_cmd_punch(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "Who do you think you are, Mike Tyson?\n"); return TRUE; } -sc_bool -lib_cmd_run(sc_gameref_t game) { +sc_bool lib_cmd_run(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -8969,16 +8742,14 @@ lib_cmd_run(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_shout(sc_gameref_t game) { +sc_bool lib_cmd_shout(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "Aaarrrrgggghhhhhh!\n"); return TRUE; } -sc_bool -lib_cmd_say(sc_gameref_t game) { +sc_bool lib_cmd_say(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_char *string = NULL; @@ -9010,8 +8781,7 @@ lib_cmd_say(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_sing(sc_gameref_t game) { +sc_bool lib_cmd_sing(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -9022,16 +8792,14 @@ lib_cmd_sing(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_sleep(sc_gameref_t game) { +sc_bool lib_cmd_sleep(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "Zzzzz. Bored are you?\n"); return TRUE; } -sc_bool -lib_cmd_talk(sc_gameref_t game) { +sc_bool lib_cmd_talk(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -9042,16 +8810,14 @@ lib_cmd_talk(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_thank(sc_gameref_t game) { +sc_bool lib_cmd_thank(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "You're welcome.\n"); return TRUE; } -sc_bool -lib_cmd_whistle(sc_gameref_t game) { +sc_bool lib_cmd_whistle(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -9062,8 +8828,7 @@ lib_cmd_whistle(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_interrogation(sc_gameref_t game) { +sc_bool lib_cmd_interrogation(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_char *string = NULL; @@ -9125,8 +8890,7 @@ lib_cmd_interrogation(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_xyzzy(sc_gameref_t game) { +sc_bool lib_cmd_xyzzy(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -9135,8 +8899,7 @@ lib_cmd_xyzzy(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_egotistic(sc_gameref_t game) { +sc_bool lib_cmd_egotistic(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); #if 0 @@ -9150,8 +8913,7 @@ lib_cmd_egotistic(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_yes_or_no(sc_gameref_t game) { +sc_bool lib_cmd_yes_or_no(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, @@ -9167,8 +8929,7 @@ lib_cmd_yes_or_no(sc_gameref_t game) { * * Malformed and rhetorical question responses. */ -sc_bool -lib_cmd_ask_npc(sc_gameref_t game) { +sc_bool lib_cmd_ask_npc(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int npc; sc_bool is_ambiguous; @@ -9185,8 +8946,7 @@ lib_cmd_ask_npc(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_ask_object(sc_gameref_t game) { +sc_bool lib_cmd_ask_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; sc_bool is_ambiguous; @@ -9207,8 +8967,7 @@ lib_cmd_ask_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_ask_other(sc_gameref_t game) { +sc_bool lib_cmd_ask_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); /* Incomplete ask command, so offer help and return. */ @@ -9223,8 +8982,7 @@ lib_cmd_ask_other(sc_gameref_t game) { * * Uninteresting kill message when no weaponry is involved. */ -sc_bool -lib_cmd_kill_other(sc_gameref_t game) { +sc_bool lib_cmd_kill_other(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, "Now that isn't very nice.\n"); @@ -9240,11 +8998,8 @@ lib_cmd_kill_other(sc_gameref_t game) { * Central handler for a range of nothing-happens messages. More * uninteresting responses. */ -static sc_bool -lib_nothing_happens_common(sc_gameref_t game, - const sc_char *verb_general, - const sc_char *verb_third_person, - sc_bool is_object) { +static sc_bool lib_nothing_happens_common(sc_gameref_t game, const sc_char *verb_general, + const sc_char *verb_third_person, sc_bool is_object) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; @@ -9298,18 +9053,14 @@ lib_nothing_happens_common(sc_gameref_t game, return TRUE; } -static sc_bool -lib_nothing_happens_object(sc_gameref_t game, - const sc_char *verb_general, - const sc_char *verb_third_person) { +static sc_bool lib_nothing_happens_object(sc_gameref_t game, + const sc_char *verb_general, const sc_char *verb_third_person) { return lib_nothing_happens_common(game, verb_general, verb_third_person, TRUE); } -static sc_bool -lib_nothing_happens_other(sc_gameref_t game, - const sc_char *verb_general, - const sc_char *verb_third_person) { +static sc_bool lib_nothing_happens_other(sc_gameref_t game, + const sc_char *verb_general, const sc_char *verb_third_person) { return lib_nothing_happens_common(game, verb_general, verb_third_person, FALSE); } @@ -9320,63 +9071,51 @@ lib_nothing_happens_other(sc_gameref_t game, * * Shake, rattle and roll, and assorted nothing-happens handlers. */ -sc_bool -lib_cmd_hit_object(sc_gameref_t game) { +sc_bool lib_cmd_hit_object(sc_gameref_t game) { return lib_nothing_happens_object(game, "hit", "hits"); } -sc_bool -lib_cmd_kick_object(sc_gameref_t game) { +sc_bool lib_cmd_kick_object(sc_gameref_t game) { return lib_nothing_happens_object(game, "kick", "kicks"); } -sc_bool -lib_cmd_press_object(sc_gameref_t game) { +sc_bool lib_cmd_press_object(sc_gameref_t game) { return lib_nothing_happens_object(game, "press", "presses"); } -sc_bool -lib_cmd_push_object(sc_gameref_t game) { +sc_bool lib_cmd_push_object(sc_gameref_t game) { return lib_nothing_happens_object(game, "push", "pushes"); } -sc_bool -lib_cmd_pull_object(sc_gameref_t game) { +sc_bool lib_cmd_pull_object(sc_gameref_t game) { return lib_nothing_happens_object(game, "pull", "pulls"); } -sc_bool -lib_cmd_shake_object(sc_gameref_t game) { +sc_bool lib_cmd_shake_object(sc_gameref_t game) { return lib_nothing_happens_object(game, "shake", "shakes"); } -sc_bool -lib_cmd_hit_other(sc_gameref_t game) { +sc_bool lib_cmd_hit_other(sc_gameref_t game) { return lib_nothing_happens_other(game, "hit", "hits"); } -sc_bool -lib_cmd_kick_other(sc_gameref_t game) { +sc_bool lib_cmd_kick_other(sc_gameref_t game) { return lib_nothing_happens_other(game, "kick", "kicks"); } -sc_bool -lib_cmd_press_other(sc_gameref_t game) { +sc_bool lib_cmd_press_other(sc_gameref_t game) { return lib_nothing_happens_other(game, "press", "presses"); } -sc_bool -lib_cmd_push_other(sc_gameref_t game) { +sc_bool lib_cmd_push_other(sc_gameref_t game) { return lib_nothing_happens_other(game, "push", "pushes"); } -sc_bool -lib_cmd_pull_other(sc_gameref_t game) { +sc_bool lib_cmd_pull_other(sc_gameref_t game) { return lib_nothing_happens_other(game, "pull", "pulls"); } -sc_bool -lib_cmd_shake_other(sc_gameref_t game) { +sc_bool lib_cmd_shake_other(sc_gameref_t game) { return lib_nothing_happens_other(game, "shake", "shakes"); } @@ -9389,9 +9128,7 @@ lib_cmd_shake_other(sc_gameref_t game) { * Central handler for a range of can't-do messages. Yet more uninterest- * ing responses. */ -static sc_bool -lib_cant_do_common(sc_gameref_t game, - const sc_char *verb, sc_bool is_object) { +static sc_bool lib_cant_do_common(sc_gameref_t game, const sc_char *verb, sc_bool is_object) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; sc_bool is_ambiguous; @@ -9424,13 +9161,11 @@ lib_cant_do_common(sc_gameref_t game, return TRUE; } -static sc_bool -lib_cant_do_object(sc_gameref_t game, const sc_char *verb) { +static sc_bool lib_cant_do_object(sc_gameref_t game, const sc_char *verb) { return lib_cant_do_common(game, verb, TRUE); } -static sc_bool -lib_cant_do_other(sc_gameref_t game, const sc_char *verb) { +static sc_bool lib_cant_do_other(sc_gameref_t game, const sc_char *verb) { return lib_cant_do_common(game, verb, FALSE); } @@ -9440,183 +9175,147 @@ lib_cant_do_other(sc_gameref_t game, const sc_char *verb) { * * Assorted can't-do messages. */ -sc_bool -lib_cmd_block_object(sc_gameref_t game) { +sc_bool lib_cmd_block_object(sc_gameref_t game) { return lib_cant_do_object(game, "block"); } -sc_bool -lib_cmd_climb_object(sc_gameref_t game) { +sc_bool lib_cmd_climb_object(sc_gameref_t game) { return lib_cant_do_object(game, "climb"); } -sc_bool -lib_cmd_clean_object(sc_gameref_t game) { +sc_bool lib_cmd_clean_object(sc_gameref_t game) { return lib_cant_do_object(game, "clean"); } -sc_bool -lib_cmd_cut_object(sc_gameref_t game) { +sc_bool lib_cmd_cut_object(sc_gameref_t game) { return lib_cant_do_object(game, "cut"); } -sc_bool -lib_cmd_drink_object(sc_gameref_t game) { +sc_bool lib_cmd_drink_object(sc_gameref_t game) { return lib_cant_do_object(game, "drink"); } -sc_bool -lib_cmd_light_object(sc_gameref_t game) { +sc_bool lib_cmd_light_object(sc_gameref_t game) { return lib_cant_do_object(game, "light"); } -sc_bool -lib_cmd_lift_object(sc_gameref_t game) { +sc_bool lib_cmd_lift_object(sc_gameref_t game) { return lib_cant_do_object(game, "lift"); } -sc_bool -lib_cmd_move_object(sc_gameref_t game) { +sc_bool lib_cmd_move_object(sc_gameref_t game) { return lib_cant_do_object(game, "move"); } -sc_bool -lib_cmd_rub_object(sc_gameref_t game) { +sc_bool lib_cmd_rub_object(sc_gameref_t game) { return lib_cant_do_object(game, "rub"); } -sc_bool -lib_cmd_stop_object(sc_gameref_t game) { +sc_bool lib_cmd_stop_object(sc_gameref_t game) { return lib_cant_do_object(game, "stop"); } -sc_bool -lib_cmd_suck_object(sc_gameref_t game) { +sc_bool lib_cmd_suck_object(sc_gameref_t game) { return lib_cant_do_object(game, "suck"); } -sc_bool -lib_cmd_touch_object(sc_gameref_t game) { +sc_bool lib_cmd_touch_object(sc_gameref_t game) { return lib_cant_do_object(game, "touch"); } -sc_bool -lib_cmd_turn_object(sc_gameref_t game) { +sc_bool lib_cmd_turn_object(sc_gameref_t game) { return lib_cant_do_object(game, "turn"); } -sc_bool -lib_cmd_unblock_object(sc_gameref_t game) { +sc_bool lib_cmd_unblock_object(sc_gameref_t game) { return lib_cant_do_object(game, "unblock"); } -sc_bool -lib_cmd_wash_object(sc_gameref_t game) { +sc_bool lib_cmd_wash_object(sc_gameref_t game) { return lib_cant_do_object(game, "wash"); } -sc_bool -lib_cmd_block_other(sc_gameref_t game) { +sc_bool lib_cmd_block_other(sc_gameref_t game) { return lib_cant_do_other(game, "block"); } -sc_bool -lib_cmd_climb_other(sc_gameref_t game) { +sc_bool lib_cmd_climb_other(sc_gameref_t game) { return lib_cant_do_other(game, "climb"); } -sc_bool -lib_cmd_clean_other(sc_gameref_t game) { +sc_bool lib_cmd_clean_other(sc_gameref_t game) { return lib_cant_do_other(game, "clean"); } -sc_bool -lib_cmd_close_other(sc_gameref_t game) { +sc_bool lib_cmd_close_other(sc_gameref_t game) { return lib_cant_do_other(game, "close"); } -sc_bool -lib_cmd_lock_other(sc_gameref_t game) { +sc_bool lib_cmd_lock_other(sc_gameref_t game) { return lib_cant_do_other(game, "lock"); } -sc_bool -lib_cmd_unlock_other(sc_gameref_t game) { +sc_bool lib_cmd_unlock_other(sc_gameref_t game) { return lib_cant_do_other(game, "unlock"); } -sc_bool -lib_cmd_stand_other(sc_gameref_t game) { +sc_bool lib_cmd_stand_other(sc_gameref_t game) { return lib_cant_do_other(game, "stand on"); } -sc_bool -lib_cmd_sit_other(sc_gameref_t game) { +sc_bool lib_cmd_sit_other(sc_gameref_t game) { return lib_cant_do_other(game, "sit on"); } -sc_bool -lib_cmd_lie_other(sc_gameref_t game) { +sc_bool lib_cmd_lie_other(sc_gameref_t game) { return lib_cant_do_other(game, "lie on"); } -sc_bool -lib_cmd_cut_other(sc_gameref_t game) { +sc_bool lib_cmd_cut_other(sc_gameref_t game) { return lib_cant_do_other(game, "cut"); } -sc_bool -lib_cmd_drink_other(sc_gameref_t game) { +sc_bool lib_cmd_drink_other(sc_gameref_t game) { return lib_cant_do_other(game, "drink"); } -sc_bool -lib_cmd_lift_other(sc_gameref_t game) { +sc_bool lib_cmd_lift_other(sc_gameref_t game) { return lib_cant_do_other(game, "lift"); } -sc_bool -lib_cmd_light_other(sc_gameref_t game) { +sc_bool lib_cmd_light_other(sc_gameref_t game) { return lib_cant_do_other(game, "light"); } -sc_bool -lib_cmd_move_other(sc_gameref_t game) { +sc_bool lib_cmd_move_other(sc_gameref_t game) { return lib_cant_do_other(game, "move"); } -sc_bool -lib_cmd_stop_other(sc_gameref_t game) { +sc_bool lib_cmd_stop_other(sc_gameref_t game) { return lib_cant_do_other(game, "stop"); } -sc_bool -lib_cmd_rub_other(sc_gameref_t game) { +sc_bool lib_cmd_rub_other(sc_gameref_t game) { return lib_cant_do_other(game, "rub"); } -sc_bool -lib_cmd_suck_other(sc_gameref_t game) { +sc_bool lib_cmd_suck_other(sc_gameref_t game) { return lib_cant_do_other(game, "suck"); } -sc_bool -lib_cmd_turn_other(sc_gameref_t game) { +sc_bool lib_cmd_turn_other(sc_gameref_t game) { return lib_cant_do_other(game, "turn"); } -sc_bool -lib_cmd_touch_other(sc_gameref_t game) { +sc_bool lib_cmd_touch_other(sc_gameref_t game) { return lib_cant_do_other(game, "touch"); } -sc_bool -lib_cmd_unblock_other(sc_gameref_t game) { +sc_bool lib_cmd_unblock_other(sc_gameref_t game) { return lib_cant_do_other(game, "unblock"); } -sc_bool -lib_cmd_wash_other(sc_gameref_t game) { +sc_bool lib_cmd_wash_other(sc_gameref_t game) { return lib_cant_do_other(game, "wash"); } @@ -9629,8 +9328,7 @@ lib_cmd_wash_other(sc_gameref_t game) { * Central handler for a range of don't_think messages. Still more * uninteresting responses. */ -static sc_bool -lib_dont_think_common(sc_gameref_t game, +static sc_bool lib_dont_think_common(sc_gameref_t game, const sc_char *verb, sc_bool is_object) { const sc_filterref_t filter = gs_get_filter(game); sc_int object; @@ -9662,13 +9360,11 @@ lib_dont_think_common(sc_gameref_t game, return TRUE; } -static sc_bool -lib_dont_think_object(sc_gameref_t game, const sc_char *verb) { +static sc_bool lib_dont_think_object(sc_gameref_t game, const sc_char *verb) { return lib_dont_think_common(game, verb, TRUE); } -static sc_bool -lib_dont_think_other(sc_gameref_t game, const sc_char *verb) { +static sc_bool lib_dont_think_other(sc_gameref_t game, const sc_char *verb) { return lib_dont_think_common(game, verb, FALSE); } @@ -9678,33 +9374,27 @@ lib_dont_think_other(sc_gameref_t game, const sc_char *verb) { * * Assorted don't-think messages. */ -sc_bool -lib_cmd_fix_object(sc_gameref_t game) { +sc_bool lib_cmd_fix_object(sc_gameref_t game) { return lib_dont_think_object(game, "fix"); } -sc_bool -lib_cmd_mend_object(sc_gameref_t game) { +sc_bool lib_cmd_mend_object(sc_gameref_t game) { return lib_dont_think_object(game, "mend"); } -sc_bool -lib_cmd_repair_object(sc_gameref_t game) { +sc_bool lib_cmd_repair_object(sc_gameref_t game) { return lib_dont_think_object(game, "repair"); } -sc_bool -lib_cmd_fix_other(sc_gameref_t game) { +sc_bool lib_cmd_fix_other(sc_gameref_t game) { return lib_dont_think_other(game, "fix"); } -sc_bool -lib_cmd_mend_other(sc_gameref_t game) { +sc_bool lib_cmd_mend_other(sc_gameref_t game) { return lib_dont_think_other(game, "mend"); } -sc_bool -lib_cmd_repair_other(sc_gameref_t game) { +sc_bool lib_cmd_repair_other(sc_gameref_t game) { return lib_dont_think_other(game, "repair"); } @@ -9714,8 +9404,7 @@ lib_cmd_repair_other(sc_gameref_t game) { * * Central handler for doing something, but unsure to what. */ -static sc_bool -lib_what(sc_gameref_t game, const sc_char *verb) { +static sc_bool lib_what(sc_gameref_t game, const sc_char *verb) { const sc_filterref_t filter = gs_get_filter(game); pf_buffer_string(filter, verb); @@ -9729,188 +9418,151 @@ lib_what(sc_gameref_t game, const sc_char *verb) { * * Assorted "what?" messages. */ -sc_bool -lib_cmd_block_what(sc_gameref_t game) { +sc_bool lib_cmd_block_what(sc_gameref_t game) { return lib_what(game, "Block"); } -sc_bool -lib_cmd_break_what(sc_gameref_t game) { +sc_bool lib_cmd_break_what(sc_gameref_t game) { return lib_what(game, "Break"); } -sc_bool -lib_cmd_destroy_what(sc_gameref_t game) { +sc_bool lib_cmd_destroy_what(sc_gameref_t game) { return lib_what(game, "Destroy"); } -sc_bool -lib_cmd_smash_what(sc_gameref_t game) { +sc_bool lib_cmd_smash_what(sc_gameref_t game) { return lib_what(game, "Smash"); } -sc_bool -lib_cmd_buy_what(sc_gameref_t game) { +sc_bool lib_cmd_buy_what(sc_gameref_t game) { return lib_what(game, "Buy"); } -sc_bool -lib_cmd_clean_what(sc_gameref_t game) { +sc_bool lib_cmd_clean_what(sc_gameref_t game) { return lib_what(game, "Clean"); } -sc_bool -lib_cmd_climb_what(sc_gameref_t game) { +sc_bool lib_cmd_climb_what(sc_gameref_t game) { return lib_what(game, "Climb"); } -sc_bool -lib_cmd_cut_what(sc_gameref_t game) { +sc_bool lib_cmd_cut_what(sc_gameref_t game) { return lib_what(game, "Cut"); } -sc_bool -lib_cmd_drink_what(sc_gameref_t game) { +sc_bool lib_cmd_drink_what(sc_gameref_t game) { return lib_what(game, "Drink"); } -sc_bool -lib_cmd_fix_what(sc_gameref_t game) { +sc_bool lib_cmd_fix_what(sc_gameref_t game) { return lib_what(game, "Fix"); } -sc_bool -lib_cmd_hit_what(sc_gameref_t game) { +sc_bool lib_cmd_hit_what(sc_gameref_t game) { return lib_what(game, "Hit"); } -sc_bool -lib_cmd_kick_what(sc_gameref_t game) { +sc_bool lib_cmd_kick_what(sc_gameref_t game) { return lib_what(game, "Kick"); } -sc_bool -lib_cmd_light_what(sc_gameref_t game) { +sc_bool lib_cmd_light_what(sc_gameref_t game) { return lib_what(game, "Light"); } -sc_bool -lib_cmd_lift_what(sc_gameref_t game) { +sc_bool lib_cmd_lift_what(sc_gameref_t game) { return lib_what(game, "Lift"); } -sc_bool -lib_cmd_mend_what(sc_gameref_t game) { +sc_bool lib_cmd_mend_what(sc_gameref_t game) { return lib_what(game, "Mend"); } -sc_bool -lib_cmd_move_what(sc_gameref_t game) { +sc_bool lib_cmd_move_what(sc_gameref_t game) { return lib_what(game, "Move"); } -sc_bool -lib_cmd_press_what(sc_gameref_t game) { +sc_bool lib_cmd_press_what(sc_gameref_t game) { return lib_what(game, "Press"); } -sc_bool -lib_cmd_pull_what(sc_gameref_t game) { +sc_bool lib_cmd_pull_what(sc_gameref_t game) { return lib_what(game, "Pull"); } -sc_bool -lib_cmd_push_what(sc_gameref_t game) { +sc_bool lib_cmd_push_what(sc_gameref_t game) { return lib_what(game, "Push"); } -sc_bool -lib_cmd_repair_what(sc_gameref_t game) { +sc_bool lib_cmd_repair_what(sc_gameref_t game) { return lib_what(game, "Repair"); } -sc_bool -lib_cmd_sell_what(sc_gameref_t game) { +sc_bool lib_cmd_sell_what(sc_gameref_t game) { return lib_what(game, "Sell"); } -sc_bool -lib_cmd_shake_what(sc_gameref_t game) { +sc_bool lib_cmd_shake_what(sc_gameref_t game) { return lib_what(game, "Shake"); } -sc_bool -lib_cmd_rub_what(sc_gameref_t game) { +sc_bool lib_cmd_rub_what(sc_gameref_t game) { return lib_what(game, "Rub"); } -sc_bool -lib_cmd_stop_what(sc_gameref_t game) { +sc_bool lib_cmd_stop_what(sc_gameref_t game) { return lib_what(game, "Stop"); } -sc_bool -lib_cmd_suck_what(sc_gameref_t game) { +sc_bool lib_cmd_suck_what(sc_gameref_t game) { return lib_what(game, "Suck"); } -sc_bool -lib_cmd_touch_what(sc_gameref_t game) { +sc_bool lib_cmd_touch_what(sc_gameref_t game) { return lib_what(game, "Touch"); } -sc_bool -lib_cmd_turn_what(sc_gameref_t game) { +sc_bool lib_cmd_turn_what(sc_gameref_t game) { return lib_what(game, "Turn"); } -sc_bool -lib_cmd_unblock_what(sc_gameref_t game) { +sc_bool lib_cmd_unblock_what(sc_gameref_t game) { return lib_what(game, "Unblock"); } -sc_bool -lib_cmd_wash_what(sc_gameref_t game) { +sc_bool lib_cmd_wash_what(sc_gameref_t game) { return lib_what(game, "Wash"); } -sc_bool -lib_cmd_drop_what(sc_gameref_t game) { +sc_bool lib_cmd_drop_what(sc_gameref_t game) { return lib_what(game, "Drop"); } -sc_bool -lib_cmd_get_what(sc_gameref_t game) { +sc_bool lib_cmd_get_what(sc_gameref_t game) { return lib_what(game, "Take"); } -sc_bool -lib_cmd_give_what(sc_gameref_t game) { +sc_bool lib_cmd_give_what(sc_gameref_t game) { return lib_what(game, "Give"); } -sc_bool -lib_cmd_open_what(sc_gameref_t game) { +sc_bool lib_cmd_open_what(sc_gameref_t game) { return lib_what(game, "Open"); } -sc_bool -lib_cmd_remove_what(sc_gameref_t game) { +sc_bool lib_cmd_remove_what(sc_gameref_t game) { return lib_what(game, "Remove"); } -sc_bool -lib_cmd_wear_what(sc_gameref_t game) { +sc_bool lib_cmd_wear_what(sc_gameref_t game) { return lib_what(game, "Wear"); } -sc_bool -lib_cmd_lock_what(sc_gameref_t game) { +sc_bool lib_cmd_lock_what(sc_gameref_t game) { return lib_what(game, "Lock"); } -sc_bool -lib_cmd_unlock_what(sc_gameref_t game) { +sc_bool lib_cmd_unlock_what(sc_gameref_t game) { return lib_what(game, "Unlock"); } @@ -9921,8 +9573,7 @@ lib_cmd_unlock_what(sc_gameref_t game) { * * Handlers for unrecognized verbs with known object/NPC. */ -sc_bool -lib_cmd_verb_object(sc_gameref_t game) { +sc_bool lib_cmd_verb_object(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); sc_int count, object, index_; @@ -9951,8 +9602,7 @@ lib_cmd_verb_object(sc_gameref_t game) { return TRUE; } -sc_bool -lib_cmd_verb_npc(sc_gameref_t game) { +sc_bool lib_cmd_verb_npc(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); sc_int count, npc, index_; @@ -9987,8 +9637,7 @@ lib_cmd_verb_npc(sc_gameref_t game) { * * Set library tracing on/off. */ -void -lib_debug_trace(sc_bool flag) { +void lib_debug_trace(sc_bool flag) { lib_trace = flag; } diff --git a/engines/glk/adrift/sclocale.cpp b/engines/glk/adrift/sclocale.cpp index b201b7faa4..140e9c9be3 100644 --- a/engines/glk/adrift/sclocale.cpp +++ b/engines/glk/adrift/sclocale.cpp @@ -50,8 +50,7 @@ enum { TABLE_SIZE = 256 }; * Helpers for building ctype tables. Sets all elements from start to end * inclusive to TRUE, and iterate this on a ranges array. */ -static void -loc_setrange_bool(sc_int start, sc_int end, sc_bool table[]) { +static void loc_setrange_bool(sc_int start, sc_int end, sc_bool table[]) { sc_int index_; for (index_ = start; index_ <= end; index_++) { @@ -60,8 +59,7 @@ loc_setrange_bool(sc_int start, sc_int end, sc_bool table[]) { } } -static void -loc_setranges_bool(const sc_int ranges[], sc_bool table[]) { +static void loc_setranges_bool(const sc_int ranges[], sc_bool table[]) { sc_int index_; for (index_ = 0; ranges[index_] > -1; index_ += 2) { @@ -79,8 +77,7 @@ loc_setranges_bool(const sc_int ranges[], sc_bool table[]) { * to end inclusive to their index value plus the given offset, and iterate * this on a ranges array. */ -static void -loc_setrange_char(sc_int start, sc_int end, sc_int offset, sc_char table[]) { +static void loc_setrange_char(sc_int start, sc_int end, sc_int offset, sc_char table[]) { sc_int index_; for (index_ = start; index_ <= end; index_++) { @@ -90,8 +87,7 @@ loc_setrange_char(sc_int start, sc_int end, sc_int offset, sc_char table[]) { } } -static void -loc_setranges_char(const sc_int ranges[], sc_char table[]) { +static void loc_setranges_char(const sc_int ranges[], sc_char table[]) { sc_int index_; for (index_ = 0; ranges[index_] > -1; index_ += 3) { @@ -109,7 +105,7 @@ loc_setranges_char(const sc_int ranges[], sc_char table[]) { */ enum { RANGES_LENGTH = 32 }; enum { SIGNATURE_COUNT = 24, SIGNATURE_LENGTH = 3 }; -typedef struct { +struct sc_locale_t { const sc_char *const name; const sc_int isspace_ranges[RANGES_LENGTH]; const sc_int isdigit_ranges[RANGES_LENGTH]; @@ -117,7 +113,7 @@ typedef struct { const sc_int toupper_ranges[RANGES_LENGTH]; const sc_int tolower_ranges[RANGES_LENGTH]; const sc_byte signature[SIGNATURE_COUNT][SIGNATURE_LENGTH]; -} sc_locale_t; +}; /* @@ -126,14 +122,14 @@ typedef struct { * table, for synchronization with changed locales. This is the dynamic data * portion of a locale. */ -typedef struct { +struct sc_locale_table_t { const sc_locale_t *locale; sc_bool isspace[TABLE_SIZE]; sc_bool isdigit[TABLE_SIZE]; sc_bool isalpha[TABLE_SIZE]; sc_char toupper[TABLE_SIZE]; sc_char tolower[TABLE_SIZE]; -} sc_locale_table_t; +}; /* * Define a single static locale table set. This set re-initializes if it @@ -149,8 +145,7 @@ static sc_locale_table_t loc_locale_tables = {NULL, {0}, {0}, {0}, {0}, {0}}; * Initialize tables for a locale. And compare the locale tables to a locale * and if not for the same locale, (re-)initialize. */ -static void -loc_synchronize_tables(const sc_locale_t *locale) { +static void loc_synchronize_tables(const sc_locale_t *locale) { /* Clear all tables and the locale pointer. */ memset(&loc_locale_tables, 0, sizeof(loc_locale_tables)); @@ -164,8 +159,7 @@ loc_synchronize_tables(const sc_locale_t *locale) { loc_locale_tables.locale = locale; } -static void -loc_check_tables_synchronized(const sc_locale_t *locale) { +static void loc_check_tables_synchronized(const sc_locale_t *locale) { if (locale != loc_locale_tables.locale) loc_synchronize_tables(locale); } @@ -250,8 +244,7 @@ static sc_bool loc_is_autodetect_enabled = TRUE; * "dd [Mm]mm yyyy". Returns the address of the month part of the string, or * NULL if it doesn't match the expected format. */ -static const sc_char * -loc_locate_signature_in_date(const sc_char *date) { +static const sc_char *loc_locate_signature_in_date(const sc_char *date) { sc_int day, year, converted; sc_char signature[SIGNATURE_LENGTH + 1]; @@ -275,8 +268,7 @@ loc_locate_signature_in_date(const sc_char *date) { * any strcasecmp() variant because the signatures are in the locale's * codepage, but the locale is not yet (by definition) set. */ -static sc_bool -loc_compare_locale_signatures(const char *signature, const sc_locale_t *locale) { +static sc_bool loc_compare_locale_signatures(const char *signature, const sc_locale_t *locale) { sc_int index_; sc_bool is_matched; @@ -302,9 +294,8 @@ loc_compare_locale_signatures(const char *signature, const sc_locale_t *locale) * Generator was run. Match this with locale signatures, and return the * first locale that matches, or NULL if none match. */ -static const sc_locale_t * -loc_find_matching_locale(const sc_char *date, - const sc_locale_t *const *locales) { +static const sc_locale_t *loc_find_matching_locale(const sc_char *date, + const sc_locale_t *const *locales) { const sc_char *signature; const sc_locale_t *matched = NULL; @@ -333,8 +324,7 @@ loc_find_matching_locale(const sc_char *date, * Set an autodetected value for the locale based on looking at a game's * compilation date. */ -void -loc_detect_game_locale(sc_prop_setref_t bundle) { +void loc_detect_game_locale(sc_prop_setref_t bundle) { assert(bundle); /* If an explicit locale has already been set, ignore the call. */ @@ -367,13 +357,11 @@ loc_detect_game_locale(sc_prop_setref_t bundle) { * be in ascii anyway, it's slightly safer to just use an ascii-only version * of this function. */ -static sc_char -loc_ascii_tolower(sc_char ch) { +static sc_char loc_ascii_tolower(sc_char ch) { return (ch >= 'A' && ch <= 'Z') ? ch - 'A' + 'a' : ch; } -static sc_int -loc_ascii_strncasecmp(const sc_char *s1, const sc_char *s2, sc_int n) { +static sc_int loc_ascii_strncasecmp(const sc_char *s1, const sc_char *s2, sc_int n) { sc_int index_; for (index_ = 0; index_ < n; index_++) { @@ -396,8 +384,7 @@ loc_ascii_strncasecmp(const sc_char *s1, const sc_char *s2, sc_int n) { * matched the name. Get the current locale, which may be the default locale * if none yet set. */ -sc_bool -loc_set_locale(const sc_char *name) { +sc_bool loc_set_locale(const sc_char *name) { const sc_locale_t *matched = NULL; const sc_locale_t *const *iterator; assert(name); @@ -424,8 +411,7 @@ loc_set_locale(const sc_char *name) { return matched ? TRUE : FALSE; } -const sc_char * -loc_get_locale(void) { +const sc_char *loc_get_locale(void) { return loc_locale->name; } @@ -438,14 +424,11 @@ loc_get_locale(void) { * * Print out locale tables. */ -static int -loc_debug_dump_new_line(sc_int index_, sc_int count) { +static int loc_debug_dump_new_line(sc_int index_, sc_int count) { return index_ < TABLE_SIZE - 1 && index_ % count == count - 1; } -static void -loc_debug_dump_bool_table(const sc_char *label, - sc_int count, const sc_bool table[]) { +static void loc_debug_dump_bool_table(const sc_char *label, sc_int count, const sc_bool table[]) { sc_int index_; sc_trace("loc_locale_tables.%s = {\n ", label); @@ -456,9 +439,7 @@ loc_debug_dump_bool_table(const sc_char *label, sc_trace("\n}\n"); } -static void -loc_debug_dump_char_table(const sc_char *label, - sc_int count, const sc_char table[]) { +static void loc_debug_dump_char_table(const sc_char *label, sc_int count, const sc_char table[]) { sc_int index_; sc_trace("loc_locale_tables.%s = {\n ", label); @@ -469,8 +450,7 @@ loc_debug_dump_char_table(const sc_char *label, sc_trace("\n}\n"); } -void -loc_debug_dump(void) { +void loc_debug_dump(void) { sc_trace("Locale: debug dump follows...\n"); loc_check_tables_synchronized(loc_locale); @@ -492,14 +472,12 @@ loc_debug_dump(void) { * "Template" functions for locale variant ctype functions. Synchronize * tables to the currently set locale, and return the value from the table. */ -static sc_bool -loc_bool_template(sc_char character, const sc_bool table[]) { +static sc_bool loc_bool_template(sc_char character, const sc_bool table[]) { loc_check_tables_synchronized(loc_locale); return table[(sc_byte) character]; } -static sc_char -loc_char_template(sc_char character, const sc_char table[]) { +static sc_char loc_char_template(sc_char character, const sc_char table[]) { loc_check_tables_synchronized(loc_locale); return table[(sc_byte) character]; } @@ -514,28 +492,23 @@ loc_char_template(sc_char character, const sc_char table[]) { * * Public entry points into locale variant ctype functions. */ -sc_bool -sc_isspace(sc_char character) { +sc_bool sc_isspace(sc_char character) { return loc_bool_template(character, loc_locale_tables.isspace); } -sc_bool -sc_isalpha(sc_char character) { +sc_bool sc_isalpha(sc_char character) { return loc_bool_template(character, loc_locale_tables.isalpha); } -sc_bool -sc_isdigit(sc_char character) { +sc_bool sc_isdigit(sc_char character) { return loc_bool_template(character, loc_locale_tables.isdigit); } -sc_char -sc_toupper(sc_char character) { +sc_char sc_toupper(sc_char character) { return loc_char_template(character, loc_locale_tables.toupper); } -sc_char -sc_tolower(sc_char character) { +sc_char sc_tolower(sc_char character) { return loc_char_template(character, loc_locale_tables.tolower); } diff --git a/engines/glk/adrift/scmemos.cpp b/engines/glk/adrift/scmemos.cpp index 9179783baa..88720f28bf 100644 --- a/engines/glk/adrift/scmemos.cpp +++ b/engines/glk/adrift/scmemos.cpp @@ -34,25 +34,27 @@ enum { MEMO_ALLOCATION_BLOCK = 32 }; * Game memo structure, saves a serialized game. Allocation is preserved so * that structures can be reused without requiring reallocation. */ -typedef struct sc_memo_s { +struct sc_memo_s { sc_byte *serialized_game; sc_int allocation; sc_int length; -} sc_memo_t; +}; +typedef sc_memo_s sc_memo_t; typedef sc_memo_t *sc_memoref_t; /* * Game command history structure, similar to a memo. Saves a player input * command to create a history, reusing allocation where possible. */ -typedef struct sc_history_s { +struct sc_history_s { sc_char *command; sc_int sequence; sc_int timestamp; sc_int turns; sc_int allocation; sc_int length; -} sc_history_t; +}; +typedef sc_history_s sc_history_t; typedef sc_history_t *sc_historyref_t; /* @@ -64,7 +66,7 @@ typedef sc_history_t *sc_historyref_t; * also a ring with limited capacity. */ enum { MEMO_UNDO_TABLE_SIZE = 16, MEMO_HISTORY_TABLE_SIZE = 64 }; -typedef struct sc_memo_set_s { +struct sc_memo_set_s { sc_uint magic; sc_memo_t memo[MEMO_UNDO_TABLE_SIZE]; sc_int memo_cursor; @@ -73,7 +75,8 @@ typedef struct sc_memo_set_s { sc_int history_count; sc_int current_history; sc_bool is_at_start; -} sc_memo_set_t; +}; +typedef sc_memo_set_s sc_memo_set_t; /* @@ -81,8 +84,7 @@ typedef struct sc_memo_set_s { * * Return TRUE if pointer is a valid memo set, FALSE otherwise. */ -static sc_bool -memo_is_valid(sc_memo_setref_t memento) { +static sc_bool memo_is_valid(sc_memo_setref_t memento) { return memento && memento->magic == MEMENTO_MAGIC; } @@ -92,8 +94,7 @@ memo_is_valid(sc_memo_setref_t memento) { * * Round up an allocation in bytes to the next allocation block. */ -static sc_int -memo_round_up(sc_int allocation) { +static sc_int memo_round_up(sc_int allocation) { sc_int extended; extended = allocation + MEMO_ALLOCATION_BLOCK - 1; @@ -106,8 +107,7 @@ memo_round_up(sc_int allocation) { * * Create and return a new set of memos. */ -sc_memo_setref_t -memo_create(void) { +sc_memo_setref_t memo_create(void) { sc_memo_setref_t memento; /* Create and initialize a clean set of memos. */ @@ -131,8 +131,7 @@ memo_create(void) { * * Destroy a memo set, and free its heap memory. */ -void -memo_destroy(sc_memo_setref_t memento) { +void memo_destroy(sc_memo_setref_t memento) { sc_int index_; assert(memo_is_valid(memento)); @@ -162,8 +161,7 @@ memo_destroy(sc_memo_setref_t memento) { * Callback function for game serialization. Appends the data passed in to * that already stored in the memo. */ -static void -memo_save_game_callback(void *opaque, const sc_byte *buffer, sc_int length) { +static void memo_save_game_callback(void *opaque, const sc_byte *buffer, sc_int length) { sc_memoref_t memo = (sc_memoref_t)opaque; sc_int required; assert(opaque && buffer && length > 0); @@ -191,8 +189,7 @@ memo_save_game_callback(void *opaque, const sc_byte *buffer, sc_int length) { * * Store a game in the next memo slot. */ -void -memo_save_game(sc_memo_setref_t memento, sc_gameref_t game) { +void memo_save_game(sc_memo_setref_t memento, sc_gameref_t game) { sc_memoref_t memo; assert(memo_is_valid(memento)); @@ -224,8 +221,7 @@ memo_save_game(sc_memo_setref_t memento, sc_gameref_t game) { * Callback function for game deserialization. Returns data from the memo * until it's drained. */ -static sc_int -memo_load_game_callback(void *opaque, sc_byte *buffer, sc_int length) { +static sc_int memo_load_game_callback(void *opaque, sc_byte *buffer, sc_int length) { sc_memoref_t memo = (sc_memoref_t)opaque; sc_int bytes; assert(opaque && buffer && length > 0); @@ -249,8 +245,7 @@ memo_load_game_callback(void *opaque, sc_byte *buffer, sc_int length) { * * Restore a game from the last memo slot used, if possible. */ -sc_bool -memo_load_game(sc_memo_setref_t memento, sc_gameref_t game) { +sc_bool memo_load_game(sc_memo_setref_t memento, sc_gameref_t game) { sc_int cursor; sc_memoref_t memo; assert(memo_is_valid(memento)); @@ -298,8 +293,7 @@ memo_load_game(sc_memo_setref_t memento, sc_gameref_t game) { * Returns TRUE if a memo restore is likely to succeed if called, FALSE * otherwise. */ -sc_bool -memo_is_load_available(sc_memo_setref_t memento) { +sc_bool memo_is_load_available(sc_memo_setref_t memento) { sc_int cursor; sc_memoref_t memo; assert(memo_is_valid(memento)); @@ -320,8 +314,7 @@ memo_is_load_available(sc_memo_setref_t memento) { * * Forget the memos of saved games. */ -void -memo_clear_games(sc_memo_setref_t memento) { +void memo_clear_games(sc_memo_setref_t memento) { sc_int index_; assert(memo_is_valid(memento)); @@ -345,9 +338,7 @@ memo_clear_games(sc_memo_setref_t memento) { * Store a player command in the command history, evicting any least recently * used item if necessary. */ -void -memo_save_command(sc_memo_setref_t memento, - const sc_char *command, sc_int timestamp, sc_int turns) { +void memo_save_command(sc_memo_setref_t memento, const sc_char *command, sc_int timestamp, sc_int turns) { sc_historyref_t history; sc_int length; assert(memo_is_valid(memento)); @@ -390,8 +381,7 @@ memo_save_command(sc_memo_setref_t memento, * to "invent" a history item at the end of the list before listing, then * remove it again as the main runner loop will add the real thing. */ -void -memo_unsave_command(sc_memo_setref_t memento) { +void memo_unsave_command(sc_memo_setref_t memento) { assert(memo_is_valid(memento)); /* Do nothing if for some reason there's no history to unsave. */ @@ -415,8 +405,7 @@ memo_unsave_command(sc_memo_setref_t memento) { * * Return a count of available saved commands. */ -sc_int -memo_get_command_count(sc_memo_setref_t memento) { +sc_int memo_get_command_count(sc_memo_setref_t memento) { assert(memo_is_valid(memento)); /* Return the lesser of the history count and the history table size. */ @@ -432,8 +421,7 @@ memo_get_command_count(sc_memo_setref_t memento) { * * Iterator rewind function, reset current location to the first command. */ -void -memo_first_command(sc_memo_setref_t memento) { +void memo_first_command(sc_memo_setref_t memento) { sc_int cursor; sc_historyref_t history; assert(memo_is_valid(memento)); @@ -458,10 +446,8 @@ memo_first_command(sc_memo_setref_t memento) { * Iterator function, return the next saved command and its sequence id * starting at 1, and the timestamp and turns when the command was saved. */ -void -memo_next_command(sc_memo_setref_t memento, - const sc_char **command, sc_int *sequence, - sc_int *timestamp, sc_int *turns) { +void memo_next_command(sc_memo_setref_t memento, const sc_char **command, + sc_int *sequence, sc_int *timestamp, sc_int *turns) { assert(memo_is_valid(memento)); /* If valid, return the current command and advance. */ @@ -494,8 +480,7 @@ memo_next_command(sc_memo_setref_t memento, * * Iterator end function, returns TRUE if more commands are readable. */ -sc_bool -memo_more_commands(sc_memo_setref_t memento) { +sc_bool memo_more_commands(sc_memo_setref_t memento) { sc_int cursor; sc_historyref_t history; assert(memo_is_valid(memento)); @@ -522,8 +507,7 @@ memo_more_commands(sc_memo_setref_t memento) { * Find and return the command string for the given sequence number (-ve * indicates an offset from the last defined), or NULL if not found. */ -const sc_char * -memo_find_command(sc_memo_setref_t memento, sc_int sequence) { +const sc_char *memo_find_command(sc_memo_setref_t memento, sc_int sequence) { sc_int target, index_; sc_historyref_t matched; assert(memo_is_valid(memento)); @@ -561,8 +545,7 @@ memo_find_command(sc_memo_setref_t memento, sc_int sequence) { * * Forget all saved commands. */ -void -memo_clear_commands(sc_memo_setref_t memento) { +void memo_clear_commands(sc_memo_setref_t memento) { sc_int index_; assert(memo_is_valid(memento)); diff --git a/engines/glk/adrift/scnpcs.cpp b/engines/glk/adrift/scnpcs.cpp index b9b60d5259..d3567f6c8f 100644 --- a/engines/glk/adrift/scnpcs.cpp +++ b/engines/glk/adrift/scnpcs.cpp @@ -36,8 +36,7 @@ static sc_bool npc_trace = FALSE; * * Return TRUE if a given NPC is currently in a given room. */ -sc_bool -npc_in_room(sc_gameref_t game, sc_int npc, sc_int room) { +sc_bool npc_in_room(sc_gameref_t game, sc_int npc, sc_int room) { if (npc_trace) { sc_trace("NPC: checking NPC %ld in room %ld (NPC is in %ld)\n", npc, room, gs_npc_location(game, npc)); @@ -52,8 +51,7 @@ npc_in_room(sc_gameref_t game, sc_int npc, sc_int room) { * * Return the count of characters in the room, including the player. */ -sc_int -npc_count_in_room(sc_gameref_t game, sc_int room) { +sc_int npc_count_in_room(sc_gameref_t game, sc_int room) { sc_int count, npc; /* Start with the player. */ @@ -73,8 +71,7 @@ npc_count_in_room(sc_gameref_t game, sc_int room) { * * Start the given walk for the given NPC. */ -void -npc_start_npc_walk(sc_gameref_t game, sc_int npc, sc_int walk) { +void npc_start_npc_walk(sc_gameref_t game, sc_int npc, sc_int walk) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[6]; sc_int movetime; @@ -99,8 +96,7 @@ npc_start_npc_walk(sc_gameref_t game, sc_int npc, sc_int walk) { * * Set initial values for NPC states, and update on turns. */ -void -npc_turn_update(sc_gameref_t game) { +void npc_turn_update(sc_gameref_t game) { sc_int index_; /* Set current values for NPC seen states. */ @@ -111,8 +107,7 @@ npc_turn_update(sc_gameref_t game) { } } -void -npc_setup_initial(sc_gameref_t game) { +void npc_setup_initial(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int index_; @@ -149,8 +144,7 @@ npc_setup_initial(sc_gameref_t game) { * * Return TRUE if a given room is in a given group. */ -static sc_bool -npc_room_in_roomgroup(sc_gameref_t game, sc_int room, sc_int group) { +static sc_bool npc_room_in_roomgroup(sc_gameref_t game, sc_int room, sc_int group) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; sc_int member; @@ -183,9 +177,7 @@ static const sc_char *const DIRNAMES_8[] = { * * Return a random member of group adjacent to given room. */ -static sc_int -npc_random_adjacent_roomgroup_member(sc_gameref_t game, - sc_int room, sc_int group) { +static sc_int npc_random_adjacent_roomgroup_member(sc_gameref_t game, sc_int room, sc_int group) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_bool eightpointcompass; @@ -232,9 +224,7 @@ npc_random_adjacent_roomgroup_member(sc_gameref_t game, * * Helper for npc_tick_npc(). */ -static void -npc_announce(sc_gameref_t game, sc_int npc, - sc_int room, sc_bool is_exit, sc_int npc_room) { +static void npc_announce(sc_gameref_t game, sc_int npc, sc_int room, sc_bool is_exit, sc_int npc_room) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5], vt_rvalue; @@ -312,8 +302,7 @@ npc_announce(sc_gameref_t game, sc_int npc, * * Helper for npc_tick_npc(). */ -static void -npc_tick_npc_walk(sc_gameref_t game, sc_int npc, sc_int walk) { +static void npc_tick_npc_walk(sc_gameref_t game, sc_int npc, sc_int walk) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[6]; sc_int roomgroups, movetimes, walkstep, start, dest, destnum; @@ -428,8 +417,7 @@ npc_tick_npc_walk(sc_gameref_t game, sc_int npc, sc_int walk) { * * Move an NPC one step along current walk. */ -static void -npc_tick_npc(sc_gameref_t game, sc_int npc) { +static void npc_tick_npc(sc_gameref_t game, sc_int npc) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[6]; sc_int walk; @@ -522,8 +510,7 @@ npc_tick_npc(sc_gameref_t game, sc_int npc) { * * Move each NPC one step along current walk. */ -void -npc_tick_npcs(sc_gameref_t game) { +void npc_tick_npcs(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_gameref_t undo = game->undo; sc_int npc; @@ -587,8 +574,7 @@ npc_tick_npcs(sc_gameref_t game) { * * Set NPC tracing on/off. */ -void -npc_debug_trace(sc_bool flag) { +void npc_debug_trace(sc_bool flag) { npc_trace = flag; } diff --git a/engines/glk/adrift/scobjcts.cpp b/engines/glk/adrift/scobjcts.cpp index 28a89abed3..50abfa1326 100644 --- a/engines/glk/adrift/scobjcts.cpp +++ b/engines/glk/adrift/scobjcts.cpp @@ -41,8 +41,7 @@ static sc_bool obj_trace = FALSE; * * Convenience functions to return TRUE for given object attributes. */ -sc_bool -obj_is_static(sc_gameref_t game, sc_int object) { +sc_bool obj_is_static(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_bool bstatic; @@ -54,8 +53,7 @@ obj_is_static(sc_gameref_t game, sc_int object) { return bstatic; } -sc_bool -obj_is_container(sc_gameref_t game, sc_int object) { +sc_bool obj_is_container(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_bool is_container; @@ -67,8 +65,7 @@ obj_is_container(sc_gameref_t game, sc_int object) { return is_container; } -sc_bool -obj_is_surface(sc_gameref_t game, sc_int object) { +sc_bool obj_is_surface(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_bool is_surface; @@ -86,8 +83,7 @@ obj_is_surface(sc_gameref_t game, sc_int object) { * * Return the index of the n'th container object found. */ -sc_int -obj_container_object(sc_gameref_t game, sc_int n) { +sc_int obj_container_object(sc_gameref_t game, sc_int n) { sc_int object, count; /* Progress through objects until n containers found. */ @@ -105,8 +101,7 @@ obj_container_object(sc_gameref_t game, sc_int n) { * * Return index such that obj_container_object(index) == objnum. */ -sc_int -obj_container_index(sc_gameref_t game, sc_int objnum) { +sc_int obj_container_index(sc_gameref_t game, sc_int objnum) { sc_int object, count; /* Progress through objects up to objnum. */ @@ -124,8 +119,7 @@ obj_container_index(sc_gameref_t game, sc_int objnum) { * * Return the index of the n'th surface object found. */ -sc_int -obj_surface_object(sc_gameref_t game, sc_int n) { +sc_int obj_surface_object(sc_gameref_t game, sc_int n) { sc_int object, count; /* Progress through objects until n surfaces found. */ @@ -143,8 +137,7 @@ obj_surface_object(sc_gameref_t game, sc_int n) { * * Return index such that obj_surface_object(index) == objnum. */ -sc_int -obj_surface_index(sc_gameref_t game, sc_int objnum) { +sc_int obj_surface_index(sc_gameref_t game, sc_int objnum) { sc_int object, count; /* Progress through objects up to objnum. */ @@ -162,8 +155,7 @@ obj_surface_index(sc_gameref_t game, sc_int objnum) { * * Return the index of the n'th openable or statussed object found. */ -sc_int -obj_stateful_object(sc_gameref_t game, sc_int n) { +sc_int obj_stateful_object(sc_gameref_t game, sc_int n) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int object, count; @@ -191,8 +183,7 @@ obj_stateful_object(sc_gameref_t game, sc_int n) { * * Return index such that obj_stateful_object(index) == objnum. */ -sc_int -obj_stateful_index(sc_gameref_t game, sc_int objnum) { +sc_int obj_stateful_index(sc_gameref_t game, sc_int objnum) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int object, count; @@ -222,8 +213,7 @@ obj_stateful_index(sc_gameref_t game, sc_int objnum) { * string is malloc'ed, and needs to be freed by the caller. Returns NULL * if no valid state string found. */ -sc_char * -obj_state_name(sc_gameref_t game, sc_int objnum) { +sc_char *obj_state_name(sc_gameref_t game, sc_int objnum) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; const sc_char *states; @@ -266,8 +256,7 @@ obj_state_name(sc_gameref_t game, sc_int objnum) { * * Return the index of the n'th non-static object found. */ -sc_int -obj_dynamic_object(sc_gameref_t game, sc_int n) { +sc_int obj_dynamic_object(sc_gameref_t game, sc_int n) { sc_int object, count; /* Progress through objects until n matches found. */ @@ -285,8 +274,7 @@ obj_dynamic_object(sc_gameref_t game, sc_int n) { * * Return the index of the n'th wearable object found. */ -sc_int -obj_wearable_object(sc_gameref_t game, sc_int n) { +sc_int obj_wearable_object(sc_gameref_t game, sc_int n) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int object, count; @@ -329,8 +317,7 @@ enum { * TODO It's possible to have static objects in the player inventory, moved * by events -- how should these be handled, as they have no SizeWeight? */ -sc_int -obj_get_size(sc_gameref_t game, sc_int object) { +sc_int obj_get_size(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int size, count; @@ -362,8 +349,7 @@ obj_get_size(sc_gameref_t game, sc_int object) { return size; } -sc_int -obj_get_weight(sc_gameref_t game, sc_int object) { +sc_int obj_get_weight(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int weight, count; @@ -413,8 +399,7 @@ obj_get_weight(sc_gameref_t game, sc_int object) { * Return the limits set on the sizes and weights a player can handle. Not * really object-related except that they deal with sizing multiples. */ -static sc_int -obj_convert_player_limit(sc_int value) { +static sc_int obj_convert_player_limit(sc_int value) { sc_int retval, index_; /* 'Tens' of value multiplied by 3 to the power 'units' of value. */ @@ -425,8 +410,7 @@ obj_convert_player_limit(sc_int value) { return retval; } -sc_int -obj_get_player_size_limit(sc_gameref_t game) { +sc_int obj_get_player_size_limit(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; sc_int max_size; @@ -438,8 +422,7 @@ obj_get_player_size_limit(sc_gameref_t game) { return obj_convert_player_limit(max_size); } -sc_int -obj_get_player_weight_limit(sc_gameref_t game) { +sc_int obj_get_player_weight_limit(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; sc_int max_weight; @@ -459,8 +442,7 @@ obj_get_player_weight_limit(sc_gameref_t game) { * Return the maximum size of an object that can be placed in a container, * and the number that will fit. */ -sc_int -obj_get_container_maxsize(sc_gameref_t game, sc_int object) { +sc_int obj_get_container_maxsize(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int maxsize, count; @@ -482,8 +464,7 @@ obj_get_container_maxsize(sc_gameref_t game, sc_int object) { return maxsize; } -sc_int -obj_get_container_capacity(sc_gameref_t game, sc_int object) { +sc_int obj_get_container_capacity(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int capacity; @@ -513,8 +494,7 @@ enum { * * Return the index of the n'th standable object found. */ -sc_int -obj_standable_object(sc_gameref_t game, sc_int n) { +sc_int obj_standable_object(sc_gameref_t game, sc_int n) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int object, count; @@ -540,8 +520,7 @@ obj_standable_object(sc_gameref_t game, sc_int n) { * * Return the index of the n'th lieable object found. */ -sc_int -obj_lieable_object(sc_gameref_t game, sc_int n) { +sc_int obj_lieable_object(sc_gameref_t game, sc_int n) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int object, count; @@ -571,8 +550,7 @@ obj_lieable_object(sc_gameref_t game, sc_int n) { * or ""; plural if prefix is "the" or "some" and short name ends with 's' * that is not preceded by 'u'. */ -sc_bool -obj_appears_plural(sc_gameref_t game, sc_int object) { +sc_bool obj_appears_plural(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; const sc_char *prefix, *name; @@ -610,8 +588,7 @@ obj_appears_plural(sc_gameref_t game, sc_int object) { * * Return TRUE if a given object is currently on the floor of a given room. */ -static sc_bool -obj_directly_in_room_internal(sc_gameref_t game, sc_int object, sc_int room) { +static sc_bool obj_directly_in_room_internal(sc_gameref_t game, sc_int object, sc_int room) { const sc_prop_setref_t bundle = gs_get_bundle(game); /* See if the object is static or dynamic. */ @@ -658,8 +635,7 @@ obj_directly_in_room_internal(sc_gameref_t game, sc_int object, sc_int room) { return gs_object_position(game, object) == room + 1; } -sc_bool -obj_directly_in_room(sc_gameref_t game, sc_int object, sc_int room) { +sc_bool obj_directly_in_room(sc_gameref_t game, sc_int object, sc_int room) { sc_bool result; /* Check, trace result, and return. */ @@ -682,8 +658,7 @@ obj_directly_in_room(sc_gameref_t game, sc_int object, sc_int room) { * directly, on an object indirectly, in an open object indirectly, or * carried by an NPC in the room. */ -static sc_bool -obj_indirectly_in_room_internal(sc_gameref_t game, sc_int object, sc_int room) { +static sc_bool obj_indirectly_in_room_internal(sc_gameref_t game, sc_int object, sc_int room) { const sc_prop_setref_t bundle = gs_get_bundle(game); /* See if the object is static or dynamic. */ @@ -782,9 +757,7 @@ obj_indirectly_in_room_internal(sc_gameref_t game, sc_int object, sc_int room) { } } -sc_bool -obj_indirectly_in_room(sc_gameref_t game, - sc_int object, sc_int room) { +sc_bool obj_indirectly_in_room(sc_gameref_t game, sc_int object, sc_int room) { sc_bool result; /* Check, trace result, and return. */ @@ -806,9 +779,7 @@ obj_indirectly_in_room(sc_gameref_t game, * Return TRUE if a given object is currently held by the player, either * directly, on an object indirectly, or in an open object indirectly. */ -static sc_bool -obj_indirectly_held_by_player_internal(sc_gameref_t game, - sc_int object) { +static sc_bool obj_indirectly_held_by_player_internal(sc_gameref_t game, sc_int object) { /* See if the object is static or dynamic. */ if (obj_is_static(game, object)) { /* Static object moved to player or room by event? */ @@ -863,8 +834,7 @@ obj_indirectly_held_by_player_internal(sc_gameref_t game, } } -sc_bool -obj_indirectly_held_by_player(sc_gameref_t game, sc_int object) { +sc_bool obj_indirectly_held_by_player(sc_gameref_t game, sc_int object) { sc_bool result; /* Check, trace result, and return. */ @@ -884,8 +854,7 @@ obj_indirectly_held_by_player(sc_gameref_t game, sc_int object) { * * Return TRUE if this object should be listed as room content. */ -sc_bool -obj_shows_initial_description(sc_gameref_t game, sc_int object) { +sc_bool obj_shows_initial_description(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int onlywhennotmoved; @@ -927,8 +896,7 @@ obj_shows_initial_description(sc_gameref_t game, sc_int object) { * * Set initial values for object states, and update after a turn. */ -void -obj_turn_update(sc_gameref_t game) { +void obj_turn_update(sc_gameref_t game) { sc_int index_; /* Update object seen flag to current state. */ @@ -939,8 +907,7 @@ obj_turn_update(sc_gameref_t game) { } } -void -obj_setup_initial(sc_gameref_t game) { +void obj_setup_initial(sc_gameref_t game) { /* Set initial seen states for objects. */ obj_turn_update(game); } @@ -951,8 +918,7 @@ obj_setup_initial(sc_gameref_t game) { * * Set object tracing on/off. */ -void -obj_debug_trace(sc_bool flag) { +void obj_debug_trace(sc_bool flag) { obj_trace = flag; } diff --git a/engines/glk/adrift/scparser.cpp b/engines/glk/adrift/scparser.cpp index 9372b5e39e..7b496939ef 100644 --- a/engines/glk/adrift/scparser.cpp +++ b/engines/glk/adrift/scparser.cpp @@ -48,24 +48,24 @@ static const sc_char *const WHITESPACE = "\t\n\v\f\r "; static sc_bool uip_trace = FALSE; /* Enumeration of tokens. TOK_NONE represents a non-occurring token. */ -typedef enum { +enum sc_uip_tok_t { TOK_NONE = 0, TOK_CHOICE, TOK_CHOICE_END, TOK_OPTIONAL, TOK_OPTIONAL_END, TOK_ALTERNATES_SEPARATOR, TOK_WILDCARD, TOK_WHITESPACE, TOK_WORD, TOK_VARIABLE, TOK_CHARACTER_REFERENCE, TOK_OBJECT_REFERENCE, TOK_NUMBER_REFERENCE, TOK_TEXT_REFERENCE, TOK_EOS -} sc_uip_tok_t; +}; /* * Small table tying token strings to tokens. Anything not whitespace and * not caught by the table is a plain TOK_WORD. */ -typedef struct { +struct sc_uip_token_entry_t { const sc_char *const name; const sc_int length; const sc_uip_tok_t token; -} sc_uip_token_entry_t; +}; static const sc_uip_token_entry_t UIP_TOKENS[] = { {"[", 1, TOK_CHOICE}, {"]", 1, TOK_CHOICE_END}, @@ -98,8 +98,7 @@ static sc_char *uip_temporary = NULL; * * Start and wrap up pattern string tokenization. */ -static void -uip_tokenize_start(const sc_char *pattern) { +static void uip_tokenize_start(const sc_char *pattern) { static sc_bool initialized = FALSE; sc_int required; @@ -129,8 +128,7 @@ uip_tokenize_start(const sc_char *pattern) { ? (sc_char *)sc_malloc(required) : uip_static_temporary; } -static void -uip_tokenize_end(void) { +static void uip_tokenize_end(void) { /* Deallocate temporary if required, and clear pattern and index. */ if (uip_temporary != uip_static_temporary) sc_free(uip_temporary); @@ -145,8 +143,7 @@ uip_tokenize_end(void) { * * Return the next token from the current pattern. */ -static sc_uip_tok_t -uip_next_token(void) { +static sc_uip_tok_t uip_next_token(void) { const sc_uip_token_entry_t *entry; sc_char close; assert(uip_pattern); @@ -211,8 +208,7 @@ uip_next_token(void) { * Return the token value of the current token. It is an error to call * here if the current token is not a TOK_WORD or TOK_VARIABLE. */ -static const sc_char * -uip_current_token_value(void) { +static const sc_char *uip_current_token_value(void) { /* If the token value is NULL, the current token isn't a word. */ if (!uip_token_value) { sc_fatal("uip_current_token_value:" @@ -230,20 +226,21 @@ uip_current_token_value(void) { * NODE_UNUSED must be zero to ensure that the statically allocated array that * forms the node pool appears initially as containing only unused nodes. */ -typedef enum { +enum sc_pttype_t { NODE_UNUSED = 0, NODE_CHOICE, NODE_OPTIONAL, NODE_WILDCARD, NODE_WHITESPACE, NODE_CHARACTER_REFERENCE, NODE_OBJECT_REFERENCE, NODE_TEXT_REFERENCE, NODE_NUMBER_REFERENCE, NODE_WORD, NODE_VARIABLE, NODE_LIST, NODE_EOS -} sc_pttype_t; -typedef struct sc_ptnode_s { +}; +struct sc_ptnode_s { struct sc_ptnode_s *left_child; struct sc_ptnode_s *right_sibling; sc_pttype_t type; sc_char *word; sc_bool is_allocated; -} sc_ptnode_t; +}; +typedef sc_ptnode_s sc_ptnode_t; typedef sc_ptnode_t *sc_ptnoderef_t; /* Predictive parser lookahead token. */ @@ -273,10 +270,10 @@ static sc_int uip_node_pool_available = UIP_NODE_POOL_SIZE; * first, then by straight malloc() should the pool empty. */ enum { UIP_WORD_POOL_SIZE = 64, UIP_SHORT_WORD_SIZE = 16 }; -typedef struct { +struct sc_ptshortword_t { sc_bool is_in_use; sc_char word[UIP_SHORT_WORD_SIZE]; -} sc_ptshortword_t; +}; typedef sc_ptshortword_t *sc_ptshortwordref_t; static sc_ptshortword_t uip_word_pool[UIP_WORD_POOL_SIZE]; static sc_int uip_word_pool_cursor = 0; @@ -287,8 +284,7 @@ static sc_int uip_word_pool_available = UIP_WORD_POOL_SIZE; * * Match a token to the lookahead, then advance lookahead. */ -static void -uip_parse_match(sc_uip_tok_t token) { +static void uip_parse_match(sc_uip_tok_t token) { if (uip_parse_lookahead == token) uip_parse_lookahead = uip_next_token(); else { @@ -307,8 +303,7 @@ uip_parse_match(sc_uip_tok_t token) { * allocate initially from static storage, for performance. If this is * exhausted, backs off to standard allocation. */ -static sc_char * -uip_new_word(const sc_char *word) { +static sc_char *uip_new_word(const sc_char *word) { sc_int required; /* @@ -357,8 +352,7 @@ uip_new_word(const sc_char *word) { * If the word was allocated, free its memory; if not, find its short word * pool entry and return it to the pool. */ -static void -uip_free_word(sc_char *word) { +static void uip_free_word(sc_char *word) { const sc_char *first_in_pool, *last_in_pool; /* Obtain the range of valid addresses for words from the word pool. */ @@ -392,8 +386,7 @@ uip_free_word(sc_char *word) { * to allocate initially from static storage, for performance. If this is * exhausted, backs off to standard allocation. */ -static sc_ptnoderef_t -uip_new_node(sc_pttype_t type) { +static sc_ptnoderef_t uip_new_node(sc_pttype_t type) { sc_ptnoderef_t node; /* @@ -441,8 +434,7 @@ uip_new_node(sc_pttype_t type) { * Destroy a node, and any allocated word memory. If the node was allocated, * free its memory; if not, return it to the pool. */ -static void -uip_destroy_node(sc_ptnoderef_t node) { +static void uip_destroy_node(sc_ptnoderef_t node) { /* Free any word contained at this node. */ if (node->word) uip_free_word(node->word); @@ -469,8 +461,7 @@ uip_destroy_node(sc_ptnoderef_t node) { * Parse a set of .../.../... alternatives for choices and optionals. The * first function is a helper, returning a newly constructed parsed list. */ -static sc_ptnoderef_t -uip_parse_new_list(void) { +static sc_ptnoderef_t uip_parse_new_list(void) { sc_ptnoderef_t list; /* Create a new list node, parse into it, and return it. */ @@ -479,8 +470,7 @@ uip_parse_new_list(void) { return list; } -static void -uip_parse_alternatives(sc_ptnoderef_t node) { +static void uip_parse_alternatives(sc_ptnoderef_t node) { sc_ptnoderef_t child; /* Parse initial alternative, then add other listed alternatives. */ @@ -499,8 +489,7 @@ uip_parse_alternatives(sc_ptnoderef_t node) { * * Parse a single pattern element. */ -static sc_ptnoderef_t -uip_parse_element(void) { +static sc_ptnoderef_t uip_parse_element(void) { sc_ptnoderef_t node = NULL; sc_uip_tok_t token; @@ -604,8 +593,7 @@ uip_parse_element(void) { * * Parse a list of pattern elements. */ -static void -uip_parse_list(sc_ptnoderef_t list) { +static void uip_parse_list(sc_ptnoderef_t list) { sc_ptnoderef_t child, node; /* Add elements until a list terminator token is encountered. */ @@ -663,8 +651,7 @@ uip_parse_list(sc_ptnoderef_t list) { * * Free and destroy a parsed pattern tree. */ -static void -uip_destroy_tree(sc_ptnoderef_t node) { +static void uip_destroy_tree(sc_ptnoderef_t node) { if (node) { /* Recursively destroy siblings, then left child. */ uip_destroy_tree(node->right_sibling); @@ -682,8 +669,7 @@ uip_destroy_tree(sc_ptnoderef_t node) { * * Print out a pattern match tree. */ -static void -uip_debug_dump_node(sc_ptnoderef_t node, sc_int depth) { +static void uip_debug_dump_node(sc_ptnoderef_t node, sc_int depth) { /* End recursion on null node. */ if (node) { sc_int index_; @@ -746,8 +732,7 @@ uip_debug_dump_node(sc_ptnoderef_t node, sc_int depth) { } } -static void -uip_debug_dump(void) { +static void uip_debug_dump(void) { sc_trace("UIParser: debug dump follows...\n"); if (uip_parse_tree) { sc_trace("uip_parse_tree = {\n"); @@ -769,8 +754,7 @@ static sc_gameref_t uip_game = NULL; * * Set up a string for matching to a pattern tree, and wrap up matching. */ -static void -uip_match_start(const sc_char *string, sc_gameref_t game) { +static void uip_match_start(const sc_char *string, sc_gameref_t game) { /* Save string, and restart index. */ uip_string = string; uip_posn = 0; @@ -779,8 +763,7 @@ uip_match_start(const sc_char *string, sc_gameref_t game) { uip_game = game; } -static void -uip_match_end(void) { +static void uip_match_end(void) { /* Clear match target string, and variable set. */ uip_string = NULL; uip_posn = 0; @@ -794,8 +777,7 @@ uip_match_end(void) { * Safety wrapper to ensure module code sees a valid game when it requires * one. */ -static sc_gameref_t -uip_get_game(void) { +static sc_gameref_t uip_get_game(void) { assert(gs_is_game_valid(uip_game)); return uip_game; } @@ -819,14 +801,12 @@ static sc_bool uip_match_node(sc_ptnoderef_t node); * advance position if necessary, on match, FALSE on no match, with position * unchanged. */ -static sc_bool -uip_match_eos(void) { +static sc_bool uip_match_eos(void) { /* Check that we hit the string's end. */ return uip_string[uip_posn] == NUL; } -static sc_bool -uip_match_word(sc_ptnoderef_t node) { +static sc_bool uip_match_word(sc_ptnoderef_t node) { sc_int length; const sc_char *word; @@ -846,8 +826,7 @@ uip_match_word(sc_ptnoderef_t node) { return FALSE; } -static sc_bool -uip_match_variable(sc_ptnoderef_t node) { +static sc_bool uip_match_variable(sc_ptnoderef_t node) { const sc_gameref_t game = uip_get_game(); const sc_var_setref_t vars = gs_get_vars(game); sc_int type; @@ -898,8 +877,7 @@ uip_match_variable(sc_ptnoderef_t node) { return FALSE; } -static sc_bool -uip_match_whitespace(void) { +static sc_bool uip_match_whitespace(void) { /* If next character is space, read whitespace and return. */ if (sc_isspace(uip_string[uip_posn])) { /* Space match, advance position and return. */ @@ -934,8 +912,7 @@ uip_match_whitespace(void) { return FALSE; } -static sc_bool -uip_match_list(sc_ptnoderef_t node) { +static sc_bool uip_match_list(sc_ptnoderef_t node) { sc_ptnoderef_t child; /* @@ -958,8 +935,7 @@ uip_match_list(sc_ptnoderef_t node) { return TRUE; } -static sc_bool -uip_match_alternatives(sc_ptnoderef_t node) { +static sc_bool uip_match_alternatives(sc_ptnoderef_t node) { sc_ptnoderef_t child; sc_int start_posn, extent; sc_bool matched; @@ -990,8 +966,7 @@ uip_match_alternatives(sc_ptnoderef_t node) { return matched; } -static sc_bool -uip_match_choice(sc_ptnoderef_t node) { +static sc_bool uip_match_choice(sc_ptnoderef_t node) { /* * Return the result of matching alternatives. The choice will therefore * fail if none of the alternatives match. @@ -999,8 +974,7 @@ uip_match_choice(sc_ptnoderef_t node) { return uip_match_alternatives(node); } -static sc_bool -uip_match_optional(sc_ptnoderef_t node) { +static sc_bool uip_match_optional(sc_ptnoderef_t node) { sc_int start_posn; sc_ptnoderef_t list; sc_bool matched; @@ -1036,8 +1010,7 @@ uip_match_optional(sc_ptnoderef_t node) { return TRUE; } -static sc_bool -uip_match_wildcard(sc_ptnoderef_t node) { +static sc_bool uip_match_wildcard(sc_ptnoderef_t node) { sc_int start_posn, limit, index_; sc_bool matched; sc_ptnoderef_t list; @@ -1099,8 +1072,7 @@ uip_match_wildcard(sc_ptnoderef_t node) { * * Attempt to match a number, or a word, from the string. */ -static sc_bool -uip_match_number(void) { +static sc_bool uip_match_number(void) { const sc_gameref_t game = uip_get_game(); const sc_var_setref_t vars = gs_get_vars(game); sc_int number; @@ -1122,8 +1094,7 @@ uip_match_number(void) { return FALSE; } -static sc_bool -uip_match_text(sc_ptnoderef_t node) { +static sc_bool uip_match_text(sc_ptnoderef_t node) { const sc_gameref_t game = uip_get_game(); const sc_var_setref_t vars = gs_get_vars(game); sc_int start_posn, limit, index_; @@ -1195,8 +1166,7 @@ uip_match_text(sc_ptnoderef_t node) { * Skip over any "a"/"an"/"the"/"some" at the head of a string. Helper for * %character% and %object% matchers. Returns the revised string position. */ -static sc_int -uip_skip_article(const sc_char *string, sc_int start) { +static sc_int uip_skip_article(const sc_char *string, sc_int start) { sc_int posn; /* Skip over articles. */ @@ -1225,8 +1195,7 @@ uip_skip_article(const sc_char *string, sc_int start) { * didn't match, otherwise the length of the current position that matched * the words passed in (the new value of uip_posn on match). */ -static sc_int -uip_compare_reference(const sc_char *words) { +static sc_int uip_compare_reference(const sc_char *words) { sc_int wpos, posn; /* Skip articles and lead in space on words and string. */ @@ -1279,8 +1248,7 @@ uip_compare_reference(const sc_char *words) { * match against both the prefixed name, and if that fails, the plain name. * Returns the extent of the match, or zero if no match. */ -static sc_int -uip_compare_prefixed_name(const sc_char *prefix, const sc_char *name) { +static sc_int uip_compare_prefixed_name(const sc_char *prefix, const sc_char *name) { sc_char buffer[UIP_SHORT_WORD_SIZE + UIP_SHORT_WORD_SIZE + 1]; sc_char *string; sc_int required, extent; @@ -1311,8 +1279,7 @@ uip_compare_prefixed_name(const sc_char *prefix, const sc_char *name) { * of a pattern, to resolve the difference between, say, "table leg" and * "table". */ -static sc_bool -uip_match_remainder(sc_ptnoderef_t node, sc_int extent) { +static sc_bool uip_match_remainder(sc_ptnoderef_t node, sc_int extent) { sc_ptnoderef_t list; sc_int start_posn; sc_bool matched; @@ -1347,8 +1314,7 @@ uip_match_remainder(sc_ptnoderef_t node, sc_int extent) { * aliases for possible matches, and sets the game npc_references flag * for any that match. The final one to match is also stored in variables. */ -static sc_bool -uip_match_character(sc_ptnoderef_t node) { +static sc_bool uip_match_character(sc_ptnoderef_t node) { const sc_gameref_t game = uip_get_game(); const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); @@ -1446,8 +1412,7 @@ uip_match_character(sc_ptnoderef_t node) { * aliases for possible matches, and sets the game object_references flag * for any that match. The final one to match is also stored in variables. */ -static sc_bool -uip_match_object(sc_ptnoderef_t node) { +static sc_bool uip_match_object(sc_ptnoderef_t node) { const sc_gameref_t game = uip_get_game(); const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); @@ -1545,8 +1510,7 @@ uip_match_object(sc_ptnoderef_t node) { * Return TRUE, with position advanced, on match, FALSE on fail with the * position unchanged. */ -static sc_bool -uip_match_node(sc_ptnoderef_t node) { +static sc_bool uip_match_node(sc_ptnoderef_t node) { sc_bool match = FALSE; /* Match depending on node type. */ @@ -1605,8 +1569,7 @@ uip_match_node(sc_ptnoderef_t node) { * allocation if it happens (detectable by comparing the return value to the * buffer passed in), or call uip_free_cleansed_string. */ -static sc_char * -uip_cleanse_string(const sc_char *original, sc_char *buffer, sc_int length) { +static sc_char *uip_cleanse_string(const sc_char *original, sc_char *buffer, sc_int length) { sc_int required; sc_char *string; @@ -1623,8 +1586,7 @@ uip_cleanse_string(const sc_char *original, sc_char *buffer, sc_int length) { return string; } -static sc_char * -uip_free_cleansed_string(sc_char *string, const sc_char *buffer) { +static sc_char *uip_free_cleansed_string(sc_char *string, const sc_char *buffer) { /* Free if the string was allocated by the function above. */ if (string != buffer) sc_free(string); @@ -1639,8 +1601,7 @@ uip_free_cleansed_string(sc_char *string, const sc_char *buffer) { * * Set pattern match tracing on/off. */ -void -uip_debug_trace(sc_bool flag) { +void uip_debug_trace(sc_bool flag) { uip_trace = flag; } @@ -1652,8 +1613,7 @@ uip_debug_trace(sc_bool flag) { * For performance, this function uses a local buffer to try to avoid the * need to copy each of the pattern and match strings passed in. */ -sc_bool -uip_match(const sc_char *pattern, const sc_char *string, sc_gameref_t game) { +sc_bool uip_match(const sc_char *pattern, const sc_char *string, sc_gameref_t game) { static sc_char *cleansed; /* For setjmp safety. */ sc_char buffer[UIP_ALLOCATION_AVOIDANCE_SIZE]; sc_bool match; @@ -1713,8 +1673,7 @@ uip_match(const sc_char *pattern, const sc_char *string, sc_gameref_t game) { * resulting string to the caller, or NULL if no pronouns were replaced. The * return string is malloc'ed, so the caller needs to remember to free it. */ -sc_char * -uip_replace_pronouns(sc_gameref_t game, const sc_char *string) { +sc_char *uip_replace_pronouns(sc_gameref_t game, const sc_char *string) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int buffer_allocation; sc_char *buffer; @@ -1856,8 +1815,7 @@ uip_replace_pronouns(sc_gameref_t game, const sc_char *string) { * pronouns for objects or NPC names as found. Later ones will overwrite * earlier ones if there is more than one in the string. */ -void -uip_assign_pronouns(sc_gameref_t game, const sc_char *string) { +void uip_assign_pronouns(sc_gameref_t game, const sc_char *string) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); const sc_char *current; diff --git a/engines/glk/adrift/scprintf.cpp b/engines/glk/adrift/scprintf.cpp index 1ea93e880a..90c41305ce 100644 --- a/engines/glk/adrift/scprintf.cpp +++ b/engines/glk/adrift/scprintf.cpp @@ -65,11 +65,11 @@ static sc_bool pf_trace = FALSE; * come before shorter ones. The
tag is missing because this is * handled separately, as a simple put of '\n'. */ -typedef struct { +struct sc_html_tags_t { const sc_char *const name; const sc_int length; const sc_int tag; -} sc_html_tags_t; +}; static const sc_html_tags_t HTML_TAGS_TABLE[] = { {"bgcolour", 8, SC_TAG_BGCOLOR}, {"bgcolor", 7, SC_TAG_BGCOLOR}, @@ -91,7 +91,7 @@ static const sc_html_tags_t HTML_TAGS_TABLE[] = { * associated size and length, a note of any conversion to apply to the next * buffered character, and a flag to let the filter ignore incoming text. */ -typedef struct sc_filter_s { +struct sc_filter_s { sc_uint magic; sc_int buffer_length; sc_int buffer_allocation; @@ -99,7 +99,8 @@ typedef struct sc_filter_s { sc_bool new_sentence; sc_bool is_muted; sc_bool needs_filtering; -} sc_filter_t; +}; +typedef sc_filter_s sc_filter_t; /* @@ -107,8 +108,7 @@ typedef struct sc_filter_s { * * Return TRUE if pointer is a valid printfilter, FALSE otherwise. */ -static sc_bool -pf_is_valid(sc_filterref_t filter) { +static sc_bool pf_is_valid(sc_filterref_t filter) { return filter && filter->magic == PRINTFILTER_MAGIC; } @@ -118,8 +118,7 @@ pf_is_valid(sc_filterref_t filter) { * * Create and return a new printfilter. */ -sc_filterref_t -pf_create(void) { +sc_filterref_t pf_create(void) { static sc_bool initialized = FALSE; sc_filterref_t filter; @@ -159,8 +158,7 @@ pf_create(void) { * * Destroy a printfilter and free its allocated memory. */ -void -pf_destroy(sc_filterref_t filter) { +void pf_destroy(sc_filterref_t filter) { assert(pf_is_valid(filter)); /* Free buffer space, and poison and free the printfilter. */ @@ -183,8 +181,7 @@ pf_destroy(sc_filterref_t filter) { * characters, and since some games have strings with this character in them, * this is probably all that can be done. */ -static sc_char * -pf_interpolate_vars(const sc_char *string, sc_var_setref_t vars) { +static sc_char *pf_interpolate_vars(const sc_char *string, sc_var_setref_t vars) { sc_char *buffer, *name; const sc_char *cursor; const sc_char *marker; @@ -291,9 +288,7 @@ pf_interpolate_vars(const sc_char *string, sc_var_setref_t vars) { * its equivalent, updating the buffer at the address passed in, including * reallocating if necessary. Return TRUE if the buffer was changed. */ -static sc_bool -pf_replace_alr(const sc_char *string, - sc_char **buffer, sc_int alr, sc_prop_setref_t bundle) { +static sc_bool pf_replace_alr(const sc_char *string, sc_char **buffer, sc_int alr, sc_prop_setref_t bundle) { sc_vartype_t vt_key[3]; const sc_char *marker, *cursor, *original, *replacement; sc_char *buffer_ = *buffer; @@ -358,9 +353,8 @@ pf_replace_alr(const sc_char *string, * ALRs were replaced, returns an allocated string with replacements done, * otherwise returns NULL. */ -static sc_char * -pf_replace_alrs(const sc_char *string, sc_prop_setref_t bundle, - sc_bool alr_applied[], sc_int alr_count) { +static sc_char *pf_replace_alrs(const sc_char *string, sc_prop_setref_t bundle, + sc_bool alr_applied[], sc_int alr_count) { sc_int index_; sc_char *buffer1, *buffer2, **buffer; const sc_char *marker; @@ -437,8 +431,7 @@ pf_replace_alrs(const sc_char *string, sc_prop_setref_t bundle, * Edit the tag-stripped text element passed in, substituting < > * +percent+ with < > %, then send to the OS-specific output functions. */ -static void -pf_output_text(const sc_char *string) { +static void pf_output_text(const sc_char *string) { sc_int index_, b_index; sc_char *buffer; @@ -487,8 +480,7 @@ pf_output_text(const sc_char *string) { * * Output an HTML-like tag element to the OS-specific tag handling function. */ -static void -pf_output_tag(const sc_char *contents) { +static void pf_output_tag(const sc_char *contents) { const sc_html_tags_t *entry; const sc_char *argument; @@ -539,8 +531,7 @@ pf_output_tag(const sc_char *contents) { * Break apart HTML-like string into normal text elements, and HTML-like * tags. */ -static void -pf_output_untagged(const sc_char *string) { +static void pf_output_untagged(const sc_char *string) { sc_char *temporary, *untagged, *contents; const sc_char *cursor; const sc_char *marker; @@ -636,9 +627,7 @@ pf_output_untagged(const sc_char *string) { * until no more changes in the current string * */ -static sc_char * -pf_filter_internal(const sc_char *string, - sc_var_setref_t vars, sc_prop_setref_t bundle) { +static sc_char *pf_filter_internal(const sc_char *string, sc_var_setref_t vars, sc_prop_setref_t bundle) { sc_int alr_count, iteration; sc_char *current; sc_bool *alr_applied; @@ -743,9 +732,7 @@ pf_filter_internal(const sc_char *string, * variables and replacing ALR's. Returns an allocated string that the caller * needs to free. */ -sc_char * -pf_filter(const sc_char *string, - sc_var_setref_t vars, sc_prop_setref_t bundle) { +sc_char *pf_filter(const sc_char *string, sc_var_setref_t vars, sc_prop_setref_t bundle) { sc_char *current; /* Filter this string, including ALRs replacements. */ @@ -769,8 +756,7 @@ pf_filter(const sc_char *string, * Used on informational strings such as the game title and author. Returns * an allocated string that the caller needs to free. */ -sc_char * -pf_filter_for_info(const sc_char *string, sc_var_setref_t vars) { +sc_char *pf_filter_for_info(const sc_char *string, sc_var_setref_t vars) { sc_char *current; /* Filter this string, excluding ALRs replacements. */ @@ -792,9 +778,7 @@ pf_filter_for_info(const sc_char *string, sc_var_setref_t vars) { * Filter buffered data, interpolating variables and replacing ALR's, and * send the resulting string to the output channel. */ -void -pf_flush(sc_filterref_t filter, - sc_var_setref_t vars, sc_prop_setref_t bundle) { +void pf_flush(sc_filterref_t filter, sc_var_setref_t vars, sc_prop_setref_t bundle) { assert(pf_is_valid(filter)); assert(vars && bundle); @@ -834,8 +818,7 @@ pf_flush(sc_filterref_t filter, * * Append a string to the filter buffer. */ -static void -pf_append_string(sc_filterref_t filter, const sc_char *string) { +static void pf_append_string(sc_filterref_t filter, const sc_char *string) { sc_int length, required; /* @@ -876,9 +859,7 @@ pf_append_string(sc_filterref_t filter, const sc_char *string) { * polated in between main flushes; used to update buffered text with variable * values before those values are updated by task actions. */ -void -pf_checkpoint(sc_filterref_t filter, - sc_var_setref_t vars, sc_prop_setref_t bundle) { +void pf_checkpoint(sc_filterref_t filter, sc_var_setref_t vars, sc_prop_setref_t bundle) { assert(pf_is_valid(filter)); assert(vars && bundle); @@ -918,8 +899,7 @@ pf_checkpoint(sc_filterref_t filter, * The second function is an optimization to avoid allocations and copying * in client code. */ -const sc_char * -pf_get_buffer(sc_filterref_t filter) { +const sc_char *pf_get_buffer(sc_filterref_t filter) { assert(pf_is_valid(filter)); /* @@ -933,8 +913,7 @@ pf_get_buffer(sc_filterref_t filter) { return NULL; } -sc_char * -pf_transfer_buffer(sc_filterref_t filter) { +sc_char *pf_transfer_buffer(sc_filterref_t filter) { assert(pf_is_valid(filter)); /* @@ -969,8 +948,7 @@ pf_transfer_buffer(sc_filterref_t filter) { * * Empty any text currently buffered in the filter. */ -void -pf_empty(sc_filterref_t filter) { +void pf_empty(sc_filterref_t filter) { assert(pf_is_valid(filter)); /* Free any allocation, and return the filter to initialization state. */ @@ -991,8 +969,7 @@ pf_empty(sc_filterref_t filter) { * Add a string, and a single character, to the printfilter buffer. If muted, * these functions do nothing. */ -void -pf_buffer_string(sc_filterref_t filter, const sc_char *string) { +void pf_buffer_string(sc_filterref_t filter, const sc_char *string) { assert(pf_is_valid(filter)); assert(string); @@ -1014,8 +991,7 @@ pf_buffer_string(sc_filterref_t filter, const sc_char *string) { } } -void -pf_buffer_character(sc_filterref_t filter, sc_char character) { +void pf_buffer_character(sc_filterref_t filter, sc_char character) { sc_char buffer[2]; assert(pf_is_valid(filter)); @@ -1033,8 +1009,7 @@ pf_buffer_character(sc_filterref_t filter, sc_char character) { * running code, which needs to run task actions and then prepend the task's * completion text. If muted, this function does nothing. */ -void -pf_prepend_string(sc_filterref_t filter, const sc_char *string) { +void pf_prepend_string(sc_filterref_t filter, const sc_char *string) { assert(pf_is_valid(filter)); assert(string); @@ -1080,8 +1055,7 @@ pf_prepend_string(sc_filterref_t filter, const sc_char *string) { * Tells the printfilter to force the next non-space character to uppercase. * Ignored if the printfilter is muted. */ -void -pf_new_sentence(sc_filterref_t filter) { +void pf_new_sentence(sc_filterref_t filter) { assert(pf_is_valid(filter)); if (!filter->is_muted) @@ -1095,15 +1069,13 @@ pf_new_sentence(sc_filterref_t filter) { * * A muted printfilter ignores all new text additions. */ -void -pf_mute(sc_filterref_t filter) { +void pf_mute(sc_filterref_t filter) { assert(pf_is_valid(filter)); filter->is_muted = TRUE; } -void -pf_clear_mute(sc_filterref_t filter) { +void pf_clear_mute(sc_filterref_t filter) { assert(pf_is_valid(filter)); filter->is_muted = FALSE; @@ -1116,8 +1088,7 @@ pf_clear_mute(sc_filterref_t filter) { * Insert an HTML-like tag into the buffered output data. The call is ignored * if the printfilter is muted. */ -void -pf_buffer_tag(sc_filterref_t filter, sc_int tag) { +void pf_buffer_tag(sc_filterref_t filter, sc_int tag) { const sc_html_tags_t *entry; assert(pf_is_valid(filter)); @@ -1145,8 +1116,7 @@ pf_buffer_tag(sc_filterref_t filter, sc_int tag) { * status lines. It ignores all tags except
, which it replaces with * a newline if requested by allow_newlines. */ -static void -pf_strip_tags_common(sc_char *string, sc_bool allow_newlines) { +static void pf_strip_tags_common(sc_char *string, sc_bool allow_newlines) { sc_char *marker, *cursor; /* Run through the string looking for <...> tags. */ @@ -1181,13 +1151,11 @@ pf_strip_tags_common(sc_char *string, sc_bool allow_newlines) { * Public interfaces to pf_strip_tags_common(). The hints version will * allow
tags to map into newlines in hints strings. */ -void -pf_strip_tags(sc_char *string) { +void pf_strip_tags(sc_char *string) { pf_strip_tags_common(string, FALSE); } -void -pf_strip_tags_for_hints(sc_char *string) { +void pf_strip_tags_for_hints(sc_char *string) { pf_strip_tags_common(string, TRUE); } @@ -1202,8 +1170,7 @@ pf_strip_tags_for_hints(sc_char *string) { * the character itself followed by a space. The return string is malloc'ed, * so the caller needs to remember to free it. */ -sc_char * -pf_escape(const sc_char *string) { +sc_char *pf_escape(const sc_char *string) { const sc_char *marker, *cursor; sc_char *buffer; @@ -1277,8 +1244,7 @@ pf_escape(const sc_char *string) { * Matches multiple words from words in string. Returns the extent of * the match if the string matched, 0 otherwise. */ -static sc_int -pf_compare_words(const sc_char *string, const sc_char *words) { +static sc_int pf_compare_words(const sc_char *string, const sc_char *words) { sc_int word_posn, posn; /* None expected, but skip leading space. */ @@ -1332,8 +1298,7 @@ pf_compare_words(const sc_char *string, const sc_char *words) { * string to the caller, or NULL if no synonym changes were needed. The * return string is malloc'ed, so the caller needs to remember to free it. */ -sc_char * -pf_filter_input(const sc_char *string, sc_prop_setref_t bundle) { +sc_char *pf_filter_input(const sc_char *string, sc_prop_setref_t bundle) { sc_vartype_t vt_key[3]; sc_int synonym_count, buffer_allocation; sc_char *buffer; @@ -1448,8 +1413,7 @@ pf_filter_input(const sc_char *string, sc_prop_setref_t bundle) { * * Set filter tracing on/off. */ -void -pf_debug_trace(sc_bool flag) { +void pf_debug_trace(sc_bool flag) { pf_trace = flag; } diff --git a/engines/glk/adrift/scprops.cpp b/engines/glk/adrift/scprops.cpp index aeb0d24db0..0888173ed2 100644 --- a/engines/glk/adrift/scprops.cpp +++ b/engines/glk/adrift/scprops.cpp @@ -80,8 +80,7 @@ typedef sc_prop_set_s sc_prop_set_t; * * Return TRUE if pointer is a valid properties set, FALSE otherwise. */ -static sc_bool -prop_is_valid(sc_prop_setref_t bundle) { +static sc_bool prop_is_valid(sc_prop_setref_t bundle) { return bundle && bundle->magic == PROP_MAGIC; } @@ -91,8 +90,7 @@ prop_is_valid(sc_prop_setref_t bundle) { * * Round up a count of elements to the next block of grow increments. */ -static sc_int -prop_round_up(sc_int elements) { +static sc_int prop_round_up(sc_int elements) { sc_int extended; extended = elements + PROP_GROW_INCREMENT - 1; @@ -111,9 +109,7 @@ prop_round_up(sc_int elements) { * realloc() in blocks of elements, and thus need to realloc() much less * frequently. */ -static void * -prop_ensure_capacity(void *array, - sc_int old_size, sc_int new_size, sc_int element_size) { +static void *prop_ensure_capacity(void *array, sc_int old_size, sc_int new_size, sc_int element_size) { sc_int current, required; /* @@ -145,8 +141,7 @@ prop_ensure_capacity(void *array, * "unblock" the allocations of prop_ensure_capacity(). Once trimmed, * the array cannot ever be grown safely again. */ -static void * -prop_trim_capacity(void *array, sc_int size, sc_int element_size) { +static void *prop_trim_capacity(void *array, sc_int size, sc_int element_size) { if (prop_round_up(size) > size) return sc_realloc(array, size * element_size); else @@ -161,8 +156,7 @@ prop_trim_capacity(void *array, sc_int size, sc_int element_size) { * The function has return type "int" to match the libc implementations of * bsearch() and qsort(). */ -static int -prop_compare(const void *string1, const void *string2) { +static int prop_compare(const void *string1, const void *string2) { return strcmp(*(sc_char * const *) string1, *(sc_char * const *) string2); } @@ -175,8 +169,7 @@ prop_compare(const void *string1, const void *string2) { * either added or already present. Any new dictionary entry will * contain a malloced copy of the string passed in. */ -static const sc_char * -prop_dictionary_lookup(sc_prop_setref_t bundle, const sc_char *string) { +static const sc_char *prop_dictionary_lookup(sc_prop_setref_t bundle, const sc_char *string) { sc_char *dict_string; /* @@ -223,8 +216,7 @@ prop_dictionary_lookup(sc_prop_setref_t bundle, const sc_char *string) { * for even a small game is large, and preallocating pools avoids excessive * malloc's of small individual nodes. */ -static sc_prop_noderef_t -prop_new_node(sc_prop_setref_t bundle) { +static sc_prop_noderef_t prop_new_node(sc_prop_setref_t bundle) { sc_int node_index; sc_prop_noderef_t node; @@ -260,8 +252,7 @@ prop_new_node(sc_prop_setref_t bundle) { * * Find a child node of the given parent whose name matches that passed in. */ -static sc_prop_noderef_t -prop_find_child(sc_prop_noderef_t parent, sc_int type, sc_vartype_t name) { +static sc_prop_noderef_t prop_find_child(sc_prop_noderef_t parent, sc_int type, sc_vartype_t name) { /* See if this node has any children. */ if (parent->child_list) { sc_int index_; @@ -330,9 +321,8 @@ prop_find_child(sc_prop_noderef_t parent, sc_int type, sc_vartype_t name) { * Add a new child node to the given parent. Return its reference. Set * needs to be passed so that string names can be added to the dictionary. */ -static sc_prop_noderef_t -prop_add_child(sc_prop_noderef_t parent, - sc_int type, sc_vartype_t name, sc_prop_setref_t bundle) { +static sc_prop_noderef_t prop_add_child(sc_prop_noderef_t parent, sc_int type, + sc_vartype_t name, sc_prop_setref_t bundle) { sc_prop_noderef_t child; /* Not possible if growable allocations have been trimmed. */ @@ -422,9 +412,8 @@ prop_add_child(sc_prop_noderef_t parent, * "I->sssis", stores an integer, with a key composed of three strings, an * integer, and another string. */ -void -prop_put(sc_prop_setref_t bundle, const sc_char *format, - sc_vartype_t vt_value, const sc_vartype_t vt_key[]) { +void prop_put(sc_prop_setref_t bundle, const sc_char *format, + sc_vartype_t vt_value, const sc_vartype_t vt_key[]) { sc_prop_noderef_t node; sc_int index_; assert(prop_is_valid(bundle)); @@ -523,9 +512,8 @@ prop_put(sc_prop_setref_t bundle, const sc_char *format, * Retrieve a property from a properties set. Format stuff as above, except * with "->" replaced with "<-". Returns FALSE if no such property exists. */ -sc_bool -prop_get(sc_prop_setref_t bundle, const sc_char *format, - sc_vartype_t *vt_rvalue, const sc_vartype_t vt_key[]) { +sc_bool prop_get(sc_prop_setref_t bundle, const sc_char *format, sc_vartype_t *vt_rvalue, + const sc_vartype_t vt_key[]) { sc_prop_noderef_t node; sc_int index_; assert(prop_is_valid(bundle)); @@ -633,8 +621,7 @@ prop_get(sc_prop_setref_t bundle, const sc_char *format, * Trim excess allocation from growable arrays, and fix the properties set * so that no further property insertions are allowed. */ -static void -prop_trim_node(sc_prop_noderef_t node) { +static void prop_trim_node(sc_prop_noderef_t node) { /* End recursion on null or childless node. */ if (node && node->child_list) { sc_int index_; @@ -650,8 +637,7 @@ prop_trim_node(sc_prop_noderef_t node) { } } -void -prop_solidify(sc_prop_setref_t bundle) { +void prop_solidify(sc_prop_setref_t bundle) { assert(prop_is_valid(bundle)); /* @@ -685,9 +671,7 @@ prop_solidify(sc_prop_setref_t bundle) { * Convenience functions to retrieve a property of a known type directly. * It is an error for the property not to exist on retrieval. */ -sc_int -prop_get_integer(sc_prop_setref_t bundle, - const sc_char *format, const sc_vartype_t vt_key[]) { +sc_int prop_get_integer(sc_prop_setref_t bundle, const sc_char *format, const sc_vartype_t vt_key[]) { sc_vartype_t vt_rvalue; assert(format[0] == PROP_INTEGER); @@ -697,9 +681,7 @@ prop_get_integer(sc_prop_setref_t bundle, return vt_rvalue.integer; } -sc_bool -prop_get_boolean(sc_prop_setref_t bundle, - const sc_char *format, const sc_vartype_t vt_key[]) { +sc_bool prop_get_boolean(sc_prop_setref_t bundle, const sc_char *format, const sc_vartype_t vt_key[]) { sc_vartype_t vt_rvalue; assert(format[0] == PROP_BOOLEAN); @@ -709,9 +691,7 @@ prop_get_boolean(sc_prop_setref_t bundle, return vt_rvalue.boolean; } -const sc_char * -prop_get_string(sc_prop_setref_t bundle, - const sc_char *format, const sc_vartype_t vt_key[]) { +const sc_char *prop_get_string(sc_prop_setref_t bundle, const sc_char *format, const sc_vartype_t vt_key[]) { sc_vartype_t vt_rvalue; assert(format[0] == PROP_STRING); @@ -728,9 +708,7 @@ prop_get_string(sc_prop_setref_t bundle, * Convenience function to retrieve a count of child properties available * for a given property. Returns zero if the property does not exist. */ -sc_int -prop_get_child_count(sc_prop_setref_t bundle, - const sc_char *format, const sc_vartype_t vt_key[]) { +sc_int prop_get_child_count(sc_prop_setref_t bundle, const sc_char *format, const sc_vartype_t vt_key[]) { sc_vartype_t vt_rvalue; assert(format[0] == PROP_INTEGER); @@ -747,8 +725,7 @@ prop_get_child_count(sc_prop_setref_t bundle, * * Create a new, empty properties set, and return it. */ -static sc_prop_setref_t -prop_create_empty() { +static sc_prop_setref_t prop_create_empty() { sc_prop_setref_t bundle; /* Create a new, empty set. */ @@ -793,8 +770,7 @@ prop_create_empty() { * * Free set memory, and destroy a properties set structure. */ -static void -prop_destroy_child_list(sc_prop_noderef_t node) { +static void prop_destroy_child_list(sc_prop_noderef_t node) { /* End recursion on null or childless node. */ if (node && node->child_list) { sc_int index_; @@ -808,8 +784,7 @@ prop_destroy_child_list(sc_prop_noderef_t node) { } } -void -prop_destroy(sc_prop_setref_t bundle) { +void prop_destroy(sc_prop_setref_t bundle) { sc_int index_; assert(prop_is_valid(bundle)); @@ -853,8 +828,7 @@ prop_destroy(sc_prop_setref_t bundle) { * * Create a new properties set based on a taf, and return it. */ -sc_prop_setref_t -prop_create(const sc_tafref_t taf) { +sc_prop_setref_t prop_create(const sc_tafref_t taf) { sc_prop_setref_t bundle; /* Create a new, empty set. */ @@ -877,8 +851,7 @@ prop_create(const sc_tafref_t taf) { * * Adopt a memory address for free'ing on destroy. */ -void -prop_adopt(sc_prop_setref_t bundle, void *addr) { +void prop_adopt(sc_prop_setref_t bundle, void *addr) { assert(prop_is_valid(bundle)); /* Extend the orphans array if necessary. */ @@ -899,8 +872,7 @@ prop_adopt(sc_prop_setref_t bundle, void *addr) { * * Print out a complete properties set. */ -static sc_bool -prop_debug_is_dictionary_string(sc_prop_setref_t bundle, const void *pointer) { +static sc_bool prop_debug_is_dictionary_string(sc_prop_setref_t bundle, const void *pointer) { const sc_char *const pointer_ = (const sc_char * const)pointer; sc_int index_; @@ -913,9 +885,8 @@ prop_debug_is_dictionary_string(sc_prop_setref_t bundle, const void *pointer) { return FALSE; } -static void -prop_debug_dump_node(sc_prop_setref_t bundle, - sc_int depth, sc_int child_index, sc_prop_noderef_t node) { +static void prop_debug_dump_node(sc_prop_setref_t bundle, sc_int depth, + sc_int child_index, sc_prop_noderef_t node) { sc_int index_; /* Write node preamble, indented two spaces for each depth count. */ @@ -953,8 +924,7 @@ prop_debug_dump_node(sc_prop_setref_t bundle, sc_trace("\n"); } -void -prop_debug_dump(sc_prop_setref_t bundle) { +void prop_debug_dump(sc_prop_setref_t bundle) { sc_int index_; assert(prop_is_valid(bundle)); @@ -988,8 +958,7 @@ prop_debug_dump(sc_prop_setref_t bundle) { * * Set property tracing on/off. */ -void -prop_debug_trace(sc_bool flag) { +void prop_debug_trace(sc_bool flag) { prop_trace = flag; } diff --git a/engines/glk/adrift/scprotos.h b/engines/glk/adrift/scprotos.h index 24103b93f8..9601f0618d 100644 --- a/engines/glk/adrift/scprotos.h +++ b/engines/glk/adrift/scprotos.h @@ -779,18 +779,13 @@ extern void if_read_line(sc_char *buffer, sc_int length); extern void if_read_debug(sc_char *buffer, sc_int length); extern sc_bool if_confirm(sc_int type); extern void *if_open_saved_game(sc_bool is_save); -extern void if_write_saved_game(void *opaque, - const sc_byte *buffer, sc_int length); -extern sc_int if_read_saved_game(void *opaque, - sc_byte *buffer, sc_int length); +extern void if_write_saved_game(void *opaque, const sc_byte *buffer, sc_int length); +extern sc_int if_read_saved_game(void *opaque, sc_byte *buffer, sc_int length); extern void if_close_saved_game(void *opaque); extern void if_display_hints(sc_gameref_t game); -extern void if_update_sound(const sc_char *filepath, - sc_int sound_offset, - sc_int sound_length, sc_bool is_looping); -extern void if_update_graphic(const sc_char *filepath, - sc_int graphic_offset, - sc_int graphic_length); +extern void if_update_sound(const sc_char *filepath, sc_int sound_offset, + sc_int sound_length, sc_bool is_looping); +extern void if_update_graphic(const sc_char *filepath, sc_int graphic_offset, sc_int graphic_length); #endif diff --git a/engines/glk/adrift/scresour.cpp b/engines/glk/adrift/scresour.cpp index 739c3d73f6..c09a5c82ab 100644 --- a/engines/glk/adrift/scresour.cpp +++ b/engines/glk/adrift/scresour.cpp @@ -37,8 +37,7 @@ static const sc_char NUL = '\0'; * * Return TRUE if the game uses sound or graphics. */ -sc_bool -res_has_sound(sc_gameref_t game) { +sc_bool res_has_sound(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; sc_bool has_sound; @@ -50,8 +49,7 @@ res_has_sound(sc_gameref_t game) { return has_sound; } -sc_bool -res_has_graphics(sc_gameref_t game) { +sc_bool res_has_graphics(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; sc_bool has_graphics; @@ -71,21 +69,18 @@ res_has_graphics(sc_gameref_t game) { * * Convenience functions to set, clear, and compare resource fields. */ -static void -res_set_resource(sc_resourceref_t resource, const sc_char *name, +static void res_set_resource(sc_resourceref_t resource, const sc_char *name, sc_int offset, sc_int length) { resource->name = name; resource->offset = offset; resource->length = length; } -void -res_clear_resource(sc_resourceref_t resource) { +void res_clear_resource(sc_resourceref_t resource) { res_set_resource(resource, "", 0, 0); } -sc_bool -res_compare_resource(sc_resourceref_t from, sc_resourceref_t with) { +sc_bool res_compare_resource(sc_resourceref_t from, sc_resourceref_t with) { return strcmp(from->name, with->name) == 0 && from->offset == with->offset && from->length == with->length; } @@ -103,10 +98,8 @@ res_compare_resource(sc_resourceref_t from, sc_resourceref_t with) { * in prop_get), and the partial key is guaranteed to contain at least * strlen(partial_format) elements. */ -void -res_handle_resource(sc_gameref_t game, - const sc_char *partial_format, - const sc_vartype_t vt_partial[]) { +void res_handle_resource(sc_gameref_t game, const sc_char *partial_format, + const sc_vartype_t vt_partial[]) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2], *vt_full; sc_int partial_length, resource_start_offset; @@ -250,8 +243,7 @@ res_handle_resource(sc_gameref_t game, * Bring resources into line with the game; called on undo, restart, * restore, and so on. */ -void -res_sync_resources(sc_gameref_t game) { +void res_sync_resources(sc_gameref_t game) { assert(gs_is_game_valid(game)); /* Deal with any latched sound stop first. */ @@ -307,8 +299,7 @@ res_sync_resources(sc_gameref_t game) { * Turn off sound and graphics, and reset the game's tracking of resources in * use to match. Called on game restart or restore. */ -void -res_cancel_resources(sc_gameref_t game) { +void res_cancel_resources(sc_gameref_t game) { assert(gs_is_game_valid(game)); /* Request that everything stops and clears. */ diff --git a/engines/glk/adrift/screstrs.cpp b/engines/glk/adrift/screstrs.cpp index 3f1db887f4..c808129415 100644 --- a/engines/glk/adrift/screstrs.cpp +++ b/engines/glk/adrift/screstrs.cpp @@ -40,8 +40,7 @@ static sc_bool restr_trace = FALSE; * * Return the index of the n'th integer found. */ -static sc_int -restr_integer_variable(sc_gameref_t game, sc_int n) { +static sc_int restr_integer_variable(sc_gameref_t game, sc_int n) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int var_count, var, count; @@ -70,9 +69,7 @@ restr_integer_variable(sc_gameref_t game, sc_int n) { * * Is object in a certain place, state, or condition. */ -static sc_bool -restr_object_in_place(sc_gameref_t game, - sc_int object, sc_int var2, sc_int var3) { +static sc_bool restr_object_in_place(sc_gameref_t game, sc_int object, sc_int var2, sc_int var3) { const sc_var_setref_t vars = gs_get_vars(game); sc_int npc; @@ -157,9 +154,8 @@ restr_object_in_place(sc_gameref_t game, * * Evaluate restrictions relating to object location. */ -static sc_bool -restr_pass_task_object_location(sc_gameref_t game, - sc_int var1, sc_int var2, sc_int var3) { +static sc_bool restr_pass_task_object_location(sc_gameref_t game, + sc_int var1, sc_int var2, sc_int var3) { const sc_var_setref_t vars = gs_get_vars(game); sc_bool should_be; sc_int object; @@ -231,8 +227,7 @@ restr_pass_task_object_location(sc_gameref_t game, * Evaluate restrictions relating to object states. This function is called * from the library by lib_pass_alt_room(), so cannot be static. */ -sc_bool -restr_pass_task_object_state(sc_gameref_t game, sc_int var1, sc_int var2) { +sc_bool restr_pass_task_object_state(sc_gameref_t game, sc_int var1, sc_int var2) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[3]; @@ -279,8 +274,7 @@ restr_pass_task_object_state(sc_gameref_t game, sc_int var1, sc_int var2) { * * Evaluate restrictions relating to task states. */ -static sc_bool -restr_pass_task_task_state(sc_gameref_t game, sc_int var1, sc_int var2) { +static sc_bool restr_pass_task_task_state(sc_gameref_t game, sc_int var1, sc_int var2) { sc_bool should_be; if (restr_trace) @@ -318,8 +312,7 @@ restr_pass_task_task_state(sc_gameref_t game, sc_int var1, sc_int var2) { * * Evaluate restrictions relating to player and NPCs. */ -static sc_bool -restr_pass_task_char(sc_gameref_t game, sc_int var1, sc_int var2, sc_int var3) { +static sc_bool restr_pass_task_char(sc_gameref_t game, sc_int var1, sc_int var2, sc_int var3) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_int npc1, npc2; @@ -437,9 +430,7 @@ restr_pass_task_char(sc_gameref_t game, sc_int var1, sc_int var2, sc_int var3) { * * Helper for restr_pass_task_var(), handles integer variable restrictions. */ -static sc_bool -restr_pass_task_int_var(sc_gameref_t game, - sc_int var2, sc_int var3, sc_int value) { +static sc_bool restr_pass_task_int_var(sc_gameref_t game, sc_int var2, sc_int var3, sc_int value) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[3]; @@ -522,9 +513,7 @@ restr_pass_task_int_var(sc_gameref_t game, * * Helper for restr_pass_task_var(), handles string variable restrictions. */ -static sc_bool -restr_pass_task_string_var(sc_int var2, - const sc_char *var4, const sc_char *value) { +static sc_bool restr_pass_task_string_var(sc_int var2, const sc_char *var4, const sc_char *value) { if (restr_trace) { sc_trace("Restr: running string" " var restriction, %ld, \"%s\", \"%s\"\n", var2, var4, value); @@ -550,10 +539,8 @@ restr_pass_task_string_var(sc_int var2, * * Evaluate restrictions relating to variables. */ -static sc_bool -restr_pass_task_var(sc_gameref_t game, - sc_int var1, sc_int var2, sc_int var3, - const sc_char *var4) { +static sc_bool restr_pass_task_var(sc_gameref_t game, sc_int var1, sc_int var2, sc_int var3, + const sc_char *var4) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[3]; @@ -607,8 +594,7 @@ restr_pass_task_var(sc_gameref_t game, * * Demultiplexer for task restrictions. */ -static sc_bool -restr_pass_task_restriction(sc_gameref_t game, sc_int task, sc_int restriction) { +static sc_bool restr_pass_task_restriction(sc_gameref_t game, sc_int task, sc_int restriction) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int type, var1, var2, var3; @@ -712,15 +698,13 @@ static sc_int restr_index = 0; * * Start and wrap up restrictions combinations string tokenization. */ -static void -restr_tokenize_start(const sc_char *expression) { +static void restr_tokenize_start(const sc_char *expression) { /* Save expression, and restart index. */ restr_expression = expression; restr_index = 0; } -static void -restr_tokenize_end(void) { +static void restr_tokenize_end(void) { restr_expression = NULL; restr_index = 0; } @@ -731,8 +715,7 @@ restr_tokenize_end(void) { * * Simple tokenizer for restrictions combination expressions. */ -static sc_char -restr_next_token(void) { +static sc_char restr_next_token(void) { assert(restr_expression); /* Find the next non-space, and return it. */ @@ -775,8 +758,7 @@ static sc_int restr_lowest_fail = -1; * Reset the evaluation stack to an empty state, and note the things we have * to note for when we need to evaluate a restriction. */ -static void -restr_eval_start(sc_gameref_t game, sc_int task) { +static void restr_eval_start(sc_gameref_t game, sc_int task) { /* Clear stack. */ restr_eval_stack = 0; restr_eval_restriction = 0; @@ -795,8 +777,7 @@ restr_eval_start(sc_gameref_t game, sc_int task) { * * Push a value onto the values stack. */ -static void -restr_eval_push(sc_bool value) { +static void restr_eval_push(sc_bool value) { if (restr_eval_stack >= MAX_NESTING_DEPTH) sc_fatal("restr_eval_push: stack overflow\n"); @@ -809,8 +790,7 @@ restr_eval_push(sc_bool value) { * * Evaluate the effect of an and/or into the values stack. */ -static void -restr_eval_action(sc_char token) { +static void restr_eval_action(sc_char token) { /* Select action based on parsed token. */ switch (token) { /* Handle evaluating and pushing a restriction result. */ @@ -875,8 +855,7 @@ restr_eval_action(sc_char token) { * * Return the top of the values stack as the evaluation result. */ -static sc_int -restr_eval_result(sc_int *lowest_fail) { +static sc_int restr_eval_result(sc_int *lowest_fail) { if (restr_eval_stack != 1) sc_fatal("restr_eval_result: values stack not completed\n"); @@ -896,8 +875,7 @@ static sc_char restr_lookahead = '\0'; * * Match a token with an expectation. */ -static void -restr_match(sc_char c) { +static void restr_match(sc_char c) { if (restr_lookahead == c) restr_lookahead = restr_next_token(); else { @@ -918,8 +896,7 @@ static void restr_bexpr(void); * * Expression parsers. Here we go again... */ -static void -restr_andexpr(void) { +static void restr_andexpr(void) { restr_bexpr(); while (restr_lookahead == TOK_AND) { restr_match(TOK_AND); @@ -928,8 +905,7 @@ restr_andexpr(void) { } } -static void -restr_orexpr(void) { +static void restr_orexpr(void) { restr_andexpr(); while (restr_lookahead == TOK_OR) { restr_match(TOK_OR); @@ -938,8 +914,7 @@ restr_orexpr(void) { } } -static void -restr_bexpr(void) { +static void restr_bexpr(void) { switch (restr_lookahead) { case TOK_RESTRICTION: restr_match(TOK_RESTRICTION); @@ -964,8 +939,7 @@ restr_bexpr(void) { * * Get the FailMessage for the given task restriction; NULL if none. */ -static const sc_char * -restr_get_fail_message(sc_gameref_t game, sc_int task, sc_int restriction) { +static const sc_char *restr_get_fail_message(sc_gameref_t game, sc_int task, sc_int restriction) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; const sc_char *message; @@ -988,8 +962,7 @@ restr_get_fail_message(sc_gameref_t game, sc_int task, sc_int restriction) { * * Set restrictions tracing on/off. */ -void -restr_debug_trace(sc_bool flag) { +void restr_debug_trace(sc_bool flag) { restr_trace = flag; } @@ -1004,10 +977,8 @@ restr_debug_trace(sc_bool flag) { * if no failing restriction has a FailMessage. The function's main return * value is TRUE if restrictions parsed successfully, FALSE otherwise. */ -sc_bool -restr_eval_task_restrictions(sc_gameref_t game, - sc_int task, sc_bool *pass, - const sc_char **fail_message) { +sc_bool restr_eval_task_restrictions(sc_gameref_t game, sc_int task, sc_bool *pass, + const sc_char **fail_message) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int restr_count, lowest_fail; diff --git a/engines/glk/adrift/scrunner.cpp b/engines/glk/adrift/scrunner.cpp index 9e979d1193..95c8f1906a 100644 --- a/engines/glk/adrift/scrunner.cpp +++ b/engines/glk/adrift/scrunner.cpp @@ -44,8 +44,7 @@ static const sc_char *const SEPARATORS = ".,"; * present, only getdynfromroom() exists. Returns TRUE if function found * and handled. */ -static sc_bool -run_is_task_function(const sc_char *pattern, sc_gameref_t game) { +static sc_bool run_is_task_function(const sc_char *pattern, sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[3]; @@ -107,10 +106,11 @@ run_is_task_function(const sc_char *pattern, sc_gameref_t game) { /* Structure used to associate a pattern with a handler function. */ -typedef struct sc_commands_s { +struct sc_commands_s { const sc_char *const command; sc_bool(*const handler)(sc_gameref_t game); -} sc_commands_t; +}; +typedef sc_commands_s sc_commands_t; typedef sc_commands_t *sc_commandsref_t; /* Movement commands for the four point compass. */ @@ -487,8 +487,7 @@ static sc_commands_t STANDARD_COMMANDS[] = { * For now, I can't find any better way to try to handle it than to make * object acquisition take precedence over game commands. */ -static sc_bool -run_priority_commands(sc_gameref_t game, const sc_char *string) { +static sc_bool run_priority_commands(sc_gameref_t game, const sc_char *string) { sc_commandsref_t command; for (command = PRIORITY_COMMANDS; command->command; command++) { @@ -502,8 +501,7 @@ run_priority_commands(sc_gameref_t game, const sc_char *string) { return FALSE; } -static sc_bool -run_standard_commands(sc_gameref_t game, const sc_char *string) { +static sc_bool run_standard_commands(sc_gameref_t game, const sc_char *string) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; sc_bool eightpointcompass; @@ -543,8 +541,7 @@ run_standard_commands(sc_gameref_t game, const sc_char *string) { * * Update the game's current room and status line strings. */ -static void -run_update_status(sc_gameref_t game) { +static void run_update_status(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[2]; @@ -589,8 +586,7 @@ run_update_status(sc_gameref_t game) { * directly for printing, rather than the filter, so that it can place its * output ahead of buffered printfilter text. */ -static void -run_notify_score_change(sc_gameref_t game) { +static void run_notify_score_change(sc_gameref_t game) { const sc_gameref_t undo = game->undo; sc_char buffer[32]; assert(gs_is_game_valid(undo)); @@ -630,10 +626,8 @@ run_notify_score_change(sc_gameref_t game) { * if a task command matches, FALSE otherwise. Ordinary or reverse commands * are selected by 'forwards'. */ -static sc_bool -run_match_task_common(sc_gameref_t game, - sc_int task, const sc_char *string, sc_bool forwards, - sc_bool is_library, sc_bool is_normal) { +static sc_bool run_match_task_common(sc_gameref_t game, sc_int task, const sc_char *string, + sc_bool forwards, sc_bool is_library, sc_bool is_normal) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; sc_int command_count, command; @@ -682,10 +676,8 @@ run_match_task_common(sc_gameref_t game, return is_matched; } -static sc_bool -run_match_task_commands(sc_gameref_t game, - sc_int task, const sc_char *string, - sc_bool forwards, sc_bool is_library) { +static sc_bool run_match_task_commands(sc_gameref_t game, sc_int task, + const sc_char *string, sc_bool forwards, sc_bool is_library) { /* * Match tasks using the normal pattern matcher, with or without any note * about whether the call is from the library. @@ -693,9 +685,8 @@ run_match_task_commands(sc_gameref_t game, return run_match_task_common(game, task, string, forwards, is_library, TRUE); } -static sc_bool -run_match_task_functions(sc_gameref_t game, - sc_int task, const sc_char *string, sc_bool forwards) { +static sc_bool run_match_task_functions(sc_gameref_t game, sc_int task, + const sc_char *string, sc_bool forwards) { /* Match tasks against "task command functions". */ return run_match_task_common(game, task, string, forwards, FALSE, FALSE); } @@ -713,8 +704,7 @@ run_match_task_functions(sc_gameref_t game, * indicates why it fails; such tasks, if run, produce their failure message * and don't change state. */ -static sc_bool -run_task_is_unrestricted(sc_gameref_t game, sc_int task) { +static sc_bool run_task_is_unrestricted(sc_gameref_t game, sc_int task) { sc_bool restrictions_passed; const sc_char *fail_message; @@ -732,8 +722,7 @@ run_task_is_unrestricted(sc_gameref_t game, sc_int task) { return restrictions_passed; } -static sc_bool -run_task_is_loudly_restricted(sc_gameref_t game, sc_int task) { +static sc_bool run_task_is_loudly_restricted(sc_gameref_t game, sc_int task) { sc_bool restrictions_passed; const sc_char *fail_message; @@ -788,9 +777,8 @@ run_task_is_loudly_restricted(sc_gameref_t game, sc_int task) { * library to try to run "get " and "drop " game commands for standard get/drop * handlers and get_all/drop_all handlers. No pressure, then. */ -static sc_bool -run_game_commands_common(sc_gameref_t game, const sc_char *string, - sc_bool include_restrictions, sc_bool is_library) { +static sc_bool run_game_commands_common(sc_gameref_t game, const sc_char *string, + sc_bool include_restrictions, sc_bool is_library) { sc_bool is_matched = FALSE, is_handled = FALSE; sc_bool *is_matching; sc_int task_count, task, direction; @@ -883,9 +871,8 @@ run_game_commands_common(sc_gameref_t game, const sc_char *string, return is_handled; } -static sc_bool -run_game_commands_in_parser_context(sc_gameref_t game, const sc_char *string, - sc_bool include_restrictions) { +static sc_bool run_game_commands_in_parser_context(sc_gameref_t game, + const sc_char *string, sc_bool include_restrictions) { /* * Try game commands, either with or without restrictions, and all full and * complete parse matching (no special case for game commands that begin @@ -894,8 +881,7 @@ run_game_commands_in_parser_context(sc_gameref_t game, const sc_char *string, return run_game_commands_common(game, string, include_restrictions, FALSE); } -static sc_bool -run_game_commands_in_library_context(sc_gameref_t game, const sc_char *string) { +static sc_bool run_game_commands_in_library_context(sc_gameref_t game, const sc_char *string) { /* * Try game commands, including restrictions, and noting that this is a * library call so that the parse matcher can exclude game commands that @@ -912,8 +898,7 @@ run_game_commands_in_library_context(sc_gameref_t game, const sc_char *string) { * "task command functions". These seem to happen in addition to any regular * command matches, so we try them as a separate action. */ -static void -run_game_functions(sc_gameref_t game, const sc_char *string) { +static void run_game_functions(sc_gameref_t game, const sc_char *string) { sc_int task_count, task, direction; /* Iterate over every task, ignoring those not runnable. */ @@ -947,8 +932,7 @@ run_game_functions(sc_gameref_t game, const sc_char *string) { * main user input handling loop; the latter by the library when looking for * game commands that override standard actions. */ -static sc_bool -run_all_commands(sc_gameref_t game, const sc_char *string) { +static sc_bool run_all_commands(sc_gameref_t game, const sc_char *string) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_bool status; @@ -1009,8 +993,7 @@ run_all_commands(sc_gameref_t game, const sc_char *string) { return status; } -sc_bool -run_game_task_commands(sc_gameref_t game, const sc_char *string) { +sc_bool run_game_task_commands(sc_gameref_t game, const sc_char *string) { return run_game_commands_in_library_context(game, string); } @@ -1032,8 +1015,7 @@ run_game_task_commands(sc_gameref_t game, const sc_char *string) { * this is a signal to reset all noted line input to initial conditions, and * just return. Sorry about the ugliness. */ -static sc_bool -run_player_input(sc_gameref_t game) { +static sc_bool run_player_input(sc_gameref_t game) { static sc_char line_buffer[LINE_BUFFER_SIZE]; static sc_char prior_element[LINE_BUFFER_SIZE]; static sc_char line_element[LINE_BUFFER_SIZE]; @@ -1254,8 +1236,7 @@ run_player_input(sc_gameref_t game) { * * Main interpreter loop. */ -static void -run_main_loop(sc_gameref_t game) { +static void run_main_loop(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); @@ -1436,8 +1417,7 @@ run_main_loop(sc_gameref_t game) { * * Create a game context from a callback. */ -sc_gameref_t -run_create(sc_read_callbackref_t callback, void *opaque) { +sc_gameref_t run_create(sc_read_callbackref_t callback, void *opaque) { sc_tafref_t taf; sc_prop_setref_t bundle; sc_var_setref_t vars, temporary_vars, undo_vars; @@ -1502,8 +1482,7 @@ run_create(sc_read_callbackref_t callback, void *opaque) { * * Return a game context to initial states to restart a game. */ -static void -run_restart_handler(sc_gameref_t game) { +static void run_restart_handler(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_gameref_t new_game; @@ -1548,8 +1527,7 @@ run_restart_handler(sc_gameref_t game) { * * Adjust a game context for continuation after restoring a game. */ -static void -run_restore_handler(sc_gameref_t game) { +static void run_restore_handler(sc_gameref_t game) { /* Invalidate the undo buffer. */ game->undo_available = FALSE; @@ -1570,8 +1548,7 @@ run_restore_handler(sc_gameref_t game) { * * Tidy up printfilter and input statics on game quit. */ -static void -run_quit_handler(sc_gameref_t game) { +static void run_quit_handler(sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); @@ -1597,8 +1574,7 @@ run_quit_handler(sc_gameref_t game) { * * Intepret the game in a game context. */ -void -run_interpret(sc_gameref_t game) { +void run_interpret(sc_gameref_t game) { assert(gs_is_game_valid(game)); /* Verify the game is not already running, and is runnable. */ @@ -1652,8 +1628,7 @@ run_interpret(sc_gameref_t game) { * * Destroy a game context, and free all resources. */ -void -run_destroy(sc_gameref_t game) { +void run_destroy(sc_gameref_t game) { assert(gs_is_game_valid(game)); /* Can't destroy the context of a running game. */ @@ -1706,8 +1681,7 @@ run_destroy(sc_gameref_t game) { * Quits a running game. This function calls a longjump to act as if * run_main_loop() returned, and so never returns to its caller. */ -void -run_quit(sc_gameref_t game) { +void run_quit(sc_gameref_t game) { assert(gs_is_game_valid(game)); /* Disallow quitting a non-running game. */ @@ -1730,8 +1704,7 @@ run_quit(sc_gameref_t game) { * function calls a longjump to act as if run_main_loop() returned, and so * never returns to its caller. For stopped games, it returns. */ -void -run_restart(sc_gameref_t game) { +void run_restart(sc_gameref_t game) { assert(gs_is_game_valid(game)); /* @@ -1757,16 +1730,14 @@ run_restart(sc_gameref_t game) { * * Saves either a running or a stopped game. */ -void -run_save(sc_gameref_t game, sc_write_callbackref_t callback, void *opaque) { +void run_save(sc_gameref_t game, sc_write_callbackref_t callback, void *opaque) { assert(gs_is_game_valid(game)); assert(callback); ser_save_game(game, callback, opaque); } -sc_bool -run_save_prompted(sc_gameref_t game) { +sc_bool run_save_prompted(sc_gameref_t game) { assert(gs_is_game_valid(game)); return ser_save_game_prompted(game); @@ -1784,9 +1755,7 @@ run_save_prompted(sc_gameref_t game) { * restore, and for stopped games, they will return, with TRUE if successful, * FALSE if restore failed. */ -static sc_bool -run_restore_common(sc_gameref_t game, - sc_read_callbackref_t callback, void *opaque) { +static sc_bool run_restore_common(sc_gameref_t game, sc_read_callbackref_t callback, void *opaque) { sc_bool is_running, status; /* @@ -1817,16 +1786,14 @@ run_restore_common(sc_gameref_t game, return status; } -sc_bool -run_restore(sc_gameref_t game, sc_read_callbackref_t callback, void *opaque) { +sc_bool run_restore(sc_gameref_t game, sc_read_callbackref_t callback, void *opaque) { assert(gs_is_game_valid(game)); assert(callback); return run_restore_common(game, callback, opaque); } -sc_bool -run_restore_prompted(sc_gameref_t game) { +sc_bool run_restore_prompted(sc_gameref_t game) { assert(gs_is_game_valid(game)); return run_restore_common(game, NULL, NULL); @@ -1839,8 +1806,7 @@ run_restore_prompted(sc_gameref_t game) { * Undo a turn in either a running or a stopped game. Returns TRUE on * successful undo, FALSE if no undo buffer is available. */ -sc_bool -run_undo(sc_gameref_t game) { +sc_bool run_undo(sc_gameref_t game) { const sc_memo_setref_t memento = gs_get_memento(game); sc_bool is_running; assert(gs_is_game_valid(game)); @@ -1896,8 +1862,7 @@ run_undo(sc_gameref_t game) { * * Query the game running state. */ -sc_bool -run_is_running(sc_gameref_t game) { +sc_bool run_is_running(sc_gameref_t game) { assert(gs_is_game_valid(game)); return game->is_running; @@ -1910,8 +1875,7 @@ run_is_running(sc_gameref_t game) { * Query the game completion state. Completed games cannot be resumed, * since they've run the exit task and thus have nowhere to go. */ -sc_bool -run_has_completed(sc_gameref_t game) { +sc_bool run_has_completed(sc_gameref_t game) { assert(gs_is_game_valid(game)); return game->has_completed; @@ -1923,8 +1887,7 @@ run_has_completed(sc_gameref_t game) { * * Query the game turn undo buffer and memo availability. */ -sc_bool -run_is_undo_available(sc_gameref_t game) { +sc_bool run_is_undo_available(sc_gameref_t game) { const sc_memo_setref_t memento = gs_get_memento(game); assert(gs_is_game_valid(game)); @@ -1938,15 +1901,10 @@ run_is_undo_available(sc_gameref_t game) { * * Get and set selected game attributes. */ -void -run_get_attributes(sc_gameref_t game, - const sc_char **game_name, const sc_char **game_author, - const sc_char **game_compile_date, - sc_int *turns, sc_int *score, sc_int *max_score, - const sc_char **current_room_name, - const sc_char **status_line, const sc_char **preferred_font, - sc_bool *bold_room_names, sc_bool *verbose, - sc_bool *notify_score_change) { +void run_get_attributes(sc_gameref_t game, const sc_char **game_name, const sc_char **game_author, + const sc_char **game_compile_date, sc_int *turns, sc_int *score, sc_int *max_score, + const sc_char **current_room_name, const sc_char **status_line, const sc_char **preferred_font, + sc_bool *bold_room_names, sc_bool *verbose, sc_bool *notify_score_change) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[2]; @@ -2022,10 +1980,8 @@ run_get_attributes(sc_gameref_t game, *notify_score_change = game->notify_score_change; } -void -run_set_attributes(sc_gameref_t game, - sc_bool bold_room_names, sc_bool verbose, - sc_bool notify_score_change) { +void run_set_attributes(sc_gameref_t game, sc_bool bold_room_names, sc_bool verbose, + sc_bool notify_score_change) { assert(gs_is_game_valid(game)); /* Set game options. */ @@ -2044,8 +2000,7 @@ run_set_attributes(sc_gameref_t game, * the token passed in and out is a pointer, and readily made opaque to * the client as a void*. */ -sc_hintref_t -run_hint_iterate(sc_gameref_t game, sc_hintref_t hint) { +sc_hintref_t run_hint_iterate(sc_gameref_t game, sc_hintref_t hint) { sc_int task; assert(gs_is_game_valid(game)); @@ -2091,9 +2046,8 @@ run_hint_iterate(sc_gameref_t game, sc_hintref_t hint) { * * Hint strings are NULL if empty (not defined by the game). */ -static const sc_char * -run_get_hint_common(sc_gameref_t game, sc_hintref_t hint, - const sc_char * (*handler)(sc_gameref_t, sc_int)) { +static const sc_char *run_get_hint_common(sc_gameref_t game, sc_hintref_t hint, + const sc_char * (*handler)(sc_gameref_t, sc_int)) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_int task; @@ -2129,18 +2083,15 @@ run_get_hint_common(sc_gameref_t game, sc_hintref_t hint, return game->hint_text; } -const sc_char * -run_get_hint_question(sc_gameref_t game, sc_hintref_t hint) { +const sc_char *run_get_hint_question(sc_gameref_t game, sc_hintref_t hint) { return run_get_hint_common(game, hint, task_get_hint_question); } -const sc_char * -run_get_subtle_hint(sc_gameref_t game, sc_hintref_t hint) { +const sc_char *run_get_subtle_hint(sc_gameref_t game, sc_hintref_t hint) { return run_get_hint_common(game, hint, task_get_hint_subtle); } -const sc_char * -run_get_unsubtle_hint(sc_gameref_t game, sc_hintref_t hint) { +const sc_char *run_get_unsubtle_hint(sc_gameref_t game, sc_hintref_t hint) { return run_get_hint_common(game, hint, task_get_hint_unsubtle); } diff --git a/engines/glk/adrift/scserial.cpp b/engines/glk/adrift/scserial.cpp index 9c41db25b4..f0693477d1 100644 --- a/engines/glk/adrift/scserial.cpp +++ b/engines/glk/adrift/scserial.cpp @@ -177,8 +177,7 @@ static void ser_flush(sc_bool is_final) { #endif } -static void -ser_buffer_character(sc_char character) { +static void ser_buffer_character(sc_char character) { /* Allocate the buffer if not yet done. */ if (!ser_buffer) { assert(ser_buffer_length == 0); @@ -202,8 +201,7 @@ ser_buffer_character(sc_char character) { * * Buffer a buffer, a string, an unsigned and signed integer, and a boolean. */ -static void -ser_buffer_buffer(const sc_char *buffer, sc_int length) { +static void ser_buffer_buffer(const sc_char *buffer, sc_int length) { sc_int index_; /* Add each character to the buffer. */ @@ -211,16 +209,14 @@ ser_buffer_buffer(const sc_char *buffer, sc_int length) { ser_buffer_character(buffer[index_]); } -static void -ser_buffer_string(const sc_char *string) { +static void ser_buffer_string(const sc_char *string) { /* Buffer string, followed by DOS style end-of-line. */ ser_buffer_buffer(string, strlen(string)); ser_buffer_character(CARRIAGE_RETURN); ser_buffer_character(NEWLINE); } -static void -ser_buffer_int(sc_int value) { +static void ser_buffer_int(sc_int value) { sc_char buffer[32]; /* Convert to a string and buffer that. */ @@ -228,8 +224,7 @@ ser_buffer_int(sc_int value) { ser_buffer_string(buffer); } -static void -ser_buffer_int_special(sc_int value) { +static void ser_buffer_int_special(sc_int value) { sc_char buffer[32]; /* Weirdo formatting for compatibility. */ @@ -237,8 +232,7 @@ ser_buffer_int_special(sc_int value) { ser_buffer_string(buffer); } -static void -ser_buffer_uint(sc_uint value) { +static void ser_buffer_uint(sc_uint value) { sc_char buffer[32]; /* Convert to a string and buffer that. */ @@ -246,8 +240,7 @@ ser_buffer_uint(sc_uint value) { ser_buffer_string(buffer); } -static void -ser_buffer_boolean(sc_bool boolean) { +static void ser_buffer_boolean(sc_bool boolean) { /* Write a 1 for TRUE, 0 for FALSE. */ ser_buffer_string(boolean ? "1" : "0"); } @@ -258,9 +251,7 @@ ser_buffer_boolean(sc_bool boolean) { * * Serialize a game and save its state using the given callback and opaque. */ -void -ser_save_game(sc_gameref_t game, - sc_write_callbackref_t callback, void *opaque) { +void ser_save_game(sc_gameref_t game, sc_write_callbackref_t callback, void *opaque) { const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -418,8 +409,7 @@ ser_save_game(sc_gameref_t game, * Serialize a game and save its state, requesting a save stream from * the user. */ -sc_bool -ser_save_game_prompted(sc_gameref_t game) { +sc_bool ser_save_game_prompted(sc_gameref_t game) { void *opaque; /* @@ -453,8 +443,7 @@ static jmp_buf ser_tas_error; * Wrapper round obtaining the next TAS file line, with variants to convert * the line content into an appropriate type. */ -static const sc_char * -ser_get_string(void) { +static const sc_char *ser_get_string(void) { const sc_char *string; /* Get the next line, and complain if absent. */ @@ -468,8 +457,7 @@ ser_get_string(void) { return string; } -static sc_int -ser_get_int(void) { +static sc_int ser_get_int(void) { const sc_char *string; sc_int value; @@ -484,8 +472,7 @@ ser_get_int(void) { return value; } -static sc_uint -ser_get_uint(void) { +static sc_uint ser_get_uint(void) { const sc_char *string; sc_uint value; @@ -500,8 +487,7 @@ ser_get_uint(void) { return value; } -static sc_bool -ser_get_boolean(void) { +static sc_bool ser_get_boolean(void) { const sc_char *string; sc_uint value; @@ -530,9 +516,7 @@ ser_get_boolean(void) { * Load a serialized game into the given game by repeated calls to the * callback() function. */ -sc_bool -ser_load_game(sc_gameref_t game, - sc_read_callbackref_t callback, void *opaque) { +sc_bool ser_load_game(sc_gameref_t game, sc_read_callbackref_t callback, void *opaque) { static sc_var_setref_t new_vars; /* For setjmp safety */ static sc_gameref_t new_game; /* For setjmp safety */ @@ -753,8 +737,7 @@ ser_load_game(sc_gameref_t game, * Load a serialized game into the given game, requesting a restore * stream from the user. */ -sc_bool -ser_load_game_prompted(sc_gameref_t game) { +sc_bool ser_load_game_prompted(sc_gameref_t game) { void *opaque; /* diff --git a/engines/glk/adrift/sctaffil.cpp b/engines/glk/adrift/sctaffil.cpp index f365a7fa46..4bee7694d0 100644 --- a/engines/glk/adrift/sctaffil.cpp +++ b/engines/glk/adrift/sctaffil.cpp @@ -94,7 +94,7 @@ struct sc_slabdesc_t { sc_int size; }; typedef sc_slabdesc_t *sc_slabdescref_t; -typedef struct sc_taf_s { +struct sc_taf_s { sc_uint magic; sc_byte header[VERSION_HEADER_SIZE + V400_HEADER_EXTRA]; sc_int version; @@ -105,7 +105,8 @@ typedef struct sc_taf_s { sc_bool is_unterminated; sc_int current_slab; sc_int current_offset; -} sc_taf_t; +}; +typedef sc_taf_s sc_taf_t; /* Microsoft Visual Basic PRNG magic numbers, initial and current state. */ @@ -125,15 +126,13 @@ static sc_int taf_random_state = 0x00a09e86; * we multiply by 255 and then divide by prng_cst3 + 1 to get output in the * range 0..254. Thanks to Rik Snel for uncovering this obfuscation. */ -static sc_byte -taf_random(void) { +static sc_byte taf_random(void) { /* Generate and return the next pseudo-random number. */ taf_random_state = (taf_random_state * PRNG_CST1 + PRNG_CST2) & PRNG_CST3; return (UCHAR_MAX * (sc_uint) taf_random_state) / (sc_uint)(PRNG_CST3 + 1); } -static void -taf_random_reset(void) { +static void taf_random_reset(void) { /* Reset PRNG to initial conditions. */ taf_random_state = PRNG_INITIAL_STATE; } @@ -144,8 +143,7 @@ taf_random_reset(void) { * * Return TRUE if pointer is a valid TAF structure, FALSE otherwise. */ -static sc_bool -taf_is_valid(sc_tafref_t taf) { +static sc_bool taf_is_valid(sc_tafref_t taf) { return taf && taf->magic == TAF_MAGIC; } @@ -155,8 +153,7 @@ taf_is_valid(sc_tafref_t taf) { * * Allocate and return a new, empty TAF structure. */ -static sc_tafref_t -taf_create_empty(void) { +static sc_tafref_t taf_create_empty(void) { sc_tafref_t taf; /* Create an empty TAF structure. */ @@ -182,8 +179,7 @@ taf_create_empty(void) { * * Free TAF memory, and destroy a TAF structure. */ -void -taf_destroy(sc_tafref_t taf) { +void taf_destroy(sc_tafref_t taf) { sc_int index_; assert(taf_is_valid(taf)); @@ -207,8 +203,7 @@ taf_destroy(sc_tafref_t taf) { * Insert nul's into slab data so that it turns into a series of nul-terminated * strings. Nul's are used to replace carriage return and newline pairs. */ -static void -taf_finalize_last_slab(sc_tafref_t taf) { +static void taf_finalize_last_slab(sc_tafref_t taf) { sc_slabdescref_t slab; sc_int index_; @@ -244,9 +239,7 @@ taf_finalize_last_slab(sc_tafref_t taf) { * line feed. If none, found, return length and set is_unterminated to TRUE. * Otherwise, return the count of usable bytes found in the buffer. */ -static sc_int -taf_find_buffer_extent(const sc_byte *buffer, - sc_int length, sc_bool *is_unterminated) { +static sc_int taf_find_buffer_extent(const sc_byte *buffer, sc_int length, sc_bool *is_unterminated) { sc_int bytes; /* Search backwards from the buffer end for the final line feed. */ @@ -271,8 +264,7 @@ taf_find_buffer_extent(const sc_byte *buffer, * Append a buffer of TAF lines to an existing TAF structure. Returns the * number of characters consumed from the buffer. */ -static sc_int -taf_append_buffer(sc_tafref_t taf, const sc_byte *buffer, sc_int length) { +static sc_int taf_append_buffer(sc_tafref_t taf, const sc_byte *buffer, sc_int length) { sc_int bytes; sc_bool is_unterminated; @@ -347,9 +339,8 @@ taf_append_buffer(sc_tafref_t taf, const sc_byte *buffer, sc_int length) { * count of bytes placed in the buffer, or 0 if no more (end of file). * Assumes that the file has been read past the header. */ -static sc_bool -taf_unobfuscate(sc_tafref_t taf, sc_read_callbackref_t callback, - void *opaque, sc_bool is_gamefile) { +static sc_bool taf_unobfuscate(sc_tafref_t taf, sc_read_callbackref_t callback, + void *opaque, sc_bool is_gamefile) { sc_byte *buffer; sc_int bytes, used_bytes, total_bytes, index_; @@ -427,7 +418,7 @@ taf_unobfuscate(sc_tafref_t taf, sc_read_callbackref_t callback, * Decompress a version 4.0 TAF */ static sc_bool taf_decompress(sc_tafref_t taf, sc_read_callbackref_t callback, - void *opaque, sc_bool is_gamefile) { + void *opaque, sc_bool is_gamefile) { #if USE_ZLIB Common::SeekableReadStream *src = (Common::SeekableReadStream *)opaque; assert(src); @@ -462,9 +453,8 @@ static sc_bool taf_decompress(sc_tafref_t taf, sc_read_callbackref_t callback, * callback() function. Callback() should return the count of bytes placed * in the buffer, or 0 if no more (end of file). */ -static sc_tafref_t -taf_create_from_callback(sc_read_callbackref_t callback, - void *opaque, sc_bool is_gamefile) { +static sc_tafref_t taf_create_from_callback(sc_read_callbackref_t callback, + void *opaque, sc_bool is_gamefile) { sc_tafref_t taf; sc_bool status = FALSE; assert(callback); @@ -555,13 +545,11 @@ taf_create_from_callback(sc_read_callbackref_t callback, * Public entry points for taf_create_from_callback(). Return a taf object * constructed from either *.TAF (game) or *.TAS (saved game state) file data. */ -sc_tafref_t -taf_create(sc_read_callbackref_t callback, void *opaque) { +sc_tafref_t taf_create(sc_read_callbackref_t callback, void *opaque) { return taf_create_from_callback(callback, opaque, TRUE); } -sc_tafref_t -taf_create_tas(sc_read_callbackref_t callback, void *opaque) { +sc_tafref_t taf_create_tas(sc_read_callbackref_t callback, void *opaque) { return taf_create_from_callback(callback, opaque, FALSE); } @@ -571,8 +559,7 @@ taf_create_tas(sc_read_callbackref_t callback, void *opaque) { * * Iterator rewind function, reset current slab location to TAF data start. */ -void -taf_first_line(sc_tafref_t taf) { +void taf_first_line(sc_tafref_t taf) { assert(taf_is_valid(taf)); /* Set current locations to TAF start. */ @@ -587,8 +574,7 @@ taf_first_line(sc_tafref_t taf) { * Iterator function, return the next line of data from a TAF, or NULL * if no more lines. */ -const sc_char * -taf_next_line(sc_tafref_t taf) { +const sc_char *taf_next_line(sc_tafref_t taf) { assert(taf_is_valid(taf)); /* If there is a next line, return it and advance current. */ @@ -622,8 +608,7 @@ taf_next_line(sc_tafref_t taf) { * * Iterator end function, returns TRUE if more TAF lines are readable. */ -sc_bool -taf_more_lines(sc_tafref_t taf) { +sc_bool taf_more_lines(sc_tafref_t taf) { assert(taf_is_valid(taf)); /* Return TRUE if not at TAF data end. */ @@ -638,8 +623,7 @@ taf_more_lines(sc_tafref_t taf) { * appended to the TAF file after the game, so this value allows them to * be located. */ -sc_int -taf_get_game_data_length(sc_tafref_t taf) { +sc_int taf_get_game_data_length(sc_tafref_t taf) { assert(taf_is_valid(taf)); /* @@ -656,8 +640,7 @@ taf_get_game_data_length(sc_tafref_t taf) { * * Return the version number of the TAF file, 400, 390, or 380. */ -sc_int -taf_get_version(sc_tafref_t taf) { +sc_int taf_get_version(sc_tafref_t taf) { assert(taf_is_valid(taf)); assert(taf->version != TAF_VERSION_NONE); @@ -673,8 +656,7 @@ taf_get_version(sc_tafref_t taf) { * properties debugging, indicating if a given address is a string in a TAF * slab, and therefore safe to print. */ -sc_bool -taf_debug_is_taf_string(sc_tafref_t taf, const void *addr) { +sc_bool taf_debug_is_taf_string(sc_tafref_t taf, const void *addr) { const sc_byte *const addr_ = (const sc_byte * const)addr; sc_int index_; @@ -691,8 +673,7 @@ taf_debug_is_taf_string(sc_tafref_t taf, const void *addr) { return FALSE; } -void -taf_debug_dump(sc_tafref_t taf) { +void taf_debug_dump(sc_tafref_t taf) { sc_int index_, current_slab, current_offset; assert(taf_is_valid(taf)); diff --git a/engines/glk/adrift/sctafpar.cpp b/engines/glk/adrift/sctafpar.cpp index 9880603faf..6c2dcda2ae 100644 --- a/engines/glk/adrift/sctafpar.cpp +++ b/engines/glk/adrift/sctafpar.cpp @@ -71,10 +71,10 @@ static const sc_byte V380_SEPARATOR[SEPARATOR_SIZE] = {0x2a, 0x2a, 0x00}; * |...| - fixup specials for versions < 4 * {special} - because some things just defy description */ -typedef struct { +struct sc_parse_schema_t { const sc_char *const class_name; const sc_char *const descriptor; -} sc_parse_schema_t; +}; /* Version 4.0 TAF file properties descriptor table. */ static const sc_parse_schema_t V400_PARSE_SCHEMA[] = { @@ -455,8 +455,7 @@ static const sc_parse_schema_t V380_PARSE_SCHEMA[] = { * * Select one of the parse schemata based on a TAF file. */ -static const sc_parse_schema_t * -parse_select_schema(sc_tafref_t taf) { +static const sc_parse_schema_t *parse_select_schema(sc_tafref_t taf) { /* Switch based on the TAF file version. */ switch (taf_get_version(taf)) { case TAF_VERSION_400: @@ -499,8 +498,7 @@ static sc_int parse_depth = 0; * Push a key of the given type onto the property key stack, and pop a key * off on unwind. */ -static void -parse_push_key(sc_vartype_t vt_key, sc_char type) { +static void parse_push_key(sc_vartype_t vt_key, sc_char type) { if (parse_depth == PARSE_MAX_DEPTH) sc_fatal("parse_push_key: stack overrun\n"); @@ -510,8 +508,7 @@ parse_push_key(sc_vartype_t vt_key, sc_char type) { parse_depth++; } -static void -parse_pop_key(void) { +static void parse_pop_key(void) { /* Check the stack has something to pop, then pop it. */ if (parse_depth == 0) sc_fatal("parse_pop_key: stack underrun\n"); @@ -526,8 +523,7 @@ parse_pop_key(void) { * index. An expedient fix is to switch i-s keys before storing a property * value */ -static void -parse_retrieve_stack(sc_char format[], sc_vartype_t vt_key[], sc_int *depth) { +static void parse_retrieve_stack(sc_char format[], sc_vartype_t vt_key[], sc_int *depth) { sc_int index_; /* Switch index-string key pairs. */ @@ -560,8 +556,7 @@ parse_retrieve_stack(sc_char format[], sc_vartype_t vt_key[], sc_int *depth) { * Dump the parse stack. Used for diagnostics on finding what we think may * be a bad game. */ -static void -parse_stack_backtrace(void) { +static void parse_stack_backtrace(void) { sc_vartype_t vt_key[PARSE_MAX_DEPTH]; sc_char format[PARSE_MAX_DEPTH]; sc_int depth, index_; @@ -595,8 +590,7 @@ parse_stack_backtrace(void) { * * Write or read a property based on the keys amassed so far. */ -static void -parse_put_property(sc_vartype_t vt_value, sc_char type) { +static void parse_put_property(sc_vartype_t vt_value, sc_char type) { sc_vartype_t vt_key[PARSE_MAX_DEPTH]; sc_char format[PARSE_MAX_DEPTH + 4]; sc_int depth; @@ -615,8 +609,7 @@ parse_put_property(sc_vartype_t vt_value, sc_char type) { prop_put(parse_bundle, format, vt_value, vt_key); } -static sc_bool -parse_get_property(sc_vartype_t *vt_rvalue, sc_char type) { +static sc_bool parse_get_property(sc_vartype_t *vt_rvalue, sc_char type) { sc_vartype_t vt_key[PARSE_MAX_DEPTH]; sc_char format[PARSE_MAX_DEPTH + 4]; sc_int depth; @@ -646,8 +639,7 @@ parse_get_property(sc_vartype_t *vt_rvalue, sc_char type) { * indicating the child count of the effectively stacked node, or zero if * no such node exists. */ -static sc_int -parse_get_child_count(void) { +static sc_int parse_get_child_count(void) { sc_vartype_t vt_rvalue; if (!parse_get_property(&vt_rvalue, PROP_INTEGER)) @@ -665,8 +657,7 @@ parse_get_child_count(void) { * Convenience forms of parse_get_property(), retrieve directly, and report * a fatal error if the property does not exist. */ -static sc_int -parse_get_integer_property(void) { +static sc_int parse_get_integer_property(void) { sc_vartype_t vt_rvalue; if (!parse_get_property(&vt_rvalue, PROP_INTEGER)) @@ -675,8 +666,7 @@ parse_get_integer_property(void) { return vt_rvalue.integer; } -static sc_bool -parse_get_boolean_property(void) { +static sc_bool parse_get_boolean_property(void) { sc_vartype_t vt_rvalue; if (!parse_get_property(&vt_rvalue, PROP_BOOLEAN)) @@ -685,8 +675,7 @@ parse_get_boolean_property(void) { return vt_rvalue.boolean; } -static const sc_char * -parse_get_string_property(void) { +static const sc_char *parse_get_string_property(void) { sc_vartype_t vt_rvalue; if (!parse_get_property(&vt_rvalue, PROP_STRING)) @@ -713,8 +702,7 @@ static sc_bool parse_use_pushback = FALSE; * the line content into an integer or boolean, and a function for effective * TAF line pushback. */ -static const sc_char * -parse_get_taf_string(void) { +static const sc_char *parse_get_taf_string(void) { const sc_char *line; /* If pushback requested, use that instead of reading. */ @@ -745,8 +733,7 @@ parse_get_taf_string(void) { return line; } -static sc_int -parse_get_taf_integer(void) { +static sc_int parse_get_taf_integer(void) { const sc_char *line; sc_int integer; @@ -762,8 +749,7 @@ parse_get_taf_integer(void) { return integer; } -static sc_bool -parse_get_taf_boolean(void) { +static sc_bool parse_get_taf_boolean(void) { const sc_char *line; sc_uint boolean; @@ -786,8 +772,7 @@ parse_get_taf_boolean(void) { return boolean != 0; } -static void -parse_taf_pushback(void) { +static void parse_taf_pushback(void) { if (parse_use_pushback || !parse_pushback_line) sc_fatal("parse_taf_pushback: too much pushback requested\n"); @@ -835,8 +820,7 @@ static void parse_descriptor(const sc_char *descriptor); * * Parse a descriptor [] array. */ -static void -parse_array(const sc_char *array) { +static void parse_array(const sc_char *array) { sc_int count, index_; sc_char element[PARSE_TEMP_LENGTH]; @@ -871,8 +855,7 @@ parse_array(const sc_char *array) { * * Parse a variable-length vector of properties. */ -static void -parse_vector_common(const sc_char *vector, sc_int count) { +static void parse_vector_common(const sc_char *vector, sc_int count) { sc_int index_; /* Parse the vector property count times, pushing a key on each. */ @@ -888,8 +871,7 @@ parse_vector_common(const sc_char *vector, sc_int count) { } } -static void -parse_vector(const sc_char *vector) { +static void parse_vector(const sc_char *vector) { sc_int count; if (parse_trace) @@ -903,8 +885,7 @@ parse_vector(const sc_char *vector) { sc_trace("Parse: leaving vector %s\n", vector); } -static void -parse_vector_alternate(const sc_char *vector) { +static void parse_vector_alternate(const sc_char *vector) { sc_int count; if (parse_trace) @@ -925,8 +906,7 @@ parse_vector_alternate(const sc_char *vector) { * * Parse a conditional field definition, with runtime test. */ -static sc_bool -parse_test_expression(const sc_char *test_expression) { +static sc_bool parse_test_expression(const sc_char *test_expression) { sc_vartype_t vt_key; sc_char plhs[PARSE_TEMP_LENGTH]; sc_int rhs; @@ -985,8 +965,7 @@ parse_test_expression(const sc_char *test_expression) { return retval; } -static void -parse_expression(const sc_char *expression) { +static void parse_expression(const sc_char *expression) { sc_char test_expression[PARSE_TEMP_LENGTH]; sc_bool is_present; @@ -1034,8 +1013,7 @@ parse_expression(const sc_char *expression) { * Helper for parse_terminal(), reads in a multiline string. The return * string is malloc'ed, and the caller needs to handle that. */ -static sc_char * -parse_read_multiline(void) { +static sc_char *parse_read_multiline(void) { const sc_byte *separator = NULL; const sc_char *line; sc_char *multiline; @@ -1080,8 +1058,7 @@ parse_read_multiline(void) { * * Common handler for string, integer, boolean, and multiline parse terminals. */ -static void -parse_terminal(const sc_char *terminal) { +static void parse_terminal(const sc_char *terminal) { sc_vartype_t vt_key, vt_value; if (parse_trace) @@ -1157,12 +1134,12 @@ parse_terminal(const sc_char *terminal) { * for the various sound and graphic resources encountered on parsing * version 4.0 games. It's unused if the version is not 4.0. */ -typedef struct { +struct sc_parse_resource_t { sc_char *name; sc_uint hash; sc_int length; sc_int offset; -} sc_parse_resource_t; +}; enum { RESOURCE_GROW_INCREMENT = 32 }; static sc_int parse_resources_length = 0; @@ -1175,8 +1152,7 @@ static sc_parse_resource_t *parse_resources = NULL; * * Free and clear down the version 4.0 resources table. */ -static void -parse_clear_v400_resources_table(void) { +static void parse_clear_v400_resources_table(void) { /* Free allocated memory and return to initial values. */ if (parse_resources) { sc_int index_; @@ -1205,9 +1181,8 @@ parse_clear_v400_resources_table(void) { * lengths; this function needs to handle that. The caller needs to compare * length with real_length to see if that happened. */ -static sc_int -parse_get_v400_resource_offset(const sc_char *name, - sc_int length, sc_int *real_length) { +static sc_int parse_get_v400_resource_offset(const sc_char *name, + sc_int length, sc_int *real_length) { sc_char *clean_name; sc_uint hash; sc_int index_, offset; @@ -1290,8 +1265,7 @@ parse_get_v400_resource_offset(const sc_char *name, * 'resource number'; -(length+2) is tantalizingly close to the index into * our parse_resources table, but not always... */ -static void -parse_handle_v400_resources(sc_bool has_sound, sc_bool has_graphics) { +static void parse_handle_v400_resources(sc_bool has_sound, sc_bool has_graphics) { sc_vartype_t vt_key, vt_value; const sc_char *file; sc_int length, offset; @@ -1391,8 +1365,7 @@ parse_handle_v400_resources(sc_bool has_sound, sc_bool has_graphics) { * Handler for special items that can't be described accurately, and * therefore need careful treatment. */ -static void -parse_special(const sc_char *special) { +static void parse_special(const sc_char *special) { if (parse_trace) sc_trace("Parse: entering special %s\n", special); @@ -1617,14 +1590,9 @@ parse_special(const sc_char *special) { * Helper for parse_fixup_v390_v380_room_alts(). Handles creation of * version 4.0 room alts for version 3.9 and version 3.8 games. */ -static void -parse_fixup_v390_v380_room_alt(const sc_char *m1, sc_int type, - const sc_char *resource1, - const sc_char *m2, sc_int var2, - const sc_char *resource2, - sc_int hide_objects, - const sc_char *changed, - sc_int var3, sc_int display_room) { +static void parse_fixup_v390_v380_room_alt(const sc_char *m1, sc_int type, + const sc_char *resource1, const sc_char *m2, sc_int var2, const sc_char *resource2, + sc_int hide_objects, const sc_char *changed, sc_int var3, sc_int display_room) { sc_vartype_t vt_key, vt_value, vt_gkey[2]; sc_bool has_sound, has_graphics; sc_int alt_count; @@ -1830,8 +1798,7 @@ enum { V390_V380_ALT_TYPEHIDE_MULT = 10 }; * converts version 3.9 and version 3.8 fixed room description alts into * an equivalent array of version 4.0 style room alts. */ -static void -parse_fixup_v390_v380_room_alts(void) { +static void parse_fixup_v390_v380_room_alts(void) { sc_vartype_t vt_key; const sc_char *m1, *m2, *changed; sc_int type, var2, hide_objects, var3, display_room; @@ -1956,8 +1923,7 @@ parse_fixup_v390_v380_room_alts(void) { * Handler for fixup special items to help with conversions from TAF version * 3.9 format into version 4.0. */ -static void -parse_fixup_v390(const sc_char *fixup) { +static void parse_fixup_v390(const sc_char *fixup) { if (parse_trace) sc_trace("Parse: entering version 3.9 fixup %s\n", fixup); @@ -2106,9 +2072,8 @@ enum { V380_TASK_MOVEMENTS = 6 }; * * Helper for parse_fixup_v380(), adds a task action. */ -static void -parse_fixup_v380_action(sc_int type, sc_int var_count, - sc_int var1, sc_int var2, sc_int var3) { +static void parse_fixup_v380_action(sc_int type, sc_int var_count, + sc_int var1, sc_int var2, sc_int var3) { sc_vartype_t vt_key, vt_value; sc_int action_count; @@ -2163,8 +2128,7 @@ parse_fixup_v380_action(sc_int type, sc_int var_count, * * Helper for parse_fixup_v380(), converts a task movement into an action. */ -static void -parse_fixup_v380_movement(sc_int mvar1, sc_int mvar2, sc_int mvar3) { +static void parse_fixup_v380_movement(sc_int mvar1, sc_int mvar2, sc_int mvar3) { sc_int var1; /* If nothing was selected to move, ignore the call. */ @@ -2245,10 +2209,8 @@ parse_fixup_v380_movement(sc_int mvar1, sc_int mvar2, sc_int mvar3) { * * Helper for parse_fixup_v380(), adds a task restriction. */ -static void -parse_fixup_v380_restr(sc_int type, sc_int var_count, - sc_int var1, sc_int var2, sc_int var3, - const sc_char *failmessage) { +static void parse_fixup_v380_restr(sc_int type, sc_int var_count, + sc_int var1, sc_int var2, sc_int var3, const sc_char *failmessage) { sc_vartype_t vt_key, vt_value; sc_int restriction_count; @@ -2314,9 +2276,7 @@ parse_fixup_v380_restr(sc_int type, sc_int var_count, * * Helper handlers for parse_fixup_v380(); create task restrictions. */ -static void -parse_fixup_v380_obj_restr(sc_bool holding, - sc_int holdobj, const sc_char *failmessage) { +static void parse_fixup_v380_obj_restr(sc_bool holding, sc_int holdobj, const sc_char *failmessage) { /* Ignore if no object selected. */ if (holdobj > 0) { sc_int var1, var2; @@ -2332,9 +2292,7 @@ parse_fixup_v380_obj_restr(sc_bool holding, } } -static void -parse_fixup_v380_task_restr(sc_bool tasknotdone, sc_int task, - const sc_char *failmessage) { +static void parse_fixup_v380_task_restr(sc_bool tasknotdone, sc_int task, const sc_char *failmessage) { /* Ignore if no task selected. */ if (task > 0) { sc_int var2; @@ -2345,8 +2303,7 @@ parse_fixup_v380_task_restr(sc_bool tasknotdone, sc_int task, } } -static void -parse_fixup_v380_wear_restr(sc_int wearobj, const sc_char *failmessage) { +static void parse_fixup_v380_wear_restr(sc_int wearobj, const sc_char *failmessage) { /* Ignore if no object selected. */ if (wearobj > 0) { sc_vartype_t vt_key[3]; @@ -2403,9 +2360,8 @@ parse_fixup_v380_wear_restr(sc_int wearobj, const sc_char *failmessage) { } } -static void -parse_fixup_v380_npc_restr(sc_bool notinsameroom, sc_int npc, - const sc_char *failmessage) { +static void parse_fixup_v380_npc_restr(sc_bool notinsameroom, sc_int npc, + const sc_char *failmessage) { /* Ignore if no NPC selected. */ if (npc > 0) { sc_int var2; @@ -2423,9 +2379,7 @@ parse_fixup_v380_npc_restr(sc_bool notinsameroom, sc_int npc, } } -static void -parse_fixup_v380_objroom_restr(sc_int obj, sc_int objroom, - const sc_char *failmessage) { +static void parse_fixup_v380_objroom_restr(sc_int obj, sc_int objroom, const sc_char *failmessage) { /* Ignore if no object selected. */ if (obj > 0) { /* Create version 4.0 restriction to check object in room. */ @@ -2433,9 +2387,8 @@ parse_fixup_v380_objroom_restr(sc_int obj, sc_int objroom, } } -static void -parse_fixup_v380_objstate_restr(sc_int obj, sc_int ivar1, sc_int ivar2, - const sc_char *failmessage) { +static void parse_fixup_v380_objstate_restr(sc_int obj, sc_int ivar1, sc_int ivar2, + const sc_char *failmessage) { sc_vartype_t vt_key[3]; sc_int object, dynamic, var2, var3; @@ -2519,8 +2472,7 @@ parse_fixup_v380_objstate_restr(sc_int obj, sc_int ivar1, sc_int ivar2, * Handler for fixup special items to help with conversions from TAF version * 3.8 format into version 4.0. */ -static void -parse_fixup_v380(const sc_char *fixup) { +static void parse_fixup_v380(const sc_char *fixup) { if (parse_trace) sc_trace("Parse: entering version 3.8 fixup %s\n", fixup); @@ -3012,8 +2964,7 @@ parse_fixup_v380(const sc_char *fixup) { * Handler for fixup special items to help with conversions from TAF version * 3.9 and version 3.8 formats into version 4.0. */ -static void -parse_fixup(const sc_char *fixup) { +static void parse_fixup(const sc_char *fixup) { /* * Pick a fixup handler specific to the TAF version. This helps keep * fixup code separate, rather than glommed into one large function. @@ -3040,8 +2991,7 @@ parse_fixup(const sc_char *fixup) { * * Parse a class descriptor element. */ -static void -parse_element(const sc_char *element) { +static void parse_element(const sc_char *element) { if (parse_trace) sc_trace("Parse: entering element %s\n", element); @@ -3096,8 +3046,7 @@ parse_element(const sc_char *element) { * * Parse a class's properties descriptor list. */ -static void -parse_descriptor(const sc_char *descriptor) { +static void parse_descriptor(const sc_char *descriptor) { sc_int next; /* Find and parse each element in the descriptor. */ @@ -3123,8 +3072,7 @@ parse_descriptor(const sc_char *descriptor) { * * Parse a class of properties. */ -static void -parse_class(const sc_char *class_) { +static void parse_class(const sc_char *class_) { sc_char class_name[PARSE_TEMP_LENGTH]; sc_int index_; sc_vartype_t vt_key; @@ -3171,8 +3119,7 @@ parse_class(const sc_char *class_) { * Add a list of all NPC walks started by each task. This is post-processing * that occurs after the TAF file has been successfully parsed. */ -static void -parse_add_walkalerts(sc_prop_setref_t bundle) { +static void parse_add_walkalerts(sc_prop_setref_t bundle) { sc_vartype_t vt_key[5]; sc_int npcs_count, npc; @@ -3225,8 +3172,7 @@ parse_add_walkalerts(sc_prop_setref_t bundle) { * Add a list of move times to all NPC walks. This is post-processing that * occurs after the TAF file has been successfully parsed. */ -static void -parse_add_movetimes(sc_prop_setref_t bundle) { +static void parse_add_movetimes(sc_prop_setref_t bundle) { sc_vartype_t vt_key[6]; sc_int npcs_count, npc; @@ -3280,8 +3226,7 @@ parse_add_movetimes(sc_prop_setref_t bundle) { * Sort ALRs by original string length and store an indexer property, so * that ALR replacements look at longer strings before shorter ones. */ -static void -parse_add_alrs_index(sc_prop_setref_t bundle) { +static void parse_add_alrs_index(sc_prop_setref_t bundle) { sc_vartype_t vt_key[3]; sc_int alr_count, index_, alr; sc_int *alr_lengths, longest, shortest, length; @@ -3345,8 +3290,7 @@ parse_add_alrs_index(sc_prop_setref_t bundle) { * for version 4.0 games. For version 3.9 and version 3.8 games, write * zero; only version 4.0 games can embed their resources into the TAF file. */ -static void -parse_add_resources_offset(sc_prop_setref_t bundle, sc_tafref_t taf) { +static void parse_add_resources_offset(sc_prop_setref_t bundle, sc_tafref_t taf) { sc_vartype_t vt_key[2], vt_value; sc_bool embedded; sc_int offset; @@ -3373,8 +3317,7 @@ parse_add_resources_offset(sc_prop_setref_t bundle, sc_tafref_t taf) { * Add the TAF version to the properties, both integer and character forms * for convenience. */ -static void -parse_add_version(sc_prop_setref_t bundle, sc_tafref_t taf) { +static void parse_add_version(sc_prop_setref_t bundle, sc_tafref_t taf) { sc_vartype_t vt_key, vt_value; /* Add the version integer to the properties. */ @@ -3469,8 +3412,7 @@ sc_bool parse_game(sc_tafref_t taf, sc_prop_setref_t bundle) { * * Set parse tracing on/off. */ -void -parse_debug_trace(sc_bool flag) { +void parse_debug_trace(sc_bool flag) { parse_trace = flag; } diff --git a/engines/glk/adrift/sctasks.cpp b/engines/glk/adrift/sctasks.cpp index 8273affef6..cab6fcbb81 100644 --- a/engines/glk/adrift/sctasks.cpp +++ b/engines/glk/adrift/sctasks.cpp @@ -56,8 +56,7 @@ static sc_bool task_trace = FALSE; * Return the assorted hint text strings, and TRUE if the given task offers * hints. */ -static const sc_char * -task_get_hint_common(sc_gameref_t game, sc_int task, const sc_char *hint) { +static const sc_char *task_get_hint_common(sc_gameref_t game, sc_int task, const sc_char *hint) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; const sc_char *retval; @@ -70,23 +69,19 @@ task_get_hint_common(sc_gameref_t game, sc_int task, const sc_char *hint) { return retval; } -const sc_char * -task_get_hint_question(sc_gameref_t game, sc_int task) { +const sc_char *task_get_hint_question(sc_gameref_t game, sc_int task) { return task_get_hint_common(game, task, "Question"); } -const sc_char * -task_get_hint_subtle(sc_gameref_t game, sc_int task) { +const sc_char *task_get_hint_subtle(sc_gameref_t game, sc_int task) { return task_get_hint_common(game, task, "Hint1"); } -const sc_char * -task_get_hint_unsubtle(sc_gameref_t game, sc_int task) { +const sc_char *task_get_hint_unsubtle(sc_gameref_t game, sc_int task) { return task_get_hint_common(game, task, "Hint2"); } -sc_bool -task_has_hints(sc_gameref_t game, sc_int task) { +sc_bool task_has_hints(sc_gameref_t game, sc_int task) { /* A non-empty question implies hints available. */ return !sc_strempty(task_get_hint_question(game, task)); } @@ -98,9 +93,7 @@ task_has_hints(sc_gameref_t game, sc_int task) { * Return TRUE if player is in a room where the task can be run and the task * is runnable in the given direction. */ -sc_bool -task_can_run_task_directional(sc_gameref_t game, - sc_int task, sc_bool forwards) { +sc_bool task_can_run_task_directional(sc_gameref_t game, sc_int task, sc_bool forwards) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int type; @@ -169,8 +162,7 @@ task_can_run_task_directional(sc_gameref_t game, * * Returns TRUE if the task can be run in either direction. */ -sc_bool -task_can_run_task(sc_gameref_t game, sc_int task) { +sc_bool task_can_run_task(sc_gameref_t game, sc_int task) { /* * Testing reversible tasks first may be a little more efficient if they * aren't common in games. There is, though, probably a little bit of @@ -186,8 +178,7 @@ task_can_run_task(sc_gameref_t game, sc_int task) { * * Move an object to a place. */ -static void -task_move_object(sc_gameref_t game, sc_int object, sc_int var2, sc_int var3) { +static void task_move_object(sc_gameref_t game, sc_int object, sc_int var2, sc_int var3) { const sc_var_setref_t vars = gs_get_vars(game); /* Select action depending on var2. */ @@ -291,9 +282,7 @@ task_move_object(sc_gameref_t game, sc_int object, sc_int var2, sc_int var3) { * * Demultiplex an object move action and execute it. */ -static void -task_run_move_object_action(sc_gameref_t game, - sc_int var1, sc_int var2, sc_int var3) { +static void task_run_move_object_action(sc_gameref_t game, sc_int var1, sc_int var2, sc_int var3) { const sc_var_setref_t vars = gs_get_vars(game); sc_int object; @@ -331,8 +320,7 @@ task_run_move_object_action(sc_gameref_t game, * * Move an NPC to a given room. */ -static void -task_move_npc_to_room(sc_gameref_t game, sc_int npc, sc_int room) { +static void task_move_npc_to_room(sc_gameref_t game, sc_int npc, sc_int room) { if (task_trace) sc_trace("Task: moving NPC %ld to room %ld\n", npc, room); @@ -354,9 +342,7 @@ task_move_npc_to_room(sc_gameref_t game, sc_int npc, sc_int room) { * * Move player or NPC. */ -static void -task_run_move_npc_action(sc_gameref_t game, - sc_int var1, sc_int var2, sc_int var3) { +static void task_run_move_npc_action(sc_gameref_t game, sc_int var1, sc_int var2, sc_int var3) { const sc_var_setref_t vars = gs_get_vars(game); sc_int npc, room, ref_npc = -1; @@ -506,8 +492,7 @@ task_run_move_npc_action(sc_gameref_t game, * * Change the status of an object. */ -static void -task_run_change_object_status(sc_gameref_t game, sc_int var1, sc_int var2) { +static void task_run_change_object_status(sc_gameref_t game, sc_int var1, sc_int var2) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_int object, openable, lockable; @@ -560,10 +545,8 @@ task_run_change_object_status(sc_gameref_t game, sc_int var1, sc_int var2) { * * Change a variable's value in inscrutable ways. */ -static void -task_run_change_variable_action(sc_gameref_t game, - sc_int var1, sc_int var2, sc_int var3, - const sc_char *expr, sc_int var5) { +static void task_run_change_variable_action(sc_gameref_t game, + sc_int var1, sc_int var2, sc_int var3, const sc_char *expr, sc_int var5) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); @@ -714,8 +697,7 @@ task_run_change_variable_action(sc_gameref_t game, * * Change game score. */ -static void -task_run_change_score_action(sc_gameref_t game, sc_int task, sc_int var1) { +static void task_run_change_score_action(sc_gameref_t game, sc_int task, sc_int var1) { const sc_prop_setref_t bundle = gs_get_bundle(game); /* Increasing or decreasing the score? */ @@ -773,8 +755,7 @@ task_run_change_score_action(sc_gameref_t game, sc_int task, sc_int var1) { * * Redirect to another task. */ -static sc_bool -task_run_set_task_action(sc_gameref_t game, sc_int var1, sc_int var2) { +static sc_bool task_run_set_task_action(sc_gameref_t game, sc_int var1, sc_int var2) { sc_bool status = FALSE; /* Select based on var1. */ @@ -805,8 +786,7 @@ task_run_set_task_action(sc_gameref_t game, sc_int var1, sc_int var2) { * * End of game task action. */ -static sc_bool -task_run_end_game_action(sc_gameref_t game, sc_int var1) { +static sc_bool task_run_end_game_action(sc_gameref_t game, sc_int var1) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_bool status = FALSE; @@ -868,8 +848,7 @@ task_run_end_game_action(sc_gameref_t game, sc_int var1) { * * Demultiplexer for task actions. */ -static sc_bool -task_run_task_action(sc_gameref_t game, sc_int task, sc_int action) { +static sc_bool task_run_task_action(sc_gameref_t game, sc_int task, sc_int action) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[5]; sc_int type, var1, var2, var3, var5; @@ -966,8 +945,7 @@ task_run_task_action(sc_gameref_t game, sc_int task, sc_int action) { * game, return immediately. Returns TRUE if any action ran and itself * returned TRUE. */ -static sc_bool -task_run_task_actions(sc_gameref_t game, sc_int task) { +static sc_bool task_run_task_actions(sc_gameref_t game, sc_int task) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -1031,8 +1009,7 @@ task_run_task_actions(sc_gameref_t game, sc_int task) { * * Start NPC walks based on alerts. */ -static void -task_start_npc_walks(sc_gameref_t game, sc_int task) { +static void task_start_npc_walks(sc_gameref_t game, sc_int task) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; sc_int alert_count, alert; @@ -1064,8 +1041,7 @@ task_start_npc_walks(sc_gameref_t game, sc_int task) { * outputting a message describing what prevented it, or why it couldn't be * done. */ -static sc_bool -task_run_task_unrestricted(sc_gameref_t game, sc_int task, sc_bool forwards) { +static sc_bool task_run_task_unrestricted(sc_gameref_t game, sc_int task, sc_bool forwards) { const sc_filterref_t filter = gs_get_filter(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -1221,8 +1197,7 @@ task_run_task_unrestricted(sc_gameref_t game, sc_int task, sc_bool forwards) { * task with an error message if we seem to be in one. Checked by counting * the call depth. */ -sc_bool -task_run_task(sc_gameref_t game, sc_int task, sc_bool forwards) { +sc_bool task_run_task(sc_gameref_t game, sc_int task, sc_bool forwards) { static sc_int recursion_depth = 0; const sc_filterref_t filter = gs_get_filter(game); @@ -1288,8 +1263,7 @@ task_run_task(sc_gameref_t game, sc_int task, sc_bool forwards) { * * Set task tracing on/off. */ -void -task_debug_trace(sc_bool flag) { +void task_debug_trace(sc_bool flag) { task_trace = flag; } diff --git a/engines/glk/adrift/scutils.cpp b/engines/glk/adrift/scutils.cpp index 97db91dbb8..0c8165d581 100644 --- a/engines/glk/adrift/scutils.cpp +++ b/engines/glk/adrift/scutils.cpp @@ -93,8 +93,7 @@ static void *sc_zero_allocation = &sc_zero_allocation; * cleared to zero. In ANSI/ISO C, zero byte allocations are implementation- * defined, so we have to take special care to get predictable behavior. */ -void * -sc_malloc(size_t size) { +void *sc_malloc(size_t size) { void *allocated; if (size == 0) @@ -110,8 +109,7 @@ sc_malloc(size_t size) { return allocated; } -void * -sc_realloc(void *pointer, size_t size) { +void *sc_realloc(void *pointer, size_t size) { void *allocated; if (size == 0) { @@ -133,8 +131,7 @@ sc_realloc(void *pointer, size_t size) { return allocated; } -void -sc_free(void *pointer) { +void sc_free(void *pointer) { if (sc_zero_allocation != &sc_zero_allocation) sc_fatal("sc_free: write to zero-byte allocation address detected\n"); @@ -150,8 +147,7 @@ sc_free(void *pointer) { * Strncasecmp and strcasecmp are not ANSI functions, so here are local * definitions to do the same jobs. */ -sc_int -sc_strncasecmp(const sc_char *s1, const sc_char *s2, sc_int n) { +sc_int sc_strncasecmp(const sc_char *s1, const sc_char *s2, sc_int n) { sc_int index_; assert(s1 && s2); @@ -166,8 +162,7 @@ sc_strncasecmp(const sc_char *s1, const sc_char *s2, sc_int n) { return 0; } -sc_int -sc_strcasecmp(const sc_char *s1, const sc_char *s2) { +sc_int sc_strcasecmp(const sc_char *s1, const sc_char *s2) { sc_int s1len, s2len, result; assert(s1 && s2); @@ -194,8 +189,7 @@ sc_strcasecmp(const sc_char *s1, const sc_char *s2) { * to return the same sequence for all platforms. The default is the first, * with the latter intended for predictability of game actions. */ -static sc_int -sc_platform_rand(sc_uint new_seed) { +static sc_int sc_platform_rand(sc_uint new_seed) { static sc_bool is_seeded = FALSE; /* If reseeding, seed with the value supplied, note seeded, and return 0. */ @@ -215,8 +209,7 @@ sc_platform_rand(sc_uint new_seed) { } } -static sc_int -sc_congruential_rand(sc_uint new_seed) { +static sc_int sc_congruential_rand(sc_uint new_seed) { static sc_bool is_seeded = FALSE; static sc_uint rand_state = 1; @@ -263,29 +256,24 @@ static sc_int(*sc_rand_function)(sc_uint) = sc_platform_rand; * handler in use, generate a random number, and a convenience function to * generate a random value within a given range. */ -void -sc_set_congruential_random(void) { +void sc_set_congruential_random(void) { sc_rand_function = sc_congruential_rand; } -void -sc_set_platform_random(void) { +void sc_set_platform_random(void) { sc_rand_function = sc_platform_rand; } -sc_bool -sc_is_congruential_random(void) { +sc_bool sc_is_congruential_random(void) { return sc_rand_function == sc_congruential_rand; } -void -sc_seed_random(sc_uint new_seed) { +void sc_seed_random(sc_uint new_seed) { /* Ignore zero values of new_seed by simply using 1 instead. */ sc_rand_function(new_seed > 0 ? new_seed : 1); } -sc_int -sc_rand(void) { +sc_int sc_rand(void) { sc_int retval; /* Passing zero indicates this is not a seed operation. */ @@ -293,8 +281,7 @@ sc_rand(void) { return retval; } -sc_int -sc_randomint(sc_int low, sc_int high) { +sc_int sc_randomint(sc_int low, sc_int high) { /* * If the range is invalid, just return the low value given. This mimics * Adrift under the same conditions, and also guards against division by @@ -313,8 +300,7 @@ static const sc_char SPACE = ' '; * * Return TRUE if a string is either zero-length or contains only whitespace. */ -sc_bool -sc_strempty(const sc_char *string) { +sc_bool sc_strempty(const sc_char *string) { sc_int index_; assert(string); @@ -335,8 +321,7 @@ sc_strempty(const sc_char *string) { * Trim leading and trailing whitespace from a string. Modifies the string * in place, and returns the string address for convenience. */ -sc_char * -sc_trim_string(sc_char *string) { +sc_char *sc_trim_string(sc_char *string) { sc_int index_; assert(string); @@ -359,8 +344,7 @@ sc_trim_string(sc_char *string) { * Modifies the string in place, and returns the string address for * convenience. */ -sc_char * -sc_normalize_string(sc_char *string) { +sc_char *sc_normalize_string(sc_char *string) { sc_int index_; assert(string); @@ -389,8 +373,7 @@ sc_normalize_string(sc_char *string) { * * Return TRUE if the first word in the string is word, case insensitive. */ -sc_bool -sc_compare_word(const sc_char *string, const sc_char *word, sc_int length) { +sc_bool sc_compare_word(const sc_char *string, const sc_char *word, sc_int length) { assert(string && word); /* Return TRUE if string starts with word, then space or string end. */ @@ -405,8 +388,7 @@ sc_compare_word(const sc_char *string, const sc_char *word, sc_int length) { * Hash a string, hashpjw algorithm, from 'Compilers, principles, techniques, * and tools', page 436, unmodulo'ed and somewhat restyled. */ -sc_uint -sc_hash(const sc_char *string) { +sc_uint sc_hash(const sc_char *string) { sc_int index_; sc_uint hash; assert(string); diff --git a/engines/glk/adrift/scvars.cpp b/engines/glk/adrift/scvars.cpp index 65957e1c6e..f9203fb384 100644 --- a/engines/glk/adrift/scvars.cpp +++ b/engines/glk/adrift/scvars.cpp @@ -57,13 +57,14 @@ static const sc_char *const VAR_NUMBERS[VAR_NUMBERS_SIZE] = { }; /* Variable entry, held on a list hashed by variable name. */ -typedef struct sc_var_s { +struct sc_var_s { struct sc_var_s *next; const sc_char *name; sc_int type; sc_vartype_t value; -} sc_var_t; +}; +typedef sc_var_s sc_var_t; typedef sc_var_t *sc_varref_t; /* @@ -73,7 +74,7 @@ typedef sc_var_t *sc_varref_t; * exceed a fill factor of two (~422 variables). */ enum { VAR_HASH_TABLE_SIZE = 211 }; -typedef struct sc_var_set_s { +struct sc_var_set_s { sc_uint magic; sc_prop_setref_t bundle; sc_int referenced_character; @@ -86,7 +87,8 @@ typedef struct sc_var_set_s { sc_uint time_offset; sc_gameref_t game; sc_varref_t variable[VAR_HASH_TABLE_SIZE]; -} sc_var_set_t; +}; +typedef sc_var_set_s sc_var_set_t; /* @@ -94,8 +96,7 @@ typedef struct sc_var_set_s { * * Return TRUE if pointer is a valid variables set, FALSE otherwise. */ -static sc_bool -var_is_valid(sc_var_setref_t vars) { +static sc_bool var_is_valid(sc_var_setref_t vars) { return vars && vars->magic == VARS_MAGIC; } @@ -105,8 +106,7 @@ var_is_valid(sc_var_setref_t vars) { * * Hash a variable name, modulo'ed to the number of buckets. */ -static sc_uint -var_hash_name(const sc_char *name) { +static sc_uint var_hash_name(const sc_char *name) { return sc_hash(name) % VAR_HASH_TABLE_SIZE; } @@ -116,8 +116,7 @@ var_hash_name(const sc_char *name) { * * Create and return a new empty set of variables. */ -static sc_var_setref_t -var_create_empty(void) { +static sc_var_setref_t var_create_empty(void) { sc_var_setref_t vars; sc_int index_; @@ -148,8 +147,7 @@ var_create_empty(void) { * * Destroy a variable set, and free its heap memory. */ -void -var_destroy(sc_var_setref_t vars) { +void var_destroy(sc_var_setref_t vars) { sc_int index_; assert(var_is_valid(vars)); @@ -185,8 +183,7 @@ var_destroy(sc_var_setref_t vars) { * Find and return a pointer to a named variable structure, or nullptr if no such * variable exists, and add a new variable structure to the lists. */ -static sc_varref_t -var_find(sc_var_setref_t vars, const sc_char *name) { +static sc_varref_t var_find(sc_var_setref_t vars, const sc_char *name) { sc_uint hash; sc_varref_t var; @@ -201,8 +198,7 @@ var_find(sc_var_setref_t vars, const sc_char *name) { return var; } -static sc_varref_t -var_add(sc_var_setref_t vars, const sc_char *name, sc_int type) { +static sc_varref_t var_add(sc_var_setref_t vars, const sc_char *name, sc_int type) { sc_varref_t var; sc_uint hash; @@ -227,8 +223,7 @@ var_add(sc_var_setref_t vars, const sc_char *name, sc_int type) { * Return the value of %scare_version%. Used to generate the system version * of this variable, and to re-initialize user versions initialized to zero. */ -static sc_int -var_get_scare_version(void) { +static sc_int var_get_scare_version(void) { sc_int major, minor, point, version; if (sscanf(SCARE_VERSION, "%ld.%ld.%ld", &major, &minor, &point) != 3) { @@ -247,9 +242,7 @@ var_get_scare_version(void) { * Store a variable type in a named variable. If not present, the variable * is created. Type is one of 'I' or 'S' for integer or string. */ -void -var_put(sc_var_setref_t vars, - const sc_char *name, sc_int type, sc_vartype_t vt_value) { +void var_put(sc_var_setref_t vars, const sc_char *name, sc_int type, sc_vartype_t vt_value) { sc_varref_t var; sc_bool is_modification; assert(var_is_valid(vars)); @@ -350,8 +343,7 @@ var_put(sc_var_setref_t vars, * Helper for object listers. Extends temporary, and appends the given text * to the string. */ -static void -var_append_temp(sc_var_setref_t vars, const sc_char *string) { +static void var_append_temp(sc_var_setref_t vars, const sc_char *string) { sc_bool new_sentence; sc_int noted; @@ -383,8 +375,7 @@ var_append_temp(sc_var_setref_t vars, const sc_char *string) { * Convenience functions to append an object's name, with and without any * prefix, to variables temporary. */ -static void -var_print_object_np(sc_gameref_t game, sc_int object) { +static void var_print_object_np(sc_gameref_t game, sc_int object) { const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -440,8 +431,7 @@ var_print_object_np(sc_gameref_t game, sc_int object) { var_append_temp(vars, name); } -static void -var_print_object(sc_gameref_t game, sc_int object) { +static void var_print_object(sc_gameref_t game, sc_int object) { const sc_var_setref_t vars = gs_get_vars(game); const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; @@ -474,9 +464,8 @@ var_print_object(sc_gameref_t game, sc_int object) { * Convenience function for listers. Selects one of two responses depending * on whether an object appears singular or plural. */ -static const sc_char * -var_select_plurality(sc_gameref_t game, sc_int object, - const sc_char *singular, const sc_char *plural) { +static const sc_char *var_select_plurality(sc_gameref_t game, sc_int object, + const sc_char *singular, const sc_char *plural) { return obj_appears_plural(game, object) ? plural : singular; } @@ -486,8 +475,7 @@ var_select_plurality(sc_gameref_t game, sc_int object, * * List the objects in a given container object. */ -static void -var_list_in_object(sc_gameref_t game, sc_int container) { +static void var_list_in_object(sc_gameref_t game, sc_int container) { const sc_var_setref_t vars = gs_get_vars(game); sc_int object, count, trail; @@ -535,8 +523,7 @@ var_list_in_object(sc_gameref_t game, sc_int container) { * * List the objects on a given surface object. */ -static void -var_list_on_object(sc_gameref_t game, sc_int supporter) { +static void var_list_on_object(sc_gameref_t game, sc_int supporter) { const sc_var_setref_t vars = gs_get_vars(game); sc_int object, count, trail; @@ -583,8 +570,7 @@ var_list_on_object(sc_gameref_t game, sc_int supporter) { * * List the objects on and in a given associate object. */ -static void -var_list_onin_object(sc_gameref_t game, sc_int associate) { +static void var_list_onin_object(sc_gameref_t game, sc_int associate) { const sc_var_setref_t vars = gs_get_vars(game); sc_int object, count, trail; sc_bool supporting; @@ -685,15 +671,13 @@ var_list_onin_object(sc_gameref_t game, sc_int associate) { * a bit easier. Set appropriate values for return type and the relevant * return value field, and always return TRUE. A macro was tempting here... */ -static sc_bool -var_return_integer(sc_int value, sc_int *type, sc_vartype_t *vt_rvalue) { +static sc_bool var_return_integer(sc_int value, sc_int *type, sc_vartype_t *vt_rvalue) { *type = VAR_INTEGER; vt_rvalue->integer = value; return TRUE; } -static sc_bool -var_return_string(const sc_char *value, sc_int *type, sc_vartype_t *vt_rvalue) { +static sc_bool var_return_string(const sc_char *value, sc_int *type, sc_vartype_t *vt_rvalue) { *type = VAR_STRING; vt_rvalue->string = value; return TRUE; @@ -706,9 +690,8 @@ var_return_string(const sc_char *value, sc_int *type, sc_vartype_t *vt_rvalue) { * Construct a system variable, and return its type and value, or FALSE * if invalid name passed in. Uses var_return_*() to reduce code untidiness. */ -static sc_bool -var_get_system(sc_var_setref_t vars, - const sc_char *name, sc_int *type, sc_vartype_t *vt_rvalue) { +static sc_bool var_get_system(sc_var_setref_t vars, const sc_char *name, + sc_int *type, sc_vartype_t *vt_rvalue) { const sc_prop_setref_t bundle = vars->bundle; const sc_gameref_t game = vars->game; @@ -1324,9 +1307,8 @@ var_get_system(sc_var_setref_t vars, * Retrieve a user variable, and return its type and value, or FALSE if the * name passed in is not a defined user variable. */ -static sc_bool -var_get_user(sc_var_setref_t vars, - const sc_char *name, sc_int *type, sc_vartype_t *vt_rvalue) { +static sc_bool var_get_user(sc_var_setref_t vars, const sc_char *name, + sc_int *type, sc_vartype_t *vt_rvalue) { sc_varref_t var; /* Check user variables for a reference to the named variable. */ @@ -1360,9 +1342,7 @@ var_get_user(sc_var_setref_t vars, * Retrieve a variable, and return its value and type. Returns FALSE if the * named variable does not exist. */ -sc_bool -var_get(sc_var_setref_t vars, - const sc_char *name, sc_int *type, sc_vartype_t *vt_rvalue) { +sc_bool var_get(sc_var_setref_t vars, const sc_char *name, sc_int *type, sc_vartype_t *vt_rvalue) { sc_bool status; assert(var_is_valid(vars)); assert(name && type && vt_rvalue); @@ -1407,8 +1387,7 @@ var_get(sc_var_setref_t vars, * Convenience functions to store and retrieve an integer variable. It is * an error for the variable not to exist or to have the wrong type. */ -void -var_put_integer(sc_var_setref_t vars, const sc_char *name, sc_int value) { +void var_put_integer(sc_var_setref_t vars, const sc_char *name, sc_int value) { sc_vartype_t vt_value; assert(var_is_valid(vars)); @@ -1416,8 +1395,7 @@ var_put_integer(sc_var_setref_t vars, const sc_char *name, sc_int value) { var_put(vars, name, VAR_INTEGER, vt_value); } -sc_int -var_get_integer(sc_var_setref_t vars, const sc_char *name) { +sc_int var_get_integer(sc_var_setref_t vars, const sc_char *name) { sc_vartype_t vt_rvalue; sc_int type; assert(var_is_valid(vars)); @@ -1438,9 +1416,7 @@ var_get_integer(sc_var_setref_t vars, const sc_char *name) { * Convenience functions to store and retrieve a string variable. It is * an error for the variable not to exist or to have the wrong type. */ -void -var_put_string(sc_var_setref_t vars, - const sc_char *name, const sc_char *string) { +void var_put_string(sc_var_setref_t vars, const sc_char *name, const sc_char *string) { sc_vartype_t vt_value; assert(var_is_valid(vars)); @@ -1448,8 +1424,7 @@ var_put_string(sc_var_setref_t vars, var_put(vars, name, VAR_STRING, vt_value); } -const sc_char * -var_get_string(sc_var_setref_t vars, const sc_char *name) { +const sc_char *var_get_string(sc_var_setref_t vars, const sc_char *name) { sc_vartype_t vt_rvalue; sc_int type; assert(var_is_valid(vars)); @@ -1469,8 +1444,7 @@ var_get_string(sc_var_setref_t vars, const sc_char *name) { * Create and return a new set of variables. Variables are created from the * properties bundle passed in. */ -sc_var_setref_t -var_create(sc_prop_setref_t bundle) { +sc_var_setref_t var_create(sc_prop_setref_t bundle) { sc_var_setref_t vars; sc_int var_count, index_; sc_vartype_t vt_key[3]; @@ -1534,8 +1508,7 @@ var_create(sc_prop_setref_t bundle) { * system variables. To ensure integrity, the game being registered must * reference this variable set. */ -void -var_register_game(sc_var_setref_t vars, sc_gameref_t game) { +void var_register_game(sc_var_setref_t vars, sc_gameref_t game) { assert(var_is_valid(vars)); assert(gs_is_game_valid(game)); @@ -1554,27 +1527,23 @@ var_register_game(sc_var_setref_t vars, sc_gameref_t game) { * * Set the "referenced" character, object, number, and text. */ -void -var_set_ref_character(sc_var_setref_t vars, sc_int character) { +void var_set_ref_character(sc_var_setref_t vars, sc_int character) { assert(var_is_valid(vars)); vars->referenced_character = character; } -void -var_set_ref_object(sc_var_setref_t vars, sc_int object) { +void var_set_ref_object(sc_var_setref_t vars, sc_int object) { assert(var_is_valid(vars)); vars->referenced_object = object; } -void -var_set_ref_number(sc_var_setref_t vars, sc_int number) { +void var_set_ref_number(sc_var_setref_t vars, sc_int number) { assert(var_is_valid(vars)); vars->referenced_number = number; vars->is_number_referenced = TRUE; } -void -var_set_ref_text(sc_var_setref_t vars, const sc_char *text) { +void var_set_ref_text(sc_var_setref_t vars, const sc_char *text) { assert(var_is_valid(vars)); /* Take a copy of the string, and retain it. */ @@ -1591,26 +1560,22 @@ var_set_ref_text(sc_var_setref_t vars, const sc_char *text) { * * Get the "referenced" character, object, number, and text. */ -sc_int -var_get_ref_character(sc_var_setref_t vars) { +sc_int var_get_ref_character(sc_var_setref_t vars) { assert(var_is_valid(vars)); return vars->referenced_character; } -sc_int -var_get_ref_object(sc_var_setref_t vars) { +sc_int var_get_ref_object(sc_var_setref_t vars) { assert(var_is_valid(vars)); return vars->referenced_object; } -sc_int -var_get_ref_number(sc_var_setref_t vars) { +sc_int var_get_ref_number(sc_var_setref_t vars) { assert(var_is_valid(vars)); return vars->referenced_number; } -const sc_char * -var_get_ref_text(sc_var_setref_t vars) { +const sc_char *var_get_ref_text(sc_var_setref_t vars) { assert(var_is_valid(vars)); /* @@ -1629,8 +1594,7 @@ var_get_ref_text(sc_var_setref_t vars) { * Get a count of seconds elapsed since the variables were created (start * of game), and set the count to a given value (game restore). */ -sc_uint -var_get_elapsed_seconds(sc_var_setref_t vars) { +sc_uint var_get_elapsed_seconds(sc_var_setref_t vars) { double delta; assert(var_is_valid(vars)); @@ -1638,8 +1602,7 @@ var_get_elapsed_seconds(sc_var_setref_t vars) { return (sc_uint) delta + vars->time_offset; } -void -var_set_elapsed_seconds(sc_var_setref_t vars, sc_uint seconds) { +void var_set_elapsed_seconds(sc_var_setref_t vars, sc_uint seconds) { assert(var_is_valid(vars)); /* @@ -1657,8 +1620,7 @@ var_set_elapsed_seconds(sc_var_setref_t vars, sc_uint seconds) { * * Set variable tracing on/off. */ -void -var_debug_trace(sc_bool flag) { +void var_debug_trace(sc_bool flag) { var_trace = flag; } @@ -1668,8 +1630,7 @@ var_debug_trace(sc_bool flag) { * * Print out a complete variables set. */ -void -var_debug_dump(sc_var_setref_t vars) { +void var_debug_dump(sc_var_setref_t vars) { sc_int index_; sc_varref_t var; assert(var_is_valid(vars)); diff --git a/engines/glk/adrift/sxfile.cpp b/engines/glk/adrift/sxfile.cpp index 4b91db9687..f5df4008d8 100644 --- a/engines/glk/adrift/sxfile.cpp +++ b/engines/glk/adrift/sxfile.cpp @@ -80,8 +80,7 @@ void *file_open_file_callback(sc_bool is_save) { return stream; } -sc_int -file_read_file_callback(void *opaque, sc_byte *buffer, sc_int length) { +sc_int file_read_file_callback(void *opaque, sc_byte *buffer, sc_int length) { sx_scr_stream_t *const stream = (sx_scr_stream_t *)opaque; sc_int bytes; assert(opaque && buffer && length > 0); @@ -106,8 +105,7 @@ file_read_file_callback(void *opaque, sc_byte *buffer, sc_int length) { return bytes; } -void -file_write_file_callback(void *opaque, const sc_byte *buffer, sc_int length) { +void file_write_file_callback(void *opaque, const sc_byte *buffer, sc_int length) { sx_scr_stream_t *const stream = (sx_scr_stream_t *)opaque; assert(opaque && buffer && length > 0); @@ -129,8 +127,7 @@ file_write_file_callback(void *opaque, const sc_byte *buffer, sc_int length) { stream->length += length; } -void -file_close_file_callback(void *opaque) { +void file_close_file_callback(void *opaque) { sx_scr_stream_t *const stream = (sx_scr_stream_t *)opaque; assert(opaque); @@ -162,8 +159,7 @@ file_close_file_callback(void *opaque) { * * Free any pending allocations and clean up on completion of a script. */ -void -file_cleanup(void) { +void file_cleanup(void) { sx_scr_stream_t *const stream = &scr_serialization_stream; sx_free(stream->data); diff --git a/engines/glk/adrift/sxglob.cpp b/engines/glk/adrift/sxglob.cpp index c6133aa458..f57eed7df2 100644 --- a/engines/glk/adrift/sxglob.cpp +++ b/engines/glk/adrift/sxglob.cpp @@ -66,9 +66,7 @@ namespace Adrift { * Match a "[...]" character range, and match general glob wildcards. See * above for notes on where these functions came from originally. */ -static int -glob_inrange_unsigned(const unsigned char **const pattern, - unsigned char ch) { +static int glob_inrange_unsigned(const unsigned char **const pattern, unsigned char ch) { const unsigned char *const pattern_ = *pattern; int in_range = FALSE; unsigned int l = 256, r = 0, index_; @@ -116,9 +114,7 @@ glob_inrange_unsigned(const unsigned char **const pattern, return in_range; } -static int -glob_match_unsigned(const unsigned char *pattern, - const unsigned char *string) { +static int glob_match_unsigned(const unsigned char *pattern, const unsigned char *string) { int is_match = FALSE; if (!*string) { @@ -161,10 +157,10 @@ glob_match_unsigned(const unsigned char *pattern, /* Structures and data for the self test function. */ -typedef struct { +struct sx_test_data_t { const sc_char *const pattern; const sc_char *const string; -} sx_test_data_t; +}; static const sx_test_data_t SHOULD_MATCH[] = { {"a", "a"}, {"abc", "abc"}, {"", ""}, @@ -226,8 +222,7 @@ static const sx_test_data_t SHOULD_NOT_MATCH[] = { * * Sed quis custodiet ipsos custodes? */ -static void -glob_self_test(void) { +static void glob_self_test(void) { const sx_test_data_t *test; sc_int errors; @@ -271,8 +266,7 @@ glob_self_test(void) { * Adapter for the above globbing functions, presenting a more standard char- * based interface. Here is where all the evil casting lives. */ -sc_bool -glob_match(const sc_char *pattern, const sc_char *string) { +sc_bool glob_match(const sc_char *pattern, const sc_char *string) { static sc_bool initialized = FALSE; const unsigned char *pattern_ = (const unsigned char *) pattern; diff --git a/engines/glk/adrift/sxscript.cpp b/engines/glk/adrift/sxscript.cpp index 33c0501a3c..566aa3485f 100644 --- a/engines/glk/adrift/sxscript.cpp +++ b/engines/glk/adrift/sxscript.cpp @@ -75,8 +75,7 @@ static sc_char *scr_game_output = NULL; * * Set error reporting for expectation errors detected in the script. */ -void -scr_set_verbose(sc_bool flag) { +void scr_set_verbose(sc_bool flag) { scr_is_verbose = flag; } @@ -88,8 +87,7 @@ scr_set_verbose(sc_bool flag) { * Simple common message and test case failure handling functions. The second * is used by the serialization helper, so is not static. */ -static void -scr_test_message(const sc_char *format, const sc_char *string) { +static void scr_test_message(const sc_char *format, const sc_char *string) { if (scr_is_verbose) { sx_trace("--- "); sx_trace(format, string); @@ -97,8 +95,7 @@ scr_test_message(const sc_char *format, const sc_char *string) { } } -void -scr_test_failed(const sc_char *format, const sc_char *string) { +void scr_test_failed(const sc_char *format, const sc_char *string) { assert(format && string); if (scr_is_verbose) { @@ -123,34 +120,28 @@ scr_test_failed(const sc_char *format, const sc_char *string) { * * Line classifiers, return TRUE if line has the given type. */ -static sc_bool -scr_is_line_type(const sc_char *line, sc_char type) { +static sc_bool scr_is_line_type(const sc_char *line, sc_char type) { return line[0] == type; } -static sc_bool -scr_is_line_comment_or_empty(const sc_char *line) { +static sc_bool scr_is_line_comment_or_empty(const sc_char *line) { return scr_is_line_type(line, SCRIPT_COMMENT) || strspn(line, "\t\n\v\f\r ") == strlen(line); } -static sc_bool -scr_is_line_game_command(const sc_char *line) { +static sc_bool scr_is_line_game_command(const sc_char *line) { return scr_is_line_type(line, GAME_COMMAND); } -static sc_bool -scr_is_line_debug_command(const sc_char *line) { +static sc_bool scr_is_line_debug_command(const sc_char *line) { return scr_is_line_type(line, DEBUG_COMMAND); } -static sc_bool -scr_is_line_command(const sc_char *line) { +static sc_bool scr_is_line_command(const sc_char *line) { return scr_is_line_game_command(line) || scr_is_line_debug_command(line); } -static sc_bool -scr_is_line_empty_debug_command(const sc_char *line) { +static sc_bool scr_is_line_empty_debug_command(const sc_char *line) { return scr_is_line_type(line, DEBUG_COMMAND) && line[1] == NUL; } @@ -168,8 +159,7 @@ typedef sx_scr_location_t *sx_scr_locationref_t; * * Save and restore the script location in the given structure. */ -static void -scr_save_location(sx_script script, sx_scr_locationref_t location) { +static void scr_save_location(sx_script script, sx_scr_locationref_t location) { location->position = script->pos(); location->line_number = scr_line_number; } @@ -217,8 +207,7 @@ static sc_char *scr_get_next_line(sx_script script) { * the second argument to the first. If the first is NULL, acts as strdup() * instead. */ -static sc_char * -scr_concatenate(sc_char *string, const sc_char *buffer) { +static sc_char *scr_concatenate(sc_char *string, const sc_char *buffer) { /* If string is not null, concatenate buffer, otherwise duplicate. */ if (string) { string = (sc_char *)sx_realloc(string, @@ -243,9 +232,7 @@ scr_concatenate(sc_char *string, const sc_char *buffer) { * returned). Command and expectation are allocated, and the caller needs to * free them. */ -static sc_bool -scr_get_next_section(sx_script script, - sc_char **command, sc_char **expectation) { +static sc_bool scr_get_next_section(sx_script script, sc_char **command, sc_char **expectation) { sc_char *line, *first_line, *other_lines; sx_scr_location_t location; @@ -308,8 +295,7 @@ scr_get_next_section(sx_script script, * error if required. It then frees both the expectation and accumulated * input. */ -static void -scr_expect(sc_char *expectation) { +static void scr_expect(sc_char *expectation) { /* * Save the expectation, and set up collection of game output if needed. * And if not needed, ensure expectation and game output are cleared. @@ -327,8 +313,7 @@ scr_expect(sc_char *expectation) { } } -static void -scr_verify_expectation(void) { +static void scr_verify_expectation(void) { /* Compare expected with actual, and handle any error detected. */ if (scr_expectation && scr_game_output) { scr_game_output = sx_normalize_string(scr_game_output); @@ -357,8 +342,7 @@ scr_verify_expectation(void) { * Also, it turns on the game debugger, and it's the caller's responsibility * to turn it off when it's no longer needed. */ -static void -scr_execute_debugger_command(const sc_char *command, sc_char *expectation) { +static void scr_execute_debugger_command(const sc_char *command, sc_char *expectation) { sc_bool status; /* Set up the expectation. */ @@ -390,8 +374,7 @@ scr_execute_debugger_command(const sc_char *command, sc_char *expectation) { * to "" so that accumulation begins. Then pass the next line of data back * to the game. */ -static sc_bool -scr_read_line_callback(sc_char *buffer, sc_int length) { +static sc_bool scr_read_line_callback(sc_char *buffer, sc_int length) { sc_char *command, *expectation; assert(buffer && length > 0); @@ -455,8 +438,7 @@ scr_read_line_callback(sc_char *buffer, sc_int length) { * game into scr_game_output, unless no expectation is set, in which case * the current game output will be NULL, and we can simply save the effort. */ -static void -scr_print_string_callback(const sc_char *string) { +static void scr_print_string_callback(const sc_char *string) { assert(string); if (scr_game_output) { @@ -476,8 +458,7 @@ scr_print_string_callback(const sc_char *string) { * "expect" pair from the script, satisfy the request with the send data, * and match against the expectations on next request or on finalization. */ -void -scr_start_script(sc_game game, sx_script script) { +void scr_start_script(sc_game game, sx_script script) { sc_char *command, *expectation; sx_scr_location_t location; assert(game && script); @@ -541,8 +522,7 @@ scr_start_script(sc_game game, sx_script script) { * clear local records of the game, stream, and error count. Returns the * count of errors detected during the script. */ -sc_int -scr_finalize_script(void) { +sc_int scr_finalize_script(void) { sc_char *command, *expectation; sc_int errors; diff --git a/engines/glk/adrift/sxtester.cpp b/engines/glk/adrift/sxtester.cpp index f82ca275ad..ae28b3b48b 100644 --- a/engines/glk/adrift/sxtester.cpp +++ b/engines/glk/adrift/sxtester.cpp @@ -54,8 +54,7 @@ static sc_int test_run_game_script(sc_game game, sx_script script) { * Run each test in the given descriptor array, reporting the results and * accumulating an error count overall. Return the total error count. */ -sc_int test_run_game_tests(const sx_test_descriptor_t tests[], - sc_int count, sc_bool is_verbose) { +sc_int test_run_game_tests(const sx_test_descriptor_t tests[], sc_int count, sc_bool is_verbose) { const sx_test_descriptor_t *test; sc_int errors; assert(tests); diff --git a/engines/glk/adrift/sxutils.cpp b/engines/glk/adrift/sxutils.cpp index 90c7385131..e4b3519ebf 100644 --- a/engines/glk/adrift/sxutils.cpp +++ b/engines/glk/adrift/sxutils.cpp @@ -89,8 +89,7 @@ static void *sx_zero_allocation = &sx_zero_allocation; * cleared to zero. In ANSI/ISO C, zero byte allocations are implementation- * defined, so we have to take special care to get predictable behavior. */ -void * -sx_malloc(size_t size) { +void *sx_malloc(size_t size) { void *allocated; if (size == 0) @@ -106,8 +105,7 @@ sx_malloc(size_t size) { return allocated; } -void * -sx_realloc(void *pointer, size_t size) { +void *sx_realloc(void *pointer, size_t size) { void *allocated; if (size == 0) { @@ -167,15 +165,13 @@ static const sc_char NUL = '\0'; * * Built in replacements for locale-sensitive libc ctype.h functions. */ -static sc_bool -sx_isspace(sc_char character) { +static sc_bool sx_isspace(sc_char character) { static const sc_char *const WHITESPACE = "\t\n\v\f\r "; return character != NUL && strchr(WHITESPACE, character) != NULL; } -static sc_bool -sx_isprint(sc_char character) { +static sc_bool sx_isprint(sc_char character) { static const sc_int MIN_PRINTABLE = ' ', MAX_PRINTABLE = '~'; return character >= MIN_PRINTABLE && character <= MAX_PRINTABLE; @@ -188,8 +184,7 @@ sx_isprint(sc_char character) { * Trim leading and trailing whitespace from a string. Modifies the string * in place, and returns the string address for convenience. */ -sc_char * -sx_trim_string(sc_char *string) { +sc_char *sx_trim_string(sc_char *string) { sc_int index_; assert(string); @@ -212,8 +207,7 @@ sx_trim_string(sc_char *string) { * and convert all non-printing characters to '?'. Modifies the string in * place, and returns the string address for convenience. */ -sc_char * -sx_normalize_string(sc_char *string) { +sc_char *sx_normalize_string(sc_char *string) { sc_int index_; assert(string); -- cgit v1.2.3