Early Roguelike Collection: xrogue/state.c comparison

comparison xrogue/state.c @ 220:f54901b9c39b

XRogue: convert to ANSI-style function declarations.

author	John "Elwin" Edwards
date	Wed, 02 Mar 2016 21:13:26 -0500
parents	3def5e487faa
children	7c1cb43f346e

comparison

equal deleted inserted replaced

-:f9ef86cf22b2
+:f54901b9c39b
 int format_error = FALSE;
 int save_debug = FALSE;
 #define DBG(x)   {if (save_debug) rsPrintf x;}
+bool rs_read_new_string(int inf, char **s);
+int find_list_ptr(struct linked_list *l, void *ptr);
+bool rs_write_coord_list(FILE *savef, struct linked_list *l);
+bool rs_read_coord_list(int inf, struct linked_list **list);
+int list_size(struct linked_list *l);
+bool rs_write_object_list(FILE *savef, struct linked_list *l);
+bool rs_read_object_list(int inf, struct linked_list **list);
 int
 rsPrintf(char *fmt, ...)
 {
 va_list ap;
 }
 return(NULL);
 }
+bool
 rs_write(FILE *savef, void *ptr, size_t size)
 {
 size_t i = 0;
 if (!write_error)
 return(WRITESTAT);
 }
 int end_of_file = FALSE;
+bool
 rs_read(int inf, void *ptr, size_t size)
 {
 int actual;
 end_of_file =FALSE;
 if (!read_error && !format_error)
 return(READSTAT);
 }
 int big_endian = 0;
+bool
 rs_write_uint(FILE *savef, unsigned int c)
 {
 char bytes[4];
 char *buf = (char *) &c;
 rs_write(savef, buf, 4);
 return(WRITESTAT);
 }
+bool
 rs_write_int(FILE *savef, int c)
 {
 char bytes[4];
 char *buf = (char *) &c;
 rs_write(savef, buf, 4);
 return(WRITESTAT);
 }
+bool
 rs_write_ulong(FILE *savef, unsigned long c)
 {
 unsigned int c2;
 char bytes[4];
 char *buf = (char *)&c;
 rs_write(savef, buf, 4);
 return(WRITESTAT);
 }
+bool
 rs_write_long(FILE *savef, long c)
 {
 int c2;
 char bytes[4];
 char *buf = (char *)&c;
 rs_write(savef, buf, 4);
 return(WRITESTAT);
 }
+bool
 rs_write_boolean(FILE *savef, bool c)
 {
 char buf;
 if (c == 0)
 rs_write(savef, &buf, 1);
 return(WRITESTAT);
 }
+bool
 rs_read_int(int inf, int *i)
 {
 char bytes[4];
 int  input;
 char *buf = (char *)&input;
 *i = *((int *) buf);
 return(READSTAT);
 }
+bool
 rs_read_uint(int inf, unsigned int *i)
 {
 char bytes[4];
 int  input;
 char *buf = (char *)&input;
 *i = *((int *) buf);
 return(READSTAT);
 }
+bool
 rs_read_ulong(int inf, unsigned long *i)
 {
 char bytes[4];
 unsigned long input;
 char *buf = (char *) &input;
 else
 *i = *((unsigned long *) buf);
 return(READSTAT);
 }
+bool
 rs_read_long(int inf, long *i)
 {
 char bytes[4];
 long input;
 char *buf = (char *) &input;
 else
 *i = *((long *) buf);
 return(READSTAT);
 }
+bool
 rs_read_boolean(int inf, bool *i)
 {
 char buf;
 rs_read(inf, &buf, 1);
 *i = buf;
 return(READSTAT);
 }
+bool
 rs_write_ints(FILE *savef, int *c, int count)
 {
 int n=0;
 rs_write_int(savef,count);
 rs_write_int(savef,c[n]);
 return(WRITESTAT);
 }
+bool
 rs_write_short(FILE *savef, short c)
 {
 char bytes[2];
 char *buf = (char *) &c;
 rs_write(savef, buf, 2);
 return(WRITESTAT);
 }
+bool
 rs_read_short(int inf, short *s)
 {
 char  bytes[2];
 short input;
 char *buf = (char *)&input;
 *s = *((short *) buf);
 return(READSTAT);
 }
+bool
 rs_write_shorts(FILE *savef, short *c, int count)
 {
 int n=0;
 rs_write_int(savef,count);
 rs_write_short(savef,c[n]);
 return(WRITESTAT);
 }
+bool
 rs_write_longs(FILE *savef, long *c, int count)
 {
 int n=0;
 rs_write_int(savef,count);
 rs_write_long(savef,c[n]);
 return(WRITESTAT);
 }
+bool
 rs_write_ulongs(FILE *savef, unsigned long *c, int count)
 {
 int n=0;
 rs_write_int(savef,count);
 rs_write_ulong(savef,c[n]);
 return(WRITESTAT);
 }
+bool
 rs_write_booleans(FILE *savef, bool *c, int count)
 {
 int n=0;
 rs_write_int(savef,count);
 rs_write_boolean(savef,c[n]);
 return(WRITESTAT);
 }
+bool
 rs_read_ints(int inf, int *i, int count)
 {
 int n=0,value=0;
 if (rs_read_int(inf,&value) != 0)
 }
 return(READSTAT);
 }
+bool
 rs_read_shorts(int inf, short *i, int count)
 {
 int n=0,value=0;
 if (rs_read_int(inf,&value) != 0)
 }
 return(READSTAT);
 }
+bool
 rs_read_longs(int inf, long *i, int count)
 {
 int n=0,value=0;
 if (rs_read_int(inf,&value) != 0)
 }
 return(READSTAT);
 }
+bool
 rs_read_ulongs(int inf, unsigned long *i, int count)
 {
 int n=0,value=0;
 if (rs_read_int(inf,&value) != 0)
 }
 return(READSTAT);
 }
+bool
 rs_read_booleans(int inf, bool *i, int count)
 {
 int n=0,value=0;
 if (rs_read_int(inf,&value) != 0)
 }
 return(READSTAT);
 }
+bool
 rs_write_levtype(FILE *savef, LEVTYPE c)
 {
 int lt;
 switch(c)
 rs_write_int(savef,lt);
 return(WRITESTAT);
 }
+bool
 rs_read_levtype(int inf, LEVTYPE *l)
 {
 int lt;
 rs_read_int(inf, &lt);
 }
 return(READSTAT);
 }
+bool
 rs_write_char(FILE *savef, char c)
 {
 rs_write(savef, &c, 1);
 DBG(("%c",c));
 return(WRITESTAT);
 }
+bool
 rs_read_char(int inf, char *c)
 {
 rs_read(inf, c, 1);
 return(READSTAT);
 }
+bool
 rs_write_uchar(FILE *savef, unsigned char c)
 {
 rs_write(savef, &c, 1);
 DBG(("%c",c));
 return(WRITESTAT);
 }
+bool
 rs_read_uchar(int inf, unsigned char *c)
 {
 rs_read(inf, c, 1);
 return(READSTAT);
 }
+bool
 rs_write_string(FILE *savef, char *s)
 {
 int len = 0;
 len = (s == NULL) ? 0 : (int) strlen(s) + 1;
 rs_write(savef, s, len);
 return(WRITESTAT);
 }
+bool
 rs_read_string_index(int inf, struct words master[], int maxindex, char **str)
 {
 int i;
 if (rs_read_int(inf,&i) != 0)
 *str = NULL;
 }
 return(READSTAT);
 }
+bool
 rs_write_string_index(FILE *savef, struct words master[], int maxindex, char *str)
 {
 int i;
 for(i = 0; i < maxindex; i++)
 rs_write_int(savef,-1);
 return(WRITESTAT);
 }
+bool
 rs_read_scrolls(int inf)
 {
 int i;
 for(i = 0; i < MAXSCROLLS; i++)
 }
 return(READSTAT);
 }
+bool
 rs_write_scrolls(FILE *savef)
 {
 int i;
 for(i = 0; i < MAXSCROLLS; i++)
 {
 rs_write_string(savef,s_names[i]);
 rs_write_boolean(savef,s_know[i]);
 rs_write_string(savef,s_guess[i]);
 }
-return(READSTAT);
+return(WRITESTAT);
 }
+bool
 rs_read_potions(int inf)
 {
 int i;
 for(i = 0; i < MAXPOTIONS; i++)
 }
 return(READSTAT);
 }
+bool
 rs_write_potions(FILE *savef)
 {
 int i;
 for(i = 0; i < MAXPOTIONS; i++)
 }
 return(WRITESTAT);
 }
+bool
 rs_read_rings(int inf)
 {
 int i;
 for(i = 0; i < MAXRINGS; i++)
 }
 return(READSTAT);
 }
+bool
 rs_write_rings(FILE *savef)
 {
 int i;
 for(i = 0; i < MAXRINGS; i++)
 }
 return(WRITESTAT);
 }
+bool
 rs_read_misc(int inf)
 {
 int i;
 for(i = 0; i < MAXMM; i++)
 }
 return(READSTAT);
 }
+bool
 rs_write_misc(FILE *savef)
 {
 int i;
 for(i = 0; i < MAXMM; i++)
 }
 return(WRITESTAT);
 }
+bool
 rs_write_sticks(FILE *savef)
 {
 int i;
 for (i = 0; i < MAXSTICKS; i++)
 }
 return(WRITESTAT);
 }
+bool
 rs_read_sticks(int inf)
 {
 int i = 0, list = 0;
 for(i = 0; i < MAXSTICKS; i++)
 }
 return(READSTAT);
 }
+bool
 rs_read_string(int inf, char *s, int max)
 {
 int len = 0;
 if (rs_read_int(inf, &len) != FALSE)
 }
 return(READSTAT);
 }
+bool
 rs_read_new_string(int inf, char **s)
 {
 int len=0;
 char *buf=0;
 }
 return(READSTAT);
 }
+bool
 rs_write_strings(FILE *savef, char *s[], int count)
 {
 int len = 0;
 int n = 0;
 }
 return(WRITESTAT);
 }
+bool
 rs_write_words(FILE *savef, struct words *w, int count)
 {
 int n = 0;
 rs_write_int(savef,count);
 }
 return(WRITESTAT);
 }
+bool
 rs_read_words(int inf, struct words *w, int count)
 {
 int n = 0;
 int value = 0;
 }
 return(READSTAT);
 }
+bool
 rs_read_new_strings(int inf, char **s, int count)
 {
 int len   = 0;
 int n     = 0;
 int value = 0;
 }
 return(READSTAT);
 }
+bool
 rs_write_coord(FILE *savef, coord *c)
 {
 DBG(("X ="));
 rs_write_int(savef, c->x);
 DBG(("Y ="));
 rs_write_int(savef, c->y);
 return(WRITESTAT);
 }
+bool
 rs_read_coord(int inf, coord *c)
 {
 rs_read_int(inf,&c->x);
 rs_read_int(inf,&c->y);
 if (tobj->o_type != MM || tobj->o_which != MM_JUG)
 return NULL;
 return tobj;
 }
+bool
 rs_write_daemons(FILE *savef, struct delayed_action *d_list,int count)
 {
 int i = 0;
 int func = 0;
 }
 return(WRITESTAT);
 }
+bool
 rs_read_daemons(int inf, struct delayed_action *d_list, int count)
 {
 int i = 0;
 int func = 0;
 int value = 0;
 }
 return(READSTAT);
 }
+bool
 rs_write_rooms(FILE *savef, struct room r[], int count)
 {
 int n = 0,i = -1;
 struct linked_list *l;
 }
 }
 return(WRITESTAT);
 }
+bool
 rs_read_rooms(int inf, struct room *r, int count)
 {
 int value = 0, n = 0, i = 0, index = 0, id = 0;
 struct linked_list *fires=NULL, *item = NULL;
 }
 return(READSTAT);
 }
+bool
 rs_write_object(FILE *savef, struct object *o)
 {
 rs_write_int(savef, RSXR_OBJECT);
 rs_write_int(savef, o->o_type);
 rs_write_coord(savef, &o->o_pos);
 DBG(("    END_CONTENTS\n"));
 return(WRITESTAT);
 }
+bool
 rs_read_object(int inf, struct object *o)
 {
 int id;
 if (rs_read_int(inf, &id) != 0)
 }
 return(READSTAT);
 }
+bool
 rs_write_stats(FILE *savef, struct stats *s)
 {
 DBG(("Stats\n"));
 rs_write_int(savef, RSXR_STATS);
 rs_write(savef, s->s_dmg, sizeof(s->s_dmg));
 return(WRITESTAT);
 }
+bool
 rs_read_stats(int inf, struct stats *s)
 {
 int id;
 if (rs_read_int(inf, &id) != 0)
 }
 return(READSTAT);
 }
+bool
 rs_write_mstats(FILE *savef, struct mstats *s)
 {
 DBG(("M-Stats\n"));
 rs_write_int(savef, RSXR_STATS);
 rs_write_short(savef, s->ms_str);
 /*printf("    Damage: %s\n",s->ms_dmg);*/
 return(WRITESTAT);
 }
+bool
 rs_read_mstats(int inf, struct mstats *s)
 {
 int id;
 if (rs_read_int(inf, &id) != 0)
 }
 return(READSTAT);
 }
+bool
 rs_write_init_weps(FILE *savef, struct init_weps *w, int count)
 {
 int i;
 DBG(("Init-Weps\n"));
 rs_write_int(savef, w[i].w_worth);
 }
 return(WRITESTAT);
 }
+bool
 rs_read_init_weps(int inf, struct init_weps *w,int count)
 {
 int id,value,i;
 rs_read_int(inf, &id);
 rs_read_int(inf, &w[i].w_worth);
 }
 return(READSTAT);
 }
+bool
 rs_write_init_armor(FILE *savef, struct init_armor *a, int count)
 {
 int i;
 DBG(("Init-Armor\n"));
 rs_write_int(savef, RSXR_IARMOR);
 rs_write_int(savef, a[i].a_wght);
 }
 return(WRITESTAT);
 }
+bool
 rs_read_init_armor(int inf, struct init_armor *a,int count)
 {
 int id,value,i;
 rs_read_int(inf, &id);
 }
 return(READSTAT);
 }
+bool
 rs_write_spells(FILE *savef, struct spells *s, int count)
 {
 int i;
 DBG(("Spells\n"));
 rs_write_int(savef, RSXR_SPELLS);
 rs_write_int(savef, s[i].s_flag);
 }
 return(WRITESTAT);
 }
+bool
 rs_read_spells(int inf, struct spells *s,int count)
 {
 int id,value,i;
 rs_read_int(inf, &id);
 rs_read_int(inf, &s[i].s_flag);
 }
 return(READSTAT);
 }
+bool
 rs_write_item_list(FILE *savef, struct item_list *i)
 {
 DBG(("Item List\n"));
 rs_write_int(savef, RSXR_ILIST);
 rs_write_char(savef, i->item_ch);
 rs_write(savef, i->item_desc, sizeof(i->item_desc));
 return(WRITESTAT);
 }
+bool
 rs_read_item_list(int inf, struct item_list *i)
 {
 int id;
 rs_read_int(inf, &id);
 rs_read_uchar(inf, &i->item_ch);
 rs_read(inf, i->item_desc,sizeof(i->item_desc));
 return(READSTAT);
 }
+bool
 rs_write_h_list(FILE *savef, struct h_list *h)
 {
 DBG(("H List\n"));
 rs_write_int(savef, RSXR_HLIST);
 rs_write_char(savef, h->h_ch);
 rs_write(savef, h->h_desc, sizeof(h->h_desc));
 return(WRITESTAT);
 }
+bool
 rs_read_h_list(int inf, struct h_list *h)
 {
 int id;
 rs_read_int(inf, &id);
 rs_read_char(inf, &h->h_ch);
 rs_read(inf, h->h_desc,sizeof(h->h_desc));
 return(READSTAT);
 }
+bool
 rs_write_death_types(FILE *savef, struct death_type *d,int count)
 {
 int i;
 DBG(("Death Types\n"));
 rs_write_int(savef, d[i].reason);
 rs_write(savef, d[i].name, sizeof(d[i].name));
 }
 return(WRITESTAT);
 }
+bool
 rs_read_death_types(int inf, struct death_type *d, int count)
 {
 int id,value,i;
 rs_read_int(inf, &id);
 rs_read(inf, d[i].name,sizeof(d[i].name));
 }
 return(READSTAT);
 }
+bool
 rs_write_character_types(FILE *savef, struct character_types *c, int count)
 {
 int i;
 DBG(("Character Types\n"));
 rs_write_int(savef, c[i].range);
 }
 return(WRITESTAT);
 }
+bool
 rs_read_character_types(int inf, struct character_types *c,int count)
 {
 int id,value,i;
 rs_read_int(inf, &id);
 rs_read_int(inf, &c[i].range);
 }
 return(READSTAT);
 }
+bool
 rs_write_traps(FILE *savef, struct trap *trap,int count)
 {
 int n;
 DBG(("Traps\n"));
 rs_write_char(savef, trap[n].tr_type);
 rs_write_char(savef, trap[n].tr_show);
 rs_write_coord(savef, &trap[n].tr_pos);
 rs_write_long(savef, trap[n].tr_flags);
 }
-}
+return(WRITESTAT);
+}
+bool
 rs_read_traps(int inf, struct trap *trap, int count)
 {
 int id = 0, value = 0, n = 0;
 if (rs_read_int(inf,&id) != 0)
 }
 return(READSTAT);
 }
+bool
 rs_write_monsters(FILE * savef, struct monster * m, int count)
 {
 int n;
 DBG(("Monsters\n"));
 }
 return(WRITESTAT);
 }
+bool
 rs_read_monsters(int inf, struct monster *m, int count)
 {
 int id = 0, value = 0, n = 0;
 char buffer[1024];
 return(READSTAT);
 }
 /*****************************************************************************/
+bool
 rs_write_coord_list(FILE *savef, struct linked_list *l)
 {
 DBG(("Coordinate List\n"));
 rs_write_int(savef, RSXR_COORDLIST);
 rs_write_int(savef, list_size(l));
 }
 return(WRITESTAT);
 }
+bool
 rs_read_coord_list(int inf, struct linked_list **list)
 {
 int id;
 int i, cnt;
 struct linked_list *l = NULL, *previous = NULL, *head = NULL;
 format_error = TRUE;
 return(READSTAT);
 }
+bool
 rs_write_object_list(FILE *savef, struct linked_list *l)
 {
 DBG(("Object List\n"));
 rs_write_int(savef, RSXR_OBJECTLIST);
 rs_write_int(savef, list_size(l));
 }
 return(WRITESTAT);
 }
+bool
 rs_read_object_list(int inf, struct linked_list **list)
 {
 int id;
 int i, cnt;
 struct linked_list *l = NULL, *previous = NULL, *head = NULL;
 }
 return(-1);
 }
+bool
 rs_write_thing(FILE *savef, struct thing *t)
 {
 int i = -1;
 DBG(("Thing\n"));
 rs_write_stats(savef, &t->maxstats);
 return(WRITESTAT);
 }
+void
 rs_fix_thing(struct thing *t)
 {
 struct linked_list *item;
 struct thing *tp;
 tp = THINGPTR(item);
 t->t_dest = &tp->t_pos;
 }
 }
+bool
 rs_read_thing(int inf, struct thing *t)
 {
 int id;
 int listid = 0, index = -1;
 struct linked_list *item;
 return(count);
 }
+bool
 rs_write_monster_list(FILE *savef, struct linked_list *l)
 {
 int cnt = 0;
 DBG(("Monster List\n"));
 }
 return(WRITESTAT);
 }
-rs_fix_monster_list(list)
+void
-struct linked_list *list;
+rs_fix_monster_list(struct linked_list *list)
 {
 struct linked_list *item;
 for(item = list; item != NULL; item = item->l_next)
 rs_fix_thing(THINGPTR(item));
 }
+bool
 rs_read_monster_list(int inf, struct linked_list **list)
 {
 int id;
 int i, cnt;
 struct linked_list *l = NULL, *previous = NULL, *head = NULL;
 else format_error = TRUE;
 return(READSTAT);
 }
+bool
 rs_write_magic_items(FILE *savef, struct magic_item *i, int count)
 {
 int n;
 DBG(("Magic Items\n"));
 }
 return(WRITESTAT);
 }
+bool
 rs_read_magic_items(int inf, struct magic_item *mi, int count)
 {
 int id;
 int n;
 int value;
 }
 return(READSTAT);
 }
+bool
 rs_write_window(FILE *savef, WINDOW *win)
 {
 int row,col,height,width;
 width = getmaxx(win);
 height = getmaxy(win);
 rs_write_int(savef,width);
 for(row=0;row<height;row++)
 for(col=0;col<width;col++)
 rs_write_int(savef, mvwinch(win,row,col));
-}
+return(WRITESTAT);
+}
+bool
 rs_read_window(int inf, WINDOW *win)
 {
 int row,col,maxlines,maxcols,value,width,height;
 width = getmaxx(win);
 }
 return(READSTAT);
 }
+bool
 rs_save_file(FILE *savef)
 {
 int i, weapon, armor, ring, misc, room = -1;
 int endian = 0x01020304;
 big_endian = ( *((char *)&endian) == 0x01 );
 sizeof(monsters)/sizeof(struct monster));           /* mons_def.c       */
 rs_write_coord(savef,&move_nh);                         /* move.c           */
 return(WRITESTAT);
 }
+bool
 rs_restore_file(int inf)
 {
 int weapon, armor, ring, misc, room = -1,i,checkpoint;
 int endian = 0x01020304;
 big_endian = ( *((char *)&endian) == 0x01 );
 rs_read_coord(inf,&move_nh);                            /* move.c           */
 return(READSTAT);
 }
+void
 rs_write_scorefile(FILE *savef, struct sc_ent *entries, int count)
 {
 int i;
 rs_write_int(savef, count);
 rs_write_short(savef, entries[i].sc_monster);
 rs_write_short(savef, entries[i].sc_quest);
 }
 }
+int
 rs_read_scorefile(FILE *savef, struct sc_ent *entries, int count)
 {
 int i,available = 0;
 int sfd = md_fileno(savef);
 return(0);
 }
+void
 rs_print_thing(FILE *outf, struct thing *thing, char *prefix, int list, int index)
 {
 int i;
 fprintf(outf,"%sList Ident : %d\n", prefix, list);
 fprintf(outf,"%st_stats    : Not Implemented\n",prefix);
 fprintf(outf,"%st_maxstats : Not Implemented\n",prefix);
 fprintf(outf,"%st_reserved : %d\n",prefix,thing->t_reserved);
 }
+void
 rs_print_game_state(FILE *outf)
 {
 fprintf(outf, "Player\n");
 rs_print_thing(outf, &player, "    ", 0, 0);
 md_htonl()
 ****/
 int
-md_rand(range)
+md_rand(int range)
-register int range;
 {
 #ifdef _WIN32
 return(range <= 0 ? 0 : rand() % range);
 #else
 return(range <= 0 ? 0 : random() % range);
 #endif
 }
 int
-md_srand(seed)
+md_srand(int seed)
-register int seed;
 {
 #ifdef _WIN32
 srand(seed);
 #else
 srandom(seed);
 #endif
 }
 void
-md_flushinp()
+md_flushinp(void)
 {
 /* ioctl(0,TIOCFLUSH) */
 /* ioctl(_tty_ch,TCFLSH,0) */
 flushinp();
 }
 int
-md_getuid()
+md_getuid(void)
 {
 #ifdef _WIN32
 return(42);
 #else
 return(getuid());
 #endif
 }
 long
-md_memused()
+md_memused(void)
 {
 #ifdef _WIN32
 MEMORYSTATUS stat;
 GlobalMemoryStatus(&stat);
 return( (long)sbrk(0) );
 #endif
 }
 char *
-md_getusername()
+md_getusername(void)
 {
 static char login[80];
 char *l = NULL;
 #ifdef _WIN32
 LPSTR mybuffer;
 return(login);
 }
 char *
-md_gethomedir()
+md_gethomedir(void)
 {
 static char homedir[PATH_MAX];
 char *h = NULL;
 size_t len;
 #if defined(_WIN32)
 return(0);
 }
 char *
-md_getroguedir()
+md_getroguedir(void)
 {
 static char path[1024];
 char *end,*home;
 if ( (home = getenv("ROGUEHOME")) != NULL)
 return("");
 }
 char *
-md_getshell()
+md_getshell(void)
 {
 static char shell[PATH_MAX];
 char *s = NULL;
 #ifdef _WIN32
 char *def = "C:\\WINDOWS\\SYSTEM32\\CMD.EXE";
 return(shell);
 }
 char *
-md_gethostname()
+md_gethostname(void)
 {
 static char nodename[80];
 char *n = NULL;
 #if !defined(_WIN32) && !defined(__DJGPP__)
 struct utsname ourname;
 return(nodename);
 }
 int
-md_shellescape()
+md_shellescape(void)
 {
 #if (!defined(_WIN32) && !defined(__DJGPP__))
 int ret_status;
 	int pid;
 #endif
 return(ret_status);
 #endif
 }
 int
-md_erasechar()
+md_erasechar(void)
 {
 /*
 return(_tty.sg_erase);
 return(_tty.c_cc[VERASE]);
 */
 return(erasechar());
 }
 int
-md_killchar()
+md_killchar(void)
 {
 /*
 return(_tty.sg_kill);
 return(_tty.c_cc[VKILL]);
 */
 return( htonl(x) );
 #endif
 }
 void
-md_init()
+md_init(void)
 {
 #ifdef __INTERIX
 char *term;
 term = getenv("TERM");
 _fmode = _O_BINARY;
 #endif
 }
 char *
-md_getpass(prompt)
+md_getpass(char *prompt)
-char *prompt;
 {
 #ifdef _WIN32
 static char password_buffer[9];
 char *p = password_buffer;
 int c, count = 0;
 * handle stop and start signals
 */
 /*UNUSED*/
 void
-tstp(a)
+tstp(int a)
-int a;
 {
 mvcur(0, cols - 1, lines - 1, 0);
 fflush(stdout);
 kill(0, SIGTSTP);
 signal(SIGTSTP, tstp);
 draw(cw);
 flushinp();
 }
 #endif
-int
+void
-md_setup()
+md_setup(void)
 {
 #ifdef SIGTSTP
 signal(SIGTSTP, tstp);
 #endif
 #ifdef SIGHUP

Mercurial > hg > early-roguelike

comparison xrogue/state.c @ 220:f54901b9c39b