This is termlib.c in view mode; [Download] [Up]
/* vi:set ts=4 sw=4:
The following software is (C) 1984 Peter da Silva,
the Mad Australian, in the public domain. It may
be re-distributed for any purpose with the inclusion
of this notice. */
/* modified by Bram Moolenaar for use with VIM - Vi Improved */
/* a few bugs removed by Olaf 'Rhialto' Seibert */
/* TERMLIB: Terminal independant database. */
#include "vim.h"
#include "proto.h"
#include "proto/termlib.pro"
#if !defined(AMIGA) && !defined(VMS)
# include <sgtty.h>
#endif
static int getent __PARMS((char *, char *, FILE *, int));
static int nextent __PARMS((char *, FILE *, int));
static int _match __PARMS((char *, char *));
static char *_addfmt __PARMS((char *, char *, int));
static char *_find __PARMS((char *, char *));
/*
* Global variables for termlib
*/
char *tent; /* Pointer to terminal entry, set by tgetent */
char PC = 0; /* Pad character, default NULL */
char *UP = 0, *BC = 0; /* Pointers to UP and BC strings from database */
short ospeed; /* Baud rate (1-16, 1=300, 16=19200), as in stty */
/*
* Module: tgetent
*
* Purpose: Get termcap entry for <term> into buffer at <tbuf>.
*
* Calling conventions: char tbuf[TBUFSZ+], term=canonical name for
* terminal.
*
* Returned values: 1 = success, -1 = can't open file,
* 0 = can't find terminal.
*
* Notes
* Should probably supply static buffer.
*
* Uses environment variables "TERM" and
* "TERMCAP". If TERM = term (that is, if the argument
* matches the environment) then it looks at TERMCAP.
* If TERMCAP begins with a slash, then it assumes
* this is the file to search rather than /etc/termcap.
* If TERMCAP does not begin with a slash, and it
* matches TERM, then this is used as the entry.
*
* This could be simplified considerably for non-UNIX
* systems.
*/
#ifdef AMIGA
# define TERMCAPFILE "s:termcap"
#else
# define TERMCAPFILE "/etc/termcap"
#endif
tgetent(tbuf, term)
char *tbuf; /* Buffer to hold termcap entry, TBUFSZ bytes max */
char *term; /* Name of terminal */
{
char tcbuf[32]; /* Temp buffer to handle */
char *tcptr = tcbuf; /* extended entries */
char *tcap = TERMCAPFILE; /* Default termcap file */
char *tmp;
FILE *termcap;
int retval = 0;
int len;
if ((tmp = (char *)vim_getenv((char_u *)"TERMCAP")) != NULL)
{
if (*tmp == '/') /* TERMCAP = name of termcap file */
{
tcap = tmp ;
#if defined(AMIGA)
/* Convert /usr/share/lib/termcap to usr:share/lib/termcap */
tcap++;
tmp = strchr(tcap, '/');
if (tmp)
*tmp = ':';
#endif
}
else /* TERMCAP = termcap entry itself */
{
int tlen = strlen(term);
while (*tmp && *tmp != ':') /* Check if TERM matches */
{
char *nexttmp;
while (*tmp == '|')
tmp++;
nexttmp = _find(tmp, ":|"); /* Rhialto */
if (tmp+tlen == nexttmp && _match(tmp, term) == tlen)
{
strcpy(tbuf, tmp);
tent = tbuf;
return 1;
}
else
tmp = nexttmp;
}
}
}
if (!(termcap = fopen(tcap, "r")))
{
strcpy(tbuf, tcap);
return -1;
}
len = 0;
while (getent(tbuf + len, term, termcap, TBUFSZ - len))
{
tcptr = tcbuf; /* Rhialto */
if ((term = tgetstr("tc", &tcptr))) /* extended entry */
{
rewind(termcap);
len = strlen(tbuf);
}
else
{
retval = 1;
tent = tbuf; /* reset it back to the beginning */
break;
}
}
fclose(termcap);
return retval;
}
static int
getent(tbuf, term, termcap, buflen)
char *tbuf, *term;
FILE *termcap;
int buflen;
{
char *tptr;
int tlen = strlen(term);
while (nextent(tbuf, termcap, buflen)) /* For each possible entry */
{
tptr = tbuf;
while (*tptr && *tptr != ':') /* : terminates name field */
{
char *nexttptr;
while (*tptr == '|') /* | seperates names */
tptr++;
nexttptr = _find(tptr, ":|"); /* Rhialto */
if (tptr + tlen == nexttptr &&
_match(tptr, term) == tlen) /* FOUND! */
{
tent = tbuf;
return 1;
}
else /* Look for next name */
tptr = nexttptr;
}
}
return 0;
}
static int
nextent(tbuf, termcap, buflen) /* Read 1 entry from TERMCAP file */
char *tbuf;
FILE *termcap;
int buflen;
{
char *lbuf = tbuf; /* lbuf=line buffer */
/* read lines straight into buffer */
while (lbuf < tbuf+buflen && /* There's room and */
fgets(lbuf, (int)(tbuf+buflen-lbuf), termcap)) /* another line */
{
int llen = strlen(lbuf);
if (*lbuf == '#') /* eat comments */
continue;
if (lbuf[-1] == ':' && /* and whitespace */
lbuf[0] == '\t' &&
lbuf[1] == ':')
{
strcpy(lbuf, lbuf+2);
llen -= 2;
}
if (lbuf[llen-2] == '\\') /* and continuations */
lbuf += llen-2;
else
{
lbuf[llen-1]=0; /* no continuation, return */
return 1;
}
}
return 0; /* ran into end of file */
}
/*
* Module: tgetflag
*
* Purpose: returns flag true or false as to the existence of a given
* entry. used with 'bs', 'am', etc...
*
* Calling conventions: id is the 2 character capability id.
*
* Returned values: 1 for success, 0 for failure.
*/
tgetflag(id)
char *id;
{
char buf[256], *ptr = buf;
return tgetstr(id, &ptr) ? 1 : 0;
}
/*
* Module: tgetnum
*
* Purpose: get numeric value such as 'li' or 'co' from termcap.
*
* Calling conventions: id = 2 character id.
*
* Returned values: -1 for failure, else numerical value.
*/
tgetnum(id)
char *id;
{
char *ptr, buf[256];
ptr = buf;
if (tgetstr(id, &ptr))
return atoi(buf);
else
return 0;
}
/*
* Module: tgetstr
*
* Purpose: get terminal capability string from database.
*
* Calling conventions: id is the two character capability id.
* (*buf) points into a hold buffer for the
* id. the capability is copied into the buffer
* and (*buf) is advanced to point to the next
* free byte in the buffer.
*
* Returned values: 0 = no such entry, otherwise returns original
* (*buf) (now a pointer to the string).
*
* Notes
* It also decodes certain escape sequences in the buffer.
* they should be obvious from the code:
* \E = escape.
* \n, \r, \t, \f, \b match the 'c' escapes.
* ^x matches control-x (^@...^_).
* \nnn matches nnn octal.
* \x, where x is anything else, matches x. I differ
* from the standard library here, in that I allow ^: to match
* :.
*
*/
char *
tgetstr(id, buf)
char *id, **buf;
{
int len = strlen(id);
char *tmp=tent;
char *hold;
int i;
do {
tmp = _find(tmp, ":"); /* For each field */
while (*tmp == ':') /* skip empty fields */
tmp++;
if (!*tmp)
break;
if (_match(id, tmp) == len) {
tmp += len; /* find '=' '@' or '#' */
if (*tmp == '@') /* :xx@: entry for tc */
return 0; /* deleted entry */
hold= *buf;
while (*++tmp && *tmp != ':') {/* not at end of field */
switch(*tmp) {
case '\\': /* Expand escapes here */
switch(*++tmp) {
case 0: /* ignore backslashes */
tmp--; /* at end of entry */
break; /* shouldn't happen */
case 'e':
case 'E': /* ESC */
*(*buf)++ = '\033';
break;
case 'n': /* \n */
*(*buf)++ = '\n';
break;
case 'r': /* \r */
*(*buf)++ = '\r';
break;
case 't': /* \t */
*(*buf)++ = '\t';
break;
case 'b': /* \b */
*(*buf)++ = '\b';
break;
case 'f': /* \f */
*(*buf)++ = '\f';
break;
case '0': /* \nnn */
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
**buf = 0;
/* get up to three digits */
for (i = 0; i < 3 && isdigit(*tmp); ++i)
**buf = **buf * 8 + *tmp++ - '0';
(*buf)++;
tmp--;
break;
default: /* \x, for all other x */
*(*buf)++= *tmp;
}
break;
case '^': /* control characters */
*(*buf)++ = *++tmp - '@';
break;
default:
*(*buf)++ = *tmp;
}
}
*(*buf)++ = 0;
return hold;
}
} while (*tmp);
return 0;
}
/*
* Module: tgoto
*
* Purpose: decode cm cursor motion string.
*
* Calling conventions: cm is cursor motion string.
* line, col, are the desired destination.
*
* Returned values: a string pointing to the decoded string, or
* "OOPS" if it cannot be decoded.
*
* Notes
* The accepted escapes are:
* %d as in printf, 0 origin.
* %2, %3 like %02d, %03d in printf.
* %. like %c
* %+x adds <x> to value, then %.
* %>xy if value>x, adds y. No output.
* %i increments line& col, no output.
* %r reverses order of line&col. No output.
* %% prints as a single %.
* %n exclusive or row & col with 0140.
* %B BCD, no output.
* %D reverse coding (x-2*(x%16)), no output.
*/
char *
tgoto(cm, col, line)
char *cm; /* cm string, from termcap */
int col, /* column, x position */
line; /* line, y position */
{
char gx, gy, /* x, y */
*ptr, /* pointer in 'cm' */
reverse = 0, /* reverse flag */
*bufp, /* pointer in returned string */
addup = 0, /* add upline */
addbak = 0, /* add backup */
c;
static char buffer[32];
if (!cm)
return "OOPS"; /* Kludge, but standard */
bufp = buffer;
ptr = cm;
while (*ptr) {
if ((c = *ptr++) != '%') { /* normal char */
*bufp++ = c;
} else { /* % escape */
switch(c = *ptr++) {
case 'd': /* decimal */
bufp = _addfmt(bufp, "%d", line);
line = col;
break;
case '2': /* 2 digit decimal */
bufp = _addfmt(bufp, "%02d", line);
line = col;
break;
case '3': /* 3 digit decimal */
bufp = _addfmt(bufp, "%03d", line);
line = col;
break;
case '>': /* %>xy: if >x, add y */
gx = *ptr++;
gy = *ptr++;
if (col>gx) col += gy;
if (line>gx) line += gy;
break;
case '+': /* %+c: add c */
line += *ptr++;
case '.': /* print x/y */
if (line == '\t' || /* these are */
line == '\n' || /* chars that */
line == '\004' || /* UNIX hates */
line == '\0') {
line++; /* so go to next pos */
if (reverse == (line == col))
addup=1; /* and mark UP */
else
addbak=1; /* or BC */
}
*bufp++=line;
line = col;
break;
case 'r': /* r: reverse */
gx = line;
line = col;
col = gx;
reverse = 1;
break;
case 'i': /* increment (1-origin screen) */
col++;
line++;
break;
case '%': /* %%=% literally */
*bufp++='%';
break;
case 'n': /* magic DM2500 code */
line ^= 0140;
col ^= 0140;
break;
case 'B': /* bcd encoding */
line = line/10<<4+line%10;
col = col/10<<4+col%10;
break;
case 'D': /* magic Delta Data code */
line = line-2*(line&15);
col = col-2*(col&15);
break;
default: /* Unknown escape */
return "OOPS";
}
}
}
if (addup) /* add upline */
if (UP) {
ptr=UP;
while (isdigit(*ptr) || *ptr == '.')
ptr++;
if (*ptr == '*')
ptr++;
while (*ptr)
*bufp++ = *ptr++;
}
if (addbak) /* add backspace */
if (BC) {
ptr=BC;
while (isdigit(*ptr) || *ptr == '.')
ptr++;
if (*ptr == '*')
ptr++;
while (*ptr)
*bufp++ = *ptr++;
}
else
*bufp++='\b';
*bufp = 0;
return(buffer);
}
/*
* Module: tinit
*
* Purpose: simplified terminal initialisation.
*
* Calling conventions: name is name of terminal.
*
* Returned values: none.
*
* Notes
* tinit calls tgetent, then sets up the global
* variables PC, UP, BC, ospeed appropriately.
*
*/
#if 0 /* already included in term.c */
char tbuf[TBUFSZ]; /* Buffer for termcap entry */
char junkbuf[TBUFSZ]; /* Big buffer for junk */
char *junkptr;
tinit(name)
char *name;
{
#ifndef AMIGA
struct sgttyb sgbuf;
#endif
char *ps;
junkptr = junkbuf;
tgetent(tbuf, name);
ps = tgetstr("pc", &junkptr);
if (ps) PC = *ps;
UP = tgetstr("up", &junkptr);
BC = tgetstr("bc", &junkptr);
#ifdef AMIGA
ospeed=0;
#else
gtty(1, &sgbuf);
ospeed=sgbuf.sg_ospeed;
#endif
return 0;
}
#endif
/*
* Module: tputs
*
* Purpose: decode padding information
*
* Calling conventions: cp = string to be padded, affcnt = # of items
* affected (lines, characters, whatever),
* outc = routine to output 1 character.
*
* Returned values: none
*
* Notes
* cp has padding information ahead of it, in the form
* nnnTEXT or nnn*TEXT. nnn is the number of milliseconds to delay,
* and may be a decimal (nnn.mmm). If the asterisk is given, then
* the delay is multiplied by afcnt. The delay is produced by outputting
* a number of nulls (or other padding char) after printing the
* TEXT.
*
*/
long _bauds[16]={
0, 50, 75, 110,
134, 150, 200, 300,
600, 1200, 1800, 2400,
4800, 9600, 19200, 19200 };
tputs(cp, affcnt, outc)
char *cp; /* string to print */
int affcnt; /* Number of lines affected */
void (*outc) __ARGS((unsigned int)); /* routine to output 1 character */
{
long frac, /* 10^(#digits after decimal point) */
counter, /* digits */
atol __ARGS((const char *));
if (isdigit(*cp)) {
counter = 0;
frac = 1000;
while (isdigit(*cp))
counter = counter * 10L + (long)(*cp++ - '0');
if (*cp == '.')
while (isdigit(*++cp)) {
counter = counter * 10L + (long)(*cp++ - '0');
frac = frac * 10;
}
if (*cp!='*') { /* multiply by affected lines */
if (affcnt>1) affcnt = 1;
}
else
cp++;
/* Calculate number of characters for padding counter/frac ms delay */
if (ospeed)
counter = (counter * _bauds[ospeed] * (long)affcnt) / frac;
while (*cp) /* output string */
(*outc)(*cp++);
if (ospeed)
while (counter--) /* followed by pad characters */
(*outc)(PC);
}
else
while (*cp)
(*outc)(*cp++);
return 0;
}
/*
* Module: tutil.c
*
* Purpose: Utility routines for TERMLIB functions.
*
*/
static int
_match(s1, s2) /* returns length of text common to s1 and s2 */
char *s1, *s2;
{
int i = 0;
while (s1[i] && s1[i] == s2[i])
i++;
return i;
}
static char *
_find(s, set) /* finds next c in s that's a member of set, returns pointer */
char *s, *set;
{
for(; *s; s++) {
char *ptr = set;
while (*ptr && *s != *ptr)
ptr++;
if (*ptr)
return s;
}
return s;
}
static char *
_addfmt(buf, fmt, val) /* add val to buf according to format fmt */
char *buf, *fmt;
int val;
{
sprintf(buf, fmt, val);
while (*buf)
buf++;
return buf;
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.