--- /dev/null
+/* SCCS Id: @(#)tclib.c 3.3 96/02/25 */
+/* Copyright (c) Robert Patrick Rankin, 1995 */
+/* NetHack may be freely redistributed. See license for details. */
+
+/* termcap library implementation */
+
+#include "config.h"
+
+#ifndef TERMCAP /* name of default termcap file */
+#define TERMCAP "/etc/termcap"
+#endif
+#ifndef TCBUFSIZ /* size of tgetent buffer; Unix man page says 1024 */
+#define TCBUFSIZ 1024
+#endif
+#define ESC '\033' /* termcap's '\E' */
+#define BEL '\007' /* ANSI C's '\a' (we assume ASCII here...) */
+
+/* exported variables, as per man page */
+char PC;
+char *BC, *UP;
+short ospeed;
+
+/* exported routines */
+int FDECL(tgetent, (char *,const char *));
+int FDECL(tgetflag, (const char *));
+int FDECL(tgetnum, (const char *));
+char *FDECL(tgetstr, (const char *,char **));
+char *FDECL(tgoto, (const char *,int,int));
+char *FDECL(tparam, (const char *,char *,int,int,int,int,int));
+void FDECL(tputs, (const char *,int,int (*)()));
+
+/* local support data */
+static char *tc_entry;
+static char bc_up_buf[24];
+#ifndef NO_DELAY_PADDING
+/* `ospeed' to baud rate conversion table, adapted from GNU termcap-1.2 */
+static short baud_rates[] = {
+ 0, 50, 75, 110, 135, 150,
+# ifdef VMS
+ 300, 600, 1200, 1800, 2000, 2400, 3600, 4800, 7200,
+# else /* assume Unix */
+ 200, 300, 600, 1200, 1800, 2400, 4800,
+# endif
+ 9600, -192, -384, /* negative is used as `100 * abs(entry)' */
+# ifdef VMS
+ -576, -768, -1152,
+# endif
+};
+#endif /* !NO_DELAY_PADDING */
+
+/* local support code */
+static int FDECL(tc_store, (const char *,const char *));
+static char *FDECL(tc_find, (FILE *,const char *,char *,int));
+static char *FDECL(tc_name, (const char *,char *));
+static const char *FDECL(tc_field, (const char *,const char **));
+
+#ifndef min
+#define min(a,b) ((a)<(b)?(a):(b))
+#endif
+
+/* retrieve the specified terminal entry and return it in `entbuf' */
+int
+tgetent(entbuf, term)
+ char *entbuf; /* size must be at least [TCBUFSIZ] */
+ const char *term;
+{
+ int result;
+ FILE *fp;
+ char *tc = getenv("TERMCAP");
+
+ tc_entry = entbuf;
+ if (!entbuf || !term)
+ return -1;
+ /* if ${TERMCAP} is found as a file, it's not an inline termcap entry */
+ if ((fp = fopen(tc ? tc : TERMCAP, "r")) != 0)
+ tc = 0;
+ /* if ${TERMCAP} isn't a file and `term' matches ${TERM}, use ${TERMCAP} */
+ if (tc) {
+ char *tm = getenv("TERM");
+ if (tm && strcmp(tm, term) == 0)
+ return tc_store(term, tc);
+ fp = fopen(TERMCAP, "r");
+ }
+ /* otherwise, look `term' up in the file */
+ if (fp) {
+ char wrkbuf[TCBUFSIZ];
+ tc = tc_find(fp, term, wrkbuf, (int)(sizeof wrkbuf - strlen(term)));
+ result = tc_store(term, tc);
+ (void) fclose(fp);
+ } else {
+ result = -1;
+ }
+ return result;
+}
+
+/* copy the entry into the output buffer */
+static int
+tc_store(trm, ent)
+ const char *trm, *ent;
+{
+ const char *bar, *col;
+ char *s;
+ size_t n;
+ int k;
+
+ if (!ent || !*ent || !trm || !*trm || (col = index(ent, ':')) == 0)
+ return 0;
+ (void) strcpy(tc_entry, trm);
+ if (((bar = index(ent, '|')) != 0 && bar < col)
+ || ((long)(n = strlen(trm)) == (long)(col - ent)
+ && strncmp(ent, trm, n) == 0))
+ (void) strcat(tc_entry, col);
+ else if (*ent == ':')
+ (void) strcat(tc_entry, ent);
+ else
+ (void) strcat(strcat(tc_entry, ":"), ent);
+
+ /* initialize global variables */
+ k = tgetnum("pc");
+ PC = (k == -1) ? '\0' : (char)k;
+ BC = s = bc_up_buf;
+ if (!tgetstr("bc", &s)) (void)strcpy(s, "\b"), s += 2;
+ UP = s;
+ (void)tgetstr("up", &s);
+#ifndef NO_DELAY_PADDING
+ /* caller must set `ospeed' */
+ if ((int)ospeed >= (int)SIZE(baud_rates))
+ ospeed = (short)(SIZE(baud_rates) - 1);
+ else if (ospeed < 0)
+ ospeed = 0;
+#endif /* !NO_DELAY_PADDING */
+
+ return 1;
+}
+
+/* search for an entry in the termcap file */
+static char *
+tc_find(fp, term, buffer, bufsiz)
+ FILE *fp;
+ const char *term;
+ char *buffer;
+ int bufsiz;
+{
+ int in, len, first, skip;
+ char *ip, *op, *tc_fetch, tcbuf[TCBUFSIZ];
+
+ buffer[0] = '\0';
+ do {
+ ip = tcbuf, in = min(bufsiz,TCBUFSIZ);
+ first = 1, skip = 0;
+ /* load entire next entry, including any continuations */
+ do {
+ if (!fgets(ip, min(in,BUFSIZ), fp)) break;
+ if (first) skip = (*ip == '#'), first = 0;
+ len = (int)strlen(ip);
+ if (!skip && len > 1
+ && *(ip + len - 1) == '\n' && *(ip + len - 2) == '\\')
+ len -= 2;
+ ip += len, in -= len;
+ } while (*(ip - 1) != '\n' && in > 0);
+ if (ferror(fp) || ip == buffer || *(ip - 1) != '\n')
+ return (char *)0;
+ *--ip = '\0'; /* strip newline */
+ if (!skip) ip = tc_name(term, tcbuf);
+ } while (skip || !ip);
+
+ /* we have the desired entry; strip cruft and look for :tc=other: */
+ tc_fetch = 0;
+ for (op = buffer; *ip; ip++) {
+ if (op == buffer || *(op - 1) != ':'
+ || (*ip != ' ' && *ip != '\t' && *ip != ':'))
+ *op++ = *ip, bufsiz -= 1;
+ if (ip[0] == ':' && ip[1] == 't' && ip[2] == 'c' && ip[3] == '=') {
+ tc_fetch = &ip[4];
+ if ((ip = index(tc_fetch, ':')) != 0) *ip = '\0';
+ break;
+ }
+ }
+ *op = '\0';
+
+ if (tc_fetch) {
+ rewind(fp);
+ tc_fetch = tc_find(fp, tc_fetch, tcbuf, min(bufsiz,TCBUFSIZ));
+ if (!tc_fetch)
+ return (char *)0;
+ if (op > buffer && *(op - 1) == ':' && *tc_fetch == ':')
+ ++tc_fetch;
+ strcpy(op, tc_fetch);
+ }
+ return buffer;
+}
+
+/* check whether `ent' contains `nam'; return start of field entries */
+static char *
+tc_name(nam, ent)
+ const char *nam;
+ char *ent;
+{
+ char *nxt, *lst, *p = ent;
+ size_t n = strlen(nam);
+
+ if ((lst = index(p, ':')) == 0) lst = p + strlen(p);
+
+ while (p < lst) {
+ if ((nxt = index(p, '|')) == 0 || nxt > lst) nxt = lst;
+ if ((long)(nxt - p) == (long)n && strncmp(p, nam, n) == 0)
+ return lst;
+ p = nxt + 1;
+ }
+ return (char *)0;
+}
+
+/* look up a numeric entry */
+int
+tgetnum(which)
+ const char *which;
+{
+ const char *q, *p = tc_field(which, &q);
+ char numbuf[32];
+ size_t n;
+
+ if (!p || p[2] != '#')
+ return -1;
+ p += 3;
+ if ((n = (size_t)(q - p)) >= sizeof numbuf)
+ return -1;
+ (void) strncpy(numbuf, p, n);
+ numbuf[n] = '\0';
+ return atoi(numbuf);
+}
+
+/* look up a boolean entry */
+int
+tgetflag(which)
+ const char *which;
+{
+ const char *p = tc_field(which, (const char **)0);
+
+ return (!p || p[2] != ':') ? 0 : 1;
+}
+
+/* look up a string entry; update `*outptr' */
+char *
+tgetstr(which, outptr)
+ const char *which;
+ char **outptr;
+{
+ int n;
+ char c, *r, *result;
+ const char *q, *p = tc_field(which, &q);
+
+ if (!p || p[2] != '=')
+ return (char *)0;
+ p += 3;
+ if ((q = index(p, ':')) == 0) q = p + strlen(p);
+ r = result = *outptr;
+ while (p < q) {
+ switch ((*r = *p++)) {
+ case '\\':
+ switch ((c = *p++)) {
+ case 'E': *r = ESC; break;
+ case 'a': *r = BEL; break;
+ case 'b': *r = '\b'; break;
+ case 'f': *r = '\f'; break;
+ case 'n': *r = '\n'; break;
+ case 'r': *r = '\r'; break;
+ case 't': *r = '\t'; break;
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ n = c - '0';
+ if (*p >= '0' && *p <= '7') n = 8 * n + (*p++ - '0');
+ if (*p >= '0' && *p <= '7') n = 8 * n + (*p++ - '0');
+ *r = (char)n;
+ break;
+ /* case '^': case '\\': */
+ default: *r = c; break;
+ }
+ break;
+ case '^':
+ *r = (*p++ & 037);
+ if (!*r) *r = (char)'\200';
+ break;
+ default:
+ break;
+ }
+ ++r;
+ }
+ *r++ = '\0';
+ *outptr = r;
+ return result;
+}
+
+/* look for a particular field name */
+static const char *
+tc_field(field, tc_end)
+ const char *field;
+ const char **tc_end;
+{
+ const char *end, *q, *p = tc_entry;
+
+ end = p + strlen(p);
+ while (p < end) {
+ if ((p = index(p, ':')) == 0)
+ break;
+ ++p;
+ if (p[0] == field[0] && p[1] == field[1]
+ && (p[2] == ':' || p[2] == '=' || p[2] == '#' || p[2] == '@'))
+ break;
+ }
+ if (tc_end) {
+ if (p) {
+ if ((q = index(p + 2, ':')) == 0) q = end;
+ } else
+ q = 0;
+ *tc_end = q;
+ }
+ return p;
+}
+
+static char cmbuf[64];
+
+/* produce a string which will position the cursor at <row,col> if output */
+char *
+tgoto(cm, col, row)
+ const char *cm;
+ int col, row;
+{
+ return tparam(cm, cmbuf, (int)(sizeof cmbuf), row, col, 0, 0);
+}
+
+/* format a parameterized string, ala sprintf */
+char *
+tparam(ctl, buf, buflen, row, col, row2, col2)
+ const char *ctl; /* parameter control string */
+ char *buf; /* output buffer */
+ int buflen; /* ought to have been `size_t'... */
+ int row, col, row2, col2;
+{
+ int atmp, ac, av[5];
+ char c, *r, *z, *bufend, numbuf[32];
+ const char *fmt;
+#ifndef NO_SPECIAL_CHARS_FIXUP
+ int bc = 0, up = 0;
+#endif
+
+ av[0] = row, av[1] = col, av[2] = row2, av[3] = col2, av[4] = 0;
+ ac = 0;
+ r = buf, bufend = r + buflen - 1;
+ while (*ctl) {
+ if ((*r = *ctl++) == '%') {
+ if (ac > 4) ac = 4;
+ fmt = 0;
+ switch ((c = *ctl++)) {
+ case '%': break; /* '%' already copied */
+ case 'd': fmt = "%d"; break;
+ case '2': fmt = "%02d"; break;
+ case '3': fmt = "%03d"; break;
+ case '+': /*FALLTHRU*/
+ case '.': *r = (char)av[ac++];
+ if (c == '+') *r += *ctl++;
+ if (!*r) {
+ *r = (char)'\200';
+ } else {
+#ifndef NO_SPECIAL_CHARS_FIXUP
+ /* avoid terminal driver intervention for
+ various control characters, to prevent
+ LF from becoming CR+LF, for instance; only
+ makes sense if this is a cursor positioning
+ sequence, but we have no way to check that */
+ while (index("\004\t\n\013\f\r", *r)) {
+ if (ac & 1) { /* row */
+ if (!UP || !*UP) break; /* can't fix */
+ ++up; /* incr row now, later move up */
+ } else { /* column */
+ if (!BC || !*BC) break; /* can't fix */
+ ++bc; /* incr column, later backspace */
+ }
+ (*r)++;
+ }
+#endif /* !NO_SPECIAL_CHARS_FIXUP */
+ } break;
+ case '>': if (av[ac] > (*ctl++ & 0377))
+ av[ac] += *ctl;
+ ++ctl; break;
+ case 'r': atmp = av[0]; av[0] = av[1]; av[1] = atmp;
+ atmp = av[2]; av[2] = av[3]; av[3] = atmp;
+ --r; break;
+ case 'i': ++av[0]; ++av[1]; ++av[2]; ++av[3];
+ --r; break;
+ case 'n': av[0] ^= 0140; av[1] ^= 0140;
+ av[2] ^= 0140; av[3] ^= 0140;
+ --r; break;
+ case 'B': av[0] = ((av[0] / 10) << 4) + (av[0] % 10);
+ av[1] = ((av[1] / 10) << 4) + (av[1] % 10);
+ av[2] = ((av[2] / 10) << 4) + (av[2] % 10);
+ av[3] = ((av[3] / 10) << 4) + (av[3] % 10);
+ --r; break;
+ case 'D': av[0] -= (av[0] & 15) << 1;
+ av[1] -= (av[1] & 15) << 1;
+ av[2] -= (av[2] & 15) << 1;
+ av[3] -= (av[3] & 15) << 1;
+ --r; break;
+ default: *++r = c; break; /* erroneous entry... */
+ }
+ if (fmt) {
+ (void) sprintf(numbuf, fmt, av[ac++]);
+ for (z = numbuf; *z && r <= bufend; z++)
+ *r++ = *z;
+ --r; /* will be re-incremented below */
+ }
+ }
+ if (++r > bufend)
+ return (char *)0;
+ }
+#ifndef NO_SPECIAL_CHARS_FIXUP
+ if (bc || up) {
+ while (--bc >= 0)
+ for (z = BC; *z && r <= bufend; z++)
+ *r++ = *z;
+ while (--up >= 0)
+ for (z = UP; *z && r <= bufend; z++)
+ *r++ = *z;
+ if (r > bufend)
+ return (char *)0;
+ }
+#endif /* !NO_SPECIAL_CHARS_FIXUP */
+ *r = '\0';
+ return buf;
+}
+
+/* send a string to the terminal, possibly padded with trailing NULs */
+void
+tputs( string, range, output_func )
+const char *string; /* characters to output */
+int range; /* number of lines affected, used for `*' delays */
+int (*output_func)(); /* actual output routine; return value ignored */
+{
+ register int c, num = 0;
+ register const char *p = string;
+
+ if (!p || !*p)
+ return;
+
+ /* pick out padding prefix, if any */
+ if (*p >= '0' && *p <= '9') {
+ do { /* note: scale `num' by 10 to accommodate fraction */
+ num += (*p++ - '0'), num *= 10;
+ } while (*p >= '0' && *p <= '9');
+ if (*p == '.')
+ ++p, num += (*p >= '0' && *p <= '9') ? (*p++ - '0') : 0;
+ if (*p == '*')
+ ++p, num *= range;
+ }
+
+ /* output the string */
+ while ((c = *p++) != '\0') {
+ if (c == '\200') c = '\0'; /* undo tgetstr's encoding */
+ (void) (*output_func)(c);
+ }
+
+#ifndef NO_DELAY_PADDING
+ /* perform padding */
+ if (num) {
+ long pad;
+
+ /* figure out how many chars needed to produce desired elapsed time */
+ pad = (long)baud_rates[ospeed];
+ if (pad < 0) pad *= -100L;
+ pad *= (long)num;
+ /* 100000 == 10 bits/char * (1000 millisec/sec scaled by 10) */
+ num = (int)(pad / 100000L); /* number of characters */
+
+ c = PC; /* assume output_func isn't allowed to change PC */
+ while (--num >= 0)
+ (void) (*output_func)(c);
+ }
+#endif /* !NO_DELAY_PADDING */
+
+ return;
+}
+
+/*tclib.c*/
projects / nethack / commitdiff