Source Code 1994 March/Source_Code_CD-ROM_Walnut_Creek_March_1994.iso/compsrcs/unix/volume26/mytinfo/part03

Text File | 1992-12-26 | 62.2 KB | 3,149 lines

Newsgroups: comp.sources.unix
From: [e-mail] (Ross Ridge)
Subject: v26i079: mytinfo - a replacement for terminfo and termcap, Part03/03
Sender: [e-mail]
Approved: [e-mail]

Submitted-By: [e-mail] (Ross Ridge)
Posting-Number: Volume 26, Issue 79
Archive-Name: mytinfo/part03

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 3 (of 3)."
# Contents:  tconv.c tparm.c tset.c
# Wrapped by [e-mail] on Sun Dec 27 14:45:20 1992
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'tconv.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'tconv.c'\"
else
echo shar: Extracting \"'tconv.c'\" \(26474 characters\)
sed "s/^X//" >'tconv.c' <<'END_OF_FILE'
X/*
X * tconv.c
X *
X * Ross Ridge
X * Public Domain
X * 92/02/01 07:30:23
X *
X * tconv [-b] [-c [-OUGd]] [-i] [-B [-D dir]] [-I] [-k] [-V] [-t term] [file]
X *
X * -c        convert from termcap
X * -i        convert from terminfo source
X * -b        convert from terminfo binary
X * -B        convert to terminfo binary
X * -I        convert to terminfo source
X * -V        print version info
X *
X * The following switches are available when converting from termcap:
X * -d        don't supply any defaults for missing capabilities
X * -O        include obsolete termcap capabilities
X * -G        include GNU capabilities
X * -U        include UW capabilities
X *
X * -k        keep comments
X * -D dir    directory to put terminfo binaries in
X *
X * -t term    name of terminal to translate
X * file        filename of termcap/terminfo database to use
X *
X * If a file is specifed and no terminal is given the entire file we be
X * translated.
X * If no terminal and no file is specified then the terminal name will be
X * taken from the environment variable TERM.
X * Unless compiling to a terminfo binary, output is to stdout.
X *
X */
X
X#define NOTLIB
X#include "defs.h"
X#define SINGLE
X#include "term.h"
X
X#include <ctype.h>
X#include <fcntl.h>
X#ifdef USE_STDDEF
X#include <sys/types.h>
X#endif
X#include <sys/stat.h>
X
X#include "strtok.c"
X#include "mkdir.c"
X
X#ifndef lint
static const char SCCSid[] = "@(#) mytinfo tconv.c 3.2 92/02/01 public domain, By Ross Ridge";
X#endif
X
extern int errno;
X
X/* the right margin of the output */
X#define LINELEN 76
X
struct term_path *path;    /* returned from _buildpath */
X
TERMINAL _term_buf;
char buf[MAX_BUF+1];    /* buffer for the termcap entry */
X
int noOT = 1;        /* -O */
int noGNU = 1;        /* -G */
int noUW = 1;        /* -W */
int dodefault = 1;    /* -d */
int keepcomments = 0;    /* -k */
int compile = 0;    /* -B */
int from_tcap = 0;    /* -c */
int from_tinfo = 0;    /* -i */
int from_tbin = 0;    /* -b */
char *directory = NULL; /* -D */
X
int continued = 0;
int termcap = 1;
X
int lineno = 0;        /* current line number */
X
X/* print the first part of a warning message */
void
warn() {
X    if (lineno == 0)
X        fprintf(stderr, "warning: ");
X    else
X        fprintf(stderr, "(%s)%d: warning: ",
X            _term_buf.name_long, lineno);
X}
X
X/* output a string indenting at the beginning of a line, and wraping
X * at the right margin.
X */
void
putstr(s)
char *s; {
X    static pos = 0;
X    int l;
X
X    if (s == NULL) {
X        if (pos != 0) {
X            pos = 0;
X            putchar('\n');
X        }
X        return;
X    }
X
X    if (termcap && noOT && *s == 'O')
X        return;
X    if (termcap && noGNU && *s == 'G')
X        return;
X    if (termcap && noUW && *s == 'U')
X        return;
X
X    l = strlen(s) + 2;
X
X    if (l + pos > LINELEN && pos != 0) {
X        putchar('\n');
X        pos = 0;
X    }
X
X    if (pos == 0) {
X        putchar('\t');
X        pos = 8;
X    } else
X        putchar(' ');
X
X    printf("%s,", s);
X
X    pos += l;
X}
X
X#ifndef MAX_PUSHED
X/* maximum # of parameters that can be pushed onto the stack */
X#define MAX_PUSHED 16
X#endif
X
int stack[MAX_PUSHED];    /* the stack */
int stackptr;        /* the next empty place on the stack */
int onstack;        /* the top of stack */
int seenm;        /* seen a %m */
int seenn;        /* seen a %n */
int seenr;        /* seen a %r */
int param;        /* current parameter */
char *dp;        /* pointer to the end of the converted string */
X
X/* push onstack on to the stack */
void
push() {
X    if (stackptr > MAX_PUSHED) {
X        warn();
X        fprintf(stderr, "string to complex to covert\n");
X    } else
X        stack[stackptr++] = onstack;
X}
X
X/* pop the top of the stack into onstack */
void
pop() {
X    if (stackptr == 0)
X        if (onstack == 0) {
X            warn();
X            fprintf(stderr, "I'm confused\n");
X        } else
X            onstack = 0;
X    else
X        onstack = stack[--stackptr];
X    param++;
X}
X
X/* convert a character to a terminfo push */
static int
cvtchar(sp)
register char *sp; {
X    char c;
X    int l;
X
X    switch(*sp) {
X    case '\\':
X        switch(*++sp) {
X        case '\'':
X        case '$':
X        case '\\':
X        case '%':
X            c = *sp;
X            l = 2;
X            break;
X        case '\0':
X            c = '\\';
X            l = 1;
X            break;
X        case '0':
X            if (sp[1] == '0' && sp[2] == '0') {
X                c = '\0';
X                l = 4;
X            } else {
X                c = '\200'; /* '\0' ???? */
X                l = 2;
X            }
X            break;
X        default:
X            c = *sp;
X            l = 2;
X            break;
X        }
X        break;
X    default:
X        c = *sp;
X        l = 1;
X    }
X    c &= 0177;
X    if (isgraph(c) && c != ',' && c != '\'' && c != '\\' && c != ':') {
X        *dp++ = '%'; *dp++ = '\''; *dp++ = c; *dp++ = '\'';
X    } else {
X        *dp++ = '%'; *dp++ = '{';
X        if (c > 99)
X            *dp++ = c / 100 + '0';
X        if (c > 9)
X            *dp++ = (c / 10) % 10 + '0';
X        *dp++ = c % 10 + '0';
X        *dp++ = '}';
X    }
X    return l;
X}
X
X/* push n copies of param on the terminfo stack if not already there */
void
getparm(parm, n)
int parm;
int n; {
X    if (seenr)  {
X        if (parm == 1)
X            parm = 2;
X        else if (parm == 2)
X            parm = 1;
X    }
X    if (onstack == parm) {
X        if (n > 1) {
X            warn();
X            fprintf(stderr, "string may not be optimal");
X            *dp++ = '%'; *dp++ = 'P'; *dp++ = 'a';
X            while(n--) {
X                *dp++ = '%'; *dp++ = 'g'; *dp++ = 'a';
X            }
X        }
X        return;
X    }
X    if (onstack != 0)
X        push();
X
X    onstack = parm;
X
X    while(n--) {        /* %p0 */
X        *dp++ = '%'; *dp++ = 'p'; *dp++ = '0' + parm;
X    }
X
X    if (seenn && parm < 3) { /* %{96}%^ */
X        *dp++ = '%'; *dp++ = '{'; *dp++ = '9'; *dp++ = '6'; *dp++ = '}';
X        *dp++ = '%'; *dp++ = '^';
X    }
X
X    if (seenm && parm < 3) { /* %{127}%^ */
X        *dp++ = '%'; *dp++ = '{'; *dp++ = '1'; *dp++ = '2'; *dp++ = '7';
X        *dp++ = '}'; *dp++ = '%'; *dp++ = '^';
X    }
X}
X
X/* convert a string to terminfo format */
char *
convstr(s, i)
register char *s;
int i; {
X    static char line[MAX_LINE];
X    register char *cap;
X    int nocode = 0;
X
X    stackptr = 0;
X    onstack = 0;
X    seenm = 0;
X    seenn = 0;
X    seenr = 0;
X    param = 1;
X
X    dp = line;
X    cap = strnames[i];
X#if 0
X    if (cap[0] == 'k'
X        || ((cap[0] == 'i' || cap[0] == 'r') && cap[1] == 's'
X        && (cap[2] == '1' || cap[2] == '2' || cap[2] == '3')))
X    /* if (k.* || [ir]s[123]) */
X        nocode = 1;
X#else
X    if (_strflags[i] != 'G')
X        nocode = 1;
X#endif
X    if (!nocode) {
X        char *d = s;
X        while(*s != '\0') {
X            if (s[0] == '\\' && s[1] != '\0')
X                s++;
X            else if (s[0] == '%' && s[1] != '\0') {
X                if (s[1] == 'p') {
X                    if (termcap) {
X                        warn();
X                        fprintf(stderr,
X"string '%s' already in terminfo format\n", strcodes[i]);
X                        nocode = 1;
X                        break;
X                    } else
X                        nocode = 1;
X                }
X                s++;
X            }
X            s++;
X        }
X        if (!nocode && !termcap) {
X            warn();
X            fprintf(stderr,
X"string '%s' not in terminfo format, converting...\n", cap);
X        }
X        s = d;
X    }
X    while(*s != '\0') {
X        switch(*s) {
X        case '%':
X            s++;
X            if (nocode) {
X                *dp++ = '%';
X                break;
X            }
X            switch(*s++) {
X            case '%': *dp++ = '%'; break;
X            case 'r':
X                if (seenr++ == 1) {
X                    warn();
X                    fprintf(stderr, "seen %%r twice\n");
X                }
X                break;
X            case 'm':
X                if (seenm++ == 1) {
X                    warn();
X                    fprintf(stderr, "seen %%m twice\n");
X                }
X                break;
X            case 'n':
X                if (seenn++ == 1) {
X                    warn();
X                    fprintf(stderr, "seen %%n twice\n");
X                }
X                break;
X            case 'i': *dp++ = '%'; *dp++ = 'i'; break;
X            case '6':
X            case 'B':
X                getparm(param, 2);
X                /* %{6}%*%+ */
X                *dp++ = '%'; *dp++ = '{'; *dp++ = '6';
X                *dp++ = '}'; *dp++ = '%'; *dp++ = '*';
X                *dp++ = '%'; *dp++ = '+';
X                break;
X            case '8':
X            case 'D':
X                getparm(param, 2);
X                /* %{2}%*%- */
X                *dp++ = '%'; *dp++ = '{'; *dp++ = '2';
X                *dp++ = '}'; *dp++ = '%'; *dp++ = '*';
X                *dp++ = '%'; *dp++ = '-';
X                break;
X            case '>':
X                getparm(param, 2);
X                /* %?%{x}%>%t%{y}%+%; */
X                *dp++ = '%'; *dp++ = '?';
X                s += cvtchar(s);
X                *dp++ = '%'; *dp++ = '>';
X                *dp++ = '%'; *dp++ = 't';
X                s += cvtchar(s);
X                *dp++ = '%'; *dp++ = '+';
X                *dp++ = '%'; *dp++ = ';';
X                break;
X            case 'a':
X                if ((*s == '=' || *s == '+' || *s == '-'
X                     || *s == '*' || *s == '/')
X                    && (s[1] == 'p' || s[1] == 'c')
X                        && s[2] != '\0') {
X                    int l;
X                    l = 2;
X                    if (*s != '=')
X                        getparm(param, 1);
X                    if (s[1] == 'p') {
X                        getparm(param + s[2] - '@', 1);
X                        if (param != onstack) {
X                            pop();
X                            param--;
X                        }
X                        l++;
X                    } else
X                        l += cvtchar(s + 2);
X                    switch(*s) {
X                    case '+':
X                        *dp++ = '%'; *dp++ = '+';
X                        break;
X                    case '-':
X                        *dp++ = '%'; *dp++ = '-';
X                        break;
X                    case '*':
X                        *dp++ = '%'; *dp++ = '*';
X                        break;
X                    case '/':
X                        *dp++ = '%'; *dp++ = '/';
X                        break;
X                    case '=':
X                        if (seenr)
X                            if (param == 1)
X                                onstack = 2;
X                            else if (param == 2)
X                                onstack = 1;
X                            else
X                                onstack = param;
X                        else
X                            onstack = param;
X                        break;
X                    }
X                    s += l;
X                    break;
X                }
X                getparm(param, 1);
X                s += cvtchar(s);
X                *dp++ = '%'; *dp++ = '+';
X                break;
X            case '+':
X                getparm(param, 1);
X                s += cvtchar(s);
X                *dp++ = '%'; *dp++ = '+';
X                *dp++ = '%'; *dp++ = 'c';
X                pop();
X                break;
X            case 's':
X                s += cvtchar(s);
X                getparm(param, 1);
X                *dp++ = '%'; *dp++ = '-';
X                break;
X            case '-':
X                s += cvtchar(s);
X                getparm(param, 1);
X                *dp++ = '%'; *dp++ = '-';
X                *dp++ = '%'; *dp++ = 'c';
X                pop();
X                break;
X            case '.':
X                getparm(param, 1);
X                *dp++ = '%'; *dp++ = 'c';
X                pop();
X                break;
X            case '2':
X                getparm(param, 1);
X                *dp++ = '%'; *dp++ = '0';
X                *dp++ = '2'; *dp++ = 'd';
X                pop();
X                break;
X            case '3':
X                getparm(param, 1);
X                *dp++ = '%'; *dp++ = '0';
X                *dp++ = '3'; *dp++ = 'd';
X                pop();
X                break;
X            case 'd':
X                getparm(param, 1);
X                *dp++ = '%'; *dp++ = 'd';
X                pop();
X                break;
X            case 'f':
X                param++;
X                break;
X            case 'b':
X                param--;
X                break;
X            default:
X                warn();
X                *dp++ = '%';
X                s--;
X                fprintf(stderr, "'%s' unknown %% code %%c",
X                    strcodes[i], *s);
X                if (*s >= 0 && *s < 32)
X                    fprintf(stderr, "^%c\n", *s + '@');
X                else if (*s < 0 || *s >= 127)
X                    fprintf(stderr, "\\%03o\n", *s & 0377);
X                else
X                    fprintf(stderr, "%c\n", *s);
X                break;
X            }
X            break;
X        case '\\':
X            if (!compile) {*dp++ = *s++; *dp++ = *s++; break;}
X            /* FALLTHROUGH */
X        case '\n':
X            if (!compile) {*dp++ = '\\'; *dp++ = 'n'; s++; break;}
X            /* FALLTHROUGH */
X        case '\t':
X            if (!compile) {*dp++ = '\\'; *dp++ = 't'; s++; break;}
X            /* FALLTHROUGH */
X        case '\r':
X            if (!compile) {*dp++ = '\\'; *dp++ = 'r'; s++; break;}
X            /* FALLTHROUGH */
X        case '\200':
X            if (!compile) {*dp++ = '\\'; *dp++ = '0'; s++; break;}
X            /* FALLTHROUGH */
X        case '\f':
X            if (!compile) {*dp++ = '\\'; *dp++ = 'f'; s++; break;}
X            /* FALLTHROUGH */
X        case '\b':
X            if (!compile) {*dp++ = '\\'; *dp++ = 'b'; s++; break;}
X            /* FALLTHROUGH */
X        case ' ':
X            if (!compile) {*dp++ = '\\'; *dp++ = 's'; s++; break;}
X            /* FALLTHROUGH */
X        case '^':
X            if (!compile) {*dp++ = '\\'; *dp++ = '^'; s++; break;}
X            /* FALLTHROUGH */
X        case ':':
X            if (!compile) {*dp++ = '\\'; *dp++ = ':'; s++; break;}
X            /* FALLTHROUGH */
X        case ',':
X            if (!compile) {*dp++ = '\\'; *dp++ = ','; s++; break;}
X            /* FALLTHROUGH */
X#if 0
X        case '\'':
X            if (!compile) {*dp++ = '\\'; *dp++ = '\''; s++; break;}
X            /* FALLTHROUGH */
X#endif
X        default:
X            if (compile)
X                *dp++ = *s++;
X            else if (*s > 0 && *s < 32) {
X                *dp++ = '^';
X                *dp++ = *s + '@';
X                s++;
X            } else if (*s <= 0 || *s >= 127) {
X                *dp++ = '\\';
X                *dp++ = ((*s & 0300) >> 6) + '0';
X                *dp++ = ((*s & 0070) >> 3) + '0';
X                *dp++ = (*s & 0007) + '0';
X                s++;
X            } else
X                *dp++ = *s++;
X            break;
X        }
X    }
X    *dp = '\0';
X    return line;
X}
X
X#define LSB(n) ((unsigned) (n) & 0377)
X#define MSB(n) (((unsigned) (n) >> 8) & 0377)
X
void
writebin(fd, name)
int fd;
char *name; {
X    static char bin[MAX_BUF + 1];
X    register char *s;
X    register char *d;
X    register int i;
X    register char *t;
X    register int n;
X    char *strtbl;
X    int sz_name, n_bools, n_nums, n_offs, sz_strs;
X    extern int _boolorder[], _numorder[], _strorder[];
X
X    strncpy(bin + 12, name, 127);
X    bin[12 + 128] = '\0';
X    sz_name = strlen(name) + 1;
X    if (sz_name > 128)
X        sz_name = 128;
X
X    s = bin + 12 + sz_name;
X    for(i = 0; _boolorder[i] != -1; i++) {
X        switch(_term_buf.bools[i]) {
X        case -1: *s++ = 0; break;
X        case  0: *s++ = 0377; break;
X        default: *s++ = 1; break;
X        }
X    }
X    n_bools = i;
X    if ((sz_name + n_bools) & 1)
X        n_bools++;
X
X    s = bin + 12 + sz_name + n_bools;
X    for(i = 0; _numorder[i] != -1; i++) {
X        n = _term_buf.nums[_numorder[i]];
X        switch(n) {
X        case -2: *s++ = 0377; *s++ = 0377; break;
X        case -1: *s++ = 0376; *s++ = 0377; break;
X        default:
X            *s++ = LSB(n);
X            *s++ = MSB(n);
X        }
X    }
X    n_nums = i;
X
X    s = bin + 12 + sz_name + n_bools + n_nums * 2;
X    for(i = 0; _strorder[i] != -1; i++) {
X        if (_term_buf.strs[_strorder[i]] == (char *) 0) {
X            *s++ = 0376; *s++ = 0377;
X        } else {
X            *s++ = 0377; *s++ = 0377;
X        }
X    }
X    n_offs = i;
X
X    s = bin + 12 + sz_name + n_bools + n_nums * 2;
X    strtbl = d = s + n_offs * 2;
X    for(i = 0; _strorder[i] != -1; i++) {
X        t = _term_buf.strs[_strorder[i]];
X        if (t == (char *) -1 || t == (char *)  0)
X            s += 2;
X        else {
X            n = d - strtbl;
X            *s++ = LSB(n);
X            *s++ = MSB(n);
X            t = convstr(t, _strorder[i]);
X            while(*t != '\0') {
X                *d++ = *t++;
X                if (d >= bin + MAX_BUF - 1) {
X                    warn();
X                    fprintf(stderr,
X                    "compiled entry to big\n");
X                    *d++ = '\0';
X                    goto toobig;
X                }
X            }
X            *d++ = '\0';
X        }
X    }
X
toobig:
X    sz_strs = d - strtbl;
X
X    bin[0] = 032;
X    bin[1] = 01;
X    bin[2] = LSB(sz_name);
X    bin[3] = MSB(sz_name);
X    bin[4] = LSB(n_bools);
X    bin[5] = MSB(n_bools);
X    bin[6] = LSB(n_nums);
X    bin[7] = MSB(n_nums);
X    bin[8] = LSB(n_offs);
X    bin[9] = MSB(n_offs);
X    bin[10] = LSB(sz_strs);
X    bin[11] = MSB(sz_strs);
X
X    if (write(fd, bin, d - bin) == -1)
X        quit(errno, "can't write binary file");
X
X    return;
X}
X
void
find_directory() {
X    struct term_path *p;
X    struct stat st;
X
X    if (directory != NULL)
X        return;
X
X    p = path;
X    while(p->type != -1 && p->file != NULL) {
X        if (stat(p->file, &st) == 0) {
X            if ((st.st_mode & 0170000) == 0040000) {
X                directory = p->file;
X                return;
X            }
X        }
X        p++;
X    }
X    quit(-1, "can't find a terminfo directory");
X}
X
X/* convert a terminal name to a binary filename */
char *
binfile(name)
char *name; {
X    static char line[MAX_LINE+1];
X
X    sprintf(line, "%s/%c/%s", directory, *name, name);
X    return line;
X}
X
char *
bindir(name)
char *name; {
X    static char line[MAX_LINE+1];
X
X    sprintf(line, "%s/%c", directory, *name);
X    return line;
X}
X
int
badname(name)
char *name; {
X    while(*name) {
X        if (*name == '/' || !isgraph(*name))
X            return 1;
X        name++;
X    }
X    return 0;
X}
X
X/* output a terminfo binary */
void
outputbin(name)
char *name; {
X    register char *s, *d, *last;
X    char tmp[MAX_LINE+1];
X    char line[MAX_LINE+1];
X    int fd;
X
X    find_directory();
X
X    s = name;
X    d = line;
X    while(*s != '\0' && d < line + MAX_LINE) {
X        *d++ = *s++;
X    }
X
X    while(d > line && d[-1] == '|') {
X        d--;
X    }
X
X    *d = '\0';
X
X    s = strtok(line, "|");
X    last = NULL;
X
X    while(s != NULL && last == NULL) {
X        if (*s == '\0') {
X            ;
X        } else if (badname(s)) {
X            if (lineno)
X                warn();
X            fprintf(stderr, "bad terminal name '%s', ingored.\n",
X                s);
X        } else {
X            if (access(bindir(s), 2) == -1) {
X                if (errno != ENOENT)
X                    quit(errno,
X                         "can't access directory '%s'",
X                         bindir(s));
X                if (mkdir(bindir(s), 0777) == -1)
X                    quit(errno, "can't make directory '%s'",
X                         bindir(s));
X            }
X            fd = open(binfile(s), O_WRONLY | O_CREAT | O_EXCL,
X                  0666);
X            if (fd == -1) {
X                if (errno != EEXIST)
X                    quit(errno, "can't open file '%s'",
X                         binfile(s));
X                if (unlink(binfile(s)) == -1)
X                    quit(errno, "can't unlink file '%s'",
X                         binfile(s));
X                fd = open(binfile(s),
X                      O_WRONLY | O_CREAT | O_EXCL, 0666);
X                if (fd == -1)
X                    quit(errno, "can't create file '%s'",
X                         binfile(s));
X            }
X            writebin(fd, name);
X            close(fd);
X            last = s;
X        }
X        s = strtok(NULL, "|");
X    }
X
X    if (last == NULL) {
X        if (lineno)
X            warn();
X        fprintf(stderr, "no terminal name, entry ignored.\n");
X        return;
X    }
X
X    while(s != NULL && s + strlen(s) != d) {
X        if (*s == '\0' || strcmp(s, last) == 0) {
X            ;
X        } else if (badname(s)) {
X            if (lineno)
X                warn();
X            fprintf(stderr, "bad terminal name '%s', ingored.\n",
X                s);
X        } else {
X            if (access(bindir(s), 2) == -1) {
X                if (errno != ENOENT)
X                    quit(errno,
X                         "can't access directory '%s'",
X                         bindir(s));
X                if (mkdir(bindir(s), 0777) == -1)
X                    quit(errno, "can't make directory '%s'",
X                         bindir(s));
X            }
X            if (access(binfile(s), 0) == -1) {
X                if (errno != ENOENT)
X                    quit(errno, "can't access file '%s'",
X                         binfile(s));
X            } else if (unlink(binfile(s)) == -1) {
X                    quit(errno, "can't unlink file '%s'",
X                         binfile(s));
X            }
X            strcpy(tmp, binfile(last));
X            if (link(tmp, binfile(s)) == -1) {
X                quit(errno, "can't link '%s' to '%s'",
X                     last, binfile(s));
X            }
X        }
X        s = strtok(NULL, "|");
X    }
X    return;
X}
X
X/* output an entry in terminfo source format */
void
outputinfo(name)
char *name; {
X    int i;
X    char line[MAX_LINE];
X
X    printf("%s,\n", name);
X
X    for(i = 0; i < NUM_OF_BOOLS; i++)
X        if (_term_buf.bools[i] == 0) {
X            sprintf(line, "%s@", boolnames[i]);
X            putstr(line);
X        } else if (_term_buf.bools[i] != -1)
X            putstr(boolnames[i]);
X
X    for(i = 0; i < NUM_OF_NUMS; i++)
X        if (_term_buf.nums[i] == -1) {
X            sprintf(line, "%s@", numnames[i]);
X            putstr(line);
X        } else if (_term_buf.nums[i] != -2) {
X            sprintf(line, "%s#%d", numnames[i], _term_buf.nums[i]);
X            putstr(line);
X        }
X
X    for(i = 0; i < NUM_OF_STRS; i++)
X        if (_term_buf.strs[i] == NULL) {
X            sprintf(line, "%s@", strnames[i]);
X            putstr(line);
X        } else if (_term_buf.strs[i] != (char *) -1) {
X            sprintf(line, "%s=%s", strnames[i],
X                convstr(_term_buf.strs[i], i));
X            putstr(line);
X        }
X    putstr(NULL);
X}
X
X/* convert a terminfo entry to binary format */
void
convtinfo() {
X    int i, r;
X
X    termcap = 0;
X
X    for(i = 0; i < NUM_OF_BOOLS; i++)
X        _term_buf.bools[i] = -1;
X    for(i = 0; i < NUM_OF_NUMS; i++)
X        _term_buf.nums[i] = -2;
X    for(i = 0; i < NUM_OF_STRS; i++)
X        _term_buf.strs[i] = (char *) -1;
X
X    _term_buf.name_all = NULL;
X
X    r = _gettinfo(buf, &_term_buf, path);
X    if (r != 0) {
X        if (lineno == 0)
X            quit(-1, "problem reading entry");
X        else {
X            warn();
X            fprintf(stderr, "problem reading entry\n");
X        }
X    }
X
X    if (compile)
X        outputbin(_term_buf.name_all);
X    else
X        outputinfo(_term_buf.name_all);
X    return;
X}
X
X/* convert a terminfo binary to terminfo source */
void
convtbin() {
X    int i, r;
X
X    termcap = 0;
X
X    for(i = 0; i < NUM_OF_BOOLS; i++)
X        _term_buf.bools[i] = -1;
X    for(i = 0; i < NUM_OF_NUMS; i++)
X        _term_buf.nums[i] = -2;
X    for(i = 0; i < NUM_OF_STRS; i++)
X        _term_buf.strs[i] = (char *) -1;
X
X    _term_buf.name_all = NULL;
X
X    r = _gettbin(buf, &_term_buf);
X    if (r != 0) {
X        if (lineno == 0)
X            quit(-1, "problem reading entry");
X        else {
X            warn();
X            fprintf(stderr, "problem reading entry\n");
X        }
X    }
X
X    outputinfo(_term_buf.name_all);
X
X    return;
X}
X
X/* convert a termcap entry to terminfo format */
void
convtcap() {
X    int i, r;
X    char *name;
X
X    termcap = 1;
X
X    for(i = 0; i < NUM_OF_BOOLS; i++)
X        _term_buf.bools[i] = -1;
X    for(i = 0; i < NUM_OF_NUMS; i++)
X        _term_buf.nums[i] = -2;
X    for(i = 0; i < NUM_OF_STRS; i++)
X        _term_buf.strs[i] = (char *) -1;
X
X    _term_buf.name_all = NULL;
X
X
X#if DEBUG
X    printf("%s\n", buf);
X#endif
X    r = _gettcap(buf, &_term_buf, path);
X    if (r != 0) {
X        if (lineno == 0)
X            quit(-1, "problem reading entry");
X        else {
X            warn();
X            fprintf(stderr, "problem reading entry\n");
X        }
X    }
X
X    if (dodefault && !continued)
X        _tcapdefault();
X
X    _tcapconv();
X
X    name = _term_buf.name_all;
X#if DEBUG
X    printf("...%s\n", name);
X#endif
X    if (name[0] != '\0' && name[1] != '\0' && name[2] == '|')
X        name += 3;    /* skip the 2 letter code */
X
X    if (compile)
X        outputbin(name);
X    else
X        outputinfo(name);
X}
X
void
convbinfile(file)
char *file; {
X    register FILE *f;
X    int r;
X
X    f = fopen(file, "r");
X
X    if (f == NULL)
X        quit(errno, "can't open '%s'", file);
X
X    r = fread(buf, sizeof(char), MAX_BUF, f);
X    if (r < 12 || buf[0] != 032 || buf[1] != 01)
X        quit(-1, "file '%s' corrupted", file);
X
X    convtbin();
X}
X
X/* convert a termcap file to terminfo format */
void
convtcfile(file)
char *file; {
X    int nocolon;
X    register int c;
X    register char *d;
X    register FILE *f;
X
X    f = fopen(file, "r");
X
X    if (f == NULL)
X        quit(errno, "can't open '%s'", file);
X
X    d = buf;
X    c = getc(f);
X    while(c != EOF) {
X        lineno++;
X        if (c == '#') {
X            if (keepcomments) {
X                do {
X                    putchar(c);
X                    c = getc(f);
X                } while(c != '\n' && c != EOF);
X                putchar('\n');
X            } else
X                do
X                    c = getc(f);
X                while(c != '\n' && c != EOF);
X            if (c != EOF)
X                c = getc(f);
X            continue;
X        }
X        while(isspace(c) && c != '\n')
X            c = getc(f);
X        if (c == '\n' && buf == d) {
X            c = getc(f);
X            continue;
X        }
X
X        while(c != EOF) {
X            if (c == '\\') {
X                c = getc(f);
X                if (c == EOF)
X                    break;
X                if (c == '\n') {
X                    c = getc(f);
X                    break;
X                }
X                *d++ = '\\';
X                *d++ = c;
X            } else if (c == '\n') {
X                *d = '\0';
X                if (*--d == ':') {
X                    nocolon = 0;
X                    *d-- = '\0';
X                } else {
X                    nocolon = 1;
X                }
X                while(d > buf && *d != ':')
X                    d--;
X                if (d[1] == 't' && d[2] == 'c' && d[3] == '=') {
X                    continued = 1;
X                    d[1] = '\0';
X                } else
X                    continued = 0;
X                convtcap();
X                if (nocolon) {
X                    warn();
X                    fprintf(stderr,
X                        "entry doesn't end with :\n");
X                }
X                _term_buf.strbuf = _endstr();
X                _del_strs(&_term_buf);
X                if (continued) {
X                    printf("\tuse=%s,\n", d + 4);
X                }
X                d = buf;
X                c = getc(f);
X                break;
X            } else
X                *d++ = c;
X            c = getc(f);
X        }
X    }
X}
X
static int
getln(f, buf, len)
XFILE *f;
register char *buf;
int len; {
X    register int c, i = 0;
X
X    while((c = getc(f)) == '#') {
X        lineno++;
X        if (keepcomments) {
X            putchar('#');
X            while((c = getc(f)) != '\n') {
X                if (c == EOF)
X                    return -1;
X                putchar(c);
X            }
X            putchar('\n');
X        } else {
X            while((c = getc(f)) != '\n')
X                if (c == EOF)
X                    return -1;
X        }
X    }
X
X    lineno++;
X    while(c != '\n') {
X        if (c == EOF)
X            return -1;
X        if (i < len) {
X            i++;
X            *buf++ = c;
X        }
X        c = getc(f);
X    }
X
X    while(isspace(*(buf-1))) {
X        buf--;
X        i--;
X    }
X
X    *buf = '\0';
X    return i;
X}
X
void
convtifile(file)
char *file; {
X    static char line[MAX_LINE+1];
X    int l;
X    int n;
X    register FILE *f;
X
X    f = fopen(file, "r");
X
X    if (f == NULL)
X        quit(errno, "can't open '%s'", file);
X
X    lineno = 0;
X
X    l = getln(f, line, MAX_LINE);
X    while(l != -1) {
X        if (line[l-1] == ':') {
X            strncpy(buf, line, MAX_BUF);
X            convtcap();
X        } else if (line[l-1] == '\\') {
X            n = MAX_BUF;
X            do {
X                line[--l] = '\0';
X                if (n > 0)
X                    strncpy(buf + MAX_BUF - n, line, n);
X                n -= l;
X                l = getln(f, line, MAX_LINE);
X            } while(l != -1 && line[l-1] == '\\');
X            if (n > 0 && l != -1)
X                strncpy(buf + MAX_BUF - n, line, n);
X            convtcap();
X        } else if (line[l-1] == ',') {
X            n = MAX_BUF;
X            do {
X                if (n > 0)
X                    strncpy(buf + MAX_BUF - n, line, n);
X                n -= l;
X                l = getln(f, line, MAX_LINE);
X            } while(l != -1 && isspace(line[0]));
X#if 0
X            printf("buf = '%s'\n", buf);
X#endif
X            convtinfo();
X            continue;
X        } else if (line[0] != '\0') {
X            warn();
X            fprintf(stderr, "malformed line\n");
X            if (keepcomments) {
X                printf("%s\n", line);
X            }
X        }
X        l = getln(f, line, MAX_LINE);
X    }
X    return;
X}
X
X/* dummy routine for quit */
X/* ARGSUSED */
void
do_cleanup(e)
int e; {
X    return;
X}
X
X/* print out usage, called by quit */
X/* ARGSUSED */
void
usage(e)
int e; {
X    fprintf(stderr,
X"usage: %s [-b] [-c [-OUGd]] [-i] [-B [-D dir]] [-I] [-k] [-V]\n\t[-t term] [file]\n",
X        prg_name);
X    return;
X}
X
int
main(argc, argv)
int argc;
char **argv; {
X    extern char *optarg;
X    extern int optind;
X    extern int opterr;
X    char *term = NULL;
X    char *file = NULL;
X    int r;
X    char c;
X    int pversion = 0;
X
X    prg_name = strrchr(argv[0], '/');
X    if (prg_name == NULL)
X        prg_name = argv[0];
X    else
X        prg_name++;
X
X    cleanup = usage;
X
X    opterr = 0;
X
X    if (strcmp(prg_name, "tic") == 0)
X        compile = 1;
X
X    while ((c = getopt(argc, argv, "bciBIOGUdkVD:t:")) != -1) {
X        switch(c) {
X        case 'O':
X            noOT = 0;
X            break;
X        case 'G':
X            noGNU = 0;
X            break;
X        case 'U':
X            noUW = 0;
X            break;
X        case 'D':
X            if (directory != NULL)
X                quit(-1, "more than one directory specified");
X            directory = optarg;
X            break;
X        case 't':
X            if (term != NULL)
X                quit(-1, "more than one terminal specified");
X            term = optarg;
X            break;
X        case 'd': dodefault = 0; break;
X        case 'k': keepcomments = 1; break;
X        case 'b': from_tbin = 1; break;
X        case 'c': from_tcap = 1; break;
X        case 'i': from_tinfo = 1; break;
X        case 'B': compile = 1; break;
X        case 'I': compile = 0; break;
X        case 'V': pversion = 1; break;
X        case '?':
X        default:
X            quit(-1, "bad or missing command line argument");
X        }
X    }
X
X    if (pversion) {
X        quit(0, "%s\n%s", _mytinfo_version, SCCSid);
X    }
X
X    if (optind == argc - 1)
X        file = argv[optind];
X    else if (optind != argc)
X        quit(-1, "wrong number of arguments");
X
X    if (from_tbin + from_tcap + from_tinfo > 1)
X        quit(-1, "more than one input file type specified");
X
X    if (!from_tcap && !from_tinfo && !from_tbin && file != NULL) {
X        if (strcmp(prg_name, "cap2info") == 0
X            || strcmp(prg_name, "captoinfo") == 0)
X            from_tcap = 1;
X        else if (strcmp(prg_name, "tic") == 0)
X            from_tinfo = 1;
X        else
X            quit(-1, "no input file type specified");
X    }
X
X    if (from_tbin && compile)
X        quit(-1, "can't convert from binary to binary");
X
X    if (file != NULL) {
X        if (from_tbin) {
X            cleanup = do_cleanup;
X            convbinfile(file);
X            exit(0);
X        }
X        if (!compile)
X            path = _buildpath(file, 0, NULL, -1);
X        else {
X            path = _buildpath(file, 0,
X                      "$TERMINFO", 2,
X                      "$MYTERMINFO", 2,
X#ifdef TERMINFODIR
X                      TERMINFODIR, 0,
X#endif
X                      NULL, -1);
X        }
X        if (path == NULL)
X            quit(-1, "can't build path");
X        if (term == NULL) {
X            cleanup = do_cleanup;
X            if (from_tcap && !compile)
X                convtcfile(file);
X            else
X                convtifile(file);
X            exit(0);
X        }
X    } else if (from_tcap && !compile)
X        path = _buildpath("$TERMCAP", 1,
X#ifdef TERMCAPFILE
X                  TERMCAPFILE, 0,
X#endif
X                  NULL, -1);
X    else if (from_tinfo || from_tbin)
X        path = _buildpath("$TERMINFO", 2,
X                  "$MYTERMINFO", 2,
X#ifdef TERMINFODIR
X                  TERMINFODIR, 0,
X#endif
X#ifdef TERMINFOSRC
X                  TERMINFOSRC, 0,
X#endif
X                  NULL, -1);
X    else if (from_tcap)
X        path = _buildpath("$TERMCAP", 1,
X#ifdef TERMCAPFILE
X                  TERMCAPFILE, 0,
X#endif
X                  "$TERMINFO", 2,
X                  "$MYTERMINFO", 2,
X#ifdef TERMINFODIR
X                  TERMINFODIR, 0,
X#endif
X                  NULL, -1);
X    else
X        path = _buildpath("$TERMINFO", 2,
X                  "$MYTERMINFO", 2,
X                  "$TERMCAP", 1,
X#ifdef TERMINFODIR
X                  TERMINFODIR, 0,
X#endif
X#ifdef TERMINFOSRC
X                  TERMINFOSRC, 0,
X#endif
X#ifdef TERMCAPFILE
X                  TERMCAPFILE, 0,
X#endif
X                  NULL, -1);
X    if (term == NULL) {
X        term = getenv("TERM");
X        if (term == NULL)
X            quit(-1, "no terminal type given");
X    }
X
X    cleanup = do_cleanup;
X
X    r = _findterm(term, path, buf);
X    switch(r) {
X    case 1:
X        convtcap();
X        break;
X    case 2:
X        convtinfo();
X        break;
X    case 3:
X        if (compile)
X            quit(-1, "entry is already compiled");
X        convtbin();
X        break;
X    default:
X        quit(-1, "can't find a terminal entry for '%s'", term);
X    }
X
X    exit(0);
X    return 0;
X}
END_OF_FILE
if test 26474 -ne `wc -c <'tconv.c'`; then
    echo shar: \"'tconv.c'\" unpacked with wrong size!
fi
# end of 'tconv.c'
fi
if test -f 'tparm.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'tparm.c'\"
else
echo shar: Extracting \"'tparm.c'\" \(16639 characters\)
sed "s/^X//" >'tparm.c' <<'END_OF_FILE'
X/*
X * tparm.c
X *
X * By Ross Ridge
X * Public Domain
X * 92/02/01 07:30:36
X *
X */
X
X#include "defs.h"
X#include "term.h"
X
X#include <ctype.h>
X
X#ifdef USE_SCCS_IDS
static const char SCCSid[] = "@(#) mytinfo tparm.c 3.2 92/02/01 public domain, By Ross Ridge";
X#endif
X
X#ifndef MAX_PUSHED
X#define MAX_PUSHED    32
X#endif
X
X#define ARG    1
X#define NUM    2
X
X#define INTEGER    1
X#define STRING    2
X
typedef struct stack_str {
X    int    type;
X    int    argnum;
X    int    value;
X} stack;
X
static stack S[MAX_PUSHED];
static stack vars['z'-'a'+1];
static int pos = 0;
X
static struct arg_str {
X    int type;
X    int    integer;
X    char    *string;
X} arg_list[10];
X
static int argcnt;
X
static va_list tparm_args;
X
static int
pusharg(arg)
int arg; {
X    if (pos == MAX_PUSHED)
X        return 1;
X    S[pos].type = ARG;
X    S[pos++].argnum = arg;
X    return 0;
X}
X
static int
pushnum(num)
int num; {
X    if (pos == MAX_PUSHED)
X        return 1;
X    S[pos].type = NUM;
X    S[pos++].value = num;
X    return 0;
X}
X
X/* VARARGS2 */
static int
getarg(argnum, type, p)
int argnum, type;
anyptr p; {
X    while (argcnt < argnum) {
X        arg_list[argcnt].type = INTEGER;
X        arg_list[argcnt++].integer = (int) va_arg(tparm_args, int);
X    }
X    if (argcnt > argnum) {
X        if (arg_list[argnum].type != type)
X            return 1;
X        else if (type == STRING)
X            *(char **)p = arg_list[argnum].string;
X        else
X            *(int *)p = arg_list[argnum].integer;
X    } else {
X        arg_list[argcnt].type = type;
X        if (type == STRING)
X            *(char **)p = arg_list[argcnt++].string
X                = (char *) va_arg(tparm_args, char *);
X        else
X            *(int *)p = arg_list[argcnt++].integer = (int) va_arg(tparm_args, int);
X    }
X    return 0;
X}
X
X
static int
popstring(str)
char **str; {
X    if (pos-- == 0)
X        return 1;
X    if (S[pos].type != ARG)
X        return 1;
X    return(getarg(S[pos].argnum, STRING, (anyptr) str));
X}
X
static int
popnum(num)
int *num; {
X    if (pos-- == 0)
X        return 1;
X    switch (S[pos].type) {
X    case ARG:
X        return (getarg(S[pos].argnum, INTEGER, (anyptr) num));
X    case NUM:
X        *num = S[pos].value;
X        return 0;
X    }
X    return 1;
X}
X
static int
cvtchar(sp, c)
register char *sp, *c; {
X    switch(*sp) {
X    case '\\':
X        switch(*++sp) {
X        case '\'':
X        case '$':
X        case '\\':
X        case '%':
X            *c = *sp;
X            return 2;
X        case '\0':
X            *c = '\\';
X            return 1;
X        case '0':
X            if (sp[1] == '0' && sp[2] == '0') {
X                *c = '\0';
X                return 4;
X            }
X            *c = '\200'; /* '\0' ???? */
X            return 2;
X        default:
X            *c = *sp;
X            return 2;
X        }
X    default:
X        *c = *sp;
X        return 1;
X    }
X}
X
static int termcap;
X
X/* sigh... this has got to be the ugliest code I've ever written.
X   Trying to handle everything has its cost, I guess.
X
X   It actually isn't to hard to figure out if a given % code is supposed
X   to be interpeted with its termcap or terminfo meaning since almost
X   all terminfo codes are invalid unless something has been pushed on
X   the stack and termcap strings will never push things on the stack
X   (%p isn't used by termcap). So where we have a choice we make the
X   decision by wether or not somthing has been pushed on the stack.
X   The static variable termcap keeps track of this; it starts out set
X   to 1 and is incremented as each argument processed by a termcap % code,
X   however if something is pushed on the stack it's set to 0 and the
X   rest of the % codes are interpeted as terminfo % codes. Another way
X   of putting it is that if termcap equals one we haven't decided either
X   way yet, if it equals zero we're looking for terminfo codes, and if
X   its greater than 1 we're looking for termcap codes.
X
X   Terminfo % codes:
X
X    %%    output a '%'
X    %[[:][-+# ][width][.precision]][doxXs]
X        output pop according to the printf format
X    %c    output pop as a char
X    %'c'    push character constant c.
X    %{n}    push decimal constant n.
X    %p[1-9] push paramter [1-9]
X    %g[a-z] push variable [a-z]
X    %P[a-z] put pop in variable [a-z]
X    %l    push the length of pop (a string)
X    %+    add pop to pop and push the result
X    %-    subtract pop from pop and push the result
X    %*    multiply pop and pop and push the result
X    %&    bitwise and pop and pop and push the result
X    %|    bitwise or pop and pop and push the result
X    %^    bitwise xor pop and pop and push the result
X    %~    push the bitwise not of pop
X    %=    compare if pop and pop are equal and push the result
X    %>    compare if pop is less than pop and push the result
X    %<    compare if pop is greater than pop and push the result
X    %A    logical and pop and pop and push the result
X    %O    logical or pop and pop and push the result
X    %!    push the logical not of pop
X    %? condition %t if_true [%e if_false] %;
X        if condtion evaulates as true then evaluate if_true,
X        else evaluate if_false. elseif's can be done:
X%? cond %t true [%e cond2 %t true2] ... [%e condN %t trueN] [%e false] %;
X    %i    add one to parameters 1 and 2. (ANSI)
X
X  Termcap Codes:
X
X    %%    output a %
X    %.    output parameter as a character
X    %d    output parameter as a decimal number
X    %2    output parameter in printf format %02d
X    %3    output parameter in printf format %03d
X    %+x    add the character x to parameter and output it as a character
X(UW)    %-x    subtract parameter FROM the character x and output it as a char
X(UW)    %ax    add the character x to parameter
X(GNU)    %a[+*-/=][cp]x
X        GNU arithmetic.
X(UW)    %sx    subtract parameter FROM the character x
X    %>xy    if parameter > character x then add character y to parameter
X    %B    convert to BCD (parameter = (parameter/10)*16 + parameter%16)
X    %D    Delta Data encode (parameter = parameter - 2*(paramter%16))
X    %i    increment the first two parameters by one
X    %n    xor the first two parameters by 0140
X(GNU)    %m    xor the first two parameters by 0177
X    %r    swap the first two parameters
X(GNU)    %b    backup to previous parameter
X(GNU)    %f    skip this parameter
X
X  Note the two definitions of %a, the GNU defintion is used if the characters
X  after the 'a' are valid, otherwise the UW definition is used.
X
X  (GNU) used by GNU Emacs termcap libraries
X  (UW) used by the University of Waterloo (MFCF) termcap libraries
X
X*/
X
X#ifdef lint
X/* VARARGS1 */
char *
tparm(str)
char *str; {
X#else /* lint */
X#ifdef USE_STDARG
X#ifdef USE_PROTOTYPES
char *tparm(char *str, ...) {
X#else /* USE_PROTOTYPES */
char *tparm(str)
char *str; {
X#endif /* USE_PROTOTYPES */
X#else /* USE_STDARG */
char *tparm(va_alist)
va_dcl {
X    char *str;
X#endif
X#endif
X    static char OOPS[] = "OOPS";
X    static char buf[MAX_LINE];
X    register char *sp, *dp;
X    register char *fmt;
X    char conv_char;
X    char scan_for;
X    int scan_depth, if_depth;
X    static int i, j;
X    static char *s, c;
X    char fmt_buf[MAX_LINE];
X    char sbuf[MAX_LINE];
X
X#ifdef lint
X    scan_depth = 0;
X#else
X#ifdef USE_STDARG
X    va_start(tparm_args, str);
X#else
X    va_start(tparm_args);
X    str = (char *) va_arg(tparm_args, char *);
X#endif
X#endif
X
X    sp = str;
X    dp = buf;
X    scan_for = 0;
X    if_depth = 0;
X    argcnt = 0;
X    pos = 0;
X    termcap = 1;
X    while(*sp != '\0') {
X        switch(*sp) {
X        case '\\':
X            if (scan_for) {
X                if (*++sp != '\0')
X                    sp++;
X                break;
X            }
X            *dp++ = *sp++;
X            if (*sp != '\0')
X                *dp++ = *sp++;
X            break;
X        case '%':
X            sp++;
X            if (scan_for) {
X                if (*sp == scan_for && if_depth == scan_depth) {
X                    if (scan_for == ';')
X                        if_depth--;
X                    scan_for = 0;
X                } else if (*sp == '?')
X                    if_depth++;
X                else if (*sp == ';') {
X                    if (if_depth == 0)
X                        return OOPS;
X                    else
X                        if_depth--;
X                }
X                sp++;
X                break;
X            }
X            fmt = NULL;
X            switch(*sp) {
X            case '%':
X                *dp++ = *sp++;
X                break;
X            case '+':
X                if (!termcap) {
X                    if (popnum(&j) || popnum(&i))
X                        return OOPS;
X                    i += j;
X                    if (pushnum(i))
X                        return OOPS;
X                    sp++;
X                    break;
X                }
X                ;/* FALLTHROUGH */
X            case 'C':
X                if (*sp == 'C') {
X                    if (getarg(termcap - 1, INTEGER, &i))
X                        return OOPS;
X                    if (i >= 96) {
X                        i /= 96;
X                        if (i == '$')
X                            *dp++ = '\\';
X                        *dp++ = i;
X                    }
X                }
X                fmt = "%c";
X                /* FALLTHROUGH */
X            case 'a':
X                if (!termcap)
X                    return OOPS;
X                if (getarg(termcap - 1, INTEGER, (anyptr) &i))
X                    return OOPS;
X                if (*++sp == '\0')
X                    return OOPS;
X                if ((sp[1] == 'p' || sp[1] == 'c')
X                        && sp[2] != '\0' && fmt == NULL) {
X                    /* GNU aritmitic parameter, what they
X                       realy need is terminfo.          */
X                    int val, lc;
X                    if (sp[1] == 'p'
X                        && getarg(termcap - 1 + sp[2] - '@',
X                              INTEGER, (anyptr) &val))
X                        return OOPS;
X                    if (sp[1] == 'c') {
X                        lc = cvtchar(sp + 2, &c) + 2;
X                    /* Mask out 8th bit so \200 can be
X                       used for \0 as per GNU doc's    */
X                        val = c & 0177;
X                    } else
X                        lc = 2;
X                    switch(sp[0]) {
X                    case '=':
X                        break;
X                    case '+':
X                        val = i + val;
X                        break;
X                    case '-':
X                        val = i - val;
X                        break;
X                    case '*':
X                        val = i * val;
X                        break;
X                    case '/':
X                        val = i / val;
X                        break;
X                    default:
X                    /* Not really GNU's %a after all... */
X                        lc = cvtchar(sp, &c);
X                        val = c + i;
X                        break;
X                    }
X                    arg_list[termcap - 1].integer = val;
X                    sp += lc;
X                    break;
X                }
X                sp += cvtchar(sp, &c);
X                arg_list[termcap - 1].integer = c + i;
X                if (fmt == NULL)
X                    break;
X                sp--;
X                /* FALLTHROUGH */
X            case '-':
X                if (!termcap) {
X                    if (popnum(&j) || popnum(&i))
X                        return OOPS;
X                    i -= j;
X                    if (pushnum(i))
X                        return OOPS;
X                    sp++;
X                    break;
X                }
X                fmt = "%c";
X                /* FALLTHROUGH */
X            case 's':
X                if (termcap && (fmt == NULL || *sp == '-')) {
X                    if (getarg(termcap - 1, INTEGER, &i))
X                        return OOPS;
X                    if (*++sp == '\0')
X                        return OOPS;
X                    sp += cvtchar(sp, &c);
X                    arg_list[termcap - 1].integer = c - i;
X                    if (fmt == NULL)
X                        break;
X                    sp--;
X                }
X                if (!termcap)
X                    return OOPS;
X                ;/* FALLTHROUGH */
X            case '.':
X                if (termcap && fmt == NULL)
X                    fmt = "%c";
X                ;/* FALLTHROUGH */
X            case 'd':
X                if (termcap && fmt == NULL)
X                    fmt = "%d";
X                ;/* FALLTHROUGH */
X            case '2':
X                if (termcap && fmt == NULL)
X                    fmt = "%02d";
X                ;/* FALLTHROUGH */
X            case '3':
X                if (termcap && fmt == NULL)
X                    fmt = "%03d";
X                ;/* FALLTHROUGH */
X            case ':': case ' ': case '#': case 'u':
X            case 'x': case 'X': case 'o': case 'c':
X            case '0': case '1': case '4': case '5':
X            case '6': case '7': case '8': case '9':
X                if (fmt == NULL) {
X                    if (termcap)
X                        return OOPS;
X                    if (*sp == ':')
X                        sp++;
X                    fmt = fmt_buf;
X                    *fmt++ = '%';
X                    while(*sp != 's' && *sp != 'x' && *sp != 'X' && *sp != 'd' && *sp != 'o' && *sp != 'c' && *sp != 'u') {
X                        if (*sp == '\0')
X                            return OOPS;
X                        *fmt++ = *sp++;
X                    }
X                    *fmt++ = *sp;
X                    *fmt = '\0';
X                    fmt = fmt_buf;
X                }
X                conv_char = fmt[strlen(fmt) - 1];
X                if (conv_char == 's') {
X                    if (popstring(&s))
X                        return OOPS;
X                    sprintf(sbuf, fmt, s);
X                } else {
X                    if (termcap) {
X                        if (getarg(termcap++ - 1,
X                               INTEGER, &i))
X                            return OOPS;
X                    } else
X                        if (popnum(&i))
X                            return OOPS;
X                    if (i == 0 && conv_char == 'c')
X                        strcpy(sbuf, "\000");
X                    else
X                        sprintf(sbuf, fmt, i);
X                }
X                sp++;
X                fmt = sbuf;
X                while(*fmt != '\0') {
X                    if (*fmt == '$')
X                        *dp++ = '\\';
X                    *dp++ = *fmt++;
X                }
X                break;
X            case 'r':
X                if (!termcap || getarg(1, INTEGER, &i))
X                    return OOPS;
X                arg_list[1].integer = arg_list[0].integer;
X                arg_list[0].integer = i;
X                sp++;
X                break;
X            case 'i':
X                if (getarg(1, INTEGER, &i)
X                    || arg_list[0].type != INTEGER)
X                    return OOPS;
X                arg_list[1].integer++;
X                arg_list[0].integer++;
X                sp++;
X                break;
X            case 'n':
X                if (!termcap || getarg(1, INTEGER, &i))
X                    return OOPS;
X                arg_list[0].integer ^= 0140;
X                arg_list[1].integer ^= 0140;
X                sp++;
X                break;
X            case '>':
X                if (!termcap) {
X                    if (popnum(&j) || popnum(&i))
X                        return OOPS;
X                    i = (i > j);
X                    if (pushnum(i))
X                        return OOPS;
X                    sp++;
X                    break;
X                }
X                if (getarg(termcap-1, INTEGER, &i))
X                    return OOPS;
X                sp += cvtchar(sp, &c);
X                if (i > c) {
X                    sp += cvtchar(sp, &c);
X                    arg_list[termcap-1].integer += c;
X                } else
X                    sp += cvtchar(sp, &c);
X                sp++;
X                break;
X            case 'B':
X                if (!termcap || getarg(termcap-1, INTEGER, &i))
X                    return OOPS;
X                arg_list[termcap-1].integer = 16*(i/10)+i%10;
X                sp++;
X                break;
X            case 'D':
X                if (!termcap || getarg(termcap-1, INTEGER, &i))
X                    return OOPS;
X                arg_list[termcap-1].integer = i - 2 * (i % 16);
X                sp++;
X                break;
X            case 'p':
X                if (termcap > 1)
X                    return OOPS;
X                if (*++sp == '\0')
X                    return OOPS;
X                if (*sp == '0')
X                    i = 9;
X                else
X                    i = *sp - '1';
X                if (i < 0 || i > 9)
X                    return OOPS;
X                if (pusharg(i))
X                    return OOPS;
X                termcap = 0;
X                sp++;
X                break;
X            case 'P':
X                if (termcap || *++sp == '\0')
X                    return OOPS;
X                i = *sp++ - 'a';
X                if (i < 0 || i > 25)
X                    return OOPS;
X                if (pos-- == 0)
X                    return OOPS;
X                switch(vars[i].type = S[pos].type) {
X                case ARG:
X                    vars[i].argnum = S[pos].argnum;
X                    break;
X                case NUM:
X                    vars[i].value = S[pos].value;
X                    break;
X                }
X                break;
X            case 'g':
X                if (termcap || *++sp == '\0')
X                    return OOPS;
X                i = *sp++ - 'a';
X                if (i < 0 || i > 25)
X                    return OOPS;
X                switch(vars[i].type) {
X                case ARG:
X                    if (pusharg(vars[i].argnum))
X                        return OOPS;
X                    break;
X                case NUM:
X                    if (pushnum(vars[i].value))
X                        return OOPS;
X                    break;
X                }
X                break;
X            case '\'':
X                if (termcap > 1)
X                    return OOPS;
X                if (*++sp == '\0')
X                    return OOPS;
X                sp += cvtchar(sp, &c);
X                if (pushnum(c) || *sp++ != '\'')
X                    return OOPS;
X                termcap = 0;
X                break;
X            case '{':
X                if (termcap > 1)
X                    return OOPS;
X                i = 0;
X                sp++;
X                while(isdigit(*sp))
X                    i = 10 * i + *sp++ - '0';
X                if (*sp++ != '}' || pushnum(i))
X                    return OOPS;
X                termcap = 0;
X                break;
X            case 'l':
X                if (termcap || popstring(&s))
X                    return OOPS;
X                i = strlen(s);
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '*':
X                if (termcap || popnum(&j) || popnum(&i))
X                    return OOPS;
X                i *= j;
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '/':
X                if (termcap || popnum(&j) || popnum(&i))
X                    return OOPS;
X                i /= j;
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case 'm':
X                if (termcap) {
X                    if (getarg(1, INTEGER, &i))
X                        return OOPS;
X                    arg_list[0].integer ^= 0177;
X                    arg_list[1].integer ^= 0177;
X                    sp++;
X                    break;
X                }
X                if (popnum(&j) || popnum(&i))
X                    return OOPS;
X                i %= j;
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '&':
X                if (popnum(&j) || popnum(&i))
X                    return OOPS;
X                i &= j;
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '|':
X                if (popnum(&j) || popnum(&i))
X                    return OOPS;
X                i |= j;
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '^':
X                if (popnum(&j) || popnum(&i))
X                    return OOPS;
X                i ^= j;
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '=':
X                if (popnum(&j) || popnum(&i))
X                    return OOPS;
X                i = (i == j);
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '<':
X                if (popnum(&j) || popnum(&i))
X                    return OOPS;
X                i = (i < j);
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case 'A':
X                if (popnum(&j) || popnum(&i))
X                    return OOPS;
X                i = (i && j);
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case 'O':
X                if (popnum(&j) || popnum(&i))
X                    return OOPS;
X                i = (i || j);
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '!':
X                if (popnum(&i))
X                    return OOPS;
X                i = !i;
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '~':
X                if (popnum(&i))
X                    return OOPS;
X                i = ~i;
X                if (pushnum(i))
X                    return OOPS;
X                sp++;
X                break;
X            case '?':
X                if (termcap > 1)
X                    return OOPS;
X                termcap = 0;
X                if_depth++;
X                sp++;
X                break;
X            case 't':
X                if (popnum(&i) || if_depth == 0)
X                    return OOPS;
X                if (!i) {
X                    scan_for = 'e';
X                    scan_depth = if_depth;
X                }
X                sp++;
X                break;
X            case 'e':
X                if (if_depth == 0)
X                    return OOPS;
X                scan_for = ';';
X                scan_depth = if_depth;
X                sp++;
X                break;
X            case ';':
X                if (if_depth-- == 0)
X                    return OOPS;
X                sp++;
X                break;
X            case 'b':
X                if (--termcap < 1)
X                    return OOPS;
X                sp++;
X                break;
X            case 'f':
X                if (!termcap++)
X                    return OOPS;
X                sp++;
X                break;
X            }
X            break;
X        default:
X            if (scan_for)
X                sp++;
X            else
X                *dp++ = *sp++;
X            break;
X        }
X    }
X    va_end(tparm_args);
X    *dp = '\0';
X    return buf;
X}
X
X#ifdef TEST
X
void
putch(c)
int c; {
X    c &= 0xff;
X    if (c > 127 || c < 0) {
X        printf("\\%03o", c);
X    } else if (c < 32) {
X        printf("^%c", c + '@');
X    } else if (c == 127) {
X        printf("^?");
X    } else {
X        putchar(c);
X    }
X}
X
char line[MAX_LINE];
X
int
main(argc, argv)
int argc;
char **argv; {
X    register char *sp;
X    putchar('\n');
X
X    while(gets(line) != NULL) {
X        sp = tparm(line, 1, -2, 30, 0, "bob was here");
X        while(*sp)
X            putch(*sp++);
X        putchar('\n');
X    }
X    return 0;
X}
X#endif
END_OF_FILE
if test 16639 -ne `wc -c <'tparm.c'`; then
    echo shar: \"'tparm.c'\" unpacked with wrong size!
fi
# end of 'tparm.c'
fi
if test -f 'tset.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'tset.c'\"
else
echo shar: Extracting \"'tset.c'\" \(15371 characters\)
sed "s/^X//" >'tset.c' <<'END_OF_FILE'
X/*
X * tset.c
X *
X * By Ross Ridge
X * Public Domain
X * 92/02/19 18:53:12
X *
X */
X
X#define NOTLIB
X
X#include "defs.h"
X
static const char SCCSid[] = "@(#) mytinfo tset.c 3.3 92/02/19 public domain, By Ross Ridge";
X
X#define SINGLE
X#include "term.h"
X
X#include <ctype.h>
X
X#ifdef USE_TERMIO
X
X#ifndef ICANON
X#include <termio.h>
X#endif
X
X#undef USE_SUSPEND
X#ifdef VSUSP
X#define USE_SUSPEND
X#endif
X
X#define USE_INTERRUPT
X
X#ifdef TCSETS
X#define USE_TERMIOS
X#else
X#undef USE_SUSPEND
X#endif
X
X#else /* USE_TERMIO */
X#ifdef USE_SGTTY
X
X#ifndef CBREAK
X#include <sgtty.h>
X#endif
X
X#undef USE_INTERRUPT
X#ifdef TIOCGETC
X#define USE_INTERRUPT
X#endif
X
X#undef USE_SUSPEND
X#ifdef TIOCGLTC
X#define USE_SUSPEND
X#endif
X
X#undef USE_NEWBSDTTY
X#ifdef TIOCSETD
X#ifdef NTTYDISC
X#define USE_NEWBSDTTY
X#endif
X#endif
X
X#else /* USE_SGTTY */
X
X#undef USE_SUSPEND
X#define USE_NOTTY
X
X#endif /* else USE_SGTTY */
X#endif /* else USE_TERMIO */
X
X#ifndef key_interrupt_char
X#undef USE_INTERRUPT
X#endif
X
X#ifndef key_suspend_char
X#undef USE_SUSPEND
X#endif
X
char *term;
int asked = 0;
long baudrate;
X
X#ifndef USE_STDLIB
X#ifdef USE_PROTOTYPES
long atol(char const *);
X#else
long atol();
X#endif
X#endif
X
X#define OUTPUT_TERM    1
X#define OUTPUT_SHELL    2
X#define OUTPUT_TERMCAP    3
X
X#define PUTS(s)        tputs(s, 1, putch)
X#define PUTCHAR(c)    putc(c, stderr)
X#define FLUSH        fflush(stderr)
X
X#ifdef USE_SMALLMEM
extern unsigned short _baud_tbl[];
X#else
extern long _baud_tbl[];
X#endif
X
extern void (*cleanup)();
X
static void
clean(e)
int e; {
X    return;
X}
X
static int
putch(c)
int c; {
X    return putc(c, stderr);
X}
X
void
set_term(name, query)
char *name;
int query; {
X    static char buf[MAX_LINE];
X    char *s, *t;
X
X    if (query) {
X        fprintf(stderr, "TERM = (%s) ", name);
X        fflush(stderr);
X        asked = 1;
X        if (gets(buf) != NULL) {
X            s = buf;
X            while(*s != '\0' && isspace(*s))
X                s++;
X            t = s;
X            while(*s != '\0' && !isspace(*s))
X                s++;
X            *s = '\0';
X            if (*t != '\0') {
X                term = t;
X                return;
X            }
X        }
X    }
X    term = strcpy(buf, name);
X}
X
int
map_term(map, ask)
char *map;
int ask; {
X    char *type;
X    char test = 0;
X    char *baud = NULL;
X
X    type = map;
X#ifndef USE_NOTTY
X    while(*map && strchr(">@<!:?", *map) == NULL)
X        map++;
X    if (*map != '\0' && *map != ':' && *map != '?') {
X        if (*map == '!') {
X            switch(*++map) {
X            case '>': test = 'g'; break;
X            case '@': test = 'n'; break;
X            case '<': test = 'l'; break;
X            default:
X                quit(-1, "bad argument to 'm' switch");
X            }
X        } else
X            test = *map;
X        *map++ = '\0';
X        baud = map;
X        while(*map && *map != ':')
X            map++;
X    }
X
X#else
X    while(*map && *map != ':' && *map != '?')
X        map++;
X#endif
X
X    if (*map == ':')
X        *map++ = '\0';
X    if (*map == '?') {
X        ask = 1;
X        *map++ = '\0';
X    }
X    if (*map == '\0')
X        quit(-1, "bad argument to 'm' switch");
X
X    if (type[0] != '\0' && strcmp(type, term) != 0) {
X        return 0;
X    }
X
X#ifndef USE_NOTTY
X    switch(test) {
X    case '>':
X        if (baudrate <= atol(baud))
X            return 0;
X        break;
X    case '<':
X        if (baudrate >= atol(baud))
X            return 0;
X        break;
X    case '@':
X        if (baudrate != atol(baud))
X            return 0;
X        break;
X    case 'l':
X        if (baudrate < atol(baud))
X            return 0;
X        break;
X    case 'g':
X        if (baudrate > atol(baud))
X            return 0;
X        break;
X    case 'n':
X        if (baudrate == atol(baud))
X            return 0;
X        break;
X    }
X#endif
X
X    set_term(map, ask);
X    return 1;
X}
X
int
conv_char(s)
char *s; {
X    if (s[0] == '^' && s[1] >= '@' && s[1] <= '\177')
X        return s[1] & 31;
X    else if (s[0] == '^' && s[1] == '?')
X        return '\177';
X    else if (s[0] != '\0')
X        return s[0];
X    else
X        return -2;
X}
X
char *
expand_char(c)
int c; {
X    static char buf[5];
X
X    if (c < 0 || c > 127) {
X        sprintf(buf, "\\%03o", c & 0177);
X    } else if (c == 127) {
X        return "DEL";
X    } else if (c < 32) {
X        buf[0] = '^';
X        buf[1] = c + 64;
X        buf[2] = '\0';
X    } else {
X        buf[0] = c;
X        buf[1] = '\0';
X    }
X
X    return buf;
X}
X
X#define START     1
X#define COPY    2
X#define ESCAPE    3
X
void
compress_buf(buf)
char *buf; {
X    char *s, *d;
X    int state = START;
X
X    d = s = buf;
X
X    while(*s) {
X        switch(state) {
X        case START:
X            if (isspace(*s) || *s == ':') {
X                s++;
X                break;
X            }
X            state = COPY;
X            /* FALLTHROUGH */
X        case COPY:
X            switch(*s) {
X            case '^':
X            case '\\':
X                state = ESCAPE;
X                break;
X            case ':':
X                state = START;
X                break;
X            }
X            *d++ = *s++;
X            break;
X
X        case ESCAPE:
X            *d++ = *s++;
X            state = COPY;
X            break;
X        }
X    }
X}
X
static void
usage(e)
int e; {
X#ifdef USE_ANSIC
X    fprintf(stderr, "usage: %s [-] [-"
X#define ARG(s)    s
X#else
X    fprintf(stderr, "usage: %s [-] [-", prg_name);
X#define ARG(s)    fputs(s, stderr);
X#endif
X            ARG("l")
X#ifndef USE_NOTTY
X#ifdef USE_NEWBSDTTY
X            ARG("n")
X#endif
X#endif
X            ARG("rsAI")
X#ifndef USE_NOTTY
X            ARG("Q")
X#endif
X            ARG("S")
X#ifndef USE_NOTTY
X            ARG("T")
X#endif
X            ARG("]")
X#ifndef USE_NOTTY
X            ARG(" [-e[c]] [-E[c]] [-k[c]]")
X#ifdef USE_INTERRUPT
X            ARG(" [-i[c]]")
X#endif
X#ifdef USE_SUSPEND
X            ARG(" [-z[c]]")
X#endif
X#endif
X            ARG("\n\t[-m ident")
X#ifndef USE_NOTTY
X            ARG("[[!][<@>]speed]")
X#endif
X            ARG(":[?]term] [term]\n")
X#ifdef USE_ANSIC
X            , prg_name);
X#endif
X
X#undef ARG
X
X    return;
X}
X
int
main(argc, argv)
int argc;
char **argv; {
X    char *s;
X    int i, j, r, c;
X    int ask = 0;
X#ifndef USE_NOTTY
X    int erase_char = -1;
X    int erase_if_bs = 0;
X    int kill_char = -1;
X#ifdef USE_INTERRUPT
X    int interrupt_char = -1;
X#endif
X#ifdef USE_SUSPEND
X    int suspend_char = -1;
X#endif
X#ifdef USE_NEWBSDTTY
X    int newbsdtty = 0;
X#endif
X#endif /* !USE_NOTTY */
X    int output_type = 0;
X    int no_term_init = 0;
X    int term_type_is = 0;
X    int no_set_to = 0;
X    int reset = 0;
X    int matched = 0;
X    int expand_tabs = -1;
X    int is_csh;
X#ifndef USE_NOTTTY
X#ifdef USE_TERMIO
X#ifdef USE_TERMIOS
X    struct termios tty;
X#else
X    struct termio tty;
X#endif
X#else
X#ifdef USE_SGTTY
X    struct sgttyb tty;
X#ifdef USE_INTERRUPT
X    struct tchars tty2;
X#endif
X#ifdef USE_SUSPEND
X    struct ltchars tty3;
X#endif
X#endif /* USE_SGTTY */
X#endif /* else USE_TERMIO */
X#endif /* !USE_NOTTY */
X    struct term_path *path;
X    char buf[MAX_BUF];
X    FILE *f;
X    int datatype;
X
X    prg_name = argv[0];
X    s = strrchr(prg_name, '/');
X    if (s != NULL && *++s != '\0') {
X        if (strcmp(s, "reset") == 0) {
X            reset = 1;
X        }
X        prg_name = s;
X    }
X
X    cleanup = clean;
X
X#ifndef USE_NOTTY
X#ifdef USE_TERMIO
X#ifdef USE_TERMIOS
X    if (ioctl(2, TCGETS, &tty) == -1)
X#else
X    if (ioctl(2, TCGETA, &tty) == -1)
X#endif
X    {
X        quit(errno, "ioctl failed");
X    }
X    baudrate = _baud_tbl[tty.c_cflag & CBAUD];
X#else
X#ifdef USE_SGTTY
X    if (gtty(2, &tty) == -1) {
X        quit(errno, "gtty failed");
X    }
X    baudrate = _baud_tbl[tty.sg_ospeed];
X#ifdef USE_INTERRUPT
X    if (ioctl(2, TIOCGETC, &tty2) == -1) {
X        quit(errno, "ioctl failed");
X    }
X#endif
X#ifdef USE_SUSPEND
X    if (ioctl(2, TIOCGLTC, &tty3) == -1) {
X        quit(errno, "ioctl failed");
X    }
X#endif
X#endif /* USE_SGTTY */
X#endif /* else USE_TERMIO */
X#endif /* !USE_NOTTY */
X
X    term = getenv("TERM");
X
X    cleanup = usage;
X
X    for(i = 1; i < argc; i++) {
X        if (argv[i][0] != '-') {
X            if (term == NULL) {
X                term = argv[i];
X            }
X            continue;
X        }
X        s = argv[i] + 1;
X        if (*s == '\0') {
X            output_type = OUTPUT_TERM;
X            continue;
X        }
X        while (*s != '\0') {
X            switch(*s++) {
X            case 'A':
X                ask = 1;
X                continue;
X#ifndef USE_NOTTY
X            case 'E':
X                erase_if_bs = 1;
X                /* FALLTHROUGH */
X            case 'e':
X                erase_char = conv_char(s);
X                break;
X            case 'k':
X                kill_char = conv_char(s);
X                break;
X#ifdef USE_INTERRUPT
X            case 'i':
X                interrupt_char = conv_char(s);
X                break;
X#endif
X#ifdef USE_SUSPEND
X            case 'z':
X                suspend_char = conv_char(s);
X                break;
X#endif
X            case 'T':
X                erase_char = kill_char
X#ifdef USE_INTERRUPT
X                    = interrupt_char
X#endif
X#ifdef USE_SUSPEND
X                    = suspend_char
X#endif
X                    = -2;
X                continue;
X#ifdef USE_NEWBSDTTY
X            case 'n':
X                newbsdtty = 1;
X                continue;
X#endif
X            case 'Q':
X                no_set_to = 1;
X                continue;
X#endif /* !USE_NOTTY */
X            case 'l':
X            case 'I':
X                no_term_init = 1;
X                continue;
X            case 'r':
X                term_type_is = 1;
X                continue;
X            case 's':
X                output_type = OUTPUT_SHELL;
X                continue;
X            case 'S':
X                output_type = OUTPUT_TERMCAP;
X                continue;
X            case 'm':
X                if (*s == '\0') {
X                    if (i == argc - 1) {
X                        quit(-1, "'m' switch requires an argument.");
X                    }
X                    s = argv[++i];
X                }
X                if (!matched) {
X                    matched = map_term(s, ask);
X                }
X                break;
X            default:
X                quit(-1, "unknown switch '%c'", s[-1]);
X                break;
X            }
X            break;
X        }
X    }
X
X    cleanup = clean;
X
X    path = _buildpath("$MYTERMINFO", 2,
X              "$TERMINFO", 2,
X              "$TERMCAP", 1,
X#ifdef TERMINFODIR
X              TERMINFODIR, 0,
X#endif
X#ifdef TERMCAPFILE
X              TERMCAPFILE, 0,
X#endif
X#ifdef TERMINFOSRC
X              TERMINFOSRC, 0,
X#endif
X              NULL, -1);
X
X    if (path == NULL) {
X        quit(-1, "malloc error");
X    }
X
X    do {
X        if (term == NULL) {
X            term = "unknown";
X        }
X
X        if (ask && !asked) {
X            set_term(term, 1);
X        }
X
X        datatype = _fillterm(term, path, buf);
X
X        switch(datatype) {
X        case -3:
X            quit(-1, "malloc error");
X            /* NOTREACHED */
X        case -2:
X            quit(-1, "database in bad format");
X            /* NOTREACHED */
X        case -1:
X            /* quit(-1, "database not found"); */
X        case 0:
X            if (ask || asked) {
X                fprintf(stderr, "terminal type '%s' unknown.\n",
X                    term);
X                term = NULL;
X                ask = 1;
X                asked = 0;
X            } else {
X                quit(-1, "terminal type '%s' unknown.\n", term);
X            }
X            break;
X        case 1:
X        case 2:
X        case 3:
X            break;
X        default:
X            quit(-1, "oops...");
X        }
X    } while(term == NULL);
X
X    _delpath(path);
X
X    cur_term->baudrate = baudrate;
X
X    if (!no_term_init) {
X
X        if (init_prog != NULL) {
X            system(init_prog);
X        }
X        FLUSH;
X
X        if (reset && reset_1string != NULL) {
X            PUTS(reset_1string);
X        } else if (init_1string != NULL) {
X            PUTS(init_1string);
X        }
X        FLUSH;
X
X        if (reset && reset_2string != NULL) {
X            PUTS(reset_2string);
X        } else if (init_2string != NULL) {
X            PUTS(init_2string);
X        }
X        FLUSH;
X
X        if (set_lr_margin != NULL) {
X            PUTS(tparm(set_lr_margin, 0, columns - 1));
X        } else if (set_left_margin_parm != NULL
X               && set_right_margin_parm != NULL) {
X            PUTS(tparm(set_left_margin_parm, 0));
X            PUTS(tparm(set_right_margin_parm, columns - 1));
X        } else if (clear_margins != NULL && set_left_margin != NULL
X               && set_right_margin != NULL) {
X            PUTS(clear_margins);
X            if (carriage_return != NULL) {
X                PUTS(carriage_return);
X            } else {
X                PUTCHAR('\r');
X            }
X            PUTS(set_left_margin);
X            if (parm_right_cursor) {
X                PUTS(tparm(parm_right_cursor, columns - 1));
X            } else {
X                for(i = 0; i < columns - 1; i++) {
X                    PUTCHAR(' ');
X                }
X            }
X            PUTS(set_right_margin);
X            if (carriage_return != NULL) {
X                PUTS(carriage_return);
X            } else {
X                PUTCHAR('\r');
X            }
X        }
X        FLUSH;
X
X        if (init_tabs != 8) {
X            if (clear_all_tabs != NULL && set_tab != NULL) {
X                if (carriage_return != NULL) {
X                    PUTS(carriage_return);
X                } else {
X                    PUTCHAR('\r');
X                }
X                PUTS(clear_all_tabs);
X                PUTS(set_tab);
X                for(i = 8; i < columns - 1; i += 8) {
X                    if (parm_right_cursor) {
X                        PUTS(tparm(parm_right_cursor,
X                             8));
X                    } else {
X                        for(j = 0; j < 8; j++) {
X                            PUTCHAR(' ');
X                        }
X                    }
X                    PUTS(set_tab);
X                }
X                if (carriage_return != NULL) {
X                    PUTS(carriage_return);
X                } else {
X                    PUTCHAR('\r');
X                }
X                expand_tabs = 0;
X                FLUSH;
X            } else {
X                expand_tabs = 1;
X            }
X        } else {
X            expand_tabs = 0;
X        }
X
X        if (reset && reset_file != NULL) {
X            f = fopen(reset_file, "r");
X            if (f == NULL) {
X                quit(errno, "Can't open reset_file: '%s'",
X                     reset_file);
X            }
X            while((c = fgetc(f)) != EOF) {
X                PUTCHAR(c);
X            }
X            fclose(f);
X        } else if (init_file != NULL) {
X            f = fopen(init_file, "r");
X            if (f == NULL) {
X                quit(errno, "Can't open init_file: '%s'",
X                     init_file);
X            }
X            while((c = fgetc(f)) != EOF) {
X                PUTCHAR(c);
X            }
X            fclose(f);
X        }
X        FLUSH;
X
X        if (reset && reset_3string != NULL) {
X            PUTS(reset_3string);
X        } else if (init_2string != NULL) {
X            PUTS(init_3string);
X        }
X        FLUSH;
X    }
X
X    if (term_type_is) {
X        fprintf(stderr, "Terminal type is %s\n", term);
X    }
X
X#ifndef USE_NOTTY
X#ifdef USE_TERMIO
X
X    if (expand_tabs == 0 && (tty.c_cflag & TABDLY) == TAB3) {
X        tty.c_cflag = tty.c_cflag & ~TABDLY;
X    } else if (expand_tabs == 1) {
X        tty.c_cflag = (tty.c_cflag & ~TABDLY) | TAB3;
X    }
X
X#define SETTO(v, m, t, c) (c != tty.c_cc[v] ? (tty.c_cc[v] = c,          \
X               !no_set_to ? fprintf(stderr, "%s set to %s\n", t, \
X                         expand_char(c)) : 0) : 0)
X
X#endif
X#ifdef USE_SGTTY
X
X#ifdef USE_NEWBSDTTY
X    if (newbsdtty) {
X        if (ioctl(2, TIOCSETD, NTTYDISC) == -1) {
X            quit(errno, "Can't switch tty to new line disc.");
X        }
X    }
X#endif
X
X    if (expand_tabs == 0) {
X        tty.sg_flags &= ~XTABS;
X    } else if (expand_tabs == 1) {
X        tty.sg_flags |= XTABS;
X    }
X
X#define SETTO(v, m, t, c) (c != m ? (m = c,                  \
X               !no_set_to ? fprintf(stderr, "%s set to %s\n", t, \
X                         expand_char(c)) : 0) : 0)
X#endif
X
X    if (erase_char != -1
X            && (!erase_if_bs || backspaces_with_bs
X            || (cursor_left == NULL && cursor_left[0] != '\b'))) {
X        if (erase_char != -2) {
X            c = erase_char;
X        } else if (cursor_left == NULL || cursor_left[0] == '\0'
X             || cursor_left[1] != '\0') {
X            c = '\b';
X        } else {
X            c = cursor_left[0];
X        }
X        SETTO(VERASE, tty.sg_erase, "Erase", c);
X    }
X
X    if (kill_char != -1) {
X        if (kill_char != -2) {
X            c = kill_char;
X        } else if (key_kill_char == NULL || key_kill_char[0] == '\0'
X               || key_kill_char[1] != '\0') {
X            c = '\025';
X        } else {
X            c = key_kill_char[0];
X        }
X        SETTO(VKILL, tty.sg_kill, "Kill", c);
X    }
X
X
X#ifdef USE_INTERRUPT
X    if (interrupt_char != -1) {
X        if (interrupt_char != -2) {
X            c = interrupt_char;
X        } else if (key_interrupt_char == NULL
X               || key_interrupt_char[0] == '\0'
X               || key_interrupt_char[1] != '\0') {
X            c = '\177';
X        } else {
X            c = key_interrupt_char[0];
X        }
X        SETTO(VINTR, tty2.t_intrc, "Interrupt", c);
X    }
X#endif
X
X#ifdef USE_SUSPEND
X    if (suspend_char != -1) {
X        if (suspend_char != -2) {
X            c = suspend_char;
X        } else if (key_suspend_char == NULL
X               || key_suspend_char[0] == '\0'
X               || key_suspend_char[1] != '\0') {
X            c = '\032';
X        } else {
X            c = key_suspend_char[0];
X        }
X        SETTO(VSUSP, tty3.t_suspc, "Suspend", c);
X    }
X#endif
X
X#ifdef USE_TERMIO
X#ifdef USE_TERMIOS
X    if (ioctl(2, TCSETS, &tty) == -1)
X#else
X    if (ioctl(2, TCSETA, &tty) == -1)
X#endif
X    {
X        quit(errno, "ioctl failed");
X    }
X#else
X#ifdef USE_SGTTY
X    if (stty(2, &tty) == -1) {
X        quit(errno, "stty failed");
X    }
X#ifdef USE_INTERRUPT
X    if (ioctl(2, TIOCSETC, &tty2) == -1) {
X        quit(errno, "ioctl failed");
X    }
X#endif
X#ifdef USE_SUSPEND
X    if (ioctl(2, TIOCSLTC, &tty3) == -1) {
X        quit(errno, "ioctl failed");
X    }
X#endif
X#endif /* USE_SGTTY */
X#endif /* else USE_TERMIO */
X#endif /* !USE_NOTTY */
X
X    s = getenv("SHELL");
X    r = strlen(s);
X
X    if (r >= 3 && strcmp("csh", s + r - 3) == 0) {
X        is_csh = 1;
X    } else {
X        is_csh = 0;
X    }
X
X    switch(output_type) {
X    case OUTPUT_TERM:
X        fprintf(stdout, "%s\n", term);
X        break;
X
X    case OUTPUT_TERMCAP:
X        if (is_csh) {
X            if (datatype == 1) {
X                compress_buf(buf);
X                fprintf(stdout, "%s %s", term, buf);
X            } else {
X                s = getenv("TERMCAP");
X                if (s == NULL || *s == '\0') {
X                    s = ":";
X                }
X                fprintf(stdout, "%s %s", term, s);
X            }
X            break;
X        }
X        /* FALLTHROUGH */
X    case OUTPUT_SHELL:
X        if (is_csh) {
X            fprintf(stdout, "set noglob;\n");
X            fprintf(stdout, "setenv TERM '%s';\n", term);
X            if (datatype == 1) {
X                compress_buf(buf);
X                fprintf(stdout, "setenv TERMCAP '%s';\n", buf);
X            }
X            fprintf(stdout, "unset noglob;\n");
X        } else {
X            fprintf(stdout, "export TERM TERMCAP;\n");
X            fprintf(stdout, "TERM='%s';\n", term);
X            if (datatype == 1) {
X                compress_buf(buf);
X                fprintf(stdout, "TERMCAP='%s';\n", buf);
X            }
X        }
X        break;
X    }
X
X    return 0;
X}
END_OF_FILE
if test 15371 -ne `wc -c <'tset.c'`; then
    echo shar: \"'tset.c'\" unpacked with wrong size!
fi
# end of 'tset.c'
fi
echo shar: End of archive 3 \(of 3\).
cp /dev/null ark3isdone
MISSING=""
for I in 1 2 3 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 3 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0