Early Roguelike Collection: xrogue/io.c comparison

comparison xrogue/io.c @ 220:f54901b9c39b

XRogue: convert to ANSI-style function declarations.

author	John "Elwin" Edwards
date	Wed, 02 Mar 2016 21:13:26 -0500
parents	ce0cf824c192
children	e52a8a7ad4c5

comparison

equal deleted inserted replaced

-:f9ef86cf22b2
+:f54901b9c39b
 #include <curses.h>
 #include <ctype.h>
 #include <stdarg.h>
 #include <string.h>
 #include "rogue.h"
+void doadd(char *fmt, va_list ap);
 /*
 * msg:
 *      Display a message at the top of the screen.
 */
 /*
 * If there is no current message, do nothing.  Otherwise, prompt the
 * player with the --More-- string.  Then erase the message.
 */
-rmmsg()
+void
+rmmsg(void)
 {
 if (mpos) {
 wclear(msgw);
 overwrite(cw, msgw);
 mvwaddstr(msgw, 0, 0, huh);
 /*
 * Display a new msg (giving him a chance to see the previous one if it
 * is up there with the --More--)
 */
-endmsg()
+void
+endmsg(void)
 {
 /* Needed to track where we are for 5.0 (PC) curses */
 register int x, y;
 if (mpos) {
 wmove(msgw, y, x);
 clearok(msgw, FALSE);
 draw(msgw);
 }
+void
 doadd(char *fmt, va_list ap)
 {
 vsprintf((char *) &msgbuf[newpos], fmt, ap);
 newpos = strlen(msgbuf);
 }
 * step_ok:
 *      returns true if it is ok for type to step on ch
 *      flgptr will be NULL if we don't know what the monster is yet!
 */
-step_ok(y, x, can_on_monst, flgptr)
+bool
-register int y, x, can_on_monst;
+step_ok(int y, int x, int can_on_monst, struct thing *flgptr)
-register struct thing *flgptr;
 {
 /* can_on_monst = MONSTOK if all we care about are physical obstacles */
 register struct linked_list *item;
 register struct thing *tp;
 unsigned char ch;
 /*
 * shoot_ok:
 *      returns true if it is ok for type to shoot over ch
 */
+bool
 shoot_ok(int ch)
 {
 switch (ch)
 {
 case ' ':
 }
 /*
 * status:
 *      Display the important stats line.  Keep the cursor where it was.
-*/
+* display: is TRUE, display unconditionally
+*/
-status(display)
-bool display;   /* is TRUE, display unconditionally */
+void
+status(bool display)
 {
 register struct stats *stat_ptr, *max_ptr;
 register int oy = 0, ox = 0, temp;
 register char *pb;
 char buf[LINELEN];
 /*
 * wait_for
 *      Sit around until the guy types the right key
 */
-wait_for(ch)
+void
-register char ch;
+wait_for(char ch)
 {
 register char c;
 clearok(msgw, FALSE);
 if (ch == '\n') {
 *      pertain only the the useful information to be displayed.
 *      If redraw is non-zero, we wait for the character "redraw" to be
 *      typed and then redraw the starting screen.
 */
-over_win(oldwin, newin, maxy, maxx, cursory, cursorx, redraw)
+void
-WINDOW *oldwin, *newin;
+over_win(WINDOW *oldwin, WINDOW *newin, int maxy, int maxx, int cursory,
-int maxy, maxx, cursory, cursorx;
+int cursorx, char redraw)
-char redraw;
 {
 char blanks[LINELEN+1];
 register int line, i;
 WINDOW *ow; /* Overlay window */
 /*
 * show_win:
 *      function used to display a window and wait before returning
 */
-show_win(scr, message)
+void
-register WINDOW *scr;
+show_win(WINDOW *scr, char *message)
-char *message;
 {
 mvwaddstr(scr, 0, 0, message);
 touchwin(scr);
 wmove(scr, hero.y, hero.x);
 draw(scr);
 /*
 * dbotline:
 *      Displays message on bottom line and waits for a space to return
 */
-dbotline(scr,message)
+void
-WINDOW *scr;
+dbotline(WINDOW *scr, char *message)
-char *message;
 {
 mvwaddstr(scr,lines-1,0,message);
 draw(scr);
 wait_for(' ');
 }
 /*
 * restscr:
 *      Restores the screen to the terminal
 */
-restscr(scr)
+void
-WINDOW *scr;
+restscr(WINDOW *scr)
 {
 clearok(scr,TRUE);
 touchwin(scr);
 draw(scr);
 }
 *      Read a byte, short, or long machine independently
 *      Always returns the value as an unsigned long.
 */
 unsigned long
-netread(error, size, stream)
+netread(int *error, int size, FILE *stream)
-int *error;
-int size;
-FILE *stream;
 {
 unsigned long result = 0L,  /* What we read in */
 partial;      /* Partial value */
 int nextc,  /* The next byte */
 i;      /* To index through the result a byte at a time */
 }
 /*
 * netwrite:
 *      Write out a byte, short, or long machine independently.
-*/
+* value: What to write
+* size: How much to write out
-netwrite(value, size, stream)
+* stream: Where to write it
-unsigned long value;    /* What to write */
+*/
-int size;       /* How much to write out */
-FILE *stream;   /* Where to write it */
+int
+netwrite(unsigned long value, int size, FILE *stream)
 {
 int i;      /* Goes through value one byte at a time */
 char outc;  /* The next character to be written */
 /* Be sure we have a right sized chunk */

Mercurial > hg > early-roguelike

comparison xrogue/io.c @ 220:f54901b9c39b