home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / pc / source / termcap.zoo / termcap.4 < prev    next >
Encoding:
Text File  |  1990-04-04  |  49.1 KB  |  2,476 lines
  1. #!/bin/sh
  2. # this is part.04 (part 4 of tinfo)
  3. # do not concatenate these parts, unpack them in order with /bin/sh
  4. # file conv.c continued
  5. #
  6. touch 2>&1 | fgrep '[-amc]' > /tmp/s3_touch$$
  7. if [ -s /tmp/s3_touch$$ ]
  8. then
  9.     TOUCH=can
  10. else
  11.     TOUCH=cannot
  12. fi
  13. rm -f /tmp/s3_touch$$
  14. CurArch=4
  15. if test ! -r s3_seq_.tmp
  16. then echo "Please unpack part 1 first!"
  17.      exit 1; fi
  18. ( read Scheck
  19.   case "$Scheck" in
  20.   "$CurArch") exit 0 ;;
  21.   *)
  22.        echo "Please unpack part $Scheck next!"
  23.        exit 1 ;;
  24.   esac
  25. ) < s3_seq_.tmp || exit 1
  26. echo "x - Continuing file conv.c"
  27. sed 's/^X//' << 'SHAR_EOF' >> conv.c
  28. X                        break;
  29. X                    case '/':
  30. X                        *dp++ = '%'; *dp++ = '/';
  31. X                        break;
  32. X                    case '=':
  33. X                        if (seenr)
  34. X                            if (param == 1)
  35. X                                onstack = 2;
  36. X                            else if (param == 2)
  37. X                                onstack = 1;
  38. X                            else
  39. X                                onstack = param;
  40. X                        else
  41. X                            onstack = param;
  42. X                        break;
  43. X                    }
  44. X                    s += l;
  45. X                    break;
  46. X                }
  47. X                getparm(param, 1);
  48. X                s += cvtchar(s);
  49. X                *dp++ = '%'; *dp++ = '+';
  50. X                break;
  51. X            case '+':
  52. X                getparm(param, 1);
  53. X                s += cvtchar(s);
  54. X                *dp++ = '%'; *dp++ = '+';
  55. X                *dp++ = '%'; *dp++ = 'c';
  56. X                pop();
  57. X                break;
  58. X            case 's':
  59. X                s += cvtchar(s);
  60. X                getparm(param, 1);
  61. X                *dp++ = '%'; *dp++ = '-';
  62. X                break;
  63. X            case '-':
  64. X                s += cvtchar(s);
  65. X                getparm(param, 1);
  66. X                *dp++ = '%'; *dp++ = '-';
  67. X                *dp++ = '%'; *dp++ = 'c';
  68. X                pop();
  69. X                break;
  70. X            case '.':
  71. X                getparm(param, 1);
  72. X                *dp++ = '%'; *dp++ = 'c';
  73. X                pop();
  74. X                break;
  75. X            case '2':
  76. X                getparm(param, 1);
  77. X                *dp++ = '%'; *dp++ = '0';
  78. X                *dp++ = '2'; *dp++ = 'd';
  79. X                pop();
  80. X                break;
  81. X            case '3':
  82. X                getparm(param, 1);
  83. X                *dp++ = '%'; *dp++ = '0';
  84. X                *dp++ = '3'; *dp++ = 'd';
  85. X                pop();
  86. X                break;
  87. X            case 'd':
  88. X                getparm(param, 1);
  89. X                *dp++ = '%'; *dp++ = 'd';
  90. X                pop();
  91. X                break;
  92. X            case 'f':
  93. X                param++;
  94. X                break;
  95. X            case 'b':
  96. X                param--;
  97. X                break;
  98. X            default:
  99. X                warn();
  100. X                *dp++ = '%';
  101. X                s--;
  102. X                fprintf(stderr, "'%s' unknown %% code %%",
  103. X                    strcodes[i], *s);
  104. X                if (*s >= 0 && *s < 32)
  105. X                    fprintf(stderr, "^%c\n", *s + '@');
  106. X                else if (*s < 0 || *s >= 127)
  107. X                    fprintf(stderr, "\\%03o\n", *s & 0377);
  108. X                else
  109. X                    fprintf(stderr, "%c\n", *s);
  110. X                break;
  111. X            }
  112. X            break;
  113. X        case '\\':
  114. X            if (!compile) {*dp++ = *s++; *dp++ = *s++; break;}
  115. X        case '\n':
  116. X            if (!compile) {*dp++ = '\\'; *dp++ = 'n'; s++; break;}
  117. X        case '\t':
  118. X            if (!compile) {*dp++ = '\\'; *dp++ = 't'; s++; break;}
  119. X        case '\r':
  120. X            if (!compile) {*dp++ = '\\'; *dp++ = 'r'; s++; break;}
  121. X        case '\200':
  122. X            if (!compile) {*dp++ = '\\'; *dp++ = '0'; s++; break;}
  123. X        case '\f':
  124. X            if (!compile) {*dp++ = '\\'; *dp++ = 'f'; s++; break;}
  125. X        case '\b':
  126. X            if (!compile) {*dp++ = '\\'; *dp++ = 'b'; s++; break;}
  127. X        case ' ':
  128. X            if (!compile) {*dp++ = '\\'; *dp++ = 's'; s++; break;}
  129. X        case '^':
  130. X            if (!compile) {*dp++ = '\\'; *dp++ = '^'; s++; break;}
  131. X        case ':':
  132. X            if (!compile) {*dp++ = '\\'; *dp++ = ':'; s++; break;}
  133. X        case ',':
  134. X            if (!compile) {*dp++ = '\\'; *dp++ = ','; s++; break;}
  135. X#if 0
  136. X        case '\'':
  137. X            if (!compile) {*dp++ = '\\'; *dp++ = '\''; s++; break;}
  138. X#endif
  139. X        default:
  140. X            if (compile) 
  141. X                *dp++ = *s++;
  142. X            else if (*s > 0 && *s < 32) {
  143. X                *dp++ = '^';
  144. X                *dp++ = *s + '@';
  145. X                s++;
  146. X            } else if (*s <= 0 || *s >= 127) {
  147. X                *dp++ = '\\';
  148. X                *dp++ = ((*s & 0300) >> 6) + '0';
  149. X                *dp++ = ((*s & 0070) >> 3) + '0';
  150. X                *dp++ = (*s & 0007) + '0';
  151. X                s++;
  152. X            } else
  153. X                *dp++ = *s++;
  154. X            break;
  155. X        }
  156. X    }
  157. X    *dp = '\0';
  158. X    return line;
  159. X}
  160. X
  161. X#define LSB(n) ((unsigned) (n) & 0377)
  162. X#define MSB(n) (((unsigned) (n) >> 8) & 0377)
  163. X
  164. Xvoid writebin(fd, name)
  165. Xint fd;
  166. Xchar *name; {
  167. X    static char bin[MAX_BUF + 1];
  168. X    register char *s;
  169. X    register char *d;
  170. X    register int i;
  171. X    register char *t;
  172. X    register int n;
  173. X    char *strtbl;
  174. X    int sz_name, n_bools, n_nums, n_offs, sz_strs;
  175. X    extern int _boolorder[], _numorder[], _strorder[];
  176. X
  177. X    strncpy(bin + 12, name, 127);
  178. X    bin[12 + 128] = '\0';
  179. X    sz_name = strlen(name) + 1;
  180. X    if (sz_name > 128)
  181. X        sz_name = 128;
  182. X
  183. X    s = bin + 12 + sz_name;
  184. X    for(i = 0; _boolorder[i] != -1; i++) {
  185. X        switch(_term_buf.bools[i]) {
  186. X        case -1: *s++ = 0; break;
  187. X        case  0: *s++ = 0377; break;
  188. X        default: *s++ = 1; break;
  189. X        }
  190. X    }
  191. X    n_bools = i;
  192. X    if ((sz_name + n_bools) & 1)
  193. X        n_bools++;
  194. X
  195. X    s = bin + 12 + sz_name + n_bools;
  196. X    for(i = 0; _numorder[i] != -1; i++) {
  197. X        n = _term_buf.nums[_numorder[i]];
  198. X        switch(n) {
  199. X        case -2: *s++ = 0377; *s++ = 0377; break;
  200. X        case -1: *s++ = 0376; *s++ = 0377; break;
  201. X        default:
  202. X            *s++ = LSB(n);
  203. X            *s++ = MSB(n);
  204. X        }
  205. X    }
  206. X    n_nums = i;
  207. X
  208. X    s = bin + 12 + sz_name + n_bools + n_nums * 2;
  209. X    for(i = 0; _strorder[i] != -1; i++) {
  210. X        if (_term_buf.strs[_strorder[i]] == (char *) 0) {
  211. X            *s++ = 0376; *s++ = 0377;
  212. X        } else {
  213. X            *s++ = 0377; *s++ = 0377;
  214. X        }
  215. X    }
  216. X    n_offs = i;
  217. X
  218. X    s = bin + 12 + sz_name + n_bools + n_nums * 2;
  219. X    strtbl = d = s + n_offs * 2;
  220. X    for(i = 0; _strorder[i] != -1; i++) {
  221. X        t = _term_buf.strs[_strorder[i]];
  222. X        if (t == (char *) -1 || t == (char *)  0)
  223. X            s += 2;
  224. X        else {
  225. X            n = d - strtbl;
  226. X            *s++ = LSB(n);
  227. X            *s++ = MSB(n);
  228. X            t = convstr(t, _strorder[i]);
  229. X            while(*t != '\0') {
  230. X                *d++ = *t++;
  231. X                if (d >= bin + MAX_BUF - 1) {
  232. X                    warn();
  233. X                    fprintf(stderr,
  234. X                    "compiled entry to big\n");
  235. X                    *d++ = '\0';
  236. X                    goto toobig;
  237. X                }
  238. X            }
  239. X            *d++ = '\0';
  240. X        }
  241. X    }
  242. X
  243. Xtoobig:
  244. X    sz_strs = d - strtbl;
  245. X
  246. X    bin[0] = 032;
  247. X    bin[1] = 01;
  248. X    bin[2] = LSB(sz_name);
  249. X    bin[3] = MSB(sz_name);
  250. X    bin[4] = LSB(n_bools);
  251. X    bin[5] = MSB(n_bools);
  252. X    bin[6] = LSB(n_nums);
  253. X    bin[7] = MSB(n_nums);
  254. X    bin[8] = LSB(n_offs);
  255. X    bin[9] = MSB(n_offs);
  256. X    bin[10] = LSB(sz_strs);
  257. X    bin[11] = MSB(sz_strs);
  258. X
  259. X    if (write(fd, bin, d - bin) == -1) 
  260. X        quit(errno, "can't write binary file");
  261. X
  262. X    return;
  263. X}
  264. X
  265. Xvoid find_directory() {
  266. X    struct term_path *p;
  267. X    struct stat st;
  268. X
  269. X    if (directory != NULL)
  270. X        return;
  271. X
  272. X    p = path;
  273. X    while(p->type != -1 && p->file != NULL) {
  274. X        if (stat(p->file, &st) == 0) {
  275. X            if ((st.st_mode & 0170000) == 0040000) {
  276. X                directory = p->file;
  277. X                return;
  278. X            }
  279. X        }
  280. X        p++;
  281. X    }
  282. X    quit(-1, "can't find a terminfo directory");
  283. X}
  284. X
  285. X/* convert a terminal name to a binary filename */
  286. Xchar *binfile(name)
  287. Xchar *name; {
  288. X    static char line[MAX_LINE+1];
  289. X
  290. X    sprintf(line, "%s/%c/%s", directory, *name, name);
  291. X    return line;
  292. X}
  293. X
  294. Xchar *bindir(name)
  295. Xchar *name; {
  296. X    static char line[MAX_LINE+1];
  297. X
  298. X    sprintf(line, "%s/%c", directory, *name);
  299. X    return line;
  300. X}
  301. X
  302. X/* output a terminfo binary */
  303. Xvoid outputbin(name)
  304. Xchar *name; {
  305. X    register char *s, *d;
  306. X    char last[MAX_LINE+1];
  307. X    static char line[MAX_LINE+1];
  308. X    int fd;
  309. X
  310. X    last[0] = '\0';
  311. X
  312. X    find_directory();
  313. X
  314. X    s = name;
  315. X    d = line;
  316. X    while(*s != '\0' && d < line + MAX_LINE)
  317. X        *d++ = *s++;
  318. X    *d = '\0';
  319. X
  320. X    s = d;
  321. X    while(*s != '|' && s >= line)
  322. X        s--;
  323. X    while(s >= line) {
  324. X        *s-- = '\0';
  325. X        while(*s != '|' && s > line)
  326. X            s--;
  327. X        if (*s == '|')
  328. X            s++;
  329. X        if (*s == '\0') {
  330. X            continue;
  331. X        }
  332. X        if (access(bindir(s), 2) == -1) {
  333. X            if (errno != ENOENT) 
  334. X                quit(errno, "can't access directory '%s'",
  335. X                     bindir(s));
  336. X            if (mkdir(bindir(s), 0777) == -1) 
  337. X                quit(errno, "can't make directory '%s'",
  338. X                     bindir(s));
  339. X        }
  340. X        if (last[0] == '\0') {
  341. X            fd = open(binfile(s), O_WRONLY | O_CREAT | O_EXCL,
  342. X                      0666);
  343. X            if (fd == -1) {
  344. X                if (errno != EEXIST)
  345. X                    quit(errno, "can't open file '%s'",
  346. X                         binfile(s));
  347. X                if (unlink(binfile(s)) == -1) 
  348. X                    quit(errno, "can't unlink file '%s'",
  349. X                         binfile(s));
  350. X                fd = open(binfile(s),
  351. X                      O_WRONLY | O_CREAT | O_EXCL, 0666);
  352. X                if (fd == -1)
  353. X                    quit(errno, "can't create file '%s'",
  354. X                         binfile(s));
  355. X            }
  356. X            writebin(fd, name);
  357. X            close(fd);
  358. X            strncpy(last, binfile(s), MAX_LINE);
  359. X            last[MAX_LINE] = '\0';
  360. X        } else {
  361. X            if (access(binfile(s), 0) == -1) {
  362. X                if (errno != ENOENT)
  363. X                    quit(errno, "can't access file '%s'",
  364. X                         binfile(s));
  365. X            } else {
  366. X                if (unlink(binfile(s)) == -1) 
  367. X                    quit(errno, "can't unlink file '%s'",
  368. X                         binfile(s));
  369. X            }
  370. X            if (link(last, binfile(s)) == -1)
  371. X                quit(errno, "can't link '%s' to '%s'",
  372. X                     last, binfile(s));
  373. X        }
  374. X        s--;
  375. X    }
  376. X    return;
  377. X}
  378. X
  379. X/* output an entry in terminfo source format */
  380. Xvoid outputinfo(name)
  381. Xchar *name; {
  382. X    int i;
  383. X    char line[MAX_LINE];
  384. X
  385. X    printf("%s,\n", name);
  386. X
  387. X    for(i = 0; i < NUM_OF_BOOLS; i++)
  388. X        if (_term_buf.bools[i] == 0) {
  389. X            sprintf(line, "%s@", boolnames[i]);
  390. X            putstr(line);
  391. X        } else if (_term_buf.bools[i] != -1)
  392. X            putstr(boolnames[i]);
  393. X
  394. X    for(i = 0; i < NUM_OF_NUMS; i++)
  395. X        if (_term_buf.nums[i] == -1) {
  396. X            sprintf(line, "%s@", numnames[i]);
  397. X            putstr(line);
  398. X        } else if (_term_buf.nums[i] != -2) {
  399. X            sprintf(line, "%s#%d", numnames[i], _term_buf.nums[i]);
  400. X            putstr(line);
  401. X        }
  402. X
  403. X    for(i = 0; i < NUM_OF_STRS; i++)
  404. X        if (_term_buf.strs[i] == NULL) {
  405. X            sprintf(line, "%s@", strnames[i]);
  406. X            putstr(line);
  407. X        } else if (_term_buf.strs[i] != (char *) -1) {
  408. X            sprintf(line, "%s=%s", strnames[i],
  409. X                convstr(_term_buf.strs[i], i));
  410. X            putstr(line);
  411. X        }
  412. X    putstr(NULL);
  413. X}
  414. X
  415. X/* convert a terminfo entry to binary format */
  416. Xvoid convtinfo() {
  417. X    int i, r;
  418. X
  419. X    termcap = 0;
  420. X
  421. X    for(i = 0; i < NUM_OF_BOOLS; i++)
  422. X        _term_buf.bools[i] = -1;
  423. X    for(i = 0; i < NUM_OF_NUMS; i++)
  424. X        _term_buf.nums[i] = -2;
  425. X    for(i = 0; i < NUM_OF_STRS; i++)
  426. X        _term_buf.strs[i] = (char *) -1;
  427. X
  428. X    _term_buf.name_all = NULL;
  429. X
  430. X    r = _gettinfo(buf, &_term_buf, path);
  431. X    if (r != 0) {
  432. X        if (lineno == 0)
  433. X            quit(-1, "problem reading entry");
  434. X        else {
  435. X            warn();
  436. X            fprintf(stderr, "problem reading entry\n");
  437. X        }
  438. X    }
  439. X
  440. X    if (compile)
  441. X        outputbin(_term_buf.name_all);
  442. X    else
  443. X        outputinfo(_term_buf.name_all);
  444. X    return;
  445. X}
  446. X
  447. X/* convert a terminfo binary to terminfo source */
  448. Xvoid convtbin() {
  449. X    int i, r;
  450. X
  451. X    termcap = 0;
  452. X
  453. X    for(i = 0; i < NUM_OF_BOOLS; i++)
  454. X        _term_buf.bools[i] = -1;
  455. X    for(i = 0; i < NUM_OF_NUMS; i++)
  456. X        _term_buf.nums[i] = -2;
  457. X    for(i = 0; i < NUM_OF_STRS; i++)
  458. X        _term_buf.strs[i] = (char *) -1;
  459. X
  460. X    _term_buf.name_all = NULL;
  461. X
  462. X    r = _gettbin(buf, &_term_buf);
  463. X    if (r != 0) {
  464. X        if (lineno == 0)
  465. X            quit(-1, "problem reading entry");
  466. X        else {
  467. X            warn();
  468. X            fprintf(stderr, "problem reading entry\n");
  469. X        }
  470. X    }
  471. X
  472. X    outputinfo(_term_buf.name_all);
  473. X
  474. X    return;
  475. X}
  476. X
  477. X/* convert a termcap entry to terminfo format */
  478. Xvoid convtcap() {
  479. X    int i, r;
  480. X    char *name;
  481. X
  482. X    termcap = 1;
  483. X
  484. X    for(i = 0; i < NUM_OF_BOOLS; i++)
  485. X        _term_buf.bools[i] = -1;
  486. X    for(i = 0; i < NUM_OF_NUMS; i++)
  487. X        _term_buf.nums[i] = -2;
  488. X    for(i = 0; i < NUM_OF_STRS; i++)
  489. X        _term_buf.strs[i] = (char *) -1;
  490. X
  491. X    _term_buf.name_all = NULL;
  492. X
  493. X    r = _gettcap(buf, &_term_buf, path);
  494. X    if (r != 0) {
  495. X        if (lineno == 0)
  496. X            quit(-1, "problem reading entry");
  497. X        else {
  498. X            warn();
  499. X            fprintf(stderr, "problem reading entry\n");
  500. X        }
  501. X    }
  502. X
  503. X    if (dodefault && !continued)
  504. X        _tcapdefault();
  505. X
  506. X    _tcapconv();
  507. X
  508. X    name = _term_buf.name_all;
  509. X    if (name[0] != '\0' && name[1] != '\0' && name[2] == '|')
  510. X        name += 3;    /* skip the 2 letter code */
  511. X
  512. X    if (compile) 
  513. X        outputbin(name);
  514. X    else
  515. X        outputinfo(name);
  516. X}
  517. X
  518. Xvoid convbinfile(file)
  519. Xchar *file; {
  520. X    register FILE *f;
  521. X    int r;
  522. X
  523. X    f = fopen(file, "r");
  524. X
  525. X    if (f == NULL)
  526. X        quit(errno, "can't open '%s'", file);
  527. X
  528. X    r = fread(buf, sizeof(char), MAX_BUF, f);
  529. X    if (r < 12 || buf[0] != 032 || buf[1] != 01)
  530. X        quit(-1, "file '%s' corrupted", file);
  531. X
  532. X    convtbin();
  533. X}
  534. X
  535. X/* convert a termcap file to terminfo format */
  536. Xvoid convtcfile(file)
  537. Xchar *file; {
  538. X    int nocolon;
  539. X    register int c;
  540. X    register char *d;
  541. X    register FILE *f;
  542. X
  543. X    f = fopen(file, "r");
  544. X
  545. X    if (f == NULL)
  546. X        quit(errno, "can't open '%s'", file);
  547. X
  548. X    d = buf;
  549. X    c = getc(f);
  550. X    while(c != EOF) {
  551. X        lineno++;
  552. X        if (c == '#') {
  553. X            if (keepcomments) {
  554. X                do {
  555. X                    putchar(c);
  556. X                    c = getc(f);
  557. X                } while(c != '\n' && c != EOF);
  558. X                putchar('\n');
  559. X            } else
  560. X                do
  561. X                    c = getc(f);
  562. X                while(c != '\n' && c != EOF);
  563. X            if (c != EOF)
  564. X                c = getc(f);
  565. X            continue;
  566. X        }
  567. X        while(isspace(c) && c != '\n')
  568. X            c = getc(f);
  569. X        if (c == '\n' && buf == d) {
  570. X            c = getc(f);
  571. X            continue;
  572. X        }
  573. X
  574. X        while(c != EOF) {
  575. X            if (c == '\\') {
  576. X                c = getc(f);
  577. X                if (c == EOF) 
  578. X                    break;
  579. X                if (c == '\n') {
  580. X                    c = getc(f);
  581. X                    break;
  582. X                }
  583. X                *d++ = '\\';
  584. X                *d++ = c;
  585. X            } else if (c == '\n') {
  586. X                *d = '\0';
  587. X                if (*--d == ':') {
  588. X                    nocolon = 0;
  589. X                    *d-- = '\0';
  590. X                } else {
  591. X                    nocolon = 1;
  592. X                }
  593. X                while(d > buf && *d != ':')
  594. X                    d--;
  595. X                if (d[1] == 't' && d[2] == 'c' && d[3] == '=') {
  596. X                    continued = 1;
  597. X                    d[1] = '\0';
  598. X                } else
  599. X                    continued = 0;
  600. X                convtcap();
  601. X                if (nocolon) {
  602. X                    warn();
  603. X                    fprintf(stderr,
  604. X                        "entry doesn't end with :\n");
  605. X                }
  606. X                _term_buf.strbuf = _endstr();
  607. X                _del_strs(&_term_buf);
  608. X                if (continued) {
  609. X                    printf("\tuse=%s,\n", d + 4);
  610. X                }
  611. X                d = buf;
  612. X                c = getc(f);
  613. X                break;
  614. X            } else
  615. X                *d++ = c;
  616. X            c = getc(f);
  617. X        }
  618. X    }
  619. X}
  620. X
  621. Xstatic int getln(f, buf, len)
  622. XFILE *f;
  623. Xregister char *buf;
  624. Xint len; {
  625. X    register int c, i = 0;
  626. X
  627. X    while((c = getc(f)) == '#') {
  628. X        lineno++;
  629. X        if (keepcomments) {
  630. X            putchar('#');
  631. X            while((c = getc(f)) != '\n') {
  632. X                if (c == EOF)
  633. X                    return -1;
  634. X                putchar(c);
  635. X            }
  636. X            putchar('\n');
  637. X        } else {
  638. X            while((c = getc(f)) != '\n')
  639. X                if (c == EOF)
  640. X                    return -1;
  641. X        }
  642. X    }
  643. X
  644. X    lineno++;
  645. X    while(c != '\n') {
  646. X        if (c == EOF)
  647. X            return -1;
  648. X        if (i < len) {
  649. X            i++;
  650. X            *buf++ = c;
  651. X        }
  652. X        c = getc(f);
  653. X    }
  654. X
  655. X    while(isspace(*(buf-1))) {
  656. X        buf--;
  657. X        i--;
  658. X    }
  659. X
  660. X    *buf = '\0';
  661. X    return i;
  662. X}
  663. X
  664. Xvoid convtifile(file)
  665. Xchar *file; {
  666. X    static char line[MAX_LINE+1];
  667. X    int l;
  668. X    int n;
  669. X    register FILE *f;
  670. X
  671. X    f = fopen(file, "r");
  672. X
  673. X    if (f == NULL)
  674. X        quit(errno, "can't open '%s'", file);
  675. X
  676. X    lineno = 0;
  677. X
  678. X    l = getln(f, line, MAX_LINE);
  679. X    while(l != -1) {
  680. X        if (line[l-1] == ':') {
  681. X            strncpy(buf, line, MAX_BUF);
  682. X            convtcap();
  683. X        } else if (line[l-1] == '\\') {
  684. X            n = MAX_BUF;
  685. X            do {
  686. X                buf[--l] = '\0';
  687. X                if (n > 0)
  688. X                    strncpy(buf + MAX_BUF - n, line, n);
  689. X                n -= l;
  690. X                l = getln(f, line, MAX_LINE);
  691. X            } while(l != -1 && line[l-1] == '\\');
  692. X            if (n > 0 && l != -1)
  693. X                strncpy(buf + MAX_BUF - n, line, n);
  694. X            convtcap();
  695. X        } else if (line[l-1] == ',') {
  696. X            n = MAX_BUF;
  697. X            do {
  698. X                if (n > 0)
  699. X                    strncpy(buf + MAX_BUF - n, line, n);
  700. X                n -= l;
  701. X                l = getln(f, line, MAX_LINE);
  702. X            } while(l != -1 && isspace(line[0]));
  703. X#if 0
  704. X            printf("buf = '%s'\n", buf);
  705. X#endif
  706. X            convtinfo();
  707. X            continue;
  708. X        } else if (line[0] != '\0') {
  709. X            warn();
  710. X            fprintf(stderr, "malformed line\n");
  711. X            if (keepcomments) {
  712. X                printf("%?%s\n", line);
  713. X            }
  714. X        }
  715. X        l = getln(f, line, MAX_LINE);
  716. X    }
  717. X    return;
  718. X}
  719. X
  720. X/* dummy routine for quit */
  721. X/* ARGSUSED */
  722. Xvoid do_cleanup(e)
  723. Xint e; {
  724. X    return;
  725. X}
  726. X
  727. X/* print out usage, called by quit */
  728. X/* ARGSUSED */
  729. Xvoid usage(e)
  730. Xint e; {
  731. X    fprintf(stderr,
  732. X"usage: %s [-b] [-c [-OUGd]] [-i] [-B [-D dir]] [-I] [-k] [-t term] [file]\n",
  733. X        prg_name);
  734. X    return;
  735. X}
  736. X
  737. Xint main(argc, argv)
  738. Xint argc;
  739. Xchar **argv; {
  740. X    char *getenv();
  741. X    extern char *optarg;
  742. X    extern int optind;
  743. X    extern int opterr;
  744. X    char *term = NULL;
  745. X    char *file = NULL;
  746. X    int r;
  747. X    char c;
  748. X
  749. X    prg_name = strrchr(argv[0], '/');
  750. X    if (prg_name == NULL)
  751. X        prg_name = argv[0];
  752. X    else
  753. X        prg_name++;
  754. X
  755. X    cleanup = usage;
  756. X
  757. X    opterr = 0;
  758. X
  759. X    if (strcmp(prg_name, "tic") == 0)
  760. X        compile = 1;
  761. X
  762. X    while ((c = getopt(argc, argv, "bciBIOGUdkd:t:")) != -1) {
  763. X        switch(c) {
  764. X        case 'O':
  765. X            noOT = 0;
  766. X            break;
  767. X        case 'G':
  768. X            noGNU = 0;
  769. X            break;
  770. X        case 'U':
  771. X            noUW = 0;
  772. X            break;
  773. X        case 'D':
  774. X            if (directory != NULL)
  775. X                quit(-1, "more than one directory specified");
  776. X            directory = optarg;
  777. X            break;
  778. X        case 't':
  779. X            if (term != NULL)
  780. X                quit(-1, "more than one terminal specified");
  781. X            term = optarg;
  782. X            break;
  783. X        case 'd': dodefault = 0; break;
  784. X        case 'k': keepcomments = 1; break;
  785. X        case 'b': from_tbin = 1; break;
  786. X        case 'c': from_tcap = 1; break;
  787. X        case 'i': from_tinfo = 1; break;
  788. X        case 'B': compile = 1; break;
  789. X        case 'I': compile = 0; break;
  790. X        case '?': 
  791. X        default:
  792. X            quit(-1, "bad or missing command line argument");
  793. X        }
  794. X    }
  795. X
  796. X    if (optind == argc - 1)
  797. X        file = argv[optind];
  798. X    else if (optind != argc)
  799. X        quit(-1, "wrong number of arguments");
  800. X
  801. X    if (from_tbin + from_tcap + from_tinfo > 1) 
  802. X        quit(-1, "more than one input file type specified");
  803. X
  804. X    if (!from_tcap && !from_tinfo && !from_tbin && file != NULL) {
  805. X        if (strcmp(prg_name, "cap2info") == 0
  806. X            || strcmp(prg_name, "captoinfo") == 0)
  807. X            from_tcap = 1;
  808. X        else if (strcmp(prg_name, "tic") == 0)
  809. X            from_tinfo = 1;
  810. X        else 
  811. X            quit(-1, "no input file type specified");
  812. X    }
  813. X
  814. X    if (from_tbin && compile) 
  815. X        quit(-1, "can't convert from binary to binary");
  816. X
  817. X    if (file != NULL) {
  818. X        if (from_tbin) {
  819. X            cleanup = do_cleanup;
  820. X            convbinfile(file);
  821. X            exit(0);
  822. X        }
  823. X        if (!compile)
  824. X            path = _buildpath(file, 0, NULL, -1);
  825. X        else {
  826. X            path = _buildpath(file, 0,
  827. X                      "$TERMINFO", 2,
  828. X                      "$MYTERMINFO", 2,
  829. X#ifdef TERMINFODIR
  830. X                      TERMINFODIR, 0,
  831. X#endif
  832. X                      NULL, -1);
  833. X        }
  834. X        if (path == NULL)
  835. X            quit(-1, "can't build path");
  836. X        if (term == NULL) {
  837. X            cleanup = do_cleanup;
  838. X            if (from_tcap && !compile)
  839. X                convtcfile(file);
  840. X            else 
  841. X                convtifile(file);
  842. X            exit(0);
  843. X        }
  844. X    } else if (from_tcap && !compile)
  845. X        path = _buildpath("$TERMCAP", 1,
  846. X#ifdef TERMCAPFILE
  847. X                  TERMCAPFILE, 0,
  848. X#endif
  849. X                  NULL, -1);
  850. X    else if (from_tinfo || from_tbin)
  851. X        path = _buildpath("$TERMINFO", 2,
  852. X                  "$MYTERMINFO", 2,
  853. X#ifdef TERMINFODIR
  854. X                  TERMINFODIR, 0,
  855. X#endif
  856. X#ifdef TERMINFOSRC
  857. X                  TERMINFOSRC, 0,
  858. X#endif
  859. X                  NULL, -1);
  860. X    else if (from_tcap)
  861. X        path = _buildpath("$TERMCAP", 1,
  862. X#ifdef TERMCAPFILE
  863. X                  TERMCAPFILE, 0,
  864. X#endif
  865. X                  "$TERMINFO", 2,
  866. X                  "$MYTERMINFO", 2,
  867. X#ifdef TERMINFODIR
  868. X                  TERMINFODIR, 0,
  869. X#endif
  870. X                  NULL, -1);
  871. X    else 
  872. X        path = _buildpath("$TERMINFO", 2,
  873. X                  "$MYTERMINFO", 2,
  874. X                  "$TERMCAP", 1,
  875. X#ifdef TERMINFODIR
  876. X                  TERMINFODIR, 0,
  877. X#endif
  878. X#ifdef TERMINFOSRC
  879. X                  TERMINFOSRC, 0,
  880. X#endif
  881. X#ifdef TERMCAPFILE
  882. X                  TERMCAPFILE, 0,
  883. X#endif
  884. X                  NULL, -1);
  885. X    if (term == NULL) {
  886. X        term = getenv("TERM");
  887. X        if (term == NULL)
  888. X            quit(-1, "no terminal type given");
  889. X    }
  890. X
  891. X    cleanup = do_cleanup;
  892. X
  893. X    r = _findterm(term, path, buf);
  894. X    switch(r) {
  895. X    case 1:
  896. X        convtcap();
  897. X        break;
  898. X    case 2:
  899. X        convtinfo();
  900. X        break;
  901. X    case 3:
  902. X        if (compile)
  903. X            quit(-1, "entry is already compiled");
  904. X        convtbin();
  905. X        break;
  906. X    default:
  907. X        quit(-1, "can't find a terminal entry for '%s'", term);
  908. X    }
  909. X
  910. X    exit(0);
  911. X    return 0;
  912. X}
  913. SHAR_EOF
  914. echo "File conv.c is complete"
  915. chmod 0644 conv.c || echo "restore of conv.c fails"
  916. case $TOUCH in
  917. can)
  918.     touch -am 0402044690 conv.c
  919.     ;;
  920. esac
  921. set `wc -c conv.c`;Wc_c=$1
  922. case "$Wc_c" in
  923. "25042") ;;
  924. *) echo original size 25042, current size $Wc_c ;;
  925. esac
  926. # ============= bsearch.c ==============
  927. echo "x - extracting bsearch.c (Text)"
  928. sed 's/^X//' << 'SHAR_EOF' > bsearch.c &&
  929. X/*
  930. X * bsearch.c
  931. X *
  932. X * This is something I found on watmath. I've made some minor changes for use
  933. X * in this package.
  934. X *
  935. X * 90/03/22 03:43:48
  936. X */
  937. X
  938. X#if 0
  939. X#ifndef lint
  940. Xstatic char *RCSid = "$OHeader: /usr/mfcf/src/accounts/libuw/RCS/bsearch.c,v 1.1 88/06/11 20:41:48 root Exp $";
  941. X#endif
  942. X#endif
  943. X
  944. X#include "defs.h"
  945. X
  946. X#ifdef USE_MYBSEARCH
  947. X#ifdef USE_SCCS_IDS
  948. Xstatic char SCCSid[] = "@(#) bsearch.c 1.1";
  949. X#endif
  950. X/*
  951. X * bsearch - find an element of a sorted vector
  952. X *
  953. X *    found = bsearch(key, array, dimension, width, compare)
  954. X *        returns a pointer to the specified element in the array,
  955. X *        or (char*)0 if the element can't be found.
  956. X *    key
  957. X *        pointer to the element to be searched for in the array
  958. X *    array
  959. X *        address of an array of elements
  960. X *    dimension
  961. X *        number of elements in the array
  962. X *    width
  963. X *        sizeof(type) of each element
  964. X *    compare
  965. X *        pointer to a function taking (char *) pointers to two elements
  966. X *        and returning <0, 0, or >0 as the first element comes before,
  967. X *        at, or after the second element.  A compare function is provided
  968. X *        for comparing strings.
  969. X*/
  970. X#if 0
  971. X/*
  972. X * $OLog:    bsearch.c,v $
  973. X * Revision 1.1  88/06/11  20:41:48  root
  974. X * Initial revision
  975. X * 
  976. X*/
  977. X#endif
  978. X
  979. X#undef bsearch
  980. X
  981. X    anyptr
  982. X_bsearch(key, array, dimension, width, compare)
  983. X    anyptr key;
  984. X    anyptr array;
  985. X    int dimension;
  986. X    size_t width;
  987. X#ifdef USE_PROTOTYPES
  988. X    int (*compare)(anyptr, anyptr);
  989. X#else
  990. X    int (*compare)();
  991. X#endif
  992. X{
  993. X    register size_t start;   /* offset to start of current interval */
  994. X    register size_t end;     /* offset to end+1 of current interval */
  995. X    register size_t middle;  /* offset to middle of current interval */
  996. X    auto int status;
  997. X
  998. X    width /= sizeof(char);
  999. X
  1000. X    start = 0;
  1001. X    middle = 0;
  1002. X    end = dimension;
  1003. X
  1004. X    while (start < end) {
  1005. X
  1006. X        middle = (start + end) / 2;
  1007. X
  1008. X        status = (*compare)(key, ((char *)array + middle*width));
  1009. X
  1010. X        if (status < 0)
  1011. X            end = middle;
  1012. X
  1013. X        else if (status > 0)
  1014. X            start = middle + 1;
  1015. X
  1016. X        else return (anyptr)(((char *)array) + middle*width);
  1017. X    }
  1018. X
  1019. X    return  0;
  1020. X}
  1021. X
  1022. X#endif /* USE_MYBSEARCH */
  1023. SHAR_EOF
  1024. chmod 0644 bsearch.c || echo "restore of bsearch.c fails"
  1025. case $TOUCH in
  1026. can)
  1027.     touch -am 0402044690 bsearch.c
  1028.     ;;
  1029. esac
  1030. set `wc -c bsearch.c`;Wc_c=$1
  1031. case "$Wc_c" in
  1032. "1993") ;;
  1033. *) echo original size 1993, current size $Wc_c ;;
  1034. esac
  1035. # ============= strtok.c ==============
  1036. echo "x - extracting strtok.c (Text)"
  1037. sed 's/^X//' << 'SHAR_EOF' > strtok.c &&
  1038. X/*
  1039. X * strtok.c
  1040. X *
  1041. X * By Ross Ridge
  1042. X * Public Domain
  1043. X * 90/03/22 03:43:48
  1044. X *
  1045. X */
  1046. X
  1047. X#ifdef TEST
  1048. X
  1049. X#ifndef LIBTEST
  1050. X#define USE_MYSTRTOK
  1051. X#endif
  1052. X#include <stdio.h>
  1053. X
  1054. X#else
  1055. X
  1056. X#include "defs.h"
  1057. X
  1058. X#endif
  1059. X
  1060. X#ifdef USE_MYSTRTOK
  1061. X
  1062. X#ifdef USE_SCCS_IDS
  1063. Xstatic char SCCSid[] = "@(#) strtok.c 1.1";
  1064. X#endif
  1065. Xstatic char *pos = NULL;
  1066. X
  1067. Xchar *strtok(s1, s2)
  1068. Xchar *s1, *s2; {
  1069. X    register char *s, *d;
  1070. X    char *start;
  1071. X
  1072. X    if (s1 == NULL) {
  1073. X        s = pos;
  1074. X        if (s == NULL)
  1075. X            return NULL;
  1076. X    } else {
  1077. X        s = s1;
  1078. X        while(*s != '\0') {
  1079. X            d = s2;
  1080. X            while(*d != *s) {
  1081. X                if (*d == '\0')
  1082. X                    goto first; /* Oh, no! A goto! */
  1083. X                d++;
  1084. X            }
  1085. X            s++;
  1086. X        }
  1087. X        pos = NULL;
  1088. X        return NULL;
  1089. X    }
  1090. X
  1091. Xfirst:
  1092. X    start = s;
  1093. X    while(*s != '\0') {
  1094. X        d = s2;
  1095. X        while(*d != '\0') {
  1096. X            if (*s == *d) {
  1097. X                *s++ = '\0';
  1098. X                while(*s != '\0') {
  1099. X                    d = s2;
  1100. X                    while(*s != *d) {
  1101. X                        if (*d == '\0') {
  1102. X                            pos = s;
  1103. X                            return start;
  1104. X                        }
  1105. X                        d++;
  1106. X                    }
  1107. X                    s++;
  1108. X                }
  1109. X                pos = NULL;
  1110. X                return start;
  1111. X            }
  1112. X            d++;
  1113. X        }
  1114. X        s++;
  1115. X    }
  1116. X    pos = NULL;
  1117. X    return start;
  1118. X}
  1119. X
  1120. X#endif
  1121. X
  1122. X#ifdef TEST
  1123. Xint main(argc, argv)
  1124. Xint argc;
  1125. Xchar **argv; {
  1126. X    extern char *gets();
  1127. X    char *s;
  1128. X    char s1[100];
  1129. X    char *s2;
  1130. X
  1131. X    if (argc > 1)
  1132. X        s2 = argv[1];
  1133. X    else
  1134. X        s2 = " ";
  1135. X
  1136. X    while (gets(s1) != NULL) {
  1137. X        s = strtok(s1, s2);
  1138. X        while(s != NULL) {
  1139. X            printf("'%s'\n", s);
  1140. X            s = strtok(NULL, s2);
  1141. X        }
  1142. X    }
  1143. X
  1144. X    return 0;
  1145. X}
  1146. X#endif
  1147. SHAR_EOF
  1148. chmod 0644 strtok.c || echo "restore of strtok.c fails"
  1149. case $TOUCH in
  1150. can)
  1151.     touch -am 0402044690 strtok.c
  1152.     ;;
  1153. esac
  1154. set `wc -c strtok.c`;Wc_c=$1
  1155. case "$Wc_c" in
  1156. "1327") ;;
  1157. *) echo original size 1327, current size $Wc_c ;;
  1158. esac
  1159. # ============= fake_stdio.c ==============
  1160. echo "x - extracting fake_stdio.c (Text)"
  1161. sed 's/^X//' << 'SHAR_EOF' > fake_stdio.c &&
  1162. X/*
  1163. X * fake_stdio.c
  1164. X *
  1165. X * By Ross Ridge
  1166. X * Public Domain
  1167. X * 90/03/22 03:43:48
  1168. X *
  1169. X * fake some stdio functions
  1170. X *
  1171. X */
  1172. X
  1173. X#include "defs.h"
  1174. X
  1175. X#include <fcntl.h>
  1176. X
  1177. X#ifdef USE_FAKE_STDIO
  1178. X
  1179. X#ifdef USE_SCCS_IDS
  1180. Xstatic char SCCSid[] = "@(#) fake_stdio.c 1.1";
  1181. X#endif
  1182. X#include "fake_stdio.h"
  1183. X
  1184. XFILE _fake_files[] = {
  1185. X    {NULL, NULL, -1, {'\0'}},
  1186. X    {NULL, NULL, -1, {'\0'}},
  1187. X    {NULL, NULL, -1, {'\0'}},
  1188. X    {NULL, NULL, -1, {'\0'}},
  1189. X    {NULL, NULL, -1, {'\0'}}
  1190. X};
  1191. X
  1192. Xint _fillbuf(f)
  1193. Xregister FILE *f; {
  1194. X    register int r;
  1195. X
  1196. X    r = read(f->fd, f->buf, FAKE_BUF_SIZE);
  1197. X    if (r == -1 || r == 0) {
  1198. X        f->pos = f->end = f->buf;
  1199. X        return EOF;
  1200. X    }
  1201. X    f->pos = f->buf + 1;
  1202. X    f->end = f->buf + r;
  1203. X
  1204. X    return f->buf[0];
  1205. X}
  1206. X
  1207. Xint fgetc(f)
  1208. Xregister FILE *f; {
  1209. X    return getc(f);
  1210. X}
  1211. X
  1212. Xchar *fgets(s, n, f)
  1213. Xchar *s;
  1214. Xint n;
  1215. Xregister FILE *f; {
  1216. X    register char *d;
  1217. X    register int l;
  1218. X    register int c;
  1219. X
  1220. X    d = s;
  1221. X    l = 1;
  1222. X    while(l < n) {
  1223. X        if ((c = getc(f)) == EOF) {
  1224. X            if (l == 0)
  1225. X                return NULL;
  1226. X            break;
  1227. X        }
  1228. X        *d++ = c;
  1229. X        if (c == '\n') 
  1230. X            break;
  1231. X        l++;
  1232. X    }
  1233. X    *d = '\0';
  1234. X    return s;
  1235. X}
  1236. X
  1237. Xstatic FILE *_fdopen(fd)
  1238. Xint fd; {
  1239. X    register FILE *f;
  1240. X    int i, r;
  1241. X
  1242. X    for(f = _fake_files, i = 0; i < FILES; i++, f++) {
  1243. X        if (f->fd == -1) {
  1244. X            f->fd = fd;
  1245. X            r = read(fd, f->buf, FAKE_BUF_SIZE);
  1246. X            if (r == -1) {
  1247. X                f->pos = f->end = f->buf;
  1248. X                return NULL;
  1249. X            }
  1250. X            f->pos = f->buf;
  1251. X            f->end = f->buf + r;
  1252. X            return f;
  1253. X        }
  1254. X    }
  1255. X    return NULL;
  1256. X}
  1257. X
  1258. XFILE *fopen(name, type)
  1259. Xchar *name;
  1260. Xchar *type; {
  1261. X    FILE *f;
  1262. X    int fd;
  1263. X
  1264. X    if (strcmp(type, "r") != 0)
  1265. X        return NULL;
  1266. X    fd = open(name, O_RDONLY);
  1267. X    if (fd == -1)
  1268. X        return NULL;
  1269. X    f = _fdopen(fd);
  1270. X    if (f == NULL)
  1271. X        close(fd);
  1272. X    return f;
  1273. X}
  1274. X
  1275. XFILE *fdopen(fd, type)
  1276. Xint fd;
  1277. Xchar *type; {
  1278. X    if (strcmp(type, "r") != 0)
  1279. X        return NULL;
  1280. X    return _fdopen(fd);
  1281. X}
  1282. X
  1283. X#endif /* USE_FAKE_STDIO */
  1284. SHAR_EOF
  1285. chmod 0644 fake_stdio.c || echo "restore of fake_stdio.c fails"
  1286. case $TOUCH in
  1287. can)
  1288.     touch -am 0402044690 fake_stdio.c
  1289.     ;;
  1290. esac
  1291. set `wc -c fake_stdio.c`;Wc_c=$1
  1292. case "$Wc_c" in
  1293. "1740") ;;
  1294. *) echo original size 1740, current size $Wc_c ;;
  1295. esac
  1296. # ============= sprintf.c ==============
  1297. echo "x - extracting sprintf.c (Text)"
  1298. sed 's/^X//' << 'SHAR_EOF' > sprintf.c &&
  1299. X/*
  1300. X * sprintf.c
  1301. X *
  1302. X * By Ross Ridge
  1303. X * Public Domain
  1304. X * 90/03/27 18:29:37
  1305. X *
  1306. X */
  1307. X
  1308. X#include "defs.h"
  1309. X
  1310. X#include <ctype.h>
  1311. X
  1312. X#ifdef USE_SCCS_IDS
  1313. Xstatic char SCCSid[] = "@(#) sprintf.c 1.2";
  1314. X#endif
  1315. X#ifdef TEST
  1316. X#define USE_FAKE_STDIO
  1317. X#undef PRINTF
  1318. X#define sprintf _sprintf
  1319. X#endif
  1320. X
  1321. X#ifdef USE_FAKE_STDIO
  1322. X
  1323. X#ifdef PRINTF
  1324. X#undef putchar
  1325. X#define PUTCHAR(c) (cnt++, putchar(c))
  1326. X#else
  1327. X#define PUTCHAR(c) (*s++ = c)
  1328. X#endif
  1329. X
  1330. X#ifdef PRINTF
  1331. X#ifdef USE_STDARG
  1332. X#ifdef USE_PROTOTYPES
  1333. Xint printf(register char *fmt, ...) {
  1334. X#else
  1335. Xint printf(fmt)
  1336. Xregister char *fmt; {
  1337. X#endif
  1338. X#else
  1339. Xint printf(va_alist)
  1340. Xva_dcl {
  1341. X    register char *fmt;
  1342. X#endif
  1343. X    register int cnt;
  1344. X#else /* PRINTF */
  1345. X#ifdef lint
  1346. X/* VARARGS1 */
  1347. Xint sprintf(str, fmt)
  1348. Xchar *str;
  1349. Xchar *fmt; {
  1350. X#else /* lint */
  1351. X#ifdef USE_STDARG
  1352. X#ifdef USE_PROTOTYPES
  1353. Xint sprintf(char *str, register char *fmt, ...) {
  1354. X#else /* USE_PROTOTYPES */
  1355. Xint sprintf(str, fmt)
  1356. Xchar *str;
  1357. Xregister char *fmt; {
  1358. X#endif /* else USE_PROTOTYPES */
  1359. X#else /* USE_STDARG */
  1360. Xint sprintf(va_alist)
  1361. Xva_dcl {
  1362. X    register char *fmt;
  1363. X    char *str;
  1364. X#endif /* else USE_STDARG */
  1365. X#endif /* else lint */
  1366. X    register char *s;
  1367. X#endif /* else PRINTF */
  1368. X    int minus;
  1369. X    int sharp;
  1370. X    int space;
  1371. X    int plus;
  1372. X    int zero;
  1373. X    int ell;
  1374. X    int prec;
  1375. X    int width;
  1376. X    int sign;
  1377. X    int pad;
  1378. X    char buf[100];
  1379. X    register long n;
  1380. X    register unsigned long u;
  1381. X    register char *d;
  1382. X    int l;
  1383. X    int k;
  1384. X    va_list args;
  1385. X
  1386. X#ifdef lint
  1387. X    args = (va_list) 0;
  1388. X#else
  1389. X#ifdef USE_STDARG
  1390. X    va_start(args, fmt);
  1391. X#else
  1392. X    va_start(args);
  1393. X#ifndef PRINTF
  1394. X    str = va_arg(args, char *);
  1395. X#endif
  1396. X    fmt = va_arg(args, char *);
  1397. X#endif
  1398. X#endif /* else lint */
  1399. X    
  1400. X
  1401. X#ifdef PRINTF
  1402. X    cnt = 0;
  1403. X#else
  1404. X    s = str;
  1405. X#endif
  1406. X
  1407. X    while(*fmt != '\0') {
  1408. X        if (*fmt == '%') {
  1409. X            fmt++;
  1410. X            if (*fmt == '%' || *fmt == '\0') {
  1411. X                PUTCHAR('%');
  1412. X                fmt++;
  1413. X                continue;
  1414. X            }
  1415. X            minus = plus = sharp = space = zero = ell = 0;
  1416. X            width = 0;
  1417. X            prec = -1;
  1418. X            do {
  1419. X                switch(*fmt) {
  1420. X                case '-': minus = 1; continue;
  1421. X                case '+': plus = 1; continue;
  1422. X                case ' ': space = 1; continue;
  1423. X                case '#': sharp = 1; continue;
  1424. X                }
  1425. X                break;
  1426. X            } while (*++fmt != '\0');
  1427. X            if (*fmt == '0') {
  1428. X                zero = 1;
  1429. X                fmt++;
  1430. X            }
  1431. X            if (*fmt == '*') {
  1432. X                width = va_arg(args, int);
  1433. X                fmt++;
  1434. X            } else if (isdigit(*fmt)) {
  1435. X                width = *fmt++ - '0';
  1436. X                while(isdigit(*fmt))
  1437. X                    width = 10 * width + *fmt++ - '0';
  1438. X            }
  1439. X            if (*fmt == '.') {
  1440. X                prec = 0;
  1441. X                fmt++;
  1442. X                if (*fmt == '*') {
  1443. X                    prec = va_arg(args, int);
  1444. X                    fmt++;
  1445. X                } else {
  1446. X                    while(isdigit(*fmt))
  1447. X                        prec = 10 * prec + *fmt++ - '0';
  1448. X                }
  1449. X            }
  1450. X            if (*fmt == 'l') {
  1451. X                ell = 1;
  1452. X                fmt++;
  1453. X            }
  1454. X            sign = 0;
  1455. X            l = 0;
  1456. X            d = buf;
  1457. X            switch(*fmt) {
  1458. X            case 'd':
  1459. X            case 'i':
  1460. X                if (ell)
  1461. X                    n = va_arg(args, long);
  1462. X                else
  1463. X                    n = va_arg(args, int);
  1464. X                if (n < 0) {
  1465. X                    sign = -1;
  1466. X                    n = -n;
  1467. X                } else {
  1468. X                    sign = 1;
  1469. X                }
  1470. X                while(n != 0) {
  1471. X                    *d++ = (n % 10) + '0';
  1472. X                    n /= 10;
  1473. X                }
  1474. X                break;
  1475. X            case 'o':
  1476. X                if (ell)
  1477. X                    u = va_arg(args, unsigned long);
  1478. X                else
  1479. X                    u = va_arg(args, unsigned );
  1480. X                while(u != 0) {
  1481. X                    *d++ = (u & 7) + '0';
  1482. X                    u >>= 3;
  1483. X                }
  1484. X                if (sharp)
  1485. X                    l = 1;
  1486. X                break;
  1487. X            case 'u':
  1488. X                if (ell)
  1489. X                    u = va_arg(args, unsigned long);
  1490. X                else
  1491. X                    u = va_arg(args, unsigned );
  1492. X                while(u != 0) {
  1493. X                    *d++ = (u % 10) + '0';
  1494. X                    u /= 10;
  1495. X                }
  1496. X                break;
  1497. X            case 'x':
  1498. X                if (ell)
  1499. X                    u = va_arg(args, unsigned long);
  1500. X                else
  1501. X                    u = va_arg(args, unsigned );
  1502. X                while(u != 0) {
  1503. X                    *d++ = "0123456789abcdef"[u & 15];
  1504. X                    u >>= 4;
  1505. X                }
  1506. X                if (sharp)
  1507. X                    l += 2;
  1508. X                break;
  1509. X            case 'X':
  1510. X                if (ell)
  1511. X                    u = va_arg(args, unsigned long);
  1512. X                else
  1513. X                    u = va_arg(args, unsigned );
  1514. X                while(u != 0) {
  1515. X                    /* just to be silly... */
  1516. X                    *d++ = (u & 15)["0123456789ABCDEF"];
  1517. X                    u >>= 4;
  1518. X                }
  1519. X                if (sharp)
  1520. X                    l += 2;
  1521. X                break;
  1522. X            case 's':
  1523. X                d = va_arg(args, char *);
  1524. X                l = strlen(d);
  1525. X                break;
  1526. X            case 'c':
  1527. X                buf[0] = va_arg(args, int);
  1528. X                l = 1;
  1529. X                break;
  1530. X            default:
  1531. X                PUTCHAR(*fmt++);
  1532. X                continue;
  1533. X            }
  1534. X            if (*fmt == 's' || *fmt == 'c') {
  1535. X                if (prec != -1 && l > prec) 
  1536. X                    l = prec;
  1537. X                pad = width - l;
  1538. X                if (zero) 
  1539. X                    while(pad-- > 0)
  1540. X                        PUTCHAR('0');
  1541. X                else if (!minus)
  1542. X                    while(pad-- > 0)
  1543. X                        PUTCHAR(' ');
  1544. X                while(l-- > 0)
  1545. X                    PUTCHAR(*d++);
  1546. X                if (minus)
  1547. X                    while(pad-- > 0)
  1548. X                        PUTCHAR(' ');
  1549. X            } else {
  1550. X                if (prec == -1)
  1551. X                    prec = 1;
  1552. X                k = d - buf;
  1553. X                if (k < prec)
  1554. X                    l += prec;
  1555. X                else
  1556. X                    l += k;
  1557. X                if (sign == -1)
  1558. X                    l++;
  1559. X                else if (sign == 1 && (space || plus))
  1560. X                    l++;
  1561. X                pad = width - l;
  1562. X                if (zero)
  1563. X                    while(pad-- > 0)
  1564. X                        PUTCHAR('0');
  1565. X                else if (!minus)
  1566. X                    while(pad-- > 0)
  1567. X                        PUTCHAR(' ');
  1568. X                if (*fmt == 'x' && sharp) {
  1569. X                    PUTCHAR('0');
  1570. X                    PUTCHAR('x');
  1571. X                } else if (*fmt == 'X' && sharp) {
  1572. X                    PUTCHAR('0');
  1573. X                    PUTCHAR('X');
  1574. X                } else if (*fmt == 'o' && sharp) {
  1575. X                    PUTCHAR('0');
  1576. X                } else if (sign == -1) {
  1577. X                    PUTCHAR('-');
  1578. X                } else if (sign == 1 && space) {
  1579. X                    PUTCHAR(' ');
  1580. X                } else if (sign == 1 && plus) {
  1581. X                    PUTCHAR('+');
  1582. X                }
  1583. X                while(k++ < prec)
  1584. X                    PUTCHAR('0');
  1585. X                while(d > buf)
  1586. X                    PUTCHAR(*--d);
  1587. X                if (!zero && minus)
  1588. X                    while(pad-- > 0)
  1589. X                        PUTCHAR(' ');
  1590. X            }
  1591. X            fmt++;
  1592. X        } else {
  1593. X            PUTCHAR(*fmt++);
  1594. X        }
  1595. X    }
  1596. X#ifdef PRINTF
  1597. X    return cnt;
  1598. X#else
  1599. X    *s = '\0';
  1600. X    return s - str;
  1601. X#endif
  1602. X}
  1603. X
  1604. X#endif /* USE_FAKE_STDIO */
  1605. X
  1606. X#ifdef TEST
  1607. X#ifndef PRINTF
  1608. X#undef sprintf
  1609. Xmain(argc, argv)
  1610. Xint argc;
  1611. Xchar *argv; {
  1612. X    char buf[256];
  1613. X
  1614. X    _sprintf(buf, "%d", 2);
  1615. X    printf("'%s'\n", buf);
  1616. X    sprintf(buf, "%d", 2);
  1617. X    printf("'%s'\n", buf);
  1618. X    _sprintf(buf, "%05d", 2);
  1619. X    printf("'%s'\n", buf);
  1620. X    sprintf(buf, "%05d", 2);
  1621. X    printf("'%s'\n", buf);
  1622. X    _sprintf(buf, "% 5d", 2);
  1623. X    printf("'%s'\n", buf);
  1624. X    sprintf(buf, "% 5d", 2);
  1625. X    printf("'%s'\n", buf);
  1626. X    _sprintf(buf, "%-5d", 2);
  1627. X    printf("'%s'\n", buf);
  1628. X    sprintf(buf, "%-5d", 2);
  1629. X    printf("'%s'\n", buf);
  1630. X    _sprintf(buf, "%5.3d", 2);
  1631. X    printf("'%s'\n", buf);
  1632. X    sprintf(buf, "%5.3d", 2);
  1633. X    printf("'%s'\n", buf);
  1634. X    _sprintf(buf, "%+d", 2);
  1635. X    printf("'%s'\n", buf);
  1636. X    sprintf(buf, "%+d", 2);
  1637. X    printf("'%s'\n", buf);
  1638. X    _sprintf(buf, "%#-1.2d", 2);
  1639. X    printf("'%s'\n", buf);
  1640. X    sprintf(buf, "%#-1.2d", 2);
  1641. X    printf("'%s'\n", buf);
  1642. X    _sprintf(buf, "% 5d", -2);
  1643. X    printf("'%s'\n", buf);
  1644. X    sprintf(buf, "% 5d", -2);
  1645. X    printf("'%s'\n", buf);
  1646. X    _sprintf(buf, "%-5d", -2);
  1647. X    printf("'%s'\n", buf);
  1648. X    sprintf(buf, "%-5d", -2);
  1649. X    printf("'%s'\n", buf);
  1650. X    _sprintf(buf, "%5.3d", -2);
  1651. X    printf("'%s'\n", buf);
  1652. X    sprintf(buf, "%5.3d", -2);
  1653. X    printf("'%s'\n", buf);
  1654. X    _sprintf(buf, "%%:%o:%x:%X:%ld:%u:%i", 10, 22, 333, -456L, 50000, 6);
  1655. X    printf("'%s'\n", buf);
  1656. X    sprintf(buf, "%%:%o:%x:%X:%ld:%u:%i", 10, 22, 333, -456L, 50000, 6);
  1657. X    printf("'%s'\n", buf);
  1658. X    _sprintf(buf, "%06o:%#6x:%#012.4X:%-5ld:%*u:%*.*i",
  1659. X        10, 22, 333, -456L, 8, 50000, 4, 2, 6);
  1660. X    printf("'%s'\n", buf);
  1661. X    sprintf(buf, "%06o:%#6x:%#012.4X:%-5ld:%*u:%*.*i",
  1662. X        10, 22, 333, -456L, 8, 50000, 4, 2, 6);
  1663. X    printf("'%s'\n", buf);
  1664. X    _sprintf(buf, "%s", "abcdefghi");
  1665. X    printf("'%s'\n", buf);
  1666. X    sprintf(buf, "%s", "abcdefghi");
  1667. X    printf("'%s'\n", buf);
  1668. X    _sprintf(buf, "%.4s", "abcdefghi");
  1669. X    printf("'%s'\n", buf);
  1670. X    sprintf(buf, "%.4s", "abcdefghi");
  1671. X    printf("'%s'\n", buf);
  1672. X    _sprintf(buf, "%4.4s", "abcdefghi");
  1673. X    printf("'%s'\n", buf);
  1674. X    sprintf(buf, "%4.4s", "abcdefghi");
  1675. X    printf("'%s'\n", buf);
  1676. X    _sprintf(buf, "%20s", "abcdefghi");
  1677. X    printf("'%s'\n", buf);
  1678. X    sprintf(buf, "%20s", "abcdefghi");
  1679. X    printf("'%s'\n", buf);
  1680. X    _sprintf(buf, "%-20s", "abcdefghi");
  1681. X    printf("'%s'\n", buf);
  1682. X    sprintf(buf, "%-20s", "abcdefghi");
  1683. X    printf("'%s'\n", buf);
  1684. X    _sprintf(buf, "%-20.20s", "abcdefghi");
  1685. X    printf("'%s'\n", buf);
  1686. X    sprintf(buf, "%-20.20s", "abcdefghi");
  1687. X    printf("'%s'\n", buf);
  1688. X    _sprintf(buf, "%#-0.20s", "abcdefghi");
  1689. X    printf("'%s'\n", buf);
  1690. X    sprintf(buf, "%#-0.20s", "abcdefghi");
  1691. X    printf("'%s'\n", buf);
  1692. X    _sprintf(buf, "%5s", "abcdefghi");
  1693. X    printf("'%s'\n", buf);
  1694. X    sprintf(buf, "%5s", "abcdefghi");
  1695. X    printf("'%s'\n", buf);
  1696. X    _sprintf(buf, "%015s", "abcdefghi");
  1697. X    printf("'%s'\n", buf);
  1698. X    sprintf(buf, "%015s", "abcdefghi");
  1699. X    printf("'%s'\n", buf);
  1700. X    _sprintf(buf, "%c", 'C');
  1701. X    printf("'%s'\n", buf);
  1702. X    sprintf(buf, "%c", 'C');
  1703. X    printf("'%s'\n", buf);
  1704. X    _sprintf(buf, "%5c", 'C');
  1705. X    printf("'%s'\n", buf);
  1706. X    sprintf(buf, "%5c", 'C');
  1707. X    printf("'%s'\n", buf);
  1708. X    _sprintf(buf, "%-5c", 'C');
  1709. X    printf("'%s'\n", buf);
  1710. X    sprintf(buf, "%-5c", 'C');
  1711. X    printf("'%s'\n", buf);
  1712. X    _sprintf(buf, "%d", 0);
  1713. X    printf("'%s'\n", buf);
  1714. X    sprintf(buf, "%d", 0);
  1715. X    printf("'%s'\n", buf);
  1716. X    _sprintf(buf, "%.d", 0);
  1717. X    printf("'%s'\n", buf);
  1718. X    sprintf(buf, "%.d", 0);
  1719. X    printf("'%s'\n", buf);
  1720. X    _sprintf(buf, "%5.0d", 0);
  1721. X    printf("'%s'\n", buf);
  1722. X    sprintf(buf, "%5.0d", 0);
  1723. X    printf("'%s'\n", buf);
  1724. X}
  1725. X#endif /* !PRINTF */
  1726. X#endif /* TEST */
  1727. SHAR_EOF
  1728. chmod 0644 sprintf.c || echo "restore of sprintf.c fails"
  1729. case $TOUCH in
  1730. can)
  1731.     touch -am 0402044690 sprintf.c
  1732.     ;;
  1733. esac
  1734. set `wc -c sprintf.c`;Wc_c=$1
  1735. case "$Wc_c" in
  1736. "8573") ;;
  1737. *) echo original size 8573, current size $Wc_c ;;
  1738. esac
  1739. # ============= clear.c ==============
  1740. echo "x - extracting clear.c (Text)"
  1741. sed 's/^X//' << 'SHAR_EOF' > clear.c &&
  1742. X/*
  1743. X * clear.c
  1744. X *
  1745. X * By Ross Ridge
  1746. X * Public Domain
  1747. X * 90/03/25 05:09:22
  1748. X *
  1749. X * clear
  1750. X * 
  1751. X * clears the terminal's screen
  1752. X *
  1753. X */
  1754. X
  1755. Xstatic char SCCSid[] = "@(#) clear.c 1.1";
  1756. X
  1757. X#ifndef USE_TERMINFO
  1758. X
  1759. X#include "defs.h"
  1760. X
  1761. X#ifdef USE_SGTTY
  1762. X#include <sgtty.h>
  1763. X#endif
  1764. X#ifdef USE_TERMIO
  1765. X#include <termio.h>
  1766. X#endif
  1767. X
  1768. Xchar PC;
  1769. Xshort ospeed;
  1770. X
  1771. Xint putch(c)
  1772. Xint c; {
  1773. X    return putchar(c);
  1774. X}
  1775. X
  1776. Xmain(argc, argv)
  1777. Xint argc;
  1778. Xchar **argv; {
  1779. X    char *getenv();
  1780. X    char *tgetstr();
  1781. X    char *term;
  1782. X    char buf[MAX_BUF];
  1783. X    char CL[MAX_LINE];
  1784. X    char *s, *pc;
  1785. X
  1786. X#ifdef USE_SGTTY
  1787. X    struct sgttyb tty;
  1788. X
  1789. X    gtty(1, &tty);
  1790. X    ospeed = tty.sg_ospeed;
  1791. X#else
  1792. X#ifdef USE_TERMIO
  1793. X    struct termio tty;
  1794. X
  1795. X    ioctl(1, TCGETA, &tty);
  1796. X    ospeed = tty.c_cflag & CBAUD;
  1797. X#else
  1798. X    ospeed = 0;
  1799. X#endif
  1800. X#endif
  1801. X
  1802. X    term = getenv("TERM");
  1803. X    if (term == NULL)
  1804. X        exit(1);
  1805. X
  1806. X    if (tgetent(buf, term) != 1)
  1807. X        exit(1);
  1808. X
  1809. X    s = CL;
  1810. X    pc = tgetstr("pc", &s);
  1811. X    if (pc != NULL)
  1812. X        PC = *pc;
  1813. X
  1814. X    s = CL;
  1815. X    tgetstr("cl", &s);
  1816. X
  1817. X    if (CL != NULL) {
  1818. X        tputs(CL, tgetnum("li"), putch);
  1819. X        exit(1);
  1820. X    }
  1821. X
  1822. X    exit(0);
  1823. X}
  1824. X
  1825. X#else /* USE_TERMINFO */
  1826. X
  1827. X#include "defs.h"
  1828. X#include "term.h"
  1829. X
  1830. Xint putch(c)
  1831. Xint c; {
  1832. X    return putchar(c);
  1833. X}
  1834. X
  1835. Xmain() {
  1836. X    setupterm((char *) 0, 1, (int *) 0); 
  1837. X    if (clear_screen == (char *) 0)
  1838. X        exit(1);
  1839. X    tputs(clear_screen, lines > 0 ? lines : 1, putch);
  1840. X    exit(0);
  1841. X}
  1842. X
  1843. X#endif /* USE_TERMINFO */
  1844. SHAR_EOF
  1845. chmod 0644 clear.c || echo "restore of clear.c fails"
  1846. case $TOUCH in
  1847. can)
  1848.     touch -am 0402044690 clear.c
  1849.     ;;
  1850. esac
  1851. set `wc -c clear.c`;Wc_c=$1
  1852. case "$Wc_c" in
  1853. "1295") ;;
  1854. *) echo original size 1295, current size $Wc_c ;;
  1855. esac
  1856. # ============= term.tail ==============
  1857. echo "x - extracting term.tail (Text)"
  1858. sed 's/^X//' << 'SHAR_EOF' > term.tail &&
  1859. X/* 
  1860. X * 90/03/27 18:29:43
  1861. X * @(#) term.tail 1.2
  1862. X *
  1863. X */
  1864. X
  1865. X#ifdef USE_TERMIO
  1866. X#ifndef ICANON
  1867. X#include <sys/termio.h>
  1868. X#endif
  1869. X#endif
  1870. X
  1871. X#ifdef USE_SGTTY
  1872. X#ifndef CBREAK
  1873. X#include <sgtty.h>
  1874. X#endif
  1875. X#endif
  1876. X
  1877. Xtypedef struct _terminal {
  1878. X    int fd;
  1879. X#ifdef USE_SMALLMEM
  1880. X    unsigned short baudrate;
  1881. X    unsigned pad:1, xon:1, termcap:1;
  1882. X#else
  1883. X    int pad;
  1884. X    int xon;
  1885. X    int termcap;
  1886. X    long baudrate;
  1887. X#endif
  1888. X    char padch;
  1889. X    short true_lines, true_columns;
  1890. X    struct strbuf {
  1891. X        struct strbuf *next;
  1892. X#ifdef USE_SMALLMEM
  1893. X        short len;
  1894. X#else
  1895. X        int len;
  1896. X#endif
  1897. X        char buf[MAX_CHUNK];
  1898. X    } *strbuf;
  1899. X    char *name, *name_long, *name_all;
  1900. X#ifdef USE_SGTTY
  1901. X    struct sgtty_str {
  1902. X        struct sgttyb v6;
  1903. X#ifdef TIOCGETC
  1904. X        struct tchars v7;
  1905. X#endif
  1906. X#ifdef TIOCLGET
  1907. X        int bsd;
  1908. X#endif
  1909. X#ifdef TIOCGLTC
  1910. X        struct ltchars bsd_new;
  1911. X#endif
  1912. X#ifdef USE_WINSZ
  1913. X#ifdef TIOCGWINSZ
  1914. X        struct winsize bsd_winsz;
  1915. X#endif
  1916. X#endif
  1917. X    } prog_mode, shell_mode;
  1918. X#else
  1919. X#ifdef USE_TERMIO
  1920. X    struct termio prog_mode, shell_mode;
  1921. X#endif
  1922. X#endif
  1923. X    char bools[NUM_OF_BOOLS];
  1924. X    short nums[NUM_OF_NUMS];
  1925. X    char *strs[NUM_OF_STRS];
  1926. X} TERMINAL;
  1927. X
  1928. X#ifndef _CUR_TERM
  1929. X#ifdef SINGLE
  1930. X
  1931. X#define _CUR_TERM _term_buf
  1932. X
  1933. X#else
  1934. X
  1935. X#define _CUR_TERM (*cur_term)
  1936. X
  1937. X#endif
  1938. X#endif
  1939. X
  1940. Xextern TERMINAL *cur_term;
  1941. Xextern TERMINAL _term_buf;
  1942. X
  1943. X#ifdef USE_PROTOTYPES
  1944. Xextern char *tparm(char *, ...);
  1945. Xextern int setupterm(char *, int, int *), set_curterm(TERMINAL *);
  1946. Xextern int del_curterm(TERMINAL *), tputs(char *, int, int (*)());
  1947. Xextern int putp(char *);
  1948. Xextern int tigetflag(char *), tigetnum(char *);
  1949. Xextern char *tigetstr(char *);
  1950. Xextern int def_prog_mode(void), def_shell_mode(void);
  1951. Xextern int reset_prog_mode(void), reset_shell_mode(void);
  1952. X#else
  1953. Xextern char *tparm();
  1954. Xextern int setupterm(), set_curterm();
  1955. Xextern int del_curterm(), tputs();
  1956. Xextern int putp();
  1957. Xextern int tigetflag(), tigetnum();
  1958. Xextern char *tigetstr();
  1959. Xextern int def_prog_mode(), def_shell_mode();
  1960. Xextern int reset_prog_mode(), reset_shell_mode();
  1961. X#endif
  1962. X
  1963. Xextern char *boolnames[], *boolcodes[], *boolfnames[];
  1964. Xextern char *numnames[], *numcodes[], *numfnames[];
  1965. Xextern char *strnames[], *strcodes[], *strfnames[];
  1966. X
  1967. X#ifndef OK
  1968. X#undef ERR
  1969. X#define OK (0)
  1970. X#define ERR (-1)
  1971. X#endif
  1972. X
  1973. X#endif /* _TERM_H_ */
  1974. SHAR_EOF
  1975. chmod 0644 term.tail || echo "restore of term.tail fails"
  1976. case $TOUCH in
  1977. can)
  1978.     touch -am 0402044690 term.tail
  1979.     ;;
  1980. esac
  1981. set `wc -c term.tail`;Wc_c=$1
  1982. case "$Wc_c" in
  1983. "2146") ;;
  1984. *) echo original size 2146, current size $Wc_c ;;
  1985. esac
  1986. # ============= defs.h ==============
  1987. echo "x - extracting defs.h (Text)"
  1988. sed 's/^X//' << 'SHAR_EOF' > defs.h &&
  1989. X/*
  1990. X * defs.h
  1991. X *
  1992. X * By Ross Ridge
  1993. X * Public Domain
  1994. X * 90/03/27 18:29:27
  1995. X *
  1996. X * @(#) defs.h 1.2
  1997. X */
  1998. X
  1999. X#ifndef _DEFS_H_
  2000. X#define _DEFS_H_
  2001. X
  2002. X#ifdef TEST
  2003. X#undef NOTLIB
  2004. X#define NOTLIB
  2005. X#endif
  2006. X
  2007. X#include "config.h"
  2008. X
  2009. X#ifdef NOTLIB
  2010. X#undef USE_FAKE_STDIO
  2011. X#endif
  2012. X
  2013. X#ifdef USE_STDLIB
  2014. X#include <stdlib.h>
  2015. X#endif
  2016. X
  2017. X#ifdef USE_STDDEF
  2018. X#include <stddef.h>
  2019. X#else
  2020. X#include <sys/types.h>
  2021. X#endif
  2022. X
  2023. X#ifdef USE_STDARG
  2024. X#include <stdarg.h>
  2025. X#else
  2026. X#include <varargs.h>
  2027. X#endif
  2028. X
  2029. X#ifdef USE_FAKE_STDIO
  2030. X#include "fake_stdio.h"
  2031. X#define sprintf _fake_sprintf
  2032. X#ifdef USE_PROTOYPES
  2033. Xint sprintf(char *, char *, ...);
  2034. X#else
  2035. Xint sprintf();
  2036. X#endif
  2037. X#else /* USE_FAKE_STDIO */
  2038. X#if 0
  2039. X#include <stdio.h>
  2040. X#else
  2041. X#undef NULL
  2042. X#include <stdio.h>
  2043. Xint _flsbuf(), _filbuf(), fclose(), ungetc(), ioctl(), puts();
  2044. X#endif
  2045. X#endif /* !USE_FAKE_STDIO */
  2046. X
  2047. X#ifdef USE_STRINGS
  2048. X#include <strings.h>
  2049. X#define strchr(s, c) index(s, c)
  2050. X#define strrchr(s, c) rindex(s, c)
  2051. X#ifndef USE_MYSTRTOK
  2052. X#ifdef USE_PROTYPES
  2053. Xchar *strtok(char *, char *);
  2054. X#else
  2055. Xchar *strtok();
  2056. X#endif
  2057. X#endif
  2058. X#else
  2059. X#include <string.h>
  2060. X#endif
  2061. X
  2062. X#ifdef USE_MEMORY
  2063. X#include <memory.h>
  2064. X#else
  2065. X#define memcpy(b, a, n) bcopy(a, b, n)
  2066. X#endif
  2067. X
  2068. X#ifdef USE_MYBSEARCH
  2069. X#define bsearch _bsearch
  2070. X#ifdef USE_PROTOTYPES
  2071. Xanyptr bsearch(anyptr, anyptr, int, size_t, int (*)(anyptr, anyptr));
  2072. X#else
  2073. Xanyptr bsearch();
  2074. X#endif
  2075. X#else
  2076. X/* anyptr bsearch(); */
  2077. X#endif
  2078. X
  2079. X#ifdef USE_MYSTRTOK
  2080. X#define strtok _strtok
  2081. X#ifdef USE_PROTOTYPES
  2082. Xchar *strtok(char *, char *);
  2083. X#else
  2084. Xchar *strtok();
  2085. X#endif
  2086. X#endif
  2087. X
  2088. X#ifdef USE_MYQSORT
  2089. X#define qsort _qsort
  2090. X#ifdef USE_PROTOTYPES
  2091. Xvoid qsort(anyptr, unsigned, size_t, int (*)(anyptr, anyptr));
  2092. X#else
  2093. Xvoid qsort();
  2094. X#endif
  2095. X#endif
  2096. X
  2097. X#include <errno.h>
  2098. X
  2099. X#define MAX_BUF    4096
  2100. X#define MAX_LINE 640
  2101. X#define MAX_NAME 128
  2102. X
  2103. X#define MAX_CHUNK MAX_LINE
  2104. X
  2105. X#define MAX_DEPTH 32
  2106. X
  2107. X#define MAX_VARNAME    32
  2108. X#define MAX_TINFONAME    5
  2109. X#define MAX_TCAPNAME    2
  2110. X
  2111. Xstruct caplist {
  2112. X    char    type;
  2113. X    char    flag;
  2114. X    char    var[MAX_VARNAME + 1];
  2115. X    char    tinfo[MAX_TINFONAME + 1];
  2116. X    char    tcap[MAX_TCAPNAME + 1];
  2117. X};
  2118. X
  2119. Xstruct term_path {
  2120. X    char *file;
  2121. X    int type;    /* 0 = file, 1 = TERMCAP env, 2 = TERMINFO env */
  2122. X};
  2123. X
  2124. Xstruct _terminal;
  2125. X
  2126. X#ifdef USE_PROTOTYPES
  2127. Xint _gettcap(char *, struct _terminal *, struct term_path *);
  2128. Xint _gettinfo(char *, struct _terminal *, struct term_path *);
  2129. Xint _fillterm(char *, struct term_path *, char *);
  2130. Xint _findterm(char *, struct term_path *, char *);
  2131. Xint _init_tty(void), _lit_output(void), _check_tty(void);
  2132. Xvoid _figure_termcap(void);
  2133. Xint _tmatch(char *, char *);
  2134. Xvoid _norm_output(void);
  2135. Xint readcaps(FILE *, struct caplist *, int);
  2136. Xnoreturn void quit(int, char *, ...);
  2137. X#ifdef lint
  2138. Xextern void (*cleanup)();
  2139. X#else
  2140. Xextern void (*cleanup)(int);
  2141. X#endif
  2142. Xint _compar(anyptr, anyptr);
  2143. Xstruct term_path *_buildpath(char *, int, ...);
  2144. Xvoid _delpath(struct term_path *);
  2145. Xchar *_addstr(char *);
  2146. Xstruct strbuf *_endstr(void);
  2147. Xvoid _del_strs(struct _terminal *);
  2148. Xvoid _tcapconv(void);
  2149. Xvoid _tcapdefault(void);
  2150. Xint _getother(char *, struct term_path *, struct _terminal *);
  2151. Xint _gettbin(char *, struct _terminal *);
  2152. X#else
  2153. Xint _gettcap(), _gettinfo(), _fillterm(), _findterm(), _init_tty();
  2154. Xint _lit_output(), _check_tty();
  2155. Xvoid _figure_termcap();
  2156. Xint _tmatch();
  2157. Xvoid _norm_output();
  2158. Xint readcaps();
  2159. Xnoreturn void /* GOTO */ quit(/*FORMAT2*/);
  2160. Xextern void (*cleanup)();
  2161. Xint _compar();
  2162. Xstruct term_path *_buildpath();
  2163. Xvoid _delpath();
  2164. Xchar *_addstr();
  2165. Xstruct strbuf *_endstr();
  2166. Xvoid _del_strs();
  2167. Xvoid _tcapconv();
  2168. Xvoid _tcapdefault();
  2169. Xint _getother();
  2170. Xint _gettbin();
  2171. X#endif
  2172. X
  2173. X#define OVERIDE
  2174. X
  2175. Xextern char _strflags[];
  2176. X
  2177. X/* for quit.c */
  2178. Xextern int sys_nerr;
  2179. Xextern char *sys_errlist[];
  2180. Xextern char *prg_name;
  2181. X
  2182. X#endif /* _DEFS_H_ */
  2183. SHAR_EOF
  2184. chmod 0644 defs.h || echo "restore of defs.h fails"
  2185. case $TOUCH in
  2186. can)
  2187.     touch -am 0402044690 defs.h
  2188.     ;;
  2189. esac
  2190. set `wc -c defs.h`;Wc_c=$1
  2191. case "$Wc_c" in
  2192. "3602") ;;
  2193. *) echo original size 3602, current size $Wc_c ;;
  2194. esac
  2195. # ============= config.h ==============
  2196. echo "x - extracting config.h (Text)"
  2197. sed 's/^X//' << 'SHAR_EOF' > config.h &&
  2198. X/*
  2199. X * config.h
  2200. X *
  2201. X * By Ross Ridge
  2202. X * Public Domain
  2203. X * 90/03/31 10:07:00
  2204. X *
  2205. X * @(#) config.h 1.3.1.1
  2206. X */
  2207. X
  2208. X/* See the file INSTALL for instructions on editing this file */
  2209. X
  2210. X#ifndef _CONFIG_H_
  2211. X#define _CONFIG_H_
  2212. X
  2213. X#ifdef __STDC__
  2214. X#define USE_ANSIC        /* undefine this if your compiler lies */
  2215. X#endif
  2216. X
  2217. X#undef USE_TERMIO        /* use termio (SysIII, SysV) */
  2218. X#undef USE_SGTTY        /* use sgtty (v7, BSD) */
  2219. X#undef USE_WINSZ        /* get window size from the tty driver */
  2220. X#undef USE_STRINGS        /* include <strings.h> instead of <string.h> */
  2221. X#undef USE_MYBSEARCH        /* your library doesn't have bsearch */
  2222. X#undef USE_MYSTRTOK        /* your library doesn't have strtok */
  2223. X#undef USE_MYQSORT        /* your library doesn't have qsort */
  2224. X#undef USE_MEMORY        /* you have an <memory.h> header */
  2225. X#undef USE_SMALLMEM         /* save some memory */
  2226. X#undef USE_FAKE_STDIO        /* don't use real stdio */
  2227. X#undef USE_DOPRNT        /* no vfprintf, use _doprnt */
  2228. X
  2229. X#undef USE_UPBC_KLUDGE        /* do tgoto like real togo */
  2230. X#undef USE_EXTERN_UPBC        /* get cuu1 and cub1 from externs UP and BC */
  2231. X/* #undef USE_LITOUT_KLUDGE    /* an alternate tgoto kludge */
  2232. X
  2233. X#ifndef USE_ANSIC
  2234. X#undef USE_PROTOTYPES        /* use ANSI C prototypes */
  2235. X#undef USE_STDLIB        /* you have an <stdlib.h> */
  2236. X#undef USE_STDARG        /* you have an <stdarg.h> */
  2237. X#undef USE_STDDEF        /* you have an <stddef.h> */
  2238. X
  2239. X#define const 
  2240. X#define volatile
  2241. X#define noreturn        /* a function that doesn't return */
  2242. X
  2243. Xtypedef char *anyptr;        /* a type that any pointer can be assigned to */
  2244. X
  2245. X#else
  2246. X
  2247. X#define USE_PROTOTYPES
  2248. X#define USE_STDLIB
  2249. X#define USE_STDARG
  2250. X#define USE_STDDEF
  2251. Xtypedef void *anyptr;
  2252. X#ifdef __GNUC__
  2253. X#define noreturn volatile
  2254. X#else
  2255. X#define noreturn
  2256. X#endif
  2257. X#endif
  2258. X
  2259. X#define TERMCAPFILE "$TERMCAPFILE $HOME/.termcap /etc/termcap"
  2260. X
  2261. X#define TERMINFOSRC "/usr/lib/terminfo/terminfo.src"
  2262. X
  2263. X#define TERMINFODIR "/usr/lib/terminfo"
  2264. X
  2265. X#endif
  2266. SHAR_EOF
  2267. chmod 0644 config.h || echo "restore of config.h fails"
  2268. case $TOUCH in
  2269. can)
  2270.     touch -am 0402044690 config.h
  2271.     ;;
  2272. esac
  2273. set `wc -c config.h`;Wc_c=$1
  2274. case "$Wc_c" in
  2275. "1816") ;;
  2276. *) echo original size 1816, current size $Wc_c ;;
  2277. esac
  2278. # ============= cap_list ==============
  2279. echo "x - extracting cap_list (Text)"
  2280. sed 's/^X//' << 'SHAR_EOF' > cap_list &&
  2281. X cap_list
  2282. X
  2283. X By Ross Ridge
  2284. X Public Domain
  2285. X 90/03/22 03:43:55
  2286. X
  2287. X @(#) cap_list 1.1
  2288. X
  2289. Xtypes: ! = boolean, # = number, $ = string, $G = string with parameters,
  2290. X       $K = string that never is outputed.
  2291. X
  2292. Xtype    variable        capname termcap 
  2293. X
  2294. XStandard terminfo capabilities:
  2295. X
  2296. X!    auto_left_margin    bw    bw
  2297. X!    auto_right_margin    am    am
  2298. X!    ceol_standout_glitch    xhp    xs
  2299. X!    dest_tabs_magic_smso    xt    xt
  2300. X!    eat_newline_glitch    xenl    xn
  2301. X!    erase_overstrike    eo    eo
  2302. X!    generic_type        gn    gn
  2303. X!    hard_copy        hc    hc
  2304. X!    hard_cursor        chts    HC
  2305. X!    has_meta_key        km    km
  2306. X!    has_status_line        hs    hs
  2307. X!    insert_null_glitch    in    in
  2308. X!    memory_above        da    da
  2309. X!    memory_below        db    db
  2310. X!    move_insert_mode    mir    mi
  2311. X!    move_standout_mode    msgr    ms
  2312. X!    needs_xon_xoff        nxon    nx
  2313. X!    no_esc_ctlc        xsb    xb
  2314. X!    no_pad_char        npc    NP
  2315. X!    non_rev_rmcup        nrrmc    NR
  2316. X!    over_strike        os    os
  2317. X!    prtr_silent        mc5i    5i
  2318. X!    status_line_esc_ok    eslok    es
  2319. X!    tilde_glitch        hz    hz
  2320. X!    transparent_underline    ul    ul
  2321. X!    xon_xoff        xon    xo
  2322. X#    columns            cols    co
  2323. X#    init_tabs        it    it
  2324. X#    label_height        lh    lh
  2325. X#    label_width        lw    lw
  2326. X#    lines            lines    li
  2327. X#    lines_of_memory        lm    lm
  2328. X#    magic_cookie_glitch    xmc    sg
  2329. X#    num_labels        nlab    Nl
  2330. X#    padding_baud_rate    pb    pb
  2331. X#    virtual_terminal    vt    vt
  2332. X#    width_status_line    wsl    ws
  2333. X$K    acs_chars        acsc    ac
  2334. X$    back_tab        cbt    bt
  2335. X$    bell            bel    bl
  2336. X$    carriage_return        cr    cr
  2337. X$G    change_scroll_region    csr    cs
  2338. X$    char_padding        rmp    rP
  2339. X$    clear_all_tabs        tbc    ct
  2340. X$    clear_margins        mgc    MC
  2341. X$    clear_screen        clear    cl
  2342. X$    clr_bol            el1    cb
  2343. X$    clr_eol            el    ce
  2344. X$    clr_eos            ed    cd
  2345. X$G    column_address        hpa    ch
  2346. X$K    command_character    cmdch    CC
  2347. X$G    cursor_address        cup    cm
  2348. X$    cursor_down        cud1    do
  2349. X$    cursor_home        home    ho
  2350. X$    cursor_invisible    civis    vi
  2351. X$    cursor_left        cub1    le
  2352. X$G    cursor_mem_address    mrcup    CM
  2353. X$    cursor_normal        cnorm    ve
  2354. X$    cursor_right        cuf1    nd
  2355. X$    cursor_to_ll        ll    ll
  2356. X$    cursor_up        cuu1    up
  2357. X$    cursor_visible        cvvis    vs
  2358. X$    delete_character    dch1    dc
  2359. X$    delete_line        dl1    dl
  2360. X$    dis_status_line        dsl    ds
  2361. X$    down_half_line        hd    hd
  2362. X$    ena_acs            enacs    eA
  2363. X$    enter_alt_charset_mode    smacs    as
  2364. X$    enter_am_mode        smam    SA
  2365. X$    enter_blink_mode    blink    mb
  2366. X$    enter_bold_mode        bold    md
  2367. X$    enter_ca_mode        smcup    ti
  2368. X$    enter_delete_mode    smdc    dm
  2369. X$    enter_dim_mode        dim    mh
  2370. X$    enter_insert_mode    smir    im
  2371. X$    enter_protected_mode    prot    mp
  2372. X$    enter_reverse_mode    rev    mr
  2373. X$    enter_secure_mode    invis    mk
  2374. X$    enter_standout_mode    smso    so
  2375. X$    enter_underline_mode    smul    us
  2376. X$    enter_xon_mode        smxon    SX
  2377. X$G    erase_chars        ech    ec
  2378. X$    exit_alt_charset_mode    rmacs    ae
  2379. X$    exit_am_mode        rmam    RA
  2380. X$    exit_attribute_mode    sgr0    me
  2381. X$    exit_ca_mode        rmcup    te
  2382. X$    exit_delete_mode    rmdc    ed
  2383. X$    exit_insert_mode    rmir    ei
  2384. X$    exit_standout_mode    rmso    se
  2385. X$    exit_underline_mode    rmul    ue
  2386. X$    exit_xon_mode        rmxon    RX
  2387. X$    flash_screen        flash    vb
  2388. X$    form_feed        ff    ff
  2389. X$    from_status_line    fsl    fs
  2390. X$     init_1string        is1    i1
  2391. X$     init_2string        is2    is
  2392. X$     init_3string        is3    i3
  2393. X$K    init_file        if    if
  2394. X$K    init_prog        iprog    iP
  2395. X$    insert_character    ich1    ic
  2396. X$    insert_line        il1    al
  2397. X$    insert_padding        ip    ip
  2398. X$K    key_a1            ka1    K1
  2399. X$K    key_a3            ka3    K3
  2400. X$K    key_b2            kb2    K2
  2401. X$K    key_backspace        kbs    kb
  2402. X$K    key_beg            kbeg    @1
  2403. X$K    key_btab        kcbt    kB
  2404. X$K    key_c1            kc1    K4
  2405. X$K    key_c3            kc3    K5
  2406. X$K    key_cancel        kcan    @2
  2407. X$K    key_catab        ktbc    ka
  2408. X$K    key_clear        kclr    kC
  2409. X$K    key_close        kclo    @3
  2410. X$K    key_command        kcmd    @4
  2411. X$K    key_copy        kcpy    @5
  2412. X$K    key_create        kcrt    @6
  2413. X$K    key_ctab        kctab    kt
  2414. X$K    key_dc            kdch1    kD
  2415. X$K    key_dl            kdl1    kL
  2416. X$K    key_down        kcud1    kd
  2417. X$K    key_eic            krmir    kM
  2418. X$K    key_end            kend    @7
  2419. X$K    key_enter        kent    @8
  2420. X$K    key_eol            kel    kE
  2421. X$K    key_eos            ked    kS
  2422. X$K    key_exit        kext    @9
  2423. X$K    key_f0            kf0    k0
  2424. X$K    key_f1            kf1    k1
  2425. X$K    key_f10            kf10    k;
  2426. X$K    key_f11            kf11    F1
  2427. X$K    key_f12            kf12    F2
  2428. X$K    key_f13            kf13    F3
  2429. X$K    key_f14            kf14    F4
  2430. X$K    key_f15            kf15    F5
  2431. X$K    key_f16            kf16    F6
  2432. X$K    key_f17            kf17    F7
  2433. X$K    key_f18            kf18    F8
  2434. X$K    key_f19            kf19    F9
  2435. X$K    key_f2            kf2    k2
  2436. X$K    key_f20            kf20    FA
  2437. X$K    key_f21            kf21    FB
  2438. X$K    key_f22            kf22    FC
  2439. X$K    key_f23            kf23    FD
  2440. X$K    key_f24            kf24    FE
  2441. X$K    key_f25            kf25    FF
  2442. X$K    key_f26            kf26    FG
  2443. X$K    key_f27            kf27    FH
  2444. X$K    key_f28            kf28    FI
  2445. X$K    key_f29            kf29    FJ
  2446. X$K    key_f3            kf3    k3
  2447. X$K    key_f30            kf30    FK
  2448. X$K    key_f31            kf31    FL
  2449. X$K    key_f32            kf32    FM
  2450. X$K    key_f33            kf33    FN
  2451. X$K    key_f34            kf34    FO
  2452. X$K    key_f35            kf35    FP
  2453. X$K    key_f36            kf36    FQ
  2454. X$K    key_f37            kf37    FR
  2455. X$K    key_f38            kf38    FS
  2456. X$K    key_f39            kf39    FT
  2457. X$K    key_f4            kf4    k4
  2458. X$K    key_f40            kf40    FU
  2459. X$K    key_f41            kf41    FV
  2460. X$K    key_f42            kf42    FW
  2461. X$K    key_f43            kf43    FX
  2462. X$K    key_f44            kf44    FY
  2463. X$K    key_f45            kf45    FZ
  2464. SHAR_EOF
  2465. echo "End of tinfo part 4"
  2466. echo "File cap_list is continued in part 5"
  2467. echo "5" > s3_seq_.tmp
  2468. exit 0
  2469. -- 
  2470. Ross Ridge                                 //
  2471. "The Great HTMU"                            [oo]
  2472. ross@contact.uucp                            -()-
  2473. ross@watcsc.waterloo.edu                         //
  2474.  
  2475.  
  2476.