/*
* termcap.c 1.1 20/7/87 agc Joypace Ltd
*
* Copyright Joypace Ltd, London, UK, 1987. All rights reserved.
* This file may be freely distributed provided that this notice
* remains attached.
*
* A public domain implementation of the termcap(3) routines.
*
* Made fully functional by Ceriel J.H. Jacobs.
*
* BUGS:
* - does not check termcap entry sizes
* - not fully tested
*/
/* $Id$ */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define CAPABLEN 2
#define ISSPACE(c) ((c) == ' ' || (c) == '\t' || (c) == '\r' || (c) == '\n')
#define ISDIGIT(x) ((x) >= '0' && (x) <= '9')
short ospeed; /* output speed */
char PC; /* padding character */
char* BC; /* back cursor movement */
char* UP; /* up cursor movement */
static const char* capab; /* the capability itself */
static int check_for_tc(void);
static int match_name(const char* buf, const char* name);
/*
* tgetent - get the termcap entry for terminal name, and put it
* in bp (which must be an array of 1024 chars). Returns 1 if
* termcap entry found, 0 if not found, and -1 if file not found.
*/
int tgetent(char* bp, const char* name)
{
FILE* fp;
char* file;
char* cp;
char buf[1024];
capab = bp;
if ((file = getenv("TERMCAP")) != (char*)NULL)
{
if (*file != '/' && (cp = getenv("TERM")) != NULL && strcmp(name, cp) == 0)
{
(void)strcpy(bp, file);
return (1);
}
else
file = "/etc/termcap";
}
else
file = "/etc/termcap";
if ((fp = fopen(file, "r")) == (FILE*)NULL)
return (-1);
while (fgets(buf, 1024, fp) != NULL)
{
if (buf[0] == '#')
continue;
while (*(cp = &buf[strlen(buf) - 2]) == '\\')
if (fgets(cp, 1024, fp) == NULL)
goto exit;
if (match_name(buf, name))
{
strcpy(bp, buf);
fclose(fp);
return (check_for_tc());
}
}
exit:
fclose(fp);
return (0);
}
/*
* Compare the terminal name with each termcap entry name; Return 1 if a
* match is found.
*/
static int
match_name(const char* buf, const char* name)
{
register const char* tp = buf;
register const char* np;
for (;;)
{
for (np = name; *np && *tp == *np; np++, tp++)
{
}
if (*np == 0 && (*tp == '|' || *tp == ':' || *tp == 0))
return (1);
while (*tp != 0 && *tp != '|' && *tp != ':')
tp++;
if (*tp++ != '|')
return (0);
}
}
/*
* Handle tc= definitions recursively.
*/
static int
check_for_tc(void)
{
static int count = 0;
const char* savcapab = capab;
char buf[1024];
char terminalname[128];
register char *p = (char*)capab + strlen(capab) - 2, *q;
while (*p != ':')
if (--p < (char*)capab)
return (0); /* no : in termcap entry */
if (p[1] != 't' || p[2] != 'c')
return (1);
if (count > 16)
return (0); /* recursion in tc= definitions */
count++;
strcpy(terminalname, &p[4]);
q = terminalname;
while (*q && *q != ':')
q++;
*q = 0;
if (tgetent(buf, terminalname) != 1)
{
--count;
return (0);
}
--count;
for (q = buf; *q && *q != ':'; q++)
{
}
strcpy(p, q);
capab = savcapab;
return (1);
}
/*
* tgetnum - get the numeric terminal capability corresponding
* to id. Returns the value, -1 if invalid.
*/
int tgetnum(const char* id)
{
const char* cp;
int ret;
if ((cp = capab) == NULL || id == NULL)
return (-1);
while (*++cp != ':')
;
while (*cp)
{
cp++;
while (ISSPACE(*cp))
cp++;
if (strncmp(cp, id, CAPABLEN) == 0)
{
while (*cp && *cp != ':' && *cp != '#')
cp++;
if (*cp != '#')
return (-1);
for (ret = 0, cp++; *cp && ISDIGIT(*cp); cp++)
ret = ret * 10 + *cp - '0';
return (ret);
}
while (*cp && *cp != ':')
cp++;
}
return (-1);
}
/*
* tgetflag - get the boolean flag corresponding to id. Returns -1
* if invalid, 0 if the flag is not in termcap entry, or 1 if it is
* present.
*/
int tgetflag(const char* id)
{
const char* cp;
if ((cp = capab) == NULL || id == NULL)
return (-1);
while (*++cp != ':')
;
while (*cp)
{
cp++;
while (ISSPACE(*cp))
cp++;
if (strncmp(cp, id, CAPABLEN) == 0)
return (1);
while (*cp && *cp != ':')
cp++;
}
return (0);
}
/*
* tgetstr - get the string capability corresponding to id and place
* it in area (advancing area at same time). Expand escape sequences
* etc. Returns the string, or NULL if it can't do it.
*/
char* tgetstr(const char* id, char** const area)
{
const char* cp;
char* ret;
int i;
if ((cp = capab) == NULL || id == NULL)
return (NULL);
while (*++cp != ':')
;
while (*cp)
{
cp++;
while (ISSPACE(*cp))
cp++;
if (strncmp(cp, id, CAPABLEN) == 0)
{
while (*cp && *cp != ':' && *cp != '=')
cp++;
if (*cp != '=')
return (NULL);
for (ret = *area, cp++; *cp && *cp != ':'; (*area)++, cp++)
switch (*cp)
{
case '^':
**area = *++cp - 'A' + 1;
break;
case '\\':
switch (*++cp)
{
case 'E':
**area = '\033';
break;
case 'n':
**area = '\n';
break;
case 'r':
**area = '\r';
break;
case 't':
**area = '\t';
break;
case 'b':
**area = '\b';
break;
case 'f':
**area = '\f';
break;
case '0':
case '1':
case '2':
case '3':
for (i = 0; *cp && ISDIGIT(*cp); cp++)
i = i * 8 + *cp - '0';
**area = i;
cp--;
break;
case '^':
case '\\':
**area = *cp;
break;
}
break;
default:
**area = *cp;
}
*(*area)++ = '\0';
return (ret);
}
while (*cp && *cp != ':')
cp++;
}
return (NULL);
}
/*
* tgoto - given the cursor motion string cm, make up the string
* for the cursor to go to (destcol, destline), and return the string.
* Returns "OOPS" if something's gone wrong, or the string otherwise.
*/
char* tgoto(const char* cm, int destcol, int destline)
{
register char* rp;
static char ret[24];
char added[16];
int* dp = &destline;
int numval;
int swapped = 0;
added[0] = 0;
for (rp = ret; *cm; cm++)
{
if (*cm == '%')
{
switch (*++cm)
{
case '>':
if (dp == NULL)
return ("OOPS");
cm++;
if (*dp > *cm++)
{
*dp += *cm;
}
break;
case '+':
case '.':
if (dp == NULL)
return ("OOPS");
if (*cm == '+')
*dp = *dp + *++cm;
for (;;)
{
switch (*dp)
{
case 0:
case 04:
case '\t':
case '\n':
/* filter these out */
if (dp == &destcol || swapped || UP)
{
strcat(added, dp == &destcol || swapped ? (BC ? BC : "\b") : UP);
(*dp)++;
continue;
}
}
break;
}
*rp++ = *dp;
dp = (dp == &destline) ? &destcol : NULL;
break;
case 'r':
{
int tmp = destline;
destline = destcol;
destcol = tmp;
swapped = 1 - swapped;
break;
}
case 'n':
destcol ^= 0140;
destline ^= 0140;
break;
case '%':
*rp++ = '%';
break;
case 'i':
destcol++;
destline++;
break;
case 'B':
if (dp == NULL)
return ("OOPS");
*dp = 16 * (*dp / 10) + *dp % 10;
break;
case 'D':
if (dp == NULL)
return ("OOPS");
*dp = *dp - 2 * (*dp % 16);
break;
case 'd':
case '2':
case '3':
if (dp == NULL)
return ("OOPS");
numval = *dp;
dp = (dp == &destline) ? &destcol : NULL;
if (numval >= 100)
{
*rp++ = '0' + numval / 100;
}
else if (*cm == '3')
{
*rp++ = ' ';
}
if (numval >= 10)
{
*rp++ = '0' + ((numval % 100) / 10);
}
else if (*cm == '3' || *cm == '2')
{
*rp++ = ' ';
}
*rp++ = '0' + (numval % 10);
break;
default:
return ("OOPS");
}
}
else
*rp++ = *cm;
}
*rp = '\0';
strcpy(rp, added);
return (ret);
}
static int tens_of_ms_p_char[] = { /* index as returned by gtty */
/* assume 10 bits per char */
0, 2000, 1333, 909, 743, 666, 500, 333, 166, 83, 55, 41, 20, 10, 5, 2
};
/*
* tputs - put the string cp out onto the terminal, using the function
* outc. Also handle padding.
*/
int tputs(register const char* cp, int affcnt, int (*outc)(int))
{
int delay = 0;
if (cp == NULL)
return (1);
while (ISDIGIT(*cp))
{
delay = delay * 10 + (*cp++ - '0');
}
delay *= 10;
if (*cp == '.')
{
cp++;
if (ISDIGIT(*cp))
{
delay += *cp++ - '0';
}
while (ISDIGIT(*cp))
cp++;
}
if (*cp == '*')
{
delay *= affcnt;
cp++;
}
while (*cp)
(*outc)(*cp++);
if (delay != 0 && ospeed > 0 && ospeed < (sizeof tens_of_ms_p_char / sizeof tens_of_ms_p_char[0]))
{
delay = (delay + tens_of_ms_p_char[ospeed] - 1) / tens_of_ms_p_char[ospeed];
while (delay--)
(*outc)(PC);
}
return (1);
}
/*
* That's all, folks...
*/