Newsgroups: comp.sources.misc
From: dan%step.uucp@uunet.uu.net (Daniel Weaver)
Subject:  v25i029:  ted - Terminfo/termcap test program, Part04/07
Message-ID: <1991Nov6.042952.5991@sparky.imd.sterling.com>
X-Md4-Signature: a745646eb8b1c916d2f461a4b855d562
Date: Wed, 6 Nov 1991 04:29:52 GMT
Approved: kent@sparky.imd.sterling.com

Submitted-by: dan%step.uucp@uunet.uu.net (Daniel Weaver)
Posting-number: Volume 25, Issue 29
Archive-name: ted/part04
Environment: UNIX

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to comp-sources-unix@uunet.uu.net if you want that tool.
# If this archive is complete, you will see the following message at the end:
#		"End of archive 4 (of 7)."
# Contents:  crum.c getcaps.c ted.h
# Wrapped by dan@step on Fri Nov  1 11:28:26 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'crum.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'crum.c'\"
else
echo shar: Extracting \"'crum.c'\" \(9550 characters\)
sed "s/^X//" >'crum.c' <<'END_OF_FILE'
X/*
X** This software is Copyright (c) 1991 by Daniel Weaver.
X**
X** Permission is hereby granted to copy, distribute or otherwise
X** use any part of this package as long as you do not try to make
X** money from it or pretend that you wrote it.  This copyright
X** notice must be maintained in any copy made.
X**
X** Use of this software constitutes acceptance for use in an AS IS
X** condition. There are NO warranties with regard to this software.
X** In no event shall the author be liable for any damages whatsoever
X** arising out of or in connection with the use or performance of this
X** software.  Any use of this software is at the user's own risk.
X**
X**  If you make modifications to this software that you feel
X**  increases it usefulness for the rest of the community, please
X**  email the changes, enhancements, bug fixes as well as any and
X**  all ideas to me. This software is going to be maintained and
X**  enhanced as deemed necessary by the community.
X*/
X/* test the cursor movement */
X
X#include "curses.h"
X#include "ted.h"
X
Xvoid
Xmove_to(rf, cf, rt, ct, sel)
Xint rf, cf, rt, ct, sel;
X   {  /* move the cursor from (rf, cf) to (rt, ct) using sel */
X      char *s;
X
X      if (sel & 8)
X         {  /* use (cup) */
X            s = tcup(cursor_address, rt, ct);
X            tputs(s, lines, putch);
X            return;
X         }
X      if (sel & 4)
X         {  /* use (hpa) (vpa) */
X            if (column_address)
X               {
X                  s = tparm(column_address, ct);
X                  tputs(s, 1, putch);
X                  cf = ct;
X               }
X            if (row_address)
X               {
X                  s = tparm(row_address, rt);
X                  tputs(s, 1, putch);
X                  rf = rt;
X               }
X         }
X      if (sel & 2)
X         {  /* paramiterized relative cursor movement */
X            if (parm_right_cursor)
X               if (cf < ct)
X                  {
X                     s = tparm(parm_right_cursor, ct - cf);
X                     tputs(s, ct - cf, putch);
X                     cf = ct;
X                  }
X            if (parm_left_cursor)
X               if (cf > ct)
X                  {
X                     s = tparm(parm_left_cursor, cf - ct);
X                     tputs(s, cf - ct, putch);
X                     cf = ct;
X                  }
X            if (parm_down_cursor)
X               if (rf < rt)
X                  {
X                     s = tparm(parm_down_cursor, rt - rf);
X                     tputs(s, rt - rf, putch);
X                     rf = rt;
X                  }
X            if (parm_up_cursor)
X               if (rf > rt)
X                  {
X                     s = tparm(parm_up_cursor, rf - rt);
X                     tputs(s, rf - rt, putch);
X                     rf = rt;
X                  }
X         }
X      if (sel & 1)
X         {
X            if (cursor_left)
X               while (cf > ct) {
X                  putp(cursor_left);  cf--;
X               }
X            /* do vertical motion next.  Just incase cursor_down
X               has a side effect of changing the column.  This could
X               happen if the tty handler translates NL to CRNL.  */
X            if (cursor_down)
X               while (rf < rt) {
X                  putp(cursor_down);  rf++;
X               }
X            if (cursor_up)
X               while (rf > rt) {
X                  putp(cursor_up);  rf--;
X               }
X            if (cursor_right)
X               while (cf < ct) {
X                  putp(cursor_right);  cf++;
X               }
X         }
X      /* last chance */
X      if (rf > rt)
X         if (can_go_home)
X            {  /* a bit drastic but ... */
X               go_home();  cf = 0;  rf = 0;
X            }
X         else
X         if (cursor_up)
X            while (rf > rt) {
X               putp(cursor_up);  rf--;
X            }
X      if (ct == 0 && rt > rf)
X         {
X            put_crlf();  cf = 0;  rf++;
X         }
X      if (ct == 0 && cf != 0)
X         {
X            put_cr();  cf = 0;
X         }
X         while (rf < rt) {
X            put_lf();  rf++;
X         }
X         while (cf > ct) {
X            put_str("\b");  cf--;
X         }
X      if (cursor_right)
X         while (cf < ct) {
X            putp(cursor_right);  cf++;
X         }
X      else  /* go ahead and trash my display */
X         while (cf < ct) {
X            putchp(' ');  cf++;
X         }
X   }
X
X
Xstatic void
Xdisplay_it(sel, txt)
Xint sel;
Xchar *txt;
X   {  /* print the display using sel */
X      int i, done_line;
X
X      put_clear();
X      go_home();
X      put_newlines(2);
X      ptextln("    The top line should be alternating <'s and >'s");
X      ptextln("    The left side should be alternating A's and V's");
X      ptext(  "    Testing ");
X      ptext(txt);  put_cr();
X
X      /* horizontal */
X      move_to(done_line = line_count, 0, 0, 2, sel);
X         for (i = 4; i < columns - 2; i += 2) {
X            putchp('>');
X            move_to(0, i - 1, 0, i, sel);
X         }
X      putchp('>');  i -= 2;
X      move_to(0, i + 1, 0, i - 1, sel);
X         for ( ; i > 2; i -= 2) {
X            putchp('<');
X            move_to(0, i, 0, i - 3, sel);
X         }
X      putchp('<');
X
X      /* vertical */
X      move_to(0, 2, 0, 0, sel);
X         for (i = 2; i < lines - 1; i += 2) {
X            putchp('V');
X            move_to(i - 2, 1, i, 0, sel);
X         }
X      putchp('V');  i -= 2;
X      move_to(i, 1, i + 1, 0, sel);
X         for (; i > 0; i -= 2) {
X            putchp('A');
X            move_to(i + 1, 1, i - 1, 0, sel);
X         }
X      putchp('A');
X      move_to(i + 1, 1, 0, 0, sel);  /* go home first */
X      move_to(0, 0, done_line + 1, 4, sel);
X      put_str("Done.");
X   }
X
X
Xtest_move()
X   {  /* test cursor movement */
X      int i;
X      char buf[256];
X
X      if (!stop_testing)
X         {
X            put_clear();
X            if (enter_ca_mode) putp(enter_ca_mode);
X         }
X
X      if (run_test(clear_screen,
X         "This terminal has no clear screen (clear)", TRUE))
X         do {
X               for (i = lines; i > 1; i--) putln("garbage");
X            put_clear();
X            ptextln("This line starts in the home position.");
X            ptext("The rest of the screen should be clear.  (clear)");
X         } while (repeat_test(FALSE));
X
X      if (run_test(cursor_home,
X         "This terminal has no home cursor (home)", TRUE))
X         do {
X            put_clear();
X            put_newlines(lines / 2);
X            go_home();
X            move_to(0, 0, 1, 0, 0);
X            ptext("This starts on the second line.");
X            go_home();
X            move_to(0, 0, lines - 1, 0, 0);
X            ptext("This line is on the bottom.");
X            go_home();
X            ptext("This line starts in the home position.  Done (home)");
X         } while (repeat_test(FALSE));
X
X      /* (ll) may be simulated with (cup).
X         If the terminal has windows then (ll) should not
X         be defined, because the position of the last line
X         could change! */
X      can_test("ll");
X      if (run_test(cursor_to_ll, cursor_address ? NULL :
X         "This terminal has no move-to-last-line (ll)", TRUE))
X         do {
X            put_clear();
X            put_str("This line could be anywhere.");
X            putp(cursor_to_ll);
X            ptext("This line is on the bottom. Done.  (ll)");
X         } while (repeat_test(FALSE));
X
X      sprintf(buf, " (cr) (nel) backspace%s",
X         cursor_home ? " (home)" : (cursor_up ? " (cuu1)" : ""));
X      if (run_test(buf, buf, FALSE))
X         do {
X            display_it(0, buf);
X         } while (repeat_test(TRUE));
X
X      sprintf(buf, "%s%s%s%s", cursor_left ? " (cub1)" : "",
X         cursor_down ? " (cud1)" : "", cursor_right ? " (cuf1)" : "",
X         cursor_up ? " (cuu1)" : "");
X      if (run_test((char *)buf[0],
X         "    (cub1) (cud1) (cuf1) (cuu1) not defined.", TRUE))
X         do {
X            display_it(1, buf);
X         } while (repeat_test(TRUE));
X
X      sprintf(buf, "%s%s%s%s", parm_left_cursor ? " (cub)" : "",
X         parm_down_cursor ? " (cud)" : "",
X         parm_right_cursor ? " (cuf)" : "",
X         parm_up_cursor ? " (cuu)" : "");
X      if (run_test((char *)buf[0],
X         "    (cub) (cud) (cuf) (cuu) not defined.", TRUE))
X         do {
X            display_it(2, buf);
X         } while (repeat_test(TRUE));
X
X      sprintf(buf, "%s%s", row_address ? " (vpa)" : "",
X         column_address ? " (hpa)" : "");
X      if (run_test((char *)buf[0],
X         "    (vpa) (hpa) not defined.", TRUE))
X         do {
X            display_it(4, buf);
X         } while (repeat_test(TRUE));
X
X      if (run_test(cursor_address, "    (cup) not defined.", TRUE))
X         do {
X            display_it(8, " (cup)");
X         } while (repeat_test(TRUE));
X
X#ifdef SVR3
X      if (cursor_address && over_strike && run_test(buf, NULL, FALSE))
X         do {
X            put_clear();
X               for (i = 0; i < columns - 2; i++) {
X                  putch('|');
X               }
X               for (i = 1; i < lines - 2; i++) {
X                  put_crlf();
X                  putch('_');
X               }
X               for (i = 0; i < columns - 2; i++) {
X                  tputs(tcup(cursor_address, 0, i), lines, putch);
X                  putch('+');
X               }
X               for (i = 0; i < lines - 2; i++) {
X                  tputs(tcup(cursor_address, i, 0), lines, putch);
X                  putch(']');
X                  putch('_');
X               }
X            go_home();
X            ptext("\n\n\n    All the characters should look the same.  Done (cup) (os)");
X         } while (repeat_test(TRUE));
X#endif
X   }
END_OF_FILE
if test 9550 -ne `wc -c <'crum.c'`; then
    echo shar: \"'crum.c'\" unpacked with wrong size!
fi
# end of 'crum.c'
fi
if test -f 'getcaps.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'getcaps.c'\"
else
echo shar: Extracting \"'getcaps.c'\" \(35222 characters\)
sed "s/^X//" >'getcaps.c' <<'END_OF_FILE'
X/*
X** This software is Copyright (c) 1991 by Daniel Weaver.
X**
X** Permission is hereby granted to copy, distribute or otherwise
X** use any part of this package as long as you do not try to make
X** money from it or pretend that you wrote it.  This copyright
X** notice must be maintained in any copy made.
X**
X** Use of this software constitutes acceptance for use in an AS IS
X** condition. There are NO warranties with regard to this software.
X** In no event shall the author be liable for any damages whatsoever
X** arising out of or in connection with the use or performance of this
X** software.  Any use of this software is at the user's own risk.
X**
X**  If you make modifications to this software that you feel
X**  increases it usefulness for the rest of the community, please
X**  email the changes, enhancements, bug fixes as well as any and
X**  all ideas to me. This software is going to be maintained and
X**  enhanced as deemed necessary by the community.
X*/
X/* termcap to terminfo conversion */
X#ifdef TESTCAP
X#include "bsd.h"
X#ifdef LIBTC
X#define tgetent tcgetent
X#define tgetnum tcgetnum
X#define tgetflag tcgetflag
X#define tgetstr tcgetstr
Xchar ttytype[256];
Xstatic char *s, *t;
Xextern char *gtname();
Xstatic int l;
X#endif
Xextern char *tgetstr();
Xchar cap_entry[4096];
Xstatic char buf[4096];
Xstatic char *bb = buf;
Xchar *captrans[] = {
X	"bw:bw", "am:am", "xsb:xb", "xhp:xs", "xenl:xn", "eo:eo",
X	"gn:gn", "hc:hc", "km:km", "hs:hs", "in:in", "da:da", "db:db",
X	"mir:mi", "msgr:ms", "os:os", "eslok:es", "xt:xt", "hz:hz",
X	"ul:ul", "xon:xo", "nxon:nx", "mc5i:5i", "chts:HC",
X	"nrrmc:NR", "npc:NP", "ndscr:ND", "ccc:cc", "bce:ut",
X	"hls:hl", "xhpa:YA", "crxm:YB", "daisy:YC", "xvpa:YD",
X	"sam:YE", "cpix:YF", "lpix:YG", "cols:co", "it:it",
X	"lines:li", "lm:lm", "xmc:sg", "pb:pb", "vt:vt", "wsl:ws",
X	"nlab:Nl", "lh:lh", "lw:lw", "ma:ma", "wnum:MW", "colors:Co",
X	"pairs:pa", "ncv:NC", "bufsz:Ya", "spinv:Yb", "spinh:Yc",
X	"maddr:Yd", "mjump:Ye", "mcs:Yf", "mls:Yg", "npins:Yh",
X	"orc:Yi", "orl:Yj", "orhi:Yk", "orvi:Yl", "cps:Ym",
X	"widcs:Yn", "cbt:bt", "bel:bl", "cr:cr", "csr:cs", "tbc:ct",
X	"clear:cl", "el:ce", "ed:cd", "hpa:ch", "cmdch:CC", "cup:cm",
X	"cud1:do", "home:ho", "civis:vi", "cub1:le", "mrcup:CM",
X	"cnorm:ve", "cuf1:nd", "ll:ll", "cuu1:up", "cvvis:vs",
X	"dch1:dc", "dl1:dl", "dsl:ds", "hd:hd", "smacs:as",
X	"blink:mb", "bold:md", "smcup:ti", "smdc:dm", "dim:mh",
X	"smir:im", "invis:mk", "prot:mp", "rev:mr", "smso:so",
X	"smul:us", "ech:ec", "rmacs:ae", "sgr0:me", "rmcup:te",
X	"rmdc:ed", "rmir:ei", "rmso:se", "rmul:ue", "flash:vb",
X	"ff:ff", "fsl:fs", "is1:i1", "is2:is", "is3:i3", "if:if",
X	"ich1:ic", "il1:al", "ip:ip", "kbs:kb", "ktbc:ka", "kclr:kC",
X	"kctab:kt", "kdch1:kD", "kdl1:kL", "kcud1:kd", "krmir:kM",
X	"kel:kE", "ked:kS", "kf0:k0", "kf1:k1", "kf10:k;", "kf2:k2",
X	"kf3:k3", "kf4:k4", "kf5:k5", "kf6:k6", "kf7:k7", "kf8:k8",
X	"kf9:k9", "khome:kh", "kich1:kI", "kil1:kA", "kcub1:kl",
X	"kll:kH", "knp:kN", "kpp:kP", "kcuf1:kr", "kind:kF", "kri:kR",
X	"khts:kT", "kcuu1:ku", "rmkx:ke", "smkx:ks", "lf0:l0",
X	"lf1:l1", "lf10:la", "lf2:l2", "lf3:l3", "lf4:l4", "lf5:l5",
X	"lf6:l6", "lf7:l7", "lf8:l8", "lf9:l9", "rmm:mo", "smm:mm",
X	"nel:nw", "pad:pc", "dch:DC", "dl:DL", "cud:DO", "ich:IC",
X	"indn:SF", "il:AL", "cub:LE", "cuf:RI", "rin:SR", "cuu:UP",
X	"pfkey:pk", "pfloc:pl", "pfx:px", "mc0:ps", "mc4:pf",
X	"mc5:po", "rep:rp", "rs1:r1", "rs2:r2", "rs3:r3", "rf:rf",
X	"rc:rc", "vpa:cv", "sc:sc", "ind:sf", "ri:sr", "sgr:sa",
X	"hts:st", "wind:wi", "ht:ta", "tsl:ts", "uc:uc", "hu:hu",
X	"iprog:iP", "ka1:K1", "ka3:K3", "kb2:K2", "kc1:K4", "kc3:K5",
X	"mc5p:pO", "rmp:rP", "acsc:ac", "pln:pn", "kcbt:kB",
X	"smxon:SX", "rmxon:RX", "smam:SA", "rmam:RA", "xonc:XN",
X	"xoffc:XF", "enacs:eA", "smln:LO", "rmln:LF", "kbeg:@1",
X	"kcan:@2", "kclo:@3", "kcmd:@4", "kcpy:@5", "kcrt:@6",
X	"kend:@7", "kent:@8", "kext:@9", "kfnd:@0", "khlp:%1",
X	"kmrk:%2", "kmsg:%3", "kmov:%4", "knxt:%5", "kopn:%6",
X	"kopt:%7", "kprv:%8", "kprt:%9", "krdo:%0", "kref:&1",
X	"krfr:&2", "krpl:&3", "krst:&4", "kres:&5", "ksav:&6",
X	"kspd:&7", "kund:&8", "kBEG:&9", "kCAN:&0", "kCMD:*1",
X	"kCPY:*2", "kCRT:*3", "kDC:*4", "kDL:*5", "kslt:*6",
X	"kEND:*7", "kEOL:*8", "kEXT:*9", "kFND:*0", "kHLP:#1",
X	"kHOM:#2", "kIC:#3", "kLFT:#4", "kMSG:%a", "kMOV:%b",
X	"kNXT:%c", "kOPT:%d", "kPRV:%e", "kPRT:%f", "kRDO:%g",
X	"kRPL:%h", "kRIT:%i", "kRES:%j", "kSAV:!1", "kSPD:!2",
X	"kUND:!3", "rfi:RF", "kf11:F1", "kf12:F2", "kf13:F3",
X	"kf14:F4", "kf15:F5", "kf16:F6", "kf17:F7", "kf18:F8",
X	"kf19:F9", "kf20:FA", "kf21:FB", "kf22:FC", "kf23:FD",
X	"kf24:FE", "kf25:FF", "kf26:FG", "kf27:FH", "kf28:FI",
X	"kf29:FJ", "kf30:FK", "kf31:FL", "kf32:FM", "kf33:FN",
X	"kf34:FO", "kf35:FP", "kf36:FQ", "kf37:FR", "kf38:FS",
X	"kf39:FT", "kf40:FU", "kf41:FV", "kf42:FW", "kf43:FX",
X	"kf44:FY", "kf45:FZ", "kf46:Fa", "kf47:Fb", "kf48:Fc",
X	"kf49:Fd", "kf50:Fe", "kf51:Ff", "kf52:Fg", "kf53:Fh",
X	"kf54:Fi", "kf55:Fj", "kf56:Fk", "kf57:Fl", "kf58:Fm",
X	"kf59:Fn", "kf60:Fo", "kf61:Fp", "kf62:Fq", "kf63:Fr",
X	"el1:cb", "mgc:MC", "smgl:ML", "smgr:MR", "fln:Lf", "sclk:SC",
X	"dclk:DK", "rmclk:RC", "cwin:CW", "wingo:WG", "hup:HU",
X	"dial:DI", "qdial:QD", "tone:TO", "pulse:PU", "hook:fh",
X	"pause:PA", "wait:WA", "u0:u0", "u1:u1", "u2:u2", "u3:u3",
X	"u4:u4", "u5:u5", "u6:u6", "u7:u7", "u8:u8", "u9:u9", "op:op",
X	"oc:oc", "initc:Ic", "initp:Ip", "scp:sp", "setf:Sf",
X	"setb:Sb", "cpi:ZA", "lpi:ZB", "chr:ZC", "cvr:ZD", "defc:ZE",
X	"swidm:ZF", "sdrfq:ZG", "sitm:ZH", "slm:ZI", "smicm:ZJ",
X	"snlq:ZK", "snrmq:ZL", "sshm:ZM", "ssubm:ZN", "ssupm:ZO",
X	"sum:ZP", "rwidm:ZQ", "ritm:ZR", "rlm:ZS", "rmicm:ZT",
X	"rshm:ZU", "rsubm:ZV", "rsupm:ZW", "rum:ZX", "mhpa:ZY",
X	"mcud1:ZZ", "mcub1:Za", "mcuf1:Zb", "mvpa:Zc", "mcuu1:Zd",
X	"porder:Ze", "mcud:Zf", "mcub:Zg", "mcuf:Zh", "mcuu:Zi",
X	"scs:Zj", "smgb:Zk", "smgbp:Zl", "smglp:Zm", "smgrp:Zn",
X	"smgt:Zo", "smgtp:Zp", "sbim:Zq", "scsd:Zr", "rbim:Zs",
X	"rcsd:Zt", "subcs:Zu", "supcs:Zv", "docr:Zw", "zerom:Zx",
X	"csnm:Zy", 0};
Xreadcaps() {
X
X	tgetent(cap_entry, getenv("TERM"));
X#ifdef LIBTC
X	for (s = cap_entry; *s != '|'; s++)
X	    if (*s == '\0' | *s == ':') { s = cap_entry; break; }
X	if (*s == '|') s++;
X	for (t = ttytype; *t = *s; t++, s++)
X	    if (*t == ':') { *t = '\0'; break; }
X#endif
X	auto_left_margin = tgetflag("bw");
X	auto_right_margin = tgetflag("am");
X	no_esc_ctlc = tgetflag("xb");
X	ceol_standout_glitch = tgetflag("xs");
X	eat_newline_glitch = tgetflag("xn");
X	erase_overstrike = tgetflag("eo");
X	generic_type = tgetflag("gn");
X	hard_copy = tgetflag("hc");
X	has_meta_key = tgetflag("km");
X	has_status_line = tgetflag("hs");
X	insert_null_glitch = tgetflag("in");
X	memory_above = tgetflag("da");
X	memory_below = tgetflag("db");
X	move_insert_mode = tgetflag("mi");
X	move_standout_mode = tgetflag("ms");
X	over_strike = tgetflag("os");
X	status_line_esc_ok = tgetflag("es");
X	dest_tabs_magic_smso = tgetflag("xt");
X	tilde_glitch = tgetflag("hz");
X	transparent_underline = tgetflag("ul");
X	xon_xoff = tgetflag("xo");
X	needs_xon_xoff = tgetflag("nx");
X	prtr_silent = tgetflag("5i");
X	hard_cursor = tgetflag("HC");
X	non_rev_rmcup = tgetflag("NR");
X	no_pad_char = tgetflag("NP");
X	non_dest_scroll_region = tgetflag("ND");
X	can_change = tgetflag("cc");
X	back_color_erase = tgetflag("ut");
X	hue_lightness_saturation = tgetflag("hl");
X	col_addr_glitch = tgetflag("YA");
X	cr_cancels_micro_mode = tgetflag("YB");
X	has_print_wheel = tgetflag("YC");
X	row_addr_glitch = tgetflag("YD");
X	semi_auto_right_margin = tgetflag("YE");
X	cpi_changes_res = tgetflag("YF");
X	lpi_changes_res = tgetflag("YG");
X	physical_tabs = tgetflag("pt");
X	columns = tgetnum("co");
X#ifndef TC
X	init_tabs = tgetnum("it");
X#endif
X	lines = tgetnum("li");
X	lines_of_memory = tgetnum("lm");
X	magic_cookie_glitch = tgetnum("sg");
X	padding_baud_rate = tgetnum("pb");
X	virtual_terminal = tgetnum("vt");
X	width_status_line = tgetnum("ws");
X	num_labels = tgetnum("Nl");
X	label_height = tgetnum("lh");
X	label_width = tgetnum("lw");
X	max_attributes = tgetnum("ma");
X	maximum_windows = tgetnum("MW");
X	max_colors = tgetnum("Co");
X	max_pairs = tgetnum("pa");
X	no_color_video = tgetnum("NC");
X	buffer_capacity = tgetnum("Ya");
X	dot_vert_spacing = tgetnum("Yb");
X	dot_horz_spacing = tgetnum("Yc");
X	max_micro_address = tgetnum("Yd");
X	max_micro_jump = tgetnum("Ye");
X	micro_char_size = tgetnum("Yf");
X	micro_line_size = tgetnum("Yg");
X	number_of_pins = tgetnum("Yh");
X	output_res_char = tgetnum("Yi");
X	output_res_line = tgetnum("Yj");
X	output_res_horz_inch = tgetnum("Yk");
X	output_res_vert_inch = tgetnum("Yl");
X	print_rate = tgetnum("Ym");
X	wide_char_size = tgetnum("Yn");
X#ifdef TC
X	enter_lab("m0", tgetstr("m0", &bb), "M0", tgetstr("M0", &bb));
X	enter_lab("m1", tgetstr("m1", &bb), "M1", tgetstr("M1", &bb));
X	enter_lab("m2", tgetstr("m2", &bb), "M2", tgetstr("M2", &bb));
X	enter_lab("m3", tgetstr("m3", &bb), "M3", tgetstr("M3", &bb));
X	enter_lab("m4", tgetstr("m4", &bb), "M4", tgetstr("M4", &bb));
X	enter_lab("m5", tgetstr("m5", &bb), "M5", tgetstr("M5", &bb));
X	enter_lab("m6", tgetstr("m6", &bb), "M6", tgetstr("M6", &bb));
X	enter_lab("m7", tgetstr("m7", &bb), "M7", tgetstr("M7", &bb));
X	enter_lab("m8", tgetstr("m8", &bb), "M8", tgetstr("M8", &bb));
X	enter_lab("m9", tgetstr("m9", &bb), "M9", tgetstr("M9", &bb));
X	enter_lab("n0", tgetstr("n0", &bb), "N0", tgetstr("N0", &bb));
X	enter_lab("n1", tgetstr("n1", &bb), "N1", tgetstr("N1", &bb));
X	enter_lab("n2", tgetstr("n2", &bb), "N2", tgetstr("N2", &bb));
X	enter_lab("n3", tgetstr("n3", &bb), "N3", tgetstr("N3", &bb));
X	enter_lab("n4", tgetstr("n4", &bb), "N4", tgetstr("N4", &bb));
X	enter_lab("n5", tgetstr("n5", &bb), "N5", tgetstr("N5", &bb));
X	enter_lab("n6", tgetstr("n6", &bb), "N6", tgetstr("N6", &bb));
X	enter_lab("n7", tgetstr("n7", &bb), "N7", tgetstr("N7", &bb));
X	enter_lab("n8", tgetstr("n8", &bb), "N8", tgetstr("N8", &bb));
X	enter_lab("n9", tgetstr("n9", &bb), "N9", tgetstr("N9", &bb));
X	enter_lab("o0", tgetstr("o0", &bb), "O0", tgetstr("O0", &bb));
X	enter_lab("o1", tgetstr("o1", &bb), "O1", tgetstr("O1", &bb));
X	enter_lab("o2", tgetstr("o2", &bb), "O2", tgetstr("O2", &bb));
X	enter_lab("o3", tgetstr("o3", &bb), "O3", tgetstr("O3", &bb));
X	enter_lab("o4", tgetstr("o4", &bb), "O4", tgetstr("O4", &bb));
X	enter_lab("o5", tgetstr("o5", &bb), "O5", tgetstr("O5", &bb));
X	enter_lab("o6", tgetstr("o6", &bb), "O6", tgetstr("O6", &bb));
X	enter_lab("o7", tgetstr("o7", &bb), "O7", tgetstr("O7", &bb));
X	enter_lab("o8", tgetstr("o8", &bb), "O8", tgetstr("O8", &bb));
X	enter_lab("o9", tgetstr("o9", &bb), "O9", tgetstr("O9", &bb));
X	enter_lab("p0", tgetstr("p0", &bb), "P0", tgetstr("P0", &bb));
X	enter_lab("p1", tgetstr("p1", &bb), "P1", tgetstr("P1", &bb));
X	enter_lab("p2", tgetstr("p2", &bb), "P2", tgetstr("P2", &bb));
X	enter_lab("p3", tgetstr("p3", &bb), "P3", tgetstr("P3", &bb));
X	enter_lab("p4", tgetstr("p4", &bb), "P4", tgetstr("P4", &bb));
X	enter_lab("p5", tgetstr("p5", &bb), "P5", tgetstr("P5", &bb));
X	enter_lab("p6", tgetstr("p6", &bb), "P6", tgetstr("P6", &bb));
X	enter_lab("p7", tgetstr("p7", &bb), "P7", tgetstr("P7", &bb));
X	enter_lab("p8", tgetstr("p8", &bb), "P8", tgetstr("P8", &bb));
X	enter_lab("p9", tgetstr("p9", &bb), "P9", tgetstr("P9", &bb));
X	enter_lab("q0", tgetstr("q0", &bb), "Q0", tgetstr("Q0", &bb));
X	enter_lab("q1", tgetstr("q1", &bb), "Q1", tgetstr("Q1", &bb));
X	enter_lab("q2", tgetstr("q2", &bb), "Q2", tgetstr("Q2", &bb));
X	enter_lab("q3", tgetstr("q3", &bb), "Q3", tgetstr("Q3", &bb));
X	enter_lab("q4", tgetstr("q4", &bb), "Q4", tgetstr("Q4", &bb));
X	enter_lab("q5", tgetstr("q5", &bb), "Q5", tgetstr("Q5", &bb));
X	enter_lab("q6", tgetstr("q6", &bb), "Q6", tgetstr("Q6", &bb));
X	enter_lab("q7", tgetstr("q7", &bb), "Q7", tgetstr("Q7", &bb));
X	enter_lab("q8", tgetstr("q8", &bb), "Q8", tgetstr("Q8", &bb));
X	enter_lab("q9", tgetstr("q9", &bb), "Q9", tgetstr("Q9", &bb));
X	enter_lab("r0", tgetstr("r0", &bb), "R0", tgetstr("R0", &bb));
X	enter_lab("r1", tgetstr("r1", &bb), "R1", tgetstr("R1", &bb));
X	enter_lab("r2", tgetstr("r2", &bb), "R2", tgetstr("R2", &bb));
X	enter_lab("r3", tgetstr("r3", &bb), "R3", tgetstr("R3", &bb));
X	enter_lab("r4", tgetstr("r4", &bb), "R4", tgetstr("R4", &bb));
X	enter_lab("r5", tgetstr("r5", &bb), "R5", tgetstr("R5", &bb));
X	enter_lab("r6", tgetstr("r6", &bb), "R6", tgetstr("R6", &bb));
X	enter_lab("r7", tgetstr("r7", &bb), "R7", tgetstr("R7", &bb));
X	enter_lab("r8", tgetstr("r8", &bb), "R8", tgetstr("R8", &bb));
X	enter_lab("r9", tgetstr("r9", &bb), "R9", tgetstr("R9", &bb));
X	enter_lab("s0", tgetstr("s0", &bb), "S0", tgetstr("S0", &bb));
X	enter_lab("s1", tgetstr("s1", &bb), "S1", tgetstr("S1", &bb));
X	enter_lab("s2", tgetstr("s2", &bb), "S2", tgetstr("S2", &bb));
X	enter_lab("s3", tgetstr("s3", &bb), "S3", tgetstr("S3", &bb));
X	enter_lab("s4", tgetstr("s4", &bb), "S4", tgetstr("S4", &bb));
X	enter_lab("s5", tgetstr("s5", &bb), "S5", tgetstr("S5", &bb));
X	enter_lab("s6", tgetstr("s6", &bb), "S6", tgetstr("S6", &bb));
X	enter_lab("s7", tgetstr("s7", &bb), "S7", tgetstr("S7", &bb));
X	enter_lab("s8", tgetstr("s8", &bb), "S8", tgetstr("S8", &bb));
X	enter_lab("s9", tgetstr("s9", &bb), "S9", tgetstr("S9", &bb));
X	enter_lab("t0", tgetstr("t0", &bb), "T0", tgetstr("T0", &bb));
X	enter_lab("t1", tgetstr("t1", &bb), "T1", tgetstr("T1", &bb));
X	enter_lab("t2", tgetstr("t2", &bb), "T2", tgetstr("T2", &bb));
X	enter_lab("t3", tgetstr("t3", &bb), "T3", tgetstr("T3", &bb));
X	enter_lab("t4", tgetstr("t4", &bb), "T4", tgetstr("T4", &bb));
X	enter_lab("t5", tgetstr("t5", &bb), "T5", tgetstr("T5", &bb));
X	enter_lab("t6", tgetstr("t6", &bb), "T6", tgetstr("T6", &bb));
X	enter_lab("t7", tgetstr("t7", &bb), "T7", tgetstr("T7", &bb));
X	enter_lab("t8", tgetstr("t8", &bb), "T8", tgetstr("T8", &bb));
X	enter_lab("t9", tgetstr("t9", &bb), "T9", tgetstr("T9", &bb));
X	enter_lab("u0", tgetstr("u0", &bb), "U0", tgetstr("U0", &bb));
X	enter_lab("u1", tgetstr("u1", &bb), "U1", tgetstr("U1", &bb));
X	enter_lab("u2", tgetstr("u2", &bb), "U2", tgetstr("U2", &bb));
X	enter_lab("u3", tgetstr("u3", &bb), "U3", tgetstr("U3", &bb));
X	enter_lab("u4", tgetstr("u4", &bb), "U4", tgetstr("U4", &bb));
X	enter_lab("u5", tgetstr("u5", &bb), "U5", tgetstr("U5", &bb));
X	enter_lab("u6", tgetstr("u6", &bb), "U6", tgetstr("U6", &bb));
X	enter_lab("u7", tgetstr("u7", &bb), "U7", tgetstr("U7", &bb));
X	enter_lab("u8", tgetstr("u8", &bb), "U8", tgetstr("U8", &bb));
X	enter_lab("u9", tgetstr("u9", &bb), "U9", tgetstr("U9", &bb));
X	enter_lab("v0", tgetstr("v0", &bb), "V0", tgetstr("V0", &bb));
X	enter_lab("v1", tgetstr("v1", &bb), "V1", tgetstr("V1", &bb));
X	enter_lab("v2", tgetstr("v2", &bb), "V2", tgetstr("V2", &bb));
X	enter_lab("v3", tgetstr("v3", &bb), "V3", tgetstr("V3", &bb));
X	enter_lab("v4", tgetstr("v4", &bb), "V4", tgetstr("V4", &bb));
X	enter_lab("v5", tgetstr("v5", &bb), "V5", tgetstr("V5", &bb));
X	enter_lab("v6", tgetstr("v6", &bb), "V6", tgetstr("V6", &bb));
X	enter_lab("v7", tgetstr("v7", &bb), "V7", tgetstr("V7", &bb));
X	enter_lab("v8", tgetstr("v8", &bb), "V8", tgetstr("V8", &bb));
X	enter_lab("v9", tgetstr("v9", &bb), "V9", tgetstr("V9", &bb));
X	enter_lab("w0", tgetstr("w0", &bb), "W0", tgetstr("W0", &bb));
X	enter_lab("w1", tgetstr("w1", &bb), "W1", tgetstr("W1", &bb));
X	enter_lab("w2", tgetstr("w2", &bb), "W2", tgetstr("W2", &bb));
X	enter_lab("w3", tgetstr("w3", &bb), "W3", tgetstr("W3", &bb));
X	enter_lab("w4", tgetstr("w4", &bb), "W4", tgetstr("W4", &bb));
X	enter_lab("w5", tgetstr("w5", &bb), "W5", tgetstr("W5", &bb));
X	enter_lab("w6", tgetstr("w6", &bb), "W6", tgetstr("W6", &bb));
X	enter_lab("w7", tgetstr("w7", &bb), "W7", tgetstr("W7", &bb));
X	enter_lab("w8", tgetstr("w8", &bb), "W8", tgetstr("W8", &bb));
X	enter_lab("w9", tgetstr("w9", &bb), "W9", tgetstr("W9", &bb));
X	enter_lab("x0", tgetstr("x0", &bb), "X0", tgetstr("X0", &bb));
X	enter_lab("x1", tgetstr("x1", &bb), "X1", tgetstr("X1", &bb));
X	enter_lab("x2", tgetstr("x2", &bb), "X2", tgetstr("X2", &bb));
X	enter_lab("x3", tgetstr("x3", &bb), "X3", tgetstr("X3", &bb));
X	enter_lab("x4", tgetstr("x4", &bb), "X4", tgetstr("X4", &bb));
X	enter_lab("x5", tgetstr("x5", &bb), "X5", tgetstr("X5", &bb));
X	enter_lab("x6", tgetstr("x6", &bb), "X6", tgetstr("X6", &bb));
X	enter_lab("x7", tgetstr("x7", &bb), "X7", tgetstr("X7", &bb));
X	enter_lab("x8", tgetstr("x8", &bb), "X8", tgetstr("X8", &bb));
X	enter_lab("x9", tgetstr("x9", &bb), "X9", tgetstr("X9", &bb));
X	enter_lab("y0", tgetstr("y0", &bb), "Y0", tgetstr("Y0", &bb));
X	enter_lab("y1", tgetstr("y1", &bb), "Y1", tgetstr("Y1", &bb));
X	enter_lab("y2", tgetstr("y2", &bb), "Y2", tgetstr("Y2", &bb));
X	enter_lab("y3", tgetstr("y3", &bb), "Y3", tgetstr("Y3", &bb));
X	enter_lab("y4", tgetstr("y4", &bb), "Y4", tgetstr("Y4", &bb));
X	enter_lab("y5", tgetstr("y5", &bb), "Y5", tgetstr("Y5", &bb));
X	enter_lab("y6", tgetstr("y6", &bb), "Y6", tgetstr("Y6", &bb));
X	enter_lab("y7", tgetstr("y7", &bb), "Y7", tgetstr("Y7", &bb));
X	enter_lab("y8", tgetstr("y8", &bb), "Y8", tgetstr("Y8", &bb));
X	enter_lab("y9", tgetstr("y9", &bb), "Y9", tgetstr("Y9", &bb));
X	enter_lab("z0", tgetstr("z0", &bb), "Z0", tgetstr("Z0", &bb));
X	enter_lab("z1", tgetstr("z1", &bb), "Z1", tgetstr("Z1", &bb));
X	enter_lab("z2", tgetstr("z2", &bb), "Z2", tgetstr("Z2", &bb));
X	enter_lab("z3", tgetstr("z3", &bb), "Z3", tgetstr("Z3", &bb));
X	enter_lab("z4", tgetstr("z4", &bb), "Z4", tgetstr("Z4", &bb));
X	enter_lab("z5", tgetstr("z5", &bb), "Z5", tgetstr("Z5", &bb));
X	enter_lab("z6", tgetstr("z6", &bb), "Z6", tgetstr("Z6", &bb));
X	enter_lab("z7", tgetstr("z7", &bb), "Z7", tgetstr("Z7", &bb));
X	enter_lab("z8", tgetstr("z8", &bb), "Z8", tgetstr("Z8", &bb));
X	enter_lab("z9", tgetstr("z9", &bb), "Z9", tgetstr("Z9", &bb));
X	enter_lab("kz", tgetstr("kz", &bb), "00", tgetstr("00", &bb));
X	enter_lab("kb", tgetstr("kb", &bb), "01", tgetstr("01", &bb));
X	enter_lab("cr", tgetstr("cr", &bb), "02", tgetstr("02", &bb));
X	enter_lab("bk", tgetstr("bk", &bb), "03", tgetstr("03", &bb));
X	enter_lab("ta", tgetstr("ta", &bb), "04", tgetstr("04", &bb));
X	enter_lab("bt", tgetstr("bt", &bb), "05", tgetstr("05", &bb));
X	enter_lab("kl", tgetstr("kl", &bb), "06", tgetstr("06", &bb));
X	enter_lab("kr", tgetstr("kr", &bb), "07", tgetstr("07", &bb));
X	enter_lab("ku", tgetstr("ku", &bb), "08", tgetstr("08", &bb));
X	enter_lab("kd", tgetstr("kd", &bb), "09", tgetstr("09", &bb));
X	enter_lab("kh", tgetstr("kh", &bb), "10", tgetstr("10", &bb));
X	enter_lab("EN", tgetstr("EN", &bb), "11", tgetstr("11", &bb));
X	enter_lab("PU", tgetstr("PU", &bb), "12", tgetstr("12", &bb));
X	enter_lab("PD", tgetstr("PD", &bb), "13", tgetstr("13", &bb));
X	enter_lab("ki", tgetstr("ki", &bb), "14", tgetstr("14", &bb));
X	enter_lab("kk", tgetstr("kk", &bb), "15", tgetstr("15", &bb));
X	enter_lab("LI", tgetstr("LI", &bb), "16", tgetstr("16", &bb));
X	enter_lab("LD", tgetstr("LD", &bb), "17", tgetstr("17", &bb));
X	enter_lab("kp", tgetstr("kp", &bb), "18", tgetstr("18", &bb));
X	enter_lab("ek", tgetstr("ek", &bb), "19", tgetstr("19", &bb));
X	enter_lab("ck", tgetstr("ck", &bb), "20", tgetstr("20", &bb));
X	enter_lab("pk", tgetstr("pk", &bb), "21", tgetstr("21", &bb));
X	enter_lab("mk", tgetstr("mk", &bb), "22", tgetstr("22", &bb));
X	enter_lab("nk", tgetstr("nk", &bb), "23", tgetstr("23", &bb));
X	enter_lab("ok", tgetstr("ok", &bb), "24", tgetstr("24", &bb));
X#endif
X	back_tab = tgetstr("bt", &bb);
X	bell = tgetstr("bl", &bb);
X	carriage_return = tgetstr("cr", &bb);
X	change_scroll_region = tgetstr("cs", &bb);
X	clear_all_tabs = tgetstr("ct", &bb);
X	clear_screen = tgetstr("cl", &bb);
X	clr_eol = tgetstr("ce", &bb);
X	clr_eos = tgetstr("cd", &bb);
X	column_address = tgetstr("ch", &bb);
X	command_character = tgetstr("CC", &bb);
X	cursor_address = tgetstr("cm", &bb);
X	cursor_down = tgetstr("do", &bb);
X	cursor_home = tgetstr("ho", &bb);
X	cursor_invisible = tgetstr("vi", &bb);
X	cursor_left = tgetstr("le", &bb);
X	cursor_mem_address = tgetstr("CM", &bb);
X	cursor_normal = tgetstr("ve", &bb);
X	cursor_right = tgetstr("nd", &bb);
X	cursor_to_ll = tgetstr("ll", &bb);
X	cursor_up = tgetstr("up", &bb);
X	cursor_visible = tgetstr("vs", &bb);
X	delete_character = tgetstr("dc", &bb);
X	delete_line = tgetstr("dl", &bb);
X	dis_status_line = tgetstr("ds", &bb);
X	down_half_line = tgetstr("hd", &bb);
X	enter_alt_charset_mode = tgetstr("as", &bb);
X	enter_blink_mode = tgetstr("mb", &bb);
X	enter_bold_mode = tgetstr("md", &bb);
X	enter_ca_mode = tgetstr("ti", &bb);
X	enter_delete_mode = tgetstr("dm", &bb);
X	enter_dim_mode = tgetstr("mh", &bb);
X	enter_insert_mode = tgetstr("im", &bb);
X	enter_secure_mode = tgetstr("mk", &bb);
X	enter_protected_mode = tgetstr("mp", &bb);
X	enter_reverse_mode = tgetstr("mr", &bb);
X	enter_standout_mode = tgetstr("so", &bb);
X	enter_underline_mode = tgetstr("us", &bb);
X	erase_chars = tgetstr("ec", &bb);
X	exit_alt_charset_mode = tgetstr("ae", &bb);
X	exit_attribute_mode = tgetstr("me", &bb);
X	exit_ca_mode = tgetstr("te", &bb);
X	exit_delete_mode = tgetstr("ed", &bb);
X	exit_insert_mode = tgetstr("ei", &bb);
X	exit_standout_mode = tgetstr("se", &bb);
X	exit_underline_mode = tgetstr("ue", &bb);
X	flash_screen = tgetstr("vb", &bb);
X	form_feed = tgetstr("ff", &bb);
X	from_status_line = tgetstr("fs", &bb);
X	init_1string = tgetstr("i1", &bb);
X	init_2string = tgetstr("is", &bb);
X	init_3string = tgetstr("i3", &bb);
X	init_file = tgetstr("if", &bb);
X	insert_character = tgetstr("ic", &bb);
X	insert_line = tgetstr("al", &bb);
X	insert_padding = tgetstr("ip", &bb);
X	enter_key("kb", key_backspace = tgetstr("kb", &bb));
X	enter_key("ka", key_catab = tgetstr("ka", &bb));
X	enter_key("kC", key_clear = tgetstr("kC", &bb));
X	enter_key("kt", key_ctab = tgetstr("kt", &bb));
X	enter_key("kD", key_dc = tgetstr("kD", &bb));
X	enter_key("kL", key_dl = tgetstr("kL", &bb));
X	enter_key("kd", key_down = tgetstr("kd", &bb));
X	enter_key("kM", key_eic = tgetstr("kM", &bb));
X	enter_key("kE", key_eol = tgetstr("kE", &bb));
X	enter_key("kS", key_eos = tgetstr("kS", &bb));
X	enter_lab("k0", key_f0 = tgetstr("k0", &bb),
X		"l0", lab_f0 = tgetstr("l0", &bb));
X	enter_lab("k1", key_f1 = tgetstr("k1", &bb),
X		"l1", lab_f1 = tgetstr("l1", &bb));
X	enter_lab("k;", key_f10 = tgetstr("k;", &bb),
X		"l;", lab_f10 = tgetstr("l;", &bb));
X	enter_lab("k2", key_f2 = tgetstr("k2", &bb),
X		"l2", lab_f2 = tgetstr("l2", &bb));
X	enter_lab("k3", key_f3 = tgetstr("k3", &bb),
X		"l3", lab_f3 = tgetstr("l3", &bb));
X	enter_lab("k4", key_f4 = tgetstr("k4", &bb),
X		"l4", lab_f4 = tgetstr("l4", &bb));
X	enter_lab("k5", key_f5 = tgetstr("k5", &bb),
X		"l5", lab_f5 = tgetstr("l5", &bb));
X	enter_lab("k6", key_f6 = tgetstr("k6", &bb),
X		"l6", lab_f6 = tgetstr("l6", &bb));
X	enter_lab("k7", key_f7 = tgetstr("k7", &bb),
X		"l7", lab_f7 = tgetstr("l7", &bb));
X	enter_lab("k8", key_f8 = tgetstr("k8", &bb),
X		"l8", lab_f8 = tgetstr("l8", &bb));
X	enter_lab("k9", key_f9 = tgetstr("k9", &bb),
X		"l9", lab_f9 = tgetstr("l9", &bb));
X	enter_key("kh", key_home = tgetstr("kh", &bb));
X	enter_key("kI", key_ic = tgetstr("kI", &bb));
X	enter_key("kA", key_il = tgetstr("kA", &bb));
X	enter_key("kl", key_left = tgetstr("kl", &bb));
X	enter_key("kH", key_ll = tgetstr("kH", &bb));
X	enter_key("kN", key_npage = tgetstr("kN", &bb));
X	enter_key("kP", key_ppage = tgetstr("kP", &bb));
X	enter_key("kr", key_right = tgetstr("kr", &bb));
X	enter_key("kF", key_sf = tgetstr("kF", &bb));
X	enter_key("kR", key_sr = tgetstr("kR", &bb));
X	enter_key("kT", key_stab = tgetstr("kT", &bb));
X	enter_key("ku", key_up = tgetstr("ku", &bb));
X	keypad_local = tgetstr("ke", &bb);
X	keypad_xmit = tgetstr("ks", &bb);
X	lab_f0 = tgetstr("l0", &bb);
X	lab_f1 = tgetstr("l1", &bb);
X	lab_f10 = tgetstr("la", &bb);
X	lab_f2 = tgetstr("l2", &bb);
X	lab_f3 = tgetstr("l3", &bb);
X	lab_f4 = tgetstr("l4", &bb);
X	lab_f5 = tgetstr("l5", &bb);
X	lab_f6 = tgetstr("l6", &bb);
X	lab_f7 = tgetstr("l7", &bb);
X	lab_f8 = tgetstr("l8", &bb);
X	lab_f9 = tgetstr("l9", &bb);
X	meta_off = tgetstr("mo", &bb);
X	meta_on = tgetstr("mm", &bb);
X	newline = tgetstr("nw", &bb);
X	pad_char = tgetstr("pc", &bb);
X	parm_dch = tgetstr("DC", &bb);
X	parm_delete_line = tgetstr("DL", &bb);
X	parm_down_cursor = tgetstr("DO", &bb);
X	parm_ich = tgetstr("IC", &bb);
X	parm_index = tgetstr("SF", &bb);
X	parm_insert_line = tgetstr("AL", &bb);
X	parm_left_cursor = tgetstr("LE", &bb);
X	parm_right_cursor = tgetstr("RI", &bb);
X	parm_rindex = tgetstr("SR", &bb);
X	parm_up_cursor = tgetstr("UP", &bb);
X	pkey_key = tgetstr("pk", &bb);
X	pkey_local = tgetstr("pl", &bb);
X	pkey_xmit = tgetstr("px", &bb);
X	print_screen = tgetstr("ps", &bb);
X	prtr_off = tgetstr("pf", &bb);
X	prtr_on = tgetstr("po", &bb);
X	repeat_char = tgetstr("rp", &bb);
X#ifndef TC
X	reset_1string = tgetstr("r1", &bb);
X	reset_2string = tgetstr("r2", &bb);
X	reset_3string = tgetstr("r3", &bb);
X#endif
X	reset_file = tgetstr("rf", &bb);
X	restore_cursor = tgetstr("rc", &bb);
X	row_address = tgetstr("cv", &bb);
X	save_cursor = tgetstr("sc", &bb);
X	scroll_forward = tgetstr("sf", &bb);
X	scroll_reverse = tgetstr("sr", &bb);
X	set_attributes = tgetstr("sa", &bb);
X	set_tab = tgetstr("st", &bb);
X	set_window = tgetstr("wi", &bb);
X	enter_key("ta", tab = tgetstr("ta", &bb));
X	to_status_line = tgetstr("ts", &bb);
X	underline_char = tgetstr("uc", &bb);
X	up_half_line = tgetstr("hu", &bb);
X	init_prog = tgetstr("iP", &bb);
X	key_a1 = tgetstr("K1", &bb);
X	key_a3 = tgetstr("K3", &bb);
X	key_b2 = tgetstr("K2", &bb);
X	key_c1 = tgetstr("K4", &bb);
X	key_c3 = tgetstr("K5", &bb);
X	prtr_non = tgetstr("pO", &bb);
X	char_padding = tgetstr("rP", &bb);
X	acs_chars = tgetstr("ac", &bb);
X	plab_norm = tgetstr("pn", &bb);
X	key_btab = tgetstr("kB", &bb);
X	enter_xon_mode = tgetstr("SX", &bb);
X	exit_xon_mode = tgetstr("RX", &bb);
X	enter_am_mode = tgetstr("SA", &bb);
X	exit_am_mode = tgetstr("RA", &bb);
X	xon_character = tgetstr("XN", &bb);
X	xoff_character = tgetstr("XF", &bb);
X	ena_acs = tgetstr("eA", &bb);
X	label_on = tgetstr("LO", &bb);
X	label_off = tgetstr("LF", &bb);
X	key_beg = tgetstr("@1", &bb);
X	key_cancel = tgetstr("@2", &bb);
X	key_close = tgetstr("@3", &bb);
X	key_command = tgetstr("@4", &bb);
X	key_copy = tgetstr("@5", &bb);
X	key_create = tgetstr("@6", &bb);
X	key_end = tgetstr("@7", &bb);
X	key_enter = tgetstr("@8", &bb);
X	key_exit = tgetstr("@9", &bb);
X	key_find = tgetstr("@0", &bb);
X	key_help = tgetstr("%1", &bb);
X	key_mark = tgetstr("%2", &bb);
X	key_message = tgetstr("%3", &bb);
X	key_move = tgetstr("%4", &bb);
X	key_next = tgetstr("%5", &bb);
X	key_open = tgetstr("%6", &bb);
X	key_options = tgetstr("%7", &bb);
X	key_previous = tgetstr("%8", &bb);
X	key_print = tgetstr("%9", &bb);
X	key_redo = tgetstr("%0", &bb);
X	key_reference = tgetstr("&1", &bb);
X	key_refresh = tgetstr("&2", &bb);
X	key_replace = tgetstr("&3", &bb);
X	key_restart = tgetstr("&4", &bb);
X	key_resume = tgetstr("&5", &bb);
X	key_save = tgetstr("&6", &bb);
X	key_suspend = tgetstr("&7", &bb);
X	key_undo = tgetstr("&8", &bb);
X	key_sbeg = tgetstr("&9", &bb);
X	key_scancel = tgetstr("&0", &bb);
X	key_scommand = tgetstr("*1", &bb);
X	key_scopy = tgetstr("*2", &bb);
X	key_screate = tgetstr("*3", &bb);
X	key_sdc = tgetstr("*4", &bb);
X	key_sdl = tgetstr("*5", &bb);
X	key_select = tgetstr("*6", &bb);
X	key_send = tgetstr("*7", &bb);
X	key_seol = tgetstr("*8", &bb);
X	key_sexit = tgetstr("*9", &bb);
X	key_sfind = tgetstr("*0", &bb);
X	key_shelp = tgetstr("#1", &bb);
X	key_shome = tgetstr("#2", &bb);
X	key_sic = tgetstr("#3", &bb);
X	key_sleft = tgetstr("#4", &bb);
X	key_smessage = tgetstr("%a", &bb);
X	key_smove = tgetstr("%b", &bb);
X	key_snext = tgetstr("%c", &bb);
X	key_soptions = tgetstr("%d", &bb);
X	key_sprevious = tgetstr("%e", &bb);
X	key_sprint = tgetstr("%f", &bb);
X	key_sredo = tgetstr("%g", &bb);
X	key_sreplace = tgetstr("%h", &bb);
X	key_sright = tgetstr("%i", &bb);
X	key_srsume = tgetstr("%j", &bb);
X	key_ssave = tgetstr("!1", &bb);
X	key_ssuspend = tgetstr("!2", &bb);
X	key_sundo = tgetstr("!3", &bb);
X	req_for_input = tgetstr("RF", &bb);
X	key_f11 = tgetstr("F1", &bb);
X	key_f12 = tgetstr("F2", &bb);
X	key_f13 = tgetstr("F3", &bb);
X	key_f14 = tgetstr("F4", &bb);
X	key_f15 = tgetstr("F5", &bb);
X	key_f16 = tgetstr("F6", &bb);
X	key_f17 = tgetstr("F7", &bb);
X	key_f18 = tgetstr("F8", &bb);
X	key_f19 = tgetstr("F9", &bb);
X	key_f20 = tgetstr("FA", &bb);
X	key_f21 = tgetstr("FB", &bb);
X	key_f22 = tgetstr("FC", &bb);
X	key_f23 = tgetstr("FD", &bb);
X	key_f24 = tgetstr("FE", &bb);
X	key_f25 = tgetstr("FF", &bb);
X	key_f26 = tgetstr("FG", &bb);
X	key_f27 = tgetstr("FH", &bb);
X	key_f28 = tgetstr("FI", &bb);
X	key_f29 = tgetstr("FJ", &bb);
X	key_f30 = tgetstr("FK", &bb);
X	key_f31 = tgetstr("FL", &bb);
X	key_f32 = tgetstr("FM", &bb);
X	key_f33 = tgetstr("FN", &bb);
X	key_f34 = tgetstr("FO", &bb);
X	key_f35 = tgetstr("FP", &bb);
X	key_f36 = tgetstr("FQ", &bb);
X	key_f37 = tgetstr("FR", &bb);
X	key_f38 = tgetstr("FS", &bb);
X	key_f39 = tgetstr("FT", &bb);
X	key_f40 = tgetstr("FU", &bb);
X	key_f41 = tgetstr("FV", &bb);
X	key_f42 = tgetstr("FW", &bb);
X	key_f43 = tgetstr("FX", &bb);
X	key_f44 = tgetstr("FY", &bb);
X	key_f45 = tgetstr("FZ", &bb);
X	key_f46 = tgetstr("Fa", &bb);
X	key_f47 = tgetstr("Fb", &bb);
X	key_f48 = tgetstr("Fc", &bb);
X	key_f49 = tgetstr("Fd", &bb);
X	key_f50 = tgetstr("Fe", &bb);
X	key_f51 = tgetstr("Ff", &bb);
X	key_f52 = tgetstr("Fg", &bb);
X	key_f53 = tgetstr("Fh", &bb);
X	key_f54 = tgetstr("Fi", &bb);
X	key_f55 = tgetstr("Fj", &bb);
X	key_f56 = tgetstr("Fk", &bb);
X	key_f57 = tgetstr("Fl", &bb);
X	key_f58 = tgetstr("Fm", &bb);
X	key_f59 = tgetstr("Fn", &bb);
X	key_f60 = tgetstr("Fo", &bb);
X	key_f61 = tgetstr("Fp", &bb);
X	key_f62 = tgetstr("Fq", &bb);
X	key_f63 = tgetstr("Fr", &bb);
X	clr_bol = tgetstr("cb", &bb);
X	clear_margins = tgetstr("MC", &bb);
X	set_left_margin = tgetstr("ML", &bb);
X	set_right_margin = tgetstr("MR", &bb);
X	label_format = tgetstr("Lf", &bb);
X	set_clock = tgetstr("SC", &bb);
X	display_clock = tgetstr("DK", &bb);
X	remove_clock = tgetstr("RC", &bb);
X	create_window = tgetstr("CW", &bb);
X	goto_window = tgetstr("WG", &bb);
X	hangup = tgetstr("HU", &bb);
X	dial_phone = tgetstr("DI", &bb);
X	quick_dial = tgetstr("QD", &bb);
X	tone = tgetstr("TO", &bb);
X	pulse = tgetstr("PU", &bb);
X	flash_hook = tgetstr("fh", &bb);
X	fixed_pause = tgetstr("PA", &bb);
X	wait_tone = tgetstr("WA", &bb);
X#ifndef TC
X	user0 = tgetstr("u0", &bb);
X	user1 = tgetstr("u1", &bb);
X	user2 = tgetstr("u2", &bb);
X	user3 = tgetstr("u3", &bb);
X	user4 = tgetstr("u4", &bb);
X	user5 = tgetstr("u5", &bb);
X	user6 = tgetstr("u6", &bb);
X	user7 = tgetstr("u7", &bb);
X	user8 = tgetstr("u8", &bb);
X	user9 = tgetstr("u9", &bb);
X#endif
X	orig_pair = tgetstr("op", &bb);
X	orig_colors = tgetstr("oc", &bb);
X	initialize_color = tgetstr("Ic", &bb);
X	initialize_pair = tgetstr("Ip", &bb);
X	set_color_pair = tgetstr("sp", &bb);
X	set_foreground = tgetstr("Sf", &bb);
X	set_background = tgetstr("Sb", &bb);
X	change_char_pitch = tgetstr("ZA", &bb);
X	change_line_pitch = tgetstr("ZB", &bb);
X	change_res_horz = tgetstr("ZC", &bb);
X	change_res_vert = tgetstr("ZD", &bb);
X	define_char = tgetstr("ZE", &bb);
X	enter_doublewide_mode = tgetstr("ZF", &bb);
X	enter_draft_quality = tgetstr("ZG", &bb);
X	enter_italics_mode = tgetstr("ZH", &bb);
X	enter_leftward_mode = tgetstr("ZI", &bb);
X	enter_micro_mode = tgetstr("ZJ", &bb);
X	enter_near_letter_quality = tgetstr("ZK", &bb);
X	enter_normal_quality = tgetstr("ZL", &bb);
X	enter_shadow_mode = tgetstr("ZM", &bb);
X	enter_subscript_mode = tgetstr("ZN", &bb);
X	enter_superscript_mode = tgetstr("ZO", &bb);
X	enter_upward_mode = tgetstr("ZP", &bb);
X	exit_doublewide_mode = tgetstr("ZQ", &bb);
X	exit_italics_mode = tgetstr("ZR", &bb);
X	exit_leftward_mode = tgetstr("ZS", &bb);
X	exit_micro_mode = tgetstr("ZT", &bb);
X	exit_shadow_mode = tgetstr("ZU", &bb);
X	exit_subscript_mode = tgetstr("ZV", &bb);
X	exit_superscript_mode = tgetstr("ZW", &bb);
X	exit_upward_mode = tgetstr("ZX", &bb);
X	micro_column_address = tgetstr("ZY", &bb);
X	micro_down = tgetstr("ZZ", &bb);
X	micro_left = tgetstr("Za", &bb);
X	micro_right = tgetstr("Zb", &bb);
X	micro_row_address = tgetstr("Zc", &bb);
X	micro_up = tgetstr("Zd", &bb);
X	order_of_pins = tgetstr("Ze", &bb);
X	parm_down_micro = tgetstr("Zf", &bb);
X	parm_left_micro = tgetstr("Zg", &bb);
X	parm_right_micro = tgetstr("Zh", &bb);
X	parm_up_micro = tgetstr("Zi", &bb);
X	select_char_set = tgetstr("Zj", &bb);
X	set_bottom_margin = tgetstr("Zk", &bb);
X	set_bottom_margin_parm = tgetstr("Zl", &bb);
X	set_left_margin_parm = tgetstr("Zm", &bb);
X	set_right_margin_parm = tgetstr("Zn", &bb);
X	set_top_margin = tgetstr("Zo", &bb);
X	set_top_margin_parm = tgetstr("Zp", &bb);
X	start_bit_image = tgetstr("Zq", &bb);
X	start_char_set_def = tgetstr("Zr", &bb);
X	stop_bit_image = tgetstr("Zs", &bb);
X	stop_char_set_def = tgetstr("Zt", &bb);
X	subscript_characters = tgetstr("Zu", &bb);
X	superscript_characters = tgetstr("Zv", &bb);
X	these_cause_cr = tgetstr("Zw", &bb);
X	zero_motion = tgetstr("Zx", &bb);
X	char_set_names = tgetstr("Zy", &bb);
X	reset_string = tgetstr("rs");
X#ifdef TC
X	cursor_invisible = tgetstr("CF", &bb);
X	captrans[cap_index("civis", 5)] = "civis:CF";
X	cursor_on = tgetstr("CO", &bb);
X	enter_alt_charset_mode = tgetstr("GS", &bb);
X	captrans[cap_index("smacs", 5)] = "smacs:GS";
X	exit_alt_charset_mode = tgetstr("GE", &bb);
X	captrans[cap_index("rmacs", 5)] = "rmacs:GE";
X	color_terminal = tgetstr("ct", &bb);
X	clear_all_tabs = (char *) 0;
X#endif
X#ifdef XENIX
X	enter_alt_charset_mode = tgetstr("GS", &bb);
X	captrans[cap_index("smacs", 5)] = "smacs:GS";
X	exit_alt_charset_mode = tgetstr("GE", &bb);
X	captrans[cap_index("rmacs", 5)] = "rmacs:GE";
X	reset_1string = (char *) 0;
X	reset_3string = (char *) 0;
X	init_1string = (char *) 0;
X	init_3string = (char *) 0;
X	enter_key("CL", key_char_left = tgetstr("CL", &bb));
X	enter_key("CW", key_change_window = tgetstr("CW", &bb));
X	enter_key("EN", key_send = tgetstr("EN", &bb));
X	enter_key("HM", key_Home = tgetstr("HM", &bb));
X	enter_key("LD", key_line_delete = tgetstr("LD", &bb));
X	enter_key("LF", key_linefeed = tgetstr("LF", &bb));
X	enter_key("NU", key_next_unlocked_cell = tgetstr("NU", &bb));
X	enter_key("PN", key_start_print = tgetstr("PN", &bb));
X	enter_key("PD", key_page_down = tgetstr("PD", &bb));
X	enter_key("PU", key_page_up = tgetstr("PU", &bb));
X	enter_key("PS", key_stop_print = tgetstr("PS", &bb));
X	enter_key("RC", key_recalc = tgetstr("RC", &bb));
X	enter_key("RF", key_toggle_ref = tgetstr("RF", &bb));
X	enter_key("RT", key_return = tgetstr("RT", &bb));
X	enter_key("UP", key_up_arrow = tgetstr("UP", &bb));
X	enter_key("WL", key_word_left = tgetstr("WL", &bb));
X	enter_key("WR", key_word_right = tgetstr("WR", &bb));
X#endif
X}
X#endif
X#ifndef SVR3
X#ifndef SVR3_2
Xchar *strnames[] = {
X	"cbt", "bel", "cr", "csr", "tbc", "clear", "el", "ed", "hpa",
X	"cmdch", "cup", "cud1", "home", "civis", "cub1", "mrcup",
X	"cnorm", "cuf1", "ll", "cuu1", "cvvis", "dch1", "dl1", "dsl",
X	"hd", "smacs", "blink", "bold", "smcup", "smdc", "dim", "smir",
X	"invis", "prot", "rev", "smso", "smul", "ech", "rmacs", "sgr0",
X	"rmcup", "rmdc", "rmir", "rmso", "rmul", "flash", "ff", "fsl",
X	"is1", "is2", "is3", "if", "ich1", "il1", "ip", "kbs", "ktbc",
X	"kclr", "kctab", "kdch1", "kdl1", "kcud1", "krmir", "kel",
X	"ked", "kf0", "kf1", "kf10", "kf2", "kf3", "kf4", "kf5", "kf6",
X	"kf7", "kf8", "kf9", "khome", "kich1", "kil1", "kcub1", "kll",
X	"knp", "kpp", "kcuf1", "kind", "kri", "khts", "kcuu1", "rmkx",
X	"smkx", "lf0", "lf1", "lf10", "lf2", "lf3", "lf4", "lf5",
X	"lf6", "lf7", "lf8", "lf9", "rmm", "smm", "nel", "pad", "dch",
X	"dl", "cud", "ich", "indn", "il", "cub", "cuf", "rin", "cuu",
X	"pfkey", "pfloc", "pfx", "mc0", "mc4", "mc5", "rep", "rs1",
X	"rs2", "rs3", "rf", "rc", "vpa", "sc", "ind", "ri", "sgr",
X	"hts", "wind", 0};
X#endif
X#endif
END_OF_FILE
if test 35222 -ne `wc -c <'getcaps.c'`; then
    echo shar: \"'getcaps.c'\" unpacked with wrong size!
fi
# end of 'getcaps.c'
fi
if test -f 'ted.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'ted.h'\"
else
echo shar: Extracting \"'ted.h'\" \(5515 characters\)
sed "s/^X//" >'ted.h' <<'END_OF_FILE'
X/*
X** This software is Copyright (c) 1991 by Daniel Weaver.
X**
X** Permission is hereby granted to copy, distribute or otherwise
X** use any part of this package as long as you do not try to make
X** money from it or pretend that you wrote it.  This copyright
X** notice must be maintained in any copy made.
X**
X** Use of this software constitutes acceptance for use in an AS IS
X** condition. There are NO warranties with regard to this software.
X** In no event shall the author be liable for any damages whatsoever
X** arising out of or in connection with the use or performance of this
X** software.  Any use of this software is at the user's own risk.
X**
X**  If you make modifications to this software that you feel
X**  increases it usefulness for the rest of the community, please
X**  email the changes, enhancements, bug fixes as well as any and
X**  all ideas to me. This software is going to be maintained and
X**  enhanced as deemed necessary by the community.
X*/
X/* terminfo test program include file */
X
X#ifdef SVR3_2
X#ifndef SVR3
X#define SVR3
X#endif
X#endif
X
X
X#ifdef TESTCAP
X#define LEFT_BRACE '['
X#define RIGHT_BRACE ']'
X
X#include "bsd.h"
Xextern char *captrans[];
X
X#ifdef LIBTC
X#define tgetent tcgetent
X#define tgetnum tcgetnum
X#define tgetflag tcgetflag
X#define tgetstr tcgetstr
X#define SETUP readcaps();
X#else
X
X#define SETUP setterm(getenv("TERM")); readcaps();\
X	if (LINES > 0) lines = LINES; if (COLS > 0) columns = COLS
X#endif
X
X#define tcup(cap, c, r) tgoto(cap, r, c)
Xextern char *tgoto();
X
X#else
X
X#include "term.h"
X
X#define SETUP setupterm((char *)0, 1, (int *)0)
X#define tcup tparm
X
X#ifdef SVR3
X#define MAX_STRINGS sizeof(struct _str_struct) / sizeof(char *)
X#else
X#define MAX_STRINGS (sizeof(struct strs) + sizeof(struct strs2)) / sizeof(char *)
Xextern char *strnames[];
X#endif
X#endif
X
X#define putp(cap) tputs(cap, 1, putch)
X
X/* Backword compatibility for System V Release 2 */
X
X#ifndef SVR3
X
X/* Booleans */
X#define no_pad_char 0
X#define needs_xon_xoff 0
X
X/* Strings */
X#define enter_xon_mode (char *)0
X#define exit_xon_mode (char *)0
X#define char_padding (char *)0
X
X#endif
X
Xextern char *tparm();
Xextern void putch();
Xextern void putchp();
Xextern void put_cr();
Xextern void put_crlf();
Xextern void put_clear();
Xextern void put_dec();
Xextern void put_str();
Xextern void put_lf();
Xextern void put_ind();
Xextern void put_newlines();
Xextern void put_columns();
Xextern void put_this();
Xextern void putln();
Xextern void ptext();
Xextern void ptextln();
Xextern void home_down();
Xextern void go_home();
Xextern void three_digit();
Xextern int getchp();
Xextern int enter_cap();
Xextern char *expand();
Xextern char *expand_to();
Xextern char *expand_command();
Xextern char *hex_expand_to();
Xextern char *print_expand();
Xextern char *liberated();
Xextern void can_test();
Xextern void verify_time();
Xextern void set_attr();
X
Xextern FILE *debug_fp;
Xextern int debug_char_count, debug_level;
Xextern char temp[];
Xextern char tty_shortname[];
X
Xextern int test_count, ACK_char, junk_chars, tty_can_sync;
X#define TTY_ACK_SIZE 64
Xextern char tty_ENQ[], tty_ACK[];
Xextern char *current_test, done_test[128];
Xextern long start_time, end_time;
Xextern int milli_pad, milli_reps;
Xextern int pad_sent;
Xextern int skip_next, rerun;
X
X#define CAP_MAX 64
X
Xstruct cap_tab {
X   char *name;
X   char *value;
X   int cur_star, cur_plain;
X   int new_star, new_plain;
X};
X
Xextern int capper, write_ted_file;
Xextern struct cap_tab cap_list[CAP_MAX];
X
X/* pad edit array, used by pad() and kotex() */
X#define EDIT_MAX 4
Xextern char *ced_name[EDIT_MAX];
Xextern char **ced_value[EDIT_MAX];
X
X/* definitions for test_pad() */
X#define NEXT_LETTER letter = letters[letter_number =\
X	letters[letter_number + 1] ? letter_number + 1 : 0]
X
Xextern char letter;
Xextern int letter_number;
Xextern int cap_tested, stop_testing, resume_testing;
Xextern int rated_lines;
Xextern int augment, reps, ops;
Xextern long char_sent, char_max, full_test;
Xextern char *cap_select;
X
X#define CLEAR_TEST_MAX 5
Xextern int clear_select;
Xextern int clr_test_value[CLEAR_TEST_MAX];
Xextern int clr_test_reps[CLEAR_TEST_MAX];
X
Xextern int replace_mode;
Xextern int char_count, line_count, expand_chars;
Xextern int can_go_home, can_clear_screen;
X
Xextern int translate_mode, scan_mode;
Xextern int building_cap_list, time_pad;
Xextern int test_length, char_mask;
X
X/* Parity bit macros */
X#define STRIP_PARITY 0x7f
X#define ALLOW_PARITY 0xff
X
X/* select_delay_type:	0 -> reset all delays
X			1 -> force long delays
X			2 -> do not change the delays */
Xextern int select_delay_type;
X
X/* select_xon_xoff:	0 -> reset xon/xoff
X			1 -> set xon/xoff
X			2 -> do not change xon/xoff */
Xextern int select_pads, select_xon_xoff;
X
Xextern int tty_abort;
Xextern int tty_frame_size;
Xextern unsigned long tty_baud_rate;
Xextern int not_a_tty, nodelay_read;
X
X/* definitions for stty_query() */
X#define TTY_NOECHO 1
X#define TTY_OUT_TRANS 2
X#define TTY_CHAR_MODE 0
Xextern int stty_query();
X
X/* ASCII control characters */
X#define A_DC1 0x11  /* Control Q */
X#define A_DC3 0x13  /* Control S */
X#define A_ESC 0x1b
X#define A_DCS 0x90
X#define A_CSI 0x9b
X#define A_ST  0x9c
X
X/* scan code definitions */
X#define MAX_SCAN 256
X
X#ifndef MAIN
X/* translate mode default strings */
Xextern char *TM_carriage_return;
Xextern char *TM_cursor_down;
Xextern char *TM_scroll_forward;
Xextern char *TM_newline;
Xextern char *TM_cursor_left;
Xextern char *TM_bell;
Xextern char *TM_form_feed;
Xextern char *TM_tab;
X#endif
X
X/* attribute structure definition */
Xstruct mode_list {
X   char *name;
X   char *begin_mode, *end_mode;
X   int number;
X};
END_OF_FILE
if test 5515 -ne `wc -c <'ted.h'`; then
    echo shar: \"'ted.h'\" unpacked with wrong size!
fi
# end of 'ted.h'
fi
echo shar: End of archive 4 \(of 7\).
cp /dev/null ark4isdone
MISSING=""
for I in 1 2 3 4 5 6 7 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 7 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

exit 0 # Just in case...
-- 
Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
Sterling Software, IMD           UUCP:     uunet!sparky!kent
Phone:    (402) 291-8300         FAX:      (402) 291-4362
Please send comp.sources.misc-related mail to kent@uunet.uu.net.