1 /* io.c Larn is copyrighted 1986 by Noah Morgan.
2 * $FreeBSD: src/games/larn/io.c,v 1.7 1999/11/16 02:57:22 billf Exp $
3 * $DragonFly: src/games/larn/io.c,v 1.7 2008/06/05 18:06:30 swildner Exp $
5 * Below are the functions in this file:
7 * setupvt100() Subroutine to set up terminal in correct mode for game
8 * clearvt100() Subroutine to clean up terminal when the game is over
9 * getchr() Routine to read in one character from the terminal
10 * scbr() Function to set cbreak -echo for the terminal
11 * sncbr() Function to set -cbreak echo for the terminal
12 * newgame() Subroutine to save the initial time and seed rnd()
14 * FILE OUTPUT ROUTINES
16 * lprintf(format, args...) printf to the output buffer
17 * lprint(integer) send binary integer to output buffer
18 * lwrite(buf,len) write a buffer to the output buffer
19 * lprcat(str) sent string to output buffer
21 * FILE OUTPUT MACROS (in header.h)
23 * lprc(character) put the character into the output buffer
27 * long lgetc() read one character from input buffer
28 * long lrint_x() read one integer from input buffer
29 * lrfill(address,number) put input bytes into a buffer
30 * char *lgetw() get a whitespace ended word from input
31 * char *lgetl() get a \n or EOF ended line from input
33 * FILE OPEN / CLOSE ROUTINES
35 * lcreat(filename) create a new file for write
36 * lopen(filename) open a file for read
37 * lappend(filename) open for append to an existing file
38 * lrclose() close the input file
39 * lwclose() close output file
40 * lflush() flush the output buffer
44 * cursor(x,y) position cursor at [x,y]
45 * cursors() position cursor at [1,24] (saves memory)
46 * cl_line(x,y) Clear line at [1,y] and leave cursor at [x,y]
47 * cl_up(x,y) Clear screen from [x,1] to current line.
48 * cl_dn(x,y) Clear screen from [1,y] to end of display.
49 * standout(str) Print the string in standout mode.
50 * set_score_output() Called when output should be literally printed.
51 * putchr(ch) Print one character in decoded output buffer.
52 * flush_buf() Flush buffer with decoded output.
53 * init_term() Terminal initialization -- setup termcap info
54 * char *tmcapcnv(sd,ss) Routine to convert VT100 \33's to termcap format
55 * beep() Routine to emit a beep if enabled (see no-beep in .larnopts)
57 * Note: ** entries are available only in termcap mode.
64 static int rawflg = 0;
65 static char saveeof, saveeol;
67 #define LINBUFSIZE 128 /* size of the lgetw() and lgetl() buffer */
68 int io_outfd; /* output file numbers */
69 int io_infd; /* input file numbers */
70 static struct termios ttx; /* storage for the tty modes */
71 static int ipoint=MAXIBUF, iepoint=MAXIBUF; /* input buffering pointers */
72 static char lgetwbuf[LINBUFSIZE]; /* get line (word) buffer */
75 static int putchr(int);
76 static void flush_buf(void);
80 * setupvt100() Subroutine to set up terminal in correct mode for game
82 * Attributes off, clear screen, set scrolling region, set tty mode
93 * clearvt100() Subroutine to clean up terminal when the game is over
95 * Attributes off, clear screen, unset scrolling region, restore tty mode
106 * getchr() Routine to read in one character from the terminal
115 lflush(); /* be sure output buffer is flushed */
116 read(0, &byt, 1); /* get byte from terminal */
121 * scbr() Function to set cbreak -echo for the terminal
123 * like: system("stty cbreak -echo")
132 saveeof = ttx.c_cc[VMIN];
133 saveeol = ttx.c_cc[VTIME];
137 ttx.c_lflag &= ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL);
138 tcsetattr(0, TCSANOW, &ttx);
142 * sncbr() Function to set -cbreak echo for the terminal
144 * like: system("stty -cbreak echo")
151 ttx.c_cc[VMIN] = saveeof;
152 ttx.c_cc[VTIME] = saveeol;
153 ttx.c_lflag |= ICANON | ECHO | ECHOE | ECHOK | ECHONL;
154 tcsetattr(0, TCSANOW, &ttx);
158 * newgame() Subroutine to save the initial time and seed rnd()
164 for (p = c, pe = c + 100; p < pe; *p++ = 0)
168 lcreat(NULL); /* open buffering for output to terminal */
172 * lprintf(format, args...) printf to the output buffer
176 * Enter with the format string in "format", as per printf() usage
177 * and any needed arguments following it
178 * Note: lprintf() only supports %s, %c and %d, with width modifier and left
179 * or right justification.
180 * No correct checking for output buffer overflow is done, but flushes
181 * are done beforehand if needed.
182 * Returns nothing of value.
185 lprintf(const char *fmt, ...)
187 va_list ap; /* pointer for variable argument list */
189 long wide, left, cont, n; /* data for lprintf */
190 char db[12]; /* %d buffer in lprintf */
192 va_start(ap, fmt); /* initialize the var args pointer */
210 n = va_arg(ap, long);
218 *tmpb = (char)(n % 10 + '0');
220 *(--tmpb) = (char)((n /= 10) % 10 + '0');
222 while (tmpb < db + 12)
225 wide -= db - tmpb + 12;
229 while (tmpb < db + 12)
239 tmpb = va_arg(ap, char *);
241 while ((*outb++ = *tmpb++))
245 n = wide - strlen(tmpb);
249 while ((*outb++ = *tmpb++))
260 *outb++ = va_arg(ap, int);
274 wide = 10 * wide + *fmt - '0';
293 * lprint(long-integer) send binary integer to output buffer
296 * +---------+---------+---------+---------+
298 * | order | | | order |
299 * | byte | | | byte |
300 * +---------+---------+---------+---------+
301 * 31 --- 24 23 --- 16 15 --- 8 7 --- 0
303 * The save order is low order first, to high order (4 bytes total)
304 * and is written to be system independent.
305 * No checking for output buffer overflow is done, but flushes if needed!
306 * Returns nothing of value.
314 *lpnt++ = 255 & (x >> 8);
315 *lpnt++ = 255 & (x >> 16);
316 *lpnt++ = 255 & (x >> 24);
320 * lwrite(buf,len) write a buffer to the output buffer
324 * Enter with the address and number of bytes to write out
325 * Returns nothing of value
328 lwrite(char *buf, int len)
333 if (len > 399) { /* don't copy data if can just write it */
339 for (str = buf; len > 0; --len)
343 write(io_outfd, buf, len);
347 if (lpnt >= lpend) /* if buffer is full flush it */
349 num2 = lpbuf + BUFBIG - lpnt; /* # bytes left in output buffer */
354 while (num2--) /* copy in the bytes */
361 * long lgetc() Read one character from input buffer
363 * Returns 0 if EOF, otherwise the character
369 if (ipoint != iepoint)
370 return (inbuffer[ipoint++]);
371 if (iepoint != MAXIBUF)
373 if ((i = read(io_infd, inbuffer, MAXIBUF)) <= 0) {
375 write(1, "error reading from input file\n", 30);
376 iepoint = ipoint = 0;
385 * long lrint_x() Read one integer from input buffer
387 * +---------+---------+---------+---------+
389 * | order | | | order |
390 * | byte | | | byte |
391 * +---------+---------+---------+---------+
392 * 31 --- 24 23 --- 16 15 --- 8 7 --- 0
394 * The save order is low order first, to high order (4 bytes total)
395 * Returns the int read
402 i |= (255 & lgetc()) << 8;
403 i |= (255 & lgetc()) << 16;
404 i |= (255 & lgetc()) << 24;
409 * lrfill(address,number) put input bytes into a buffer
413 * Reads "number" bytes into the buffer pointed to by "address".
414 * Returns nothing of value
417 lrfill(char *adr, int num)
422 if (iepoint == ipoint) {
423 if (num > 5) { /* fast way */
424 if (read(io_infd, adr, num) != num)
425 write(2, "error reading from input file\n", 30);
432 num2 = iepoint - ipoint; /* # of bytes left in the buffer */
435 pnt = inbuffer + ipoint;
445 * char *lgetw() Get a whitespace ended word from input
447 * Returns pointer to a buffer that contains word. If EOF, returns a NULL
453 int n = LINBUFSIZE, quote = 0;
457 while ((cc <= 32) && (cc > '\0')); /* eat whitespace */
458 for (;; --n, cc = lgetc()) {
459 if ((cc == '\0') && (lgp == lgetwbuf)) /* EOF */
461 if ((n <= 1) || ((cc <= 32) && (quote == 0))) {
473 * char *lgetl() Function to read in a line ended by newline or EOF
475 * Returns pointer to a buffer that contains the line. If EOF, returns NULL
480 int i = LINBUFSIZE, ch;
481 char *str = lgetwbuf;
483 if ((*str++ = ch = lgetc()) == '\0') {
484 if (str == lgetwbuf + 1) /* EOF */
488 return (lgetwbuf); /* line ended by EOF */
490 if ((ch == '\n') || (i <= 1)) /* line ended by \n */
496 * lcreat(filename) Create a new file for write
499 * lcreat(NULL); means to the terminal
500 * Returns -1 if error, otherwise the file descriptor opened.
506 lpend = lpbuf + BUFBIG;
508 return (io_outfd = 1);
509 if ((io_outfd = creat(str, 0644)) < 0) {
511 lprintf("error creating file <%s>\n", str);
519 * lopen(filename) Open a file for read
522 * lopen(0) means from the terminal
523 * Returns -1 if error, otherwise the file descriptor opened.
528 ipoint = iepoint = MAXIBUF;
530 return (io_infd = 0);
531 if ((io_infd = open(str, O_RDONLY)) < 0) {
541 * lappend(filename) Open for append to an existing file
544 * lappend(0) means to the terminal
545 * Returns -1 if error, otherwise the file descriptor opened.
551 lpend = lpbuf + BUFBIG;
553 return (io_outfd = 1);
554 if ((io_outfd = open(str, O_RDWR)) < 0) {
558 lseek(io_outfd, 0, SEEK_END); /* seek to end of file */
563 * lrclose() close the input file
565 * Returns nothing of value.
575 * lwclose() close output file flushing if needed
577 * Returns nothing of value.
588 * lprcat(string) append a string to the output buffer
589 * avoids calls to lprintf (time consuming)
592 lprcat(const char *str)
598 while ((*str2++ = *str++) != '\0')
605 * cursor(x,y) Subroutine to set the cursor position
607 * x and y are the cursor coordinates, and lpbuff is the output buffer where
608 * escape sequence will be placed.
610 static const char *y_num[]= { "\33[","\33[","\33[2","\33[3","\33[4","\33[5","\33[6",
611 "\33[7","\33[8","\33[9","\33[10","\33[11","\33[12","\33[13","\33[14",
612 "\33[15","\33[16","\33[17","\33[18","\33[19","\33[20","\33[21","\33[22",
615 static const char *x_num[]= { "H","H",";2H",";3H",";4H",";5H",";6H",";7H",";8H",";9H",
616 ";10H",";11H",";12H",";13H",";14H",";15H",";16H",";17H",";18H",";19H",
617 ";20H",";21H",";22H",";23H",";24H",";25H",";26H",";27H",";28H",";29H",
618 ";30H",";31H",";32H",";33H",";34H",";35H",";36H",";37H",";38H",";39H",
619 ";40H",";41H",";42H",";43H",";44H",";45H",";46H",";47H",";48H",";49H",
620 ";50H",";51H",";52H",";53H",";54H",";55H",";56H",";57H",";58H",";59H",
621 ";60H",";61H",";62H",";63H",";64H",";65H",";66H",";67H",";68H",";69H",
622 ";70H",";71H",";72H",";73H",";74H",";75H",";76H",";77H",";78H",";79H",
632 p = y_num[y]; /* get the string to print */
634 *lpnt++ = *p++; /* print the string */
636 p = x_num[x]; /* get the string to print */
638 *lpnt++ = *p++; /* print the string */
642 * cursor(x,y) Put cursor at specified coordinates staring at [1,1] (termcap)
657 * Routine to position cursor at beginning of 24th line
667 * Warning: ringing the bell is control code 7. Don't use in defines.
668 * Don't change the order of these defines.
669 * Also used in helpfiles. Codes used in helpfiles should be \E[1 to \E[7 with
673 static char cap[256];
674 char *CM, *CE, *CD, *CL, *SO, *SE, *AL, *DL;/* Termcap capabilities */
675 static char *outbuf = 0; /* translated output buffer */
678 * init_term() Terminal initialization -- setup termcap info
684 char *capptr = cap + 10;
687 switch (tgetent(termbuf, term = getenv("TERM"))) {
689 write(2, "Cannot open termcap file.\n", 26);
692 write(2, "Cannot find entry of ", 21);
693 write(2, term, strlen(term));
694 write(2, " in termcap\n", 12);
698 CM = tgetstr("cm", &capptr); /* Cursor motion */
699 CE = tgetstr("ce", &capptr); /* Clear to eoln */
700 CL = tgetstr("cl", &capptr); /* Clear screen */
703 AL = tgetstr("al", &capptr); /* Insert line */
704 DL = tgetstr("dl", &capptr); /* Delete line */
705 SO = tgetstr("so", &capptr); /* Begin standout mode */
706 SE = tgetstr("se", &capptr); /* End standout mode */
707 CD = tgetstr("cd", &capptr); /* Clear to end of display */
709 if (!CM) { /* can't find cursor motion entry */
710 write(2, "Sorry, for a ", 13);
711 write(2, term, strlen(term));
712 write(2, ", I can't find the cursor motion entry in termcap\n", 50);
715 if (!CE) { /* can't find clear to end of line entry */
716 write(2, "Sorry, for a ", 13);
717 write(2, term, strlen(term));
718 write(2, ", I can't find the clear to end of line entry in termcap\n", 57);
721 if (!CL) { /* can't find clear entire screen entry */
722 write(2, "Sorry, for a ", 13);
723 write(2, term, strlen(term));
724 write(2, ", I can't find the clear entire screen entry in termcap\n", 56);
727 /* get memory for decoded output buffer*/
728 if ((outbuf = malloc(BUFBIG + 16)) == 0) {
729 write(2, "Error malloc'ing memory for decoded output buffer\n", 50);
730 died(-285); /* malloc() failure */
736 * cl_line(x,y) Clear the whole line indicated by 'y' and leave cursor at [x,y]
739 cl_line(int x, int y)
752 * cl_up(x,y) Clear screen from [x,1] to current position. Leave cursor at [x,y]
759 lprcat("\33[1J\33[2K");
763 for (i = 1; i <= y; i++) {
772 * cl_dn(x,y) Clear screen from [1,y] to end of display. Leave cursor at [x,y]
779 lprcat("\33[J\33[2K");
785 for (i = y; i <= 24; i++) {
798 * standout(str) Print the argument string in inverse video (standout mode).
801 standout(const char *str)
817 * set_score_output() Called when output should be literally printed.
820 set_score_output(void)
826 * lflush() Flush the output buffer
828 * Returns nothing of value.
829 * for termcap version: Flush output in output buffer according to output
830 * status as indicated by `enable_scroll'
833 static int scrline = 18; /* line # for wraparound instead of scrolling if no DL */
843 if ((lpoint = lpnt - lpbuf) > 0) {
845 c[BYTESOUT] += lpoint;
847 if (enable_scroll <= -1) {
849 if (write(io_outfd, lpbuf, lpoint) != lpoint)
850 write(2, "error writing to output file\n", 29);
851 lpnt = lpbuf; /* point back to beginning of buffer */
854 for (str = lpbuf; str < lpnt; str++) {
861 tputs(CL, 0, putchr);
866 tputs(CE, 0, putchr);
870 tputs(CD, 0, putchr);
874 tputs(SO, 0, putchr);
878 tputs(SE, 0, putchr);
884 tputs(tgoto(CM, curx, cury), 0, putchr);
888 if ((cury == 23) && enable_scroll) {
889 if (!DL || !AL) { /* wraparound or scroll? */
895 tputs(tgoto(CM, 0, scrline), 0, putchr);
896 tputs(CE, 0, putchr);
900 tputs(tgoto(CM, 0, scrline), 0, putchr);
901 tputs(CE, 0, putchr);
903 tputs(tgoto(CM, 0, 19), 0, putchr);
904 tputs(DL, 0, putchr);
905 tputs(tgoto(CM, 0, 23), 0, putchr);
921 flush_buf(); /* flush real output buffer now */
925 * lflush() flush the output buffer
927 * Returns nothing of value.
933 if ((lpoint = lpnt - lpbuf) > 0) {
935 c[BYTESOUT] += lpoint;
937 if (write(io_outfd, lpbuf, lpoint) != lpoint)
938 write(2, "error writing to output file\n", 29);
940 lpnt = lpbuf; /* point back to beginning of buffer */
945 static int pindex = 0;
947 * putchr(ch) Print one character in decoded output buffer.
952 outbuf[pindex++] = ch;
953 if (pindex >= BUFBIG)
959 * flush_buf() Flush buffer with decoded output.
965 write(io_outfd, outbuf, pindex);
970 * char *tmcapcnv(sd,ss) Routine to convert VT100 escapes to termcap format
972 * Processes only the \33[#m sequence (converts . files for termcap use
975 tmcapcnv(char *sd, char *ss)
977 int tmstate = 0; /* 0=normal, 1=\33 2=[ 3=# */
978 char tmdigit = 0; /* the # in \33[#m */
995 if (isdigit((int)*ss)) {
1018 *sd = 0; /* NULL terminator */
1024 * beep() Routine to emit a beep if enabled (see no-beep in .larnopts)