home *** CD-ROM | disk | FTP | other *** search
/ The UNIX CD Bookshelf / OREILLY_TUCB_UNIX_CD.iso / upt / examples / SOURCES / INDEX / RTR / INDEX. next >
Encoding:
Text File  |  1998-07-24  |  12.2 KB  |  621 lines
  1. *** createdb.c.orig    Wed Nov  4 22:04:20 1992
  2. --- createdb.c    Wed Nov  4 23:56:23 1992
  3. ***************
  4. *** 126,131 ****
  5. --- 126,132 ----
  6.        */
  7.       if ((pid = fork()) < 0) {
  8.           error("%s: cannot fork.\n", pname, 0, 0);
  9. +                 sleep(2);
  10.           exit(1);
  11.       }
  12.   
  13. ***************
  14. *** 133,140 ****
  15.        * Execute the editor.
  16.        */
  17.       if (pid == 0) {
  18. !         execl(editor, editor, fname, 0);
  19.           perror(editor);
  20.           exit(1);
  21.       }
  22.   
  23. --- 134,142 ----
  24.        * Execute the editor.
  25.        */
  26.       if (pid == 0) {
  27. !         execlp(editor, editor, fname, 0);
  28.           perror(editor);
  29. +                 sleep(2);
  30.           exit(1);
  31.       }
  32.   
  33. *** dbio.c.orig    Wed Nov  4 22:04:22 1992
  34. --- dbio.c    Wed Nov  4 23:48:26 1992
  35. ***************
  36. *** 17,22 ****
  37. --- 17,23 ----
  38.    * 
  39.    */
  40.   #include <sys/param.h>
  41. + #include <sys/types.h>
  42.   #include <sys/stat.h>
  43.   #include <curses.h>
  44.   #include <stdio.h>
  45. ***************
  46. *** 258,264 ****
  47.        * Set the file mode to the mode of the original
  48.        * file.  Mark the database as unmodified.
  49.        */
  50. !     fchmod(fileno(fp), st.st_mode & 0777);
  51.       dbmodified = 0;
  52.   
  53.       fclose(fp);
  54. --- 259,265 ----
  55.        * Set the file mode to the mode of the original
  56.        * file.  Mark the database as unmodified.
  57.        */
  58. !     chmod(realfile, st.st_mode & 0777);
  59.       dbmodified = 0;
  60.   
  61.       fclose(fp);
  62. *** defs.h.orig    Wed Nov  4 22:04:22 1992
  63. --- defs.h    Wed Nov  4 23:47:51 1992
  64. ***************
  65. *** 44,53 ****
  66.   #endif
  67.   
  68.   /*
  69. !  * Usually defined in ttychars.h.
  70.    */
  71. ! #ifndef CTRL
  72. ! #define CTRL(c)        ('c' & 037)
  73.   #endif
  74.   
  75.   /*
  76. --- 44,61 ----
  77.   #endif
  78.   
  79.   /*
  80. !  * Usually defined in ttychars.h, but sometimes wrongly defined in others.
  81.    */
  82. ! #undef CTRL
  83. ! #define CTRL(c)        (c & 037)
  84. ! 
  85. ! #define bzero(s, n) memset(s, 0, n)
  86. ! 
  87. ! #include <limits.h>
  88. ! 
  89. ! #ifdef _POSIX_PATH_MAX
  90. ! #undef MAXPATHLEN
  91. ! #define MAXPATHLEN _POSIX_PATH_MAX
  92.   #endif
  93.   
  94.   /*
  95. No differences encountered
  96. *** printdb.c.orig    Wed Nov  4 22:04:25 1992
  97. --- printdb.c    Tue Nov 10 23:16:13 1992
  98. ***************
  99. *** 16,22 ****
  100.    * Initial revision
  101.    * 
  102.    */
  103. ! #include <sys/file.h>
  104.   #include <stdio.h>
  105.   #include "defs.h"
  106.   
  107. --- 16,22 ----
  108.    * Initial revision
  109.    * 
  110.    */
  111. ! #include <unistd.h>
  112.   #include <stdio.h>
  113.   #include "defs.h"
  114.   
  115. *** screen.c.orig    Wed Nov  4 22:05:31 1992
  116. --- screen.c    Tue Nov 10 23:10:34 1992
  117. ***************
  118. *** 66,79 ****
  119.        */
  120.       while ((c = getchar()) != EOF) {
  121.           switch (c) {
  122. !         case CTRL(a):            /* beginning of line    */
  123.               col = col0;
  124.               break;
  125. !         case CTRL(b):            /* back character    */
  126.               if (col > col0)
  127.                   col--;
  128.               break;
  129. !         case CTRL(d):            /* delete character    */
  130.               /*
  131.                * If there's stuff in the string,
  132.                * delete this character.
  133. --- 66,79 ----
  134.        */
  135.       while ((c = getchar()) != EOF) {
  136.           switch (c) {
  137. !         case CTRL('a'):            /* beginning of line    */
  138.               col = col0;
  139.               break;
  140. !         case CTRL('b'):            /* back character    */
  141.               if (col > col0)
  142.                   col--;
  143.               break;
  144. !         case CTRL('d'):            /* delete character    */
  145.               /*
  146.                * If there's stuff in the string,
  147.                * delete this character.
  148. ***************
  149. *** 102,115 ****
  150.               }
  151.   
  152.               break;
  153. !         case CTRL(e):            /* end of line        */
  154.               col = col0 + len;
  155.               break;
  156. !         case CTRL(f):            /* forward character    */
  157.               if ((col - col0) < len)
  158.                   col++;
  159.               break;
  160. !         case CTRL(h):            /* backspace delete    */
  161.           case '\177':
  162.               /*
  163.                * If there's stuff in the string,
  164. --- 102,115 ----
  165.               }
  166.   
  167.               break;
  168. !         case CTRL('e'):            /* end of line        */
  169.               col = col0 + len;
  170.               break;
  171. !         case CTRL('f'):            /* forward character    */
  172.               if ((col - col0) < len)
  173.                   col++;
  174.               break;
  175. !         case CTRL('h'):            /* backspace delete    */
  176.           case '\177':
  177.               /*
  178.                * If there's stuff in the string,
  179. ***************
  180. *** 139,145 ****
  181.                   delch();
  182.               }
  183.               break;
  184. !         case CTRL(k):            /* kill line        */
  185.               /*
  186.                * Clear the string.
  187.                */
  188. --- 139,145 ----
  189.                   delch();
  190.               }
  191.               break;
  192. !         case CTRL('k'):            /* kill line        */
  193.               /*
  194.                * Clear the string.
  195.                */
  196. ***************
  197. *** 152,164 ****
  198.                   clrtoeol();
  199.               }
  200.               break;
  201. !         case CTRL(l):            /* redraw screen    */
  202.               wrefresh(curscr);
  203.               break;
  204.           case '\n':            /* return the string    */
  205.               line[len] = '\0';
  206.               return;
  207.           default:            /* regular character    */
  208.               /*
  209.                * If it's the user's line-kill character,
  210.                * we'll accept that to kill the line too.
  211. --- 152,166 ----
  212.                   clrtoeol();
  213.               }
  214.               break;
  215. !         case CTRL('l'):            /* redraw screen    */
  216.               wrefresh(curscr);
  217.               break;
  218. +         case '\r':            /* return the string    */
  219.           case '\n':            /* return the string    */
  220.               line[len] = '\0';
  221.               return;
  222.           default:            /* regular character    */
  223. + #if 0
  224.               /*
  225.                * If it's the user's line-kill character,
  226.                * we'll accept that to kill the line too.
  227. ***************
  228. *** 171,177 ****
  229.                   *line = '\0';
  230.                   len = 0;
  231.               }
  232. !             else {
  233.                   /*
  234.                    * If it's a printable character,
  235.                    * insert it into the string.
  236. --- 173,181 ----
  237.                   *line = '\0';
  238.                   len = 0;
  239.               }
  240. !             else
  241. ! #endif
  242. !                         {
  243.                   /*
  244.                    * If it's a printable character,
  245.                    * insert it into the string.
  246. ***************
  247. *** 332,338 ****
  248.           case 'x':
  249.               byebye();
  250.               break;
  251. !         case CTRL(l):            /* redraw screen    */
  252.               wrefresh(curscr);
  253.               break;
  254.           }
  255. --- 336,342 ----
  256.           case 'x':
  257.               byebye();
  258.               break;
  259. !         case CTRL('l'):            /* redraw screen    */
  260.               wrefresh(curscr);
  261.               break;
  262.           }
  263. ***************
  264. *** 414,419 ****
  265. --- 418,424 ----
  266.            * Dispatch the command...
  267.            */
  268.           switch (c) {
  269. +         case '\r':            /* go to next entry    */
  270.           case '\n':            /* go to next entry    */
  271.               /*
  272.                * Save this one.
  273. ***************
  274. *** 567,580 ****
  275.           len = &tmp.db_lens[row];
  276.   
  277.           switch (c) {
  278. !         case CTRL(a):            /* beginning of line    */
  279.               col = col0;
  280.               break;
  281. !         case CTRL(b):            /* back character    */
  282.               if (col > col0)
  283.                   col--;
  284.               break;
  285. !         case CTRL(d):            /* delete character    */
  286.               if (*len) {
  287.                   /*
  288.                    * Calculate position of character
  289. --- 572,585 ----
  290.           len = &tmp.db_lens[row];
  291.   
  292.           switch (c) {
  293. !         case CTRL('a'):            /* beginning of line    */
  294.               col = col0;
  295.               break;
  296. !         case CTRL('b'):            /* back character    */
  297.               if (col > col0)
  298.                   col--;
  299.               break;
  300. !         case CTRL('d'):            /* delete character    */
  301.               if (*len) {
  302.                   /*
  303.                    * Calculate position of character
  304. ***************
  305. *** 599,612 ****
  306.               }
  307.   
  308.               break;
  309. !         case CTRL(e):            /* end of line        */
  310.               col = col0 + *len;
  311.               break;
  312. !         case CTRL(f):            /* forward character    */
  313.               if ((col - col0) < *len)
  314.                   col++;
  315.               break;
  316. !         case CTRL(h):            /* backspace delete    */
  317.           case '\177':
  318.               if (*len) {
  319.                   /*
  320. --- 604,617 ----
  321.               }
  322.   
  323.               break;
  324. !         case CTRL('e'):            /* end of line        */
  325.               col = col0 + *len;
  326.               break;
  327. !         case CTRL('f'):            /* forward character    */
  328.               if ((col - col0) < *len)
  329.                   col++;
  330.               break;
  331. !         case CTRL('h'):            /* backspace delete    */
  332.           case '\177':
  333.               if (*len) {
  334.                   /*
  335. ***************
  336. *** 632,638 ****
  337.                   delch();
  338.               }
  339.               break;
  340. !         case CTRL(k):            /* kill line        */
  341.               /*
  342.                * Kill the line.
  343.                */
  344. --- 637,643 ----
  345.                   delch();
  346.               }
  347.               break;
  348. !         case CTRL('k'):            /* kill line        */
  349.               /*
  350.                * Kill the line.
  351.                */
  352. ***************
  353. *** 645,654 ****
  354.                   clrtoeol();
  355.               }
  356.               break;
  357. !         case CTRL(l):            /* redraw screen    */
  358.               wrefresh(curscr);
  359.               break;
  360. !         case CTRL(n):            /* next line        */
  361.               /*
  362.                * Wrap around to the top if necessary.
  363.                */
  364. --- 650,659 ----
  365.                   clrtoeol();
  366.               }
  367.               break;
  368. !         case CTRL('l'):            /* redraw screen    */
  369.               wrefresh(curscr);
  370.               break;
  371. !         case CTRL('n'):            /* next line        */
  372.               /*
  373.                * Wrap around to the top if necessary.
  374.                */
  375. ***************
  376. *** 662,668 ****
  377.               if ((col - col0) > tmp.db_lens[row])
  378.                   col = col0 + tmp.db_lens[row];
  379.               break;
  380. !         case CTRL(p):            /* previous line    */
  381.               /*
  382.                * Wrap around if necessary.
  383.                */
  384. --- 667,673 ----
  385.               if ((col - col0) > tmp.db_lens[row])
  386.                   col = col0 + tmp.db_lens[row];
  387.               break;
  388. !         case CTRL('p'):            /* previous line    */
  389.               /*
  390.                * Wrap around if necessary.
  391.                */
  392. ***************
  393. *** 676,682 ****
  394.               if ((col - col0) > tmp.db_lens[row])
  395.                   col = col0 + tmp.db_lens[row];
  396.               break;
  397. !         case CTRL([):            /* save entry        */
  398.               /*
  399.                * Prompt for whether to save the entry.
  400.                */
  401. --- 681,687 ----
  402.               if ((col - col0) > tmp.db_lens[row])
  403.                   col = col0 + tmp.db_lens[row];
  404.               break;
  405. !         case CTRL('['):            /* save entry        */
  406.               /*
  407.                * Prompt for whether to save the entry.
  408.                */
  409. ***************
  410. *** 687,692 ****
  411. --- 692,698 ----
  412.                * See what they said.
  413.                */
  414.               switch (c) {
  415. +             case '\r':        /* never mind        */
  416.               case '\n':        /* never mind        */
  417.                   move(idx.idx_nlines+2, 0);
  418.                   clrtoeol();
  419. ***************
  420. *** 717,722 ****
  421. --- 723,729 ----
  422.                   return(0);
  423.               }
  424.               break;
  425. +         case '\r':            /* go to next line    */
  426.           case '\n':            /* go to next line    */
  427.               /*
  428.                * Wrap around if necessary.
  429. ***************
  430. *** 726,731 ****
  431. --- 733,739 ----
  432.               col = col0;
  433.               break;
  434.           default:            /* something else    */
  435. + #if 0
  436.               /*
  437.                * If it's the user's kill character, we'll
  438.                * accept that to delete the line too.
  439. ***************
  440. *** 738,744 ****
  441.                   *line = '\0';
  442.                   *len = 0;
  443.               }
  444. !             else {
  445.                   /*
  446.                    * If it's a printable character, insert
  447.                    * it into the string.
  448. --- 746,754 ----
  449.                   *line = '\0';
  450.                   *len = 0;
  451.               }
  452. !             else
  453. ! #endif
  454. !                         {
  455.                   /*
  456.                    * If it's a printable character, insert
  457.                    * it into the string.
  458. *** searchdb.c.orig    Wed Nov  4 22:04:33 1992
  459. --- searchdb.c    Wed Nov  4 23:08:32 1992
  460. ***************
  461. *** 38,44 ****
  462.        * to all lower case.
  463.        */
  464.       if (igncase) {
  465. !         for (p = pattern; *p != NULL; p++) {
  466.               if (isupper(*p))
  467.                   *p = tolower(*p);
  468.           }
  469. --- 38,44 ----
  470.        * to all lower case.
  471.        */
  472.       if (igncase) {
  473. !         for (p = pattern; *p != 0; p++) {
  474.               if (isupper(*p))
  475.                   *p = tolower(*p);
  476.           }
  477. ***************
  478. *** 74,80 ****
  479.                   p = db[i].db_lines[j];
  480.                   q = buf;
  481.   
  482. !                 while (*p != NULL) {
  483.                       *q++ = isupper(*p) ? tolower(*p) : *p;
  484.                       p++;
  485.                   }
  486. --- 74,80 ----
  487.                   p = db[i].db_lines[j];
  488.                   q = buf;
  489.   
  490. !                 while (*p != 0) {
  491.                       *q++ = isupper(*p) ? tolower(*p) : *p;
  492.                       p++;
  493.                   }
  494. ***************
  495. *** 109,111 ****
  496. --- 109,148 ----
  497.       return(code);
  498.   }
  499.   
  500. + 
  501. + #ifdef SYSV
  502. + 
  503. + static char* re;
  504. + 
  505. + char* re_comp(s)
  506. +     char* s;
  507. + {
  508. +     extern char* regcmp();
  509. + 
  510. +     if (s == 0 || !*s)
  511. +         return;
  512. + 
  513. +     if (re)
  514. +         free(re);
  515. + 
  516. +     re = regcmp(s, 0);
  517. + 
  518. +     return (re ? 0 : "Regex compile error");
  519. + }
  520. + 
  521. + re_exec(s)
  522. +     char* s;
  523. + {
  524. +     extern char* regex();
  525. + 
  526. +     char* match;
  527. + 
  528. +     if (!re)
  529. +         return -1;
  530. +     
  531. +     match = regex(re, s);
  532. + 
  533. +     return (match && !*match);
  534. + }
  535. + 
  536. + #endif
  537. *** selectdb.c.orig    Wed Nov  4 22:04:34 1992
  538. --- selectdb.c    Tue Nov 10 22:59:53 1992
  539. ***************
  540. *** 16,23 ****
  541.    * Initial revision
  542.    * 
  543.    */
  544. ! #include <sys/param.h>
  545. ! #include <sys/dir.h>
  546.   #include <curses.h>
  547.   #include <stdio.h>
  548.   #include "defs.h"
  549. --- 16,22 ----
  550.    * Initial revision
  551.    * 
  552.    */
  553. ! #include <dirent.h>
  554.   #include <curses.h>
  555.   #include <stdio.h>
  556.   #include "defs.h"
  557. ***************
  558. *** 62,69 ****
  559.       /*
  560.        * Prompt for the name of a database.
  561.        */
  562. !     while (*dbname == '\0')
  563. !         prompt_str(spread+2, 0, "Select a database: ", dbname);
  564.   
  565.       /*
  566.        * If the database exists, return its name.
  567. --- 61,73 ----
  568.       /*
  569.        * Prompt for the name of a database.
  570.        */
  571. !         prompt_str(spread+2, 0, "Select a database: ", dbname);
  572. !         if (*dbname == '\0')
  573. !         {
  574. !             reset_modes();
  575. !             printf("\nExiting - no database sepecified!\n");
  576. !             exit (1);
  577. !         }
  578.   
  579.       /*
  580.        * If the database exists, return its name.
  581. ***************
  582. *** 88,97 ****
  583.   {
  584.       DIR *dp;
  585.       int ndbs;
  586. !     char *rindex();
  587.       register char *s;
  588.       extern int compare();
  589. !     register struct direct *d;
  590.   
  591.       ndbs = 0;
  592.   
  593. --- 92,101 ----
  594.   {
  595.       DIR *dp;
  596.       int ndbs;
  597. !     char *strrchr();
  598.       register char *s;
  599.       extern int compare();
  600. !     register struct dirent *d;
  601.   
  602.       ndbs = 0;
  603.   
  604. ***************
  605. *** 111,117 ****
  606.            * Search for a "." in the name, which marks
  607.            * the suffix.
  608.            */
  609. !         if ((s = rindex(d->d_name, '.')) == NULL)
  610.               continue;
  611.   
  612.           /*
  613. --- 115,121 ----
  614.            * Search for a "." in the name, which marks
  615.            * the suffix.
  616.            */
  617. !         if ((s = strrchr(d->d_name, '.')) == NULL)
  618.               continue;
  619.   
  620.           /*
  621.