GLK: Change all references to glui32 and glsi32 to uint and int

This should finally fix compilation for the Amiga, which had
difference sized types. And the renamed types are clearer for
ScummVM anyway

1 files changed, 103 insertions, 103 deletions

diff --git a/engines/glk/glk_api.h b/engines/glk/glk_api.h
index 2dd2501f72..030b50e751 100644
--- a/engines/glk/glk_api.h
+++ b/engines/glk/glk_api.h
@@ -51,8 +51,8 @@ public:
 	void glk_set_interrupt_handler(void(*func)(void));
 	void glk_tick(void);
 
-	glui32 glk_gestalt(glui32 id, glui32 val);
-	glui32 glk_gestalt_ext(glui32 id, glui32 val, glui32 *arr, glui32 arrlen);
+	uint glk_gestalt(uint id, uint val);
+	uint glk_gestalt_ext(uint id, uint val, uint *arr, uint arrlen);
 
 	unsigned char glk_char_to_lower(unsigned char ch);
 	unsigned char glk_char_to_upper(unsigned char ch);
@@ -65,35 +65,35 @@ public:
 	/**
 	 * Open a new window
 	 */
-	winid_t glk_window_open(winid_t split, glui32 method, glui32 size,
-	                        glui32 wintype, glui32 rock = 0) const;
+	winid_t glk_window_open(winid_t split, uint method, uint size,
+	                        uint wintype, uint rock = 0) const;
 
 	void glk_window_close(winid_t win, stream_result_t *result = nullptr);
-	void glk_window_get_size(winid_t win, glui32 *width, glui32 *height);
-	void glk_window_set_arrangement(winid_t win, glui32 method,
-	                                glui32 size, winid_t keyWin);
-	void glk_window_get_arrangement(winid_t win, glui32 *method,
-	                                glui32 *size, winid_t *keyWin);
-	winid_t glk_window_iterate(winid_t win, glui32 *rock = 0);
-	glui32 glk_window_get_rock(winid_t win);
-	glui32 glk_window_get_type(winid_t win);
+	void glk_window_get_size(winid_t win, uint *width, uint *height);
+	void glk_window_set_arrangement(winid_t win, uint method,
+	                                uint size, winid_t keyWin);
+	void glk_window_get_arrangement(winid_t win, uint *method,
+	                                uint *size, winid_t *keyWin);
+	winid_t glk_window_iterate(winid_t win, uint *rock = 0);
+	uint glk_window_get_rock(winid_t win);
+	uint glk_window_get_type(winid_t win);
 	winid_t glk_window_get_parent(winid_t win);
 	winid_t glk_window_get_sibling(winid_t win);
 	void glk_window_clear(winid_t win);
-	void glk_window_move_cursor(winid_t win, glui32 xpos, glui32 ypos);
+	void glk_window_move_cursor(winid_t win, uint xpos, uint ypos);
 
 	strid_t glk_window_get_stream(winid_t win);
 	void glk_window_set_echo_stream(winid_t win, strid_t str);
 	strid_t glk_window_get_echo_stream(winid_t win);
 	void glk_set_window(winid_t win);
 
-	strid_t glk_stream_open_file(frefid_t fileref, FileMode fmode, glui32 rock = 0);
-	strid_t glk_stream_open_memory(char *buf, glui32 buflen, FileMode fmode, glui32 rock = 0);
+	strid_t glk_stream_open_file(frefid_t fileref, FileMode fmode, uint rock = 0);
+	strid_t glk_stream_open_memory(char *buf, uint buflen, FileMode fmode, uint rock = 0);
 	void glk_stream_close(strid_t str, stream_result_t *result = nullptr);
-	strid_t glk_stream_iterate(strid_t str, glui32 *rockptr) const;
-	glui32 glk_stream_get_rock(strid_t str) const;
-	void glk_stream_set_position(strid_t str, glsi32 pos, glui32 seekMode);
-	glui32 glk_stream_get_position(strid_t str) const;
+	strid_t glk_stream_iterate(strid_t str, uint *rockptr) const;
+	uint glk_stream_get_rock(strid_t str) const;
+	void glk_stream_set_position(strid_t str, int pos, uint seekMode);
+	uint glk_stream_get_position(strid_t str) const;
 	void glk_stream_set_current(strid_t str);
 	strid_t glk_stream_get_current(void);
 
@@ -101,38 +101,38 @@ public:
 	void glk_put_char_stream(strid_t str, unsigned char ch);
 	void glk_put_string(const char *s);
 	void glk_put_string_stream(strid_t str, const char *s);
-	void glk_put_buffer(const char *buf, glui32 len);
-	void glk_put_buffer_stream(strid_t str, const char *buf, glui32 len);
-	void glk_set_style(glui32 styl);
-	void glk_set_style_stream(strid_t str, glui32 styl);
-
-	glsi32 glk_get_char_stream(strid_t str);
-	glui32 glk_get_line_stream(strid_t str, char *buf, glui32 len);
-	glui32 glk_get_buffer_stream(strid_t str, char *buf, glui32 len);
-
-	void glk_stylehint_set(glui32 wintype, glui32 styl, glui32 hint,
-	                       glsi32 val);
-	void glk_stylehint_clear(glui32 wintype, glui32 style, glui32 hint);
-	glui32 glk_style_distinguish(winid_t win, glui32 style1, glui32 style2);
-	bool glk_style_measure(winid_t win, glui32 style, glui32 hint, glui32 *result);
-
-	frefid_t glk_fileref_create_temp(glui32 usage, glui32 rock = 0);
-	frefid_t glk_fileref_create_by_name(glui32 usage, const char *name, glui32 rock = 0);
-	frefid_t glk_fileref_create_by_prompt(glui32 usage, FileMode fmode, glui32 rock = 0);
-	frefid_t glk_fileref_create_from_fileref(glui32 usage, frefid_t fref, glui32 rock = 0);
+	void glk_put_buffer(const char *buf, uint len);
+	void glk_put_buffer_stream(strid_t str, const char *buf, uint len);
+	void glk_set_style(uint styl);
+	void glk_set_style_stream(strid_t str, uint styl);
+
+	int glk_get_char_stream(strid_t str);
+	uint glk_get_line_stream(strid_t str, char *buf, uint len);
+	uint glk_get_buffer_stream(strid_t str, char *buf, uint len);
+
+	void glk_stylehint_set(uint wintype, uint styl, uint hint,
+	                       int val);
+	void glk_stylehint_clear(uint wintype, uint style, uint hint);
+	uint glk_style_distinguish(winid_t win, uint style1, uint style2);
+	bool glk_style_measure(winid_t win, uint style, uint hint, uint *result);
+
+	frefid_t glk_fileref_create_temp(uint usage, uint rock = 0);
+	frefid_t glk_fileref_create_by_name(uint usage, const char *name, uint rock = 0);
+	frefid_t glk_fileref_create_by_prompt(uint usage, FileMode fmode, uint rock = 0);
+	frefid_t glk_fileref_create_from_fileref(uint usage, frefid_t fref, uint rock = 0);
 	void glk_fileref_destroy(frefid_t fref);
-	frefid_t glk_fileref_iterate(frefid_t fref, glui32 *rockptr);
-	glui32 glk_fileref_get_rock(frefid_t fref);
+	frefid_t glk_fileref_iterate(frefid_t fref, uint *rockptr);
+	uint glk_fileref_get_rock(frefid_t fref);
 	void glk_fileref_delete_file(frefid_t fref);
-	glui32 glk_fileref_does_file_exist(frefid_t fref);
+	uint glk_fileref_does_file_exist(frefid_t fref);
 
 	void glk_select(event_t *event);
 	void glk_select_poll(event_t *event);
 
-	void glk_request_timer_events(glui32 millisecs);
+	void glk_request_timer_events(uint millisecs);
 
-	void glk_request_line_event(winid_t win, char *buf, glui32 maxlen,
-	                            glui32 initlen);
+	void glk_request_line_event(winid_t win, char *buf, uint maxlen,
+	                            uint initlen);
 	void glk_request_char_event(winid_t win);
 	void glk_request_mouse_event(winid_t win);
 
@@ -141,105 +141,105 @@ public:
 	void glk_cancel_mouse_event(winid_t win);
 
 #ifdef GLK_MODULE_LINE_ECHO
-	void glk_set_echo_line_event(winid_t win, glui32 val);
+	void glk_set_echo_line_event(winid_t win, uint val);
 #endif /* GLK_MODULE_LINE_ECHO */
 
 #ifdef GLK_MODULE_LINE_TERMINATORS
-	void glk_set_terminators_line_event(winid_t win, glui32 *keycodes,
-	                                    glui32 count);
+	void glk_set_terminators_line_event(winid_t win, uint *keycodes,
+	                                    uint count);
 #endif /* GLK_MODULE_LINE_TERMINATORS */
 
 	/** \addtogroup Unicode
 	 *  @{
 	 */
 
-	glui32 glk_buffer_to_lower_case_uni(glui32 *buf, glui32 len,
-	                                    glui32 numchars);
-	glui32 glk_buffer_to_upper_case_uni(glui32 *buf, glui32 len,
-	                                    glui32 numchars);
-	glui32 glk_buffer_to_title_case_uni(glui32 *buf, glui32 len,
-	                                    glui32 numchars, glui32 lowerrest);
+	uint glk_buffer_to_lower_case_uni(uint *buf, uint len,
+	                                    uint numchars);
+	uint glk_buffer_to_upper_case_uni(uint *buf, uint len,
+	                                    uint numchars);
+	uint glk_buffer_to_title_case_uni(uint *buf, uint len,
+	                                    uint numchars, uint lowerrest);
 
-	void glk_put_char_uni(glui32 ch);
-	void glk_put_string_uni(glui32 *s);
-	void glk_put_buffer_uni(glui32 *buf, glui32 len);
-	void glk_put_char_stream_uni(strid_t str, glui32 ch);
-	void glk_put_string_stream_uni(strid_t str, const glui32 *s);
-	void glk_put_buffer_stream_uni(strid_t str, const glui32 *buf, glui32 len);
+	void glk_put_char_uni(uint ch);
+	void glk_put_string_uni(uint *s);
+	void glk_put_buffer_uni(uint *buf, uint len);
+	void glk_put_char_stream_uni(strid_t str, uint ch);
+	void glk_put_string_stream_uni(strid_t str, const uint *s);
+	void glk_put_buffer_stream_uni(strid_t str, const uint *buf, uint len);
 
-	glsi32 glk_get_char_stream_uni(strid_t str);
-	glui32 glk_get_buffer_stream_uni(strid_t str, glui32 *buf, glui32 len);
-	glui32 glk_get_line_stream_uni(strid_t str, glui32 *buf, glui32 len);
+	int glk_get_char_stream_uni(strid_t str);
+	uint glk_get_buffer_stream_uni(strid_t str, uint *buf, uint len);
+	uint glk_get_line_stream_uni(strid_t str, uint *buf, uint len);
 
-	strid_t glk_stream_open_file_uni(frefid_t fileref, FileMode fmode, glui32 rock = 0);
-	strid_t glk_stream_open_memory_uni(glui32 *buf, glui32 buflen, FileMode fmode, glui32 rock = 0);
+	strid_t glk_stream_open_file_uni(frefid_t fileref, FileMode fmode, uint rock = 0);
+	strid_t glk_stream_open_memory_uni(uint *buf, uint buflen, FileMode fmode, uint rock = 0);
 
 	void glk_request_char_event_uni(winid_t win);
-	void glk_request_line_event_uni(winid_t win, glui32 *buf,
-	                                glui32 maxlen, glui32 initlen);
+	void glk_request_line_event_uni(winid_t win, uint *buf,
+	                                uint maxlen, uint initlen);
 
 	/** @}*/
 
 #ifdef GLK_MODULE_UNICODE_NORM
 
-	glui32 glk_buffer_canon_decompose_uni(glui32 *buf, glui32 len,
-	                                      glui32 numchars);
-	glui32 glk_buffer_canon_normalize_uni(glui32 *buf, glui32 len,
-	                                      glui32 numchars);
+	uint glk_buffer_canon_decompose_uni(uint *buf, uint len,
+	                                      uint numchars);
+	uint glk_buffer_canon_normalize_uni(uint *buf, uint len,
+	                                      uint numchars);
 
 #endif /* GLK_MODULE_UNICODE_NORM */
 
 #ifdef GLK_MODULE_IMAGE
 
-	bool glk_image_draw(winid_t win, glui32 image, glsi32 val1, glsi32 val2);
-	bool glk_image_draw_scaled(winid_t win, glui32 image,
-	                             glsi32 val1, glsi32 val2, glui32 width, glui32 height);
-	bool glk_image_get_info(glui32 image, glui32 *width, glui32 *height);
+	bool glk_image_draw(winid_t win, uint image, int val1, int val2);
+	bool glk_image_draw_scaled(winid_t win, uint image,
+	                             int val1, int val2, uint width, uint height);
+	bool glk_image_get_info(uint image, uint *width, uint *height);
 
 	void glk_window_flow_break(winid_t win);
 
 	void glk_window_erase_rect(winid_t win,
-	                           glsi32 left, glsi32 top, glui32 width, glui32 height);
-	void glk_window_fill_rect(winid_t win, glui32 color,
-	                          glsi32 left, glsi32 top, glui32 width, glui32 height);
-	void glk_window_set_background_color(winid_t win, glui32 color);
+	                           int left, int top, uint width, uint height);
+	void glk_window_fill_rect(winid_t win, uint color,
+	                          int left, int top, uint width, uint height);
+	void glk_window_set_background_color(winid_t win, uint color);
 
 #endif /* GLK_MODULE_IMAGE */
 
 #ifdef GLK_MODULE_SOUND
 
-	schanid_t glk_schannel_create(glui32 rock = 0);
+	schanid_t glk_schannel_create(uint rock = 0);
 	void glk_schannel_destroy(schanid_t chan);
-	schanid_t glk_schannel_iterate(schanid_t chan, glui32 *rockptr);
-	glui32 glk_schannel_get_rock(schanid_t chan);
+	schanid_t glk_schannel_iterate(schanid_t chan, uint *rockptr);
+	uint glk_schannel_get_rock(schanid_t chan);
 
-	glui32 glk_schannel_play(schanid_t chan, glui32 snd);
-	glui32 glk_schannel_play_ext(schanid_t chan, glui32 snd, glui32 repeats,
-	                             glui32 notify);
+	uint glk_schannel_play(schanid_t chan, uint snd);
+	uint glk_schannel_play_ext(schanid_t chan, uint snd, uint repeats,
+	                             uint notify);
 	void glk_schannel_stop(schanid_t chan);
-	void glk_schannel_set_volume(schanid_t chan, glui32 vol);
+	void glk_schannel_set_volume(schanid_t chan, uint vol);
 
-	void glk_sound_load_hint(glui32 snd, glui32 flag);
+	void glk_sound_load_hint(uint snd, uint flag);
 
 #ifdef GLK_MODULE_SOUND2
 	/* Note that this section is nested inside the #ifdef GLK_MODULE_SOUND.
 	GLK_MODULE_SOUND must be defined if GLK_MODULE_SOUND2 is. */
 
-	schanid_t glk_schannel_create_ext(glui32 rock, glui32 volume);
-	glui32 glk_schannel_play_multi(schanid_t *chanarray, glui32 chancount,
-	                               glui32 *sndarray, glui32 soundcount, glui32 notify);
+	schanid_t glk_schannel_create_ext(uint rock, uint volume);
+	uint glk_schannel_play_multi(schanid_t *chanarray, uint chancount,
+	                               uint *sndarray, uint soundcount, uint notify);
 	void glk_schannel_pause(schanid_t chan);
 	void glk_schannel_unpause(schanid_t chan);
-	void glk_schannel_set_volume_ext(schanid_t chan, glui32 vol,
-	                                 glui32 duration, glui32 notify);
+	void glk_schannel_set_volume_ext(schanid_t chan, uint vol,
+	                                 uint duration, uint notify);
 
 #endif /* GLK_MODULE_SOUND2 */
 #endif /* GLK_MODULE_SOUND */
 
 #ifdef GLK_MODULE_HYPERLINKS
 
-	void glk_set_hyperlink(glui32 linkval);
-	void glk_set_hyperlink_stream(strid_t str, glui32 linkval);
+	void glk_set_hyperlink(uint linkval);
+	void glk_set_hyperlink_stream(strid_t str, uint linkval);
 	void glk_request_hyperlink_event(winid_t win);
 	void glk_cancel_hyperlink_event(winid_t win);
 
@@ -248,15 +248,15 @@ public:
 #ifdef GLK_MODULE_DATETIME
 
 	void glk_current_time(glktimeval_t *time);
-	glsi32 glk_current_simple_time(glui32 factor);
+	int glk_current_simple_time(uint factor);
 	void glk_time_to_date_utc(const glktimeval_t *time, glkdate_t *date);
 	void glk_time_to_date_local(const glktimeval_t *time, glkdate_t *date);
-	void glk_simple_time_to_date_utc(glsi32 time, glui32 factor, glkdate_t *date);
-	void glk_simple_time_to_date_local(glsi32 time, glui32 factor, glkdate_t *date);
+	void glk_simple_time_to_date_utc(int time, uint factor, glkdate_t *date);
+	void glk_simple_time_to_date_local(int time, uint factor, glkdate_t *date);
 	void glk_date_to_time_utc(const glkdate_t *date, glktimeval_t *time);
 	void glk_date_to_time_local(const glkdate_t *date, glktimeval_t *time);
-	glsi32 glk_date_to_simple_time_utc(const glkdate_t *date, glui32 factor);
-	glsi32 glk_date_to_simple_time_local(const glkdate_t *date, glui32 factor);
+	int glk_date_to_simple_time_utc(const glkdate_t *date, uint factor);
+	int glk_date_to_simple_time_local(const glkdate_t *date, uint factor);
 
 #endif /* GLK_MODULE_DATETIME */
 
@@ -281,12 +281,12 @@ public:
 	 * Removes the specified string from the end of the output buffer, if
 	 * indeed it is there.
 	 */
-	void garglk_unput_string_uni(const glui32 *str);
+	void garglk_unput_string_uni(const uint *str);
 
-	void garglk_set_zcolors(glui32 fg, glui32 bg);
-	void garglk_set_zcolors_stream(strid_t str, glui32 fg, glui32 bg);
-	void garglk_set_reversevideo(glui32 reverse);
-	void garglk_set_reversevideo_stream(strid_t str, glui32 reverse);
+	void garglk_set_zcolors(uint fg, uint bg);
+	void garglk_set_zcolors_stream(strid_t str, uint fg, uint bg);
+	void garglk_set_reversevideo(uint reverse);
+	void garglk_set_reversevideo_stream(strid_t str, uint reverse);
 };
 
 } // End of namespace Glk