home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / unix / volume03 / tctoti < prev    next >
Encoding:
Internet Message Format  |  1988-09-11  |  19.5 KB
  1. From: Robert Viduya <genrad!linus!gatech!gitpyr!robert>
  2. Subject: termcap to terminfo converter
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 3, Issue 30
  7. Submitted by: Robert Viduya <gatech!gitpyr!robert>
  8.  
  9.  
  10. The following is a program that I posted late last january.  Due to requests
  11. on net.info-terms, I'm reposting it.
  12.  
  13. The program converts termcap database files to terminfo source files.  It
  14. reads the termcap file from standard input and writes the terminfo source
  15. to standard output.  I tried to be as complete as possible, but I wasn't
  16. able to implement some things due to ambiguous documentation.  The
  17. unimplemented parts are in the %-escapes.  I wasn't sure about some of
  18. the more exotic termcap %-escapes like '%B'.  However, things like '%c',
  19. '%d', '%2d' and '%+' are implemented.
  20.  
  21.         as usual, send bug reports...
  22.  
  23.             robert
  24.  
  25. --
  26. Robert Viduya                            01111000
  27. Office of Computing Services
  28. Georgia Institute of Technology
  29.  
  30. UUCP:    {akgua,allegra,amd,hplabs,ihnp4,masscomp,ut-ngp,rlgvax,sb1, ..
  31.      uf-cgrl,unmvax,ut-sally}!gatech!{gitpyr,gt-oscar,gt-felix}!robert
  32. BITNET:    CC100RV @ GITVM1
  33. ------cut here----
  34. #! /bin/sh
  35. #    Run the following text with /bin/sh to create:
  36. #    Makefile
  37. #    captoinfo.c
  38. #    getcap.c
  39. #    putinfo.c
  40. #    tget.c
  41. if test -f 'Makefile'
  42. then
  43.     echo "`basename $0`: can't extract" 'Makefile' "- file exists" 1>&2
  44. else
  45.     sed 's/^X//' << '--End_of_Makefile--' > 'Makefile'
  46. XCFLAGS    =    -O
  47. XOBJS    =    captoinfo.o getcap.o putinfo.o tget.o
  48. X
  49. Xcaptoinfo:    $(OBJS)
  50. X        cc $(CFLAGS) $(OBJS) -o captoinfo
  51. X
  52. Xcaptoinfo.o:    captoinfo.c
  53. X
  54. Xgetcap.o:    getcap.c
  55. X
  56. Xputinfo.o:    putinfo.c
  57. X
  58. Xtget.o:        tget.c
  59. --End_of_Makefile--
  60.     if test 198 -ne `wc -c < 'Makefile'`
  61.     then
  62.         echo "`basename $0`: error in" 'Makefile' ": sent 198 chars, received `wc -c < 'Makefile'`" 1>&2
  63.     fi
  64. fi
  65. if test -f 'captoinfo.c'
  66. then
  67.     echo "`basename $0`: can't extract" 'captoinfo.c' "- file exists" 1>&2
  68. else
  69.     sed 's/^X//' << '--End_of_captoinfo.c--' > 'captoinfo.c'
  70. X/*
  71. X * captoinfo:
  72. X *    Translate termcap terminal database to terminfo source
  73. X *    format.
  74. X *
  75. X *    Captoinfo reads standard input, which is assumed to be
  76. X *    a termcap file and writes the equivalent to standard
  77. X *    output in terminfo source format.
  78. X *
  79. X * This code is copyrighted and may not be sold without due compensation
  80. X * to both Georgia Tech and myself.  Since I refuse to go through all the
  81. X * legal hassles involved, good luck.  Oh yeah... don't remove this
  82. X * paragraph either.
  83. X *
  84. X * Robert Viduya - Georgia Institute of Technology.
  85. X *
  86. X *    {gitpyr,gt-oscar,gt-felix}!robert
  87. X */
  88. X#include <stdio.h>
  89. X
  90. X#define    bool    char
  91. X#define    TRUE    1
  92. X#define    FALSE    0
  93. X
  94. Xchar    buffer[2048];
  95. X
  96. X
  97. Xmain ()
  98. X{
  99. X    int        c;
  100. X
  101. X    while ((c = getchar ()) != EOF) {
  102. X    if (c == '#') {
  103. X        (void) putchar (c);
  104. X        do {
  105. X        c = getchar ();
  106. X        (void) putchar (c);
  107. X        } while (c != '\n');
  108. X    }
  109. X    else {
  110. X        if (ungetc (c, stdin) == EOF) {
  111. X        fprintf (stderr, "ungetc failed.\n");
  112. X        exit (1);
  113. X        }
  114. X        get_termcap ();
  115. X        print_name ();
  116. X        print_bools ();
  117. X        print_nums ();
  118. X        print_strs ();
  119. X    }
  120. X    }
  121. X    exit (0);
  122. X}
  123. --End_of_captoinfo.c--
  124.     if test 1086 -ne `wc -c < 'captoinfo.c'`
  125.     then
  126.         echo "`basename $0`: error in" 'captoinfo.c' ": sent 1086 chars, received `wc -c < 'captoinfo.c'`" 1>&2
  127.     fi
  128. fi
  129. if test -f 'getcap.c'
  130. then
  131.     echo "`basename $0`: can't extract" 'getcap.c' "- file exists" 1>&2
  132. else
  133.     sed 's/^X//' << '--End_of_getcap.c--' > 'getcap.c'
  134. X#include <stdio.h>
  135. X#include <ctype.h>
  136. X
  137. X#define    bool    char
  138. X#define    TRUE    1
  139. X#define    FALSE    0
  140. X
  141. Xextern char    buffer[];
  142. X
  143. X
  144. X/*
  145. X * get_termcap:
  146. X *    read next termcap entry into buffer from standard input.
  147. X */
  148. Xget_termcap ()
  149. X{
  150. X    int        c;
  151. X    char    *bptr;
  152. X
  153. X    bptr = buffer;
  154. X    while ((c = getchar ()) != '\n') {
  155. X    if (c == '\\') {
  156. X        if ((c = getchar ()) != '\n') {
  157. X        if (ungetc (c, stdin) == EOF) {
  158. X            fprintf (stderr, "ungetc failed.\n");
  159. X            exit (1);
  160. X        }
  161. X        *(bptr++) = '\\';
  162. X        }
  163. X    }
  164. X    else {
  165. X        *(bptr++) = c;
  166. X    }
  167. X    }
  168. X    *bptr = '\0';
  169. X}
  170. --End_of_getcap.c--
  171.     if test 544 -ne `wc -c < 'getcap.c'`
  172.     then
  173.         echo "`basename $0`: error in" 'getcap.c' ": sent 544 chars, received `wc -c < 'getcap.c'`" 1>&2
  174.     fi
  175. fi
  176. if test -f 'putinfo.c'
  177. then
  178.     echo "`basename $0`: can't extract" 'putinfo.c' "- file exists" 1>&2
  179. else
  180.     sed 's/^X//' << '--End_of_putinfo.c--' > 'putinfo.c'
  181. X#include <stdio.h>
  182. X#include <strings.h>
  183. X#include <ctype.h>
  184. X
  185. X#define    bool    char
  186. X#define    TRUE    1
  187. X#define    FALSE    0
  188. X
  189. X#define    MAXINDEX(array)    (sizeof(array)/sizeof(array[0]))
  190. X
  191. X/*
  192. X * bools & boolcaps:
  193. X *    lookup translate table for boolean fields.
  194. X */
  195. Xstruct    bools {
  196. X    char    *capname;    /* termcap name */
  197. X    char    *infoname;    /* terminfo name */
  198. X};
  199. Xstruct    bools    boolcaps[] = {
  200. X    { "bw", "bw" },    { "am", "am" },        { "xb", "xsb" },
  201. X    { "xs", "xhp" },    { "xn", "xenl" },    { "eo", "eo" },
  202. X    { "gn", "gn" },    { "hc", "hc" },        { "km", "km" },
  203. X    { "hs", "hs" },    { "in", "in" },        { "da", "da" },
  204. X    { "db", "db" },    { "mi", "mir" },    { "ms", "msgr" },
  205. X    { "os", "os" },    { "es", "eslok" },    { "xt", "xt" },
  206. X    { "hz", "hz" },    { "ul", "ul" },        { "xo", "xon" }
  207. X};
  208. X#define MAXBOOLS    MAXINDEX(boolcaps)
  209. X
  210. X/*
  211. X * nums & numcaps:
  212. X *    lookup translate table for numeric capabilities.
  213. X */
  214. Xstruct    nums {
  215. X    char    *capname;    /* termcap name */
  216. X    char    *infoname;    /* terminfo name */
  217. X};
  218. Xstruct    nums    numcaps[] = {
  219. X    { "co", "cols" },    { "it", "it" },        { "li", "lines" },
  220. X    { "lm", "lm" },    { "sg", "xmc" },    { "pb", "pb" },
  221. X    { "vt", "vt" },    { "ws", "wsl" }
  222. X};
  223. X#define    MAXNUMS        MAXINDEX(numcaps)
  224. X
  225. X/*
  226. X * strs & strcaps:
  227. X *    lookup translate table for string capabilities.
  228. X */
  229. Xstruct    strs    {
  230. X    char    *capname;    /* termcap name */
  231. X    char    *infoname;    /* terminfo name */
  232. X    char    *dflt;        /* default value */
  233. X};
  234. Xstruct    strs    strcaps[] = {
  235. X    { "bt",    "cbt",        ((char *)0) },
  236. X    { "bl",    "bel",        "\007" },
  237. X    { "cr",    "cr",        "\r" },
  238. X    { "cs",    "csr",        ((char *)0) },
  239. X    { "ct",    "tbc",        ((char *)0) },
  240. X    { "cl",    "clear",    ((char *)0) },
  241. X    { "ce",    "el",        ((char *)0) },
  242. X    { "cd",    "ed",        ((char *)0) },
  243. X    { "ch",    "hpa",        ((char *)0) },
  244. X    { "CC",    "cmdch",    ((char *)0) },
  245. X    { "cm",    "cup",        ((char *)0) },
  246. X    { "do",    "cud1",        "\n" },
  247. X    { "ho",    "home",        ((char *)0) },
  248. X    { "vi",    "civis",    ((char *)0) },
  249. X    { "le",    "cub1",        "\b" },        /* special case - check bc */
  250. X    { "CM",    "mrcup",    ((char *)0) },
  251. X    { "ve",    "cnorm",    ((char *)0) },
  252. X    { "nd",    "cuf1",        ((char *)0) },
  253. X    { "ll",    "ll",        ((char *)0) },
  254. X    { "up",    "cuu1",        ((char *)0) },
  255. X    { "vs",    "cvvis",    ((char *)0) },
  256. X    { "dc",    "dch1",        ((char *)0) },
  257. X    { "dl",    "dl1",        ((char *)0) },
  258. X    { "ds",    "dsl",        ((char *)0) },
  259. X    { "hd",    "hd",        ((char *)0) },
  260. X    { "as",    "smacs",    ((char *)0) },
  261. X    { "mb",    "blink",    ((char *)0) },
  262. X    { "md",    "bold",        ((char *)0) },
  263. X    { "ti",    "smcup",    ((char *)0) },
  264. X    { "dm",    "smdc",        ((char *)0) },
  265. X    { "mh",    "dim",        ((char *)0) },
  266. X    { "im",    "smir",        ((char *)0) },
  267. X    { "mp",    "prot",        ((char *)0) },
  268. X    { "mr",    "rev",        ((char *)0) },
  269. X    { "mk",    "invis",    ((char *)0) },
  270. X    { "so",    "smso",        ((char *)0) },
  271. X    { "us",    "smul",        ((char *)0) },
  272. X    { "ec",    "ech",        ((char *)0) },
  273. X    { "ae",    "rmacs",    ((char *)0) },
  274. X    { "me",    "sgr0",        ((char *)0) },
  275. X    { "te",    "rmcup",    ((char *)0) },
  276. X    { "ed",    "rmdc",        ((char *)0) },
  277. X    { "ei",    "rmir",        ((char *)0) },
  278. X    { "se",    "rmso",        ((char *)0) },
  279. X    { "ue",    "rmul",        ((char *)0) },
  280. X    { "vb",    "flash",    ((char *)0) },
  281. X    { "ff",    "ff",        ((char *)0) },
  282. X    { "fs",    "fsl",        ((char *)0) },
  283. X    { "is",    "is1",        ((char *)0) },
  284. X    { "i1",    "is2",        ((char *)0) },
  285. X    { "i2",    "is3",        ((char *)0) },
  286. X    { "if",    "if",        ((char *)0) },
  287. X    { "ic",    "ich1",        ((char *)0) },
  288. X    { "al",    "il1",        ((char *)0) },
  289. X    { "ip",    "ip",        ((char *)0) },
  290. X    { "kb",    "kbs",        "\b" },
  291. X    { "ka",    "ktbc",        ((char *)0) },
  292. X    { "kC",    "kclr",        ((char *)0) },
  293. X    { "kt",    "kctab",    ((char *)0) },
  294. X    { "kD",    "kdch1",    ((char *)0) },
  295. X    { "kL",    "kdl1",        ((char *)0) },
  296. X    { "kd",    "kcud1",    "\n" },
  297. X    { "kM",    "krmir",    ((char *)0) },
  298. X    { "kE",    "kel",        ((char *)0) },
  299. X    { "kS",    "ked",        ((char *)0) },
  300. X    { "k0",    "kf0",        ((char *)0) },
  301. X    { "k1",    "kf1",        ((char *)0) },
  302. X    { "k2",    "kf2",        ((char *)0) },
  303. X    { "k3",    "kf3",        ((char *)0) },
  304. X    { "k4",    "kf4",        ((char *)0) },
  305. X    { "k5",    "kf5",        ((char *)0) },
  306. X    { "k6",    "kf6",        ((char *)0) },
  307. X    { "k7",    "kf7",        ((char *)0) },
  308. X    { "k8",    "kf8",        ((char *)0) },
  309. X    { "k9",    "kf9",        ((char *)0) },
  310. X    { "kh",    "khome",    ((char *)0) },
  311. X    { "kI",    "kich1",    ((char *)0) },
  312. X    { "kA",    "kil1",        ((char *)0) },
  313. X    { "kl",    "kcub1",    "\b" },
  314. X    { "kH",    "kll",        ((char *)0) },
  315. X    { "kN",    "knp",        ((char *)0) },
  316. X    { "kP",    "kpp",        ((char *)0) },
  317. X    { "kr",    "kcuf1",    ((char *)0) },
  318. X    { "kF",    "kind",        ((char *)0) },
  319. X    { "kR",    "kri",        ((char *)0) },
  320. X    { "kT",    "khts",        ((char *)0) },
  321. X    { "ku",    "kcuu1",    ((char *)0) },
  322. X    { "ke",    "rmkx",        ((char *)0) },
  323. X    { "ks",    "smkx",        ((char *)0) },
  324. X    { "l0",    "lf0",        ((char *)0) },
  325. X    { "l1",    "lf1",        ((char *)0) },
  326. X    { "l2",    "lf2",        ((char *)0) },
  327. X    { "l3",    "lf3",        ((char *)0) },
  328. X    { "l4",    "lf4",        ((char *)0) },
  329. X    { "l5",    "lf5",        ((char *)0) },
  330. X    { "l6",    "lf6",        ((char *)0) },
  331. X    { "l7",    "lf7",        ((char *)0) },
  332. X    { "l8",    "lf8",        ((char *)0) },
  333. X    { "l9",    "lf9",        ((char *)0) },
  334. X    { "mm",    "smm",        ((char *)0) },
  335. X    { "mo",    "rmm",        ((char *)0) },
  336. X    { "nw",    "nel",        "\r\n" },
  337. X    { "pc",    "pad",        ((char *)0) },
  338. X    { "DC",    "dch",        ((char *)0) },
  339. X    { "DL",    "dl",        ((char *)0) },
  340. X    { "DO",    "cud",        ((char *)0) },
  341. X    { "IC",    "ich",        ((char *)0) },
  342. X    { "SF",    "indn",        ((char *)0) },
  343. X    { "AL",    "il",        ((char *)0) },
  344. X    { "LE",    "cub",        ((char *)0) },
  345. X    { "RI",    "cuf",        ((char *)0) },
  346. X    { "SR",    "rin",        ((char *)0) },
  347. X    { "UP",    "cuu",        ((char *)0) },
  348. X    { "pk",    "pfkey",    ((char *)0) },
  349. X    { "pl",    "pfloc",    ((char *)0) },
  350. X    { "px",    "pfx",        ((char *)0) },
  351. X    { "ps",    "mc0",        ((char *)0) },
  352. X    { "pf",    "mc4",        ((char *)0) },
  353. X    { "po",    "mc5",        ((char *)0) },
  354. X    { "rp",    "rep",        ((char *)0) },
  355. X    { "rs",    "rs1",        ((char *)0) },
  356. X    { "r1",    "rs2",        ((char *)0) },
  357. X    { "r2",    "rs3",        ((char *)0) },
  358. X    { "rf",    "rf",        ((char *)0) },
  359. X    { "rc",    "rc",        ((char *)0) },
  360. X    { "cv",    "vpa",        ((char *)0) },
  361. X    { "sc",    "sc",        ((char *)0) },
  362. X    { "sf",    "ind",        "\n" },
  363. X    { "sr",    "ri",        ((char *)0) },
  364. X    { "sa",    "sgr",        ((char *)0) },
  365. X    { "st",    "hts",        ((char *)0) },
  366. X    { "wi",    "wind",        ((char *)0) },
  367. X    { "ta",    "ht",        ((char *)0) },    /* conditional - check pt */
  368. X    { "ts",    "tsl",        ((char *)0) },
  369. X    { "uc",    "uc",        ((char *)0) },
  370. X    { "hu",    "hu",        ((char *)0) },
  371. X    { "iP",    "iprog",    ((char *)0) },
  372. X    { "K1",    "ka1",        ((char *)0) },
  373. X    { "K2",    "kb2",        ((char *)0) },
  374. X    { "K3",    "ka3",        ((char *)0) },
  375. X    { "K4",    "kc1",        ((char *)0) },
  376. X    { "K5",    "kc3",        ((char *)0) },
  377. X    { "pO",    "mc5p",        ((char *)0) },
  378. X    { "tc",    "use",        ((char *)0) }
  379. X};
  380. X#define    MAXSTRS        MAXINDEX(strcaps)
  381. X
  382. Xint    tgetname ();    /* get termcap name */
  383. Xint    tgetflag ();    /* get termcap boolean value */
  384. Xint    tgetnum ();    /* get termcap numeric value */
  385. Xint    tgetstr ();    /* get termcap string value */
  386. X
  387. X
  388. X/*
  389. X * print_name:
  390. X *    print name and aliases of current termcap entry.
  391. X */
  392. Xprint_name ()
  393. X{
  394. X    char    name[100];
  395. X
  396. X    tgetname (name);
  397. X    printf ("%s,\n", name);
  398. X}
  399. X
  400. X/*
  401. X * print_bools:
  402. X *    print all boolean fields of current termcap entry.
  403. X */
  404. Xprint_bools ()
  405. X{
  406. X    int        i, val;
  407. X    bool    stuffprinted = FALSE;
  408. X
  409. X    for (i = 0; i < MAXBOOLS; i++)
  410. X    if (val = tgetflag (boolcaps[i].capname)) {
  411. X        if (val == 1)
  412. X        printf ("\t%s,", boolcaps[i].infoname);
  413. X        else
  414. X        printf ("\t%s@,", boolcaps[i].infoname);
  415. X        stuffprinted = TRUE;
  416. X    }
  417. X    if (stuffprinted)
  418. X    (void) putchar ('\n');
  419. X}
  420. X
  421. X/*
  422. X * print_nums:
  423. X *    print all numeric fields of current termcap entry.
  424. X */
  425. Xprint_nums ()
  426. X{
  427. X    int        i, capval;
  428. X    bool    stuffprinted = FALSE;
  429. X
  430. X    for (i = 0; i < MAXNUMS; i++)
  431. X    if ((capval = tgetnum (numcaps[i].capname)) >= 0) {
  432. X        printf ("\t%s#%d,", numcaps[i].infoname, capval);
  433. X        stuffprinted = TRUE;
  434. X    }
  435. X    else if (capval == -2) {
  436. X        printf ("\t%s@,", numcaps[i].infoname);
  437. X        stuffprinted = TRUE;
  438. X    }
  439. X    if (stuffprinted)
  440. X    (void) putchar ('\n');
  441. X}
  442. X
  443. X/*
  444. X * print_strs:
  445. X *    print all string fields of current termcap entry.
  446. X */
  447. Xprint_strs ()
  448. X{
  449. X    int        i, count = 0;
  450. X    char    capval[100];
  451. X
  452. X    for (i = 0; i < MAXSTRS; i++) {
  453. X    tgetstr (strcaps[i].capname, capval);
  454. X    if (!capval[0]) {
  455. X        if (strcmp (strcaps[i].capname, "le") == 0) {
  456. X        tgetstr ("bc", capval);
  457. X        }
  458. X        else if (strcmp (strcaps[i].capname, "ta") == 0) { 
  459. X        if (tgetflag ("pt")) {
  460. X            capval[0] = '\t';
  461. X            capval[1] = '\0';
  462. X        }
  463. X        }
  464. X    }
  465. X    if ((!capval[0]) && (strcaps[i].dflt))
  466. X        (void) strcpy (capval, strcaps[i].dflt);
  467. X    if (capval[0]) {
  468. X        if (strcmp (capval, "@") != 0) {
  469. X        printf ("\t%s=", strcaps[i].infoname);
  470. X        if (strcmp(strcaps[i].infoname,"use") != 0) {
  471. X            put_str (capval);
  472. X            printf (",");
  473. X        }
  474. X        else
  475. X            printf ("%s,", capval);
  476. X        }
  477. X        else
  478. X        printf ("%s@,", strcaps[i].infoname);
  479. X        count++;
  480. X        if (!(count %= 3))
  481. X        putchar ('\n');
  482. X    }
  483. X    }
  484. X    if (count)
  485. X    (void) putchar ('\n');
  486. X}
  487. X
  488. X/*
  489. X * put_str:
  490. X *    translate strings to printable format and print them.
  491. X */
  492. Xput_str (s)
  493. Xchar    *s;
  494. X{
  495. X    bool    rflag = FALSE;    /* % codes */
  496. X    char    *c;
  497. X    int        parm;
  498. X
  499. X    if ((isdigit (*s)) || (*s == '.')) {    /* handle padding */
  500. X    printf ("$<");
  501. X    while ((isdigit (*s)) || (*s == '.')) {
  502. X        (void) putchar (*s);
  503. X        s++;
  504. X    }
  505. X    if (*s == '*') {
  506. X        (void) putchar (*s);
  507. X        s++;
  508. X    }
  509. X    (void) putchar ('>');
  510. X    }
  511. X    for (c = s; *c; c++) {    /* scan for % codes (needs work) */
  512. X    if (*c == '%') {
  513. X        c++;
  514. X        switch (*c) {
  515. X        case 'r':
  516. X            rflag = TRUE;
  517. X            break;
  518. X        default:
  519. X            break;    /* ignore */
  520. X        }
  521. X    }
  522. X    }
  523. X    parm = 0;
  524. X    while (*s) {        /* print the string */
  525. X    switch (*s) {
  526. X        case '%':
  527. X        s++;
  528. X        switch (*s) {
  529. X            case '%':
  530. X            printf ("%%%%");
  531. X            break;
  532. X            case 'i':
  533. X            printf ("%%i");
  534. X            break;
  535. X            case 'd':
  536. X            parm++;
  537. X            if ((rflag) && (parm <= 2)) {
  538. X                if (parm == 1)
  539. X                printf ("%%p2%%d");
  540. X                else
  541. X                printf ("%%p1%%d");
  542. X            }
  543. X            else
  544. X                printf ("%%p%d%%d", parm);
  545. X            break;
  546. X            case '2':
  547. X            parm++;
  548. X            if ((rflag) && (parm <= 2)) {
  549. X                if (parm == 1)
  550. X                printf ("%%p2%%02d");
  551. X                else
  552. X                printf ("%%p1%%02d");
  553. X            }
  554. X            else
  555. X                printf ("%%p%d%%02d", parm);
  556. X            break;
  557. X            case '3':
  558. X            parm++;
  559. X            if ((rflag) && (parm <= 2)) {
  560. X                if (parm == 1)
  561. X                printf ("%%p2%%03d");
  562. X                else
  563. X                printf ("%%p1%%03d");
  564. X            }
  565. X            else
  566. X                printf ("%%p%d%%03d", parm);
  567. X            break;
  568. X            case '.':
  569. X            parm++;
  570. X            if ((rflag) && (parm <= 2)) {
  571. X                if (parm == 1)
  572. X                printf ("%%p2%%c");
  573. X                else
  574. X                printf ("%%p1%%c");
  575. X            }
  576. X            else
  577. X                printf ("%%p%d%%c", parm);
  578. X            break;
  579. X            case '+':
  580. X            s++;
  581. X            parm++;
  582. X            if ((rflag) && (parm <= 2)) {
  583. X                if (parm == 1)
  584. X                printf ("%%p2%%'%c'%%+%%c", *s);
  585. X                else
  586. X                printf ("%%p1%%'%c'%%+%%c", *s);
  587. X            }
  588. X            else
  589. X                printf ("%%p%d%%'%c'%%+%%c", parm, *s);
  590. X            break;
  591. X            default:
  592. X            break;    /* ignore */
  593. X        }
  594. X        break;
  595. X        case '\200':
  596. X        printf ("\\0");
  597. X        break;
  598. X        case '\177':
  599. X        printf ("^?");
  600. X        break;
  601. X        case ',':
  602. X        printf ("\\,");
  603. X        break;
  604. X        case '\\':
  605. X        printf ("\\\\");
  606. X        break;
  607. X        case '^':
  608. X        printf ("\\^");
  609. X        break;
  610. X        case ':':
  611. X        printf ("\\:");
  612. X        break;
  613. X        case '\033':
  614. X        printf ("\\E");
  615. X        break;
  616. X        case '\n':
  617. X        printf ("\\n");
  618. X        break;
  619. X        case '\r':
  620. X        printf ("\\r");
  621. X        break;
  622. X        case '\t':
  623. X        printf ("\\t");
  624. X        break;
  625. X        case '\b':
  626. X        printf ("\\b");
  627. X        break;
  628. X        case '\f':
  629. X        printf ("\\f");
  630. X        break;
  631. X        case ' ':
  632. X        printf ("\\s");
  633. X        break;
  634. X        default:
  635. X        if (*s < ' ')
  636. X            printf ("^%c", *s + 'A' - 1);
  637. X        else
  638. X            (void) putchar (*s);
  639. X        break;
  640. X    }
  641. X    s++;
  642. X    }
  643. X}
  644. --End_of_putinfo.c--
  645.     if test 11301 -ne `wc -c < 'putinfo.c'`
  646.     then
  647.         echo "`basename $0`: error in" 'putinfo.c' ": sent 11301 chars, received `wc -c < 'putinfo.c'`" 1>&2
  648.     fi
  649. fi
  650. if test -f 'tget.c'
  651. then
  652.     echo "`basename $0`: can't extract" 'tget.c' "- file exists" 1>&2
  653. else
  654.     sed 's/^X//' << '--End_of_tget.c--' > 'tget.c'
  655. X#include <stdio.h>
  656. X#include <ctype.h>
  657. X#include <strings.h>
  658. X
  659. X#define    bool    char
  660. X#define    TRUE    1
  661. X#define    FALSE    0
  662. X
  663. Xextern char    buffer[];
  664. X
  665. X
  666. X/*
  667. X * scan:
  668. X *    scan for character in string, return position of character.
  669. X *    similar to index/strchr, except that if char not found, returns
  670. X *    pointer to null at end of string, instead of a null pointer.
  671. X */
  672. Xchar *
  673. Xscan (s, c)
  674. Xregister char    *s;
  675. Xregister char    c;
  676. X{
  677. X    while ((*s) && (*s != c))
  678. X    s++;
  679. X    return (s);
  680. X}
  681. X
  682. X/* findcap:
  683. X *     returns pointer to just after capname (trailing ':' for flags,
  684. X *    '#' for nums, '=' for strs, '@' for disabled stuff) or to null
  685. X *     after termcap if not found.
  686. X */
  687. Xchar *
  688. Xfindcap (capname)
  689. Xchar    *capname;
  690. X{
  691. X    register char    *bptr = buffer;
  692. X    register bool    found = FALSE;
  693. X    char        cap[3];
  694. X
  695. X    cap[2] = '\0';
  696. X    while ((!found) && (*bptr)) {
  697. X    bptr = scan (bptr, ':');
  698. X    if (*bptr) {
  699. X        cap[0] = *(bptr + 1);
  700. X        cap[1] = *(bptr + 2);
  701. X        if (strcmp (cap,capname) == 0) {
  702. X        found = TRUE;
  703. X        bptr += 3;    /* skip colon and capname */
  704. X        }
  705. X        else
  706. X        bptr++;        /* skip colon */
  707. X    }
  708. X    }
  709. X    return (bptr);
  710. X}
  711. X
  712. X/*
  713. X * tgetname:
  714. X *    store name of termcap entry in name
  715. X */
  716. Xtgetname (name)
  717. Xchar    *name;
  718. X{
  719. X    char    *bptr;
  720. X
  721. X    bptr = buffer;
  722. X
  723. X    while ((*bptr) && (*bptr != ':'))
  724. X    *(name++) = *(bptr++);
  725. X    *(name) = '\0';
  726. X}
  727. X
  728. X/*
  729. X * tgetflag:
  730. X *    return 1 if capname present, 0 otherwise, -1 if '@'ed.
  731. X */
  732. Xint
  733. Xtgetflag (capname)
  734. Xchar    *capname;
  735. X{
  736. X    char    *c;
  737. X
  738. X    c = findcap (capname);
  739. X    if (*c == '\0')
  740. X    return (0);
  741. X    else if (*c == '@')
  742. X    return (-1);
  743. X    else
  744. X    return (1);
  745. X}
  746. X
  747. X/*
  748. X * tgetnum:
  749. X *    return value of capname, -1 if not present, -2 if '@'ed.
  750. X */
  751. Xint
  752. Xtgetnum (capname)
  753. Xchar    *capname;
  754. X{
  755. X    char    *c;
  756. X    int        val;
  757. X
  758. X    c = findcap (capname);
  759. X    if (*c == '@')
  760. X    return (-2);
  761. X    else if (*c != '\0') {
  762. X    c++;    /* skip '#' */
  763. X    val = 0;
  764. X    while (isdigit (*c)) {
  765. X        val = (val * 10) + (*c - '0');
  766. X        c++;
  767. X    }
  768. X    return (val);
  769. X    }
  770. X    else
  771. X    return (-1);
  772. X}
  773. X
  774. X/*
  775. X * tgetstr:
  776. X *    store binary value of capname into value, store null if
  777. X *    not present, store "@" if '@'ed.
  778. X */
  779. Xtgetstr (capname, value)
  780. Xchar        *capname;
  781. Xregister char    *value;
  782. X{
  783. X    register char    *c;
  784. X
  785. X    c = findcap (capname);
  786. X    if (*c == '@')
  787. X    strcpy (value, "@");
  788. X    else if (*c != '\0') {
  789. X    c++;    /* skip '=' */
  790. X    while ((*c) && (*c != ':')) {
  791. X        if (*c == '^') {
  792. X        c++;
  793. X        if (islower (*c)) 
  794. X            *(value++) = toupper(*(c++)) - '@';    /* ascii dependent */
  795. X        else
  796. X            *(value++) = *(c++) - '@';    /* ascii dependent */
  797. X        }
  798. X        else if (*c == '\\') {
  799. X        c++;
  800. X        switch (*c) {
  801. X            case 'E':
  802. X            *(value++) = '\033';
  803. X            c++;
  804. X            break;
  805. X            case 'n':
  806. X            *(value++) = '\n';
  807. X            c++;
  808. X            break;
  809. X            case 'r':
  810. X            *(value++) = '\r';
  811. X            c++;
  812. X            break;
  813. X            case 't':
  814. X            *(value++) = '\t';
  815. X            c++;
  816. X            break;
  817. X            case 'b':
  818. X            *(value++) = '\b';
  819. X            c++;
  820. X            break;
  821. X            case 'f':
  822. X            *(value++) = '\f';
  823. X            c++;
  824. X            break;
  825. X            default:
  826. X            if (isdigit (*c)) {    /* octal value */
  827. X                *value = '\0';
  828. X                while (isdigit (*c)) {
  829. X                *value = ((*value) * 8) + ((*c) - '0');
  830. X                c++;
  831. X                }
  832. X                value++;
  833. X            }
  834. X            else
  835. X                *(value++) = *(c++);
  836. X            break;
  837. X        }
  838. X        }
  839. X        else
  840. X        *(value++) = *(c++);
  841. X    }
  842. X    *value = '\0';
  843. X    }
  844. X    else
  845. X    *value = '\0';
  846. X}
  847. --End_of_tget.c--
  848.     if test 3196 -ne `wc -c < 'tget.c'`
  849.     then
  850.         echo "`basename $0`: error in" 'tget.c' ": sent 3196 chars, received `wc -c < 'tget.c'`" 1>&2
  851.     fi
  852. fi
  853. exit
  854.  
  855.