home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / rcs / rcs56src / source / grep / pc-files / grep.pat < prev    next >
Encoding:
Text File  |  1992-01-19  |  26.3 KB  |  981 lines
  1. diff -cbBw orig/dfa.c grep/dfa.c
  2. *** orig/dfa.c    Mon May 07 09:08:54 1990
  3. --- grep/dfa.c    Sun Jan 19 18:42:02 1992
  4. ***************
  5. *** 109,114 ****
  6. --- 109,115 ----
  7.   #include <assert.h>
  8.   #include <ctype.h>
  9.   #include "dfa.h"
  10. + #include "regex.h"
  11.   
  12.   #ifdef __STDC__
  13.   typedef void *ptr_t;
  14. diff -cbBw orig/dfa.h grep/dfa.h
  15. *** orig/dfa.h    Mon May 07 09:08:54 1990
  16. --- grep/dfa.h    Sun Jan 19 18:40:38 1992
  17. ***************
  18. *** 115,126 ****
  19.   #ifdef __STDC__
  20.   
  21.   /* Missing include files for GNU C. */
  22. ! /* #include <stdlib.h> */
  23.   typedef int size_t;
  24.   extern void *calloc(int, size_t);
  25.   extern void *malloc(size_t);
  26.   extern void *realloc(void *, size_t);
  27.   extern void free(void *);
  28.   
  29.   extern char *bcopy(), *bzero();
  30.   
  31. --- 115,129 ----
  32.   #ifdef __STDC__
  33.   
  34.   /* Missing include files for GNU C. */
  35. ! #ifdef OS2
  36. ! #include <stdlib.h>
  37. ! #else
  38.   typedef int size_t;
  39.   extern void *calloc(int, size_t);
  40.   extern void *malloc(size_t);
  41.   extern void *realloc(void *, size_t);
  42.   extern void free(void *);
  43. + #endif
  44.   
  45.   extern char *bcopy(), *bzero();
  46.   
  47. ***************
  48. *** 149,154 ****
  49. --- 152,159 ----
  50.   
  51.   #endif /* ! __STDC__ */
  52.   
  53. + #if 0 /* This is really defined in regex.h */
  54. + 
  55.   /* 1 means plain parentheses serve as grouping, and backslash
  56.        parentheses are needed for literal searching.
  57.      0 means backslash-parentheses are grouping, and plain parentheses
  58. ***************
  59. *** 186,193 ****
  60. --- 191,202 ----
  61.   #define RE_SYNTAX_GREP (RE_BK_PLUS_QM | RE_NEWLINE_OR)
  62.   #define RE_SYNTAX_EMACS 0
  63.   
  64. + #endif
  65. + 
  66.   /* The NULL pointer. */
  67. + #ifndef OS2
  68.   #define NULL 0
  69. + #endif
  70.   
  71.   /* Number of bits in an unsigned char. */
  72.   #define CHARBITS 8
  73. diff -cbBw orig/grep.c grep/grep.c
  74. *** orig/grep.c    Mon May 07 09:08:54 1990
  75. --- grep/grep.c    Sun Jan 19 18:40:38 1992
  76. ***************
  77. *** 127,134 ****
  78. --- 127,136 ----
  79.   
  80.   extern char *optarg;
  81.   extern optind, opterr;
  82. + #ifndef OS2
  83.   extern errno;
  84.   extern char *sys_errlist[];
  85. + #endif
  86.   
  87.   #define MAX(a, b) ((a) > (b) ? (a) : (b))
  88.   
  89. ***************
  90. *** 373,378 ****
  91. --- 375,382 ----
  92.                          next_line - matching_line - 1,
  93.                          NULL) < 0)
  94.           {
  95. +           --match_count;        /* debugged by kaoru.  August 15, 1990. */
  96. +           ++line_count;        /* debugged by kaoru.  August 15, 1990. */
  97.             resume = next_line;
  98.             if (resume == search_limit)
  99.           break;
  100. ***************
  101. *** 533,549 ****
  102.     return nonmatching_lines ? (line_count - 1) - match_count : match_count;
  103.   }
  104.   
  105.   void
  106.   usage_and_die()
  107.   {
  108. !   fprintf(stderr,
  109. ! "usage: %s [-CVbchilnsvwx] [-<num>] [-AB <num>] [-f file] [-e] expr [files]\n",
  110. !           prog);
  111.     exit(ERROR);
  112.   }
  113.   
  114. - static char version[] = "GNU e?grep, version 1.5";
  115. - 
  116.   main(argc, argv)
  117.        int argc;
  118.        char **argv;
  119. --- 537,581 ----
  120.     return nonmatching_lines ? (line_count - 1) - match_count : match_count;
  121.   }
  122.   
  123. + 
  124. + #ifdef EGREP
  125. + static char version[] = "GNU egrep, version 1.5";
  126. + #else
  127. + static char version[] = "GNU grep, version 1.5";
  128. + #endif
  129. + 
  130.   void
  131.   usage_and_die()
  132.   {
  133. !   printf("\n%s\n", version);
  134. !   printf("\nUsage: %s [-CVbchilnsvwx] [-<num>] [-AB <num>]"
  135. !                     " [-f file] [-e] expr [files]\n\n", prog);
  136. !   printf(
  137. !   "  -A <num>  print <num> lines of context after every matching line\n"
  138. !   "  -B <num>  print <num> lines of context before every matching line\n"
  139. !   "  -C        print 2 lines of context on each side of every match\n"
  140. !   "  -<num>    print <num> lines of context on each side\n"
  141. !   "  -V        print the version number on stderr\n"
  142. !   );
  143. !   printf(
  144. !   "  -b        print every match preceded by its byte offset\n"
  145. !   "  -c        print a total count of matching lines only\n"
  146. !   "  -e <expr> search for <expr>; useful if <expr> begins with -\n"
  147. !   "  -f <file> take <expr> from the given <file>\n"
  148. !   "  -h        don't display filenames on matches\n"
  149. !   "  -i        ignore case difference when comparing strings\n"
  150. !   );
  151. !   printf(
  152. !   "  -l        list files containing matches only\n"
  153. !   "  -n        print each match preceded by its line number\n"
  154. !   "  -s        run silently producing no output except error messages\n"
  155. !   "  -v        print only lines that contain no matches for the <expr>\n"
  156. !   "  -w        print only lines where the match is a complete word\n"
  157. !   "  -x        print only lines where the match is a whole line\n");
  158. ! 
  159.     exit(ERROR);
  160.   }
  161.   
  162.   main(argc, argv)
  163.        int argc;
  164.        char **argv;
  165. ***************
  166. *** 607,613 ****
  167.       break;
  168.   
  169.         case 'V':
  170. !     fprintf(stderr, "%s\n", version);
  171.       break;
  172.   
  173.         case 'b':
  174. --- 639,646 ----
  175.       break;
  176.   
  177.         case 'V':
  178. !         fprintf(stderr, "\n%s\n", version);
  179. !         exit(ERROR);
  180.       break;
  181.   
  182.         case 'b':
  183. diff -cbBw orig/regex.c grep/regex.c
  184. *** orig/regex.c    Mon May 07 09:08:56 1990
  185. --- grep/regex.c    Sun Jan 19 14:30:04 1992
  186. ***************
  187. *** 20,25 ****
  188. --- 20,26 ----
  189.      You are forbidden to forbid anyone else to use, share and improve
  190.      what you give them.   Help stamp out software-hoarding!  */
  191.   
  192. + #define USG
  193.   
  194.   /* To test, compile with -Dtest.
  195.    This Dtestable feature turns this into a self-contained program
  196. ***************
  197. *** 39,48 ****
  198. --- 40,51 ----
  199.   #else  /* not emacs */
  200.   
  201.   #ifdef USG
  202. + #ifndef BSTRING
  203.   #define bcopy(s,d,n)    memcpy((d),(s),(n))
  204.   #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  205.   #define bzero(s,n)    memset((s),0,(n))
  206.   #endif
  207. + #endif
  208.   
  209.   /* Make alloca work the best possible way.  */
  210.   #ifdef __GNUC__
  211. ***************
  212. *** 53,58 ****
  213. --- 56,68 ----
  214.   #endif
  215.   #endif
  216.   
  217. + #ifdef OS2
  218. + #include <stdlib.h>
  219. + #include <string.h>
  220. + #include <memory.h>
  221. + #include <malloc.h>
  222. + #endif
  223. + 
  224.   /*
  225.    * Define the syntax stuff, so we can do the \<...\> things.
  226.    */
  227. ***************
  228. *** 72,78 ****
  229.   static char re_syntax_table[256];
  230.   
  231.   static void
  232. ! init_syntax_once ()
  233.   {
  234.      register int c;
  235.      static int done = 0;
  236. --- 82,88 ----
  237.   static char re_syntax_table[256];
  238.   
  239.   static void
  240. ! init_syntax_once (void)
  241.   {
  242.      register int c;
  243.      static int done = 0;
  244. ***************
  245. *** 91,96 ****
  246. --- 101,108 ----
  247.      for (c = '0'; c <= '9'; c++)
  248.        re_syntax_table[c] = Sword;
  249.   
  250. +    re_syntax_table['_'] = Sword;
  251. + 
  252.      done = 1;
  253.   }
  254.   
  255. ***************
  256. *** 112,120 ****
  257.   #define BYTEWIDTH 8
  258.   
  259.   #ifndef SIGN_EXTEND_CHAR
  260. ! #define SIGN_EXTEND_CHAR(x) (x)
  261.   #endif
  262. ! 
  263.   static int obscure_syntax = 0;
  264.   
  265.   /* Specify the precise syntax of regexp for compilation.
  266. --- 124,132 ----
  267.   #define BYTEWIDTH 8
  268.   
  269.   #ifndef SIGN_EXTEND_CHAR
  270. ! #define SIGN_EXTEND_CHAR(x) ((int) (signed char) x)
  271.   #endif
  272. ! 
  273.   static int obscure_syntax = 0;
  274.   
  275.   /* Specify the precise syntax of regexp for compilation.
  276. ***************
  277. *** 125,131 ****
  278.      RE_NO_BK_PARENS and RE_NO_BK_VBAR.  */
  279.   
  280.   int
  281. ! re_set_syntax (syntax)
  282.   {
  283.     int ret;
  284.   
  285. --- 137,143 ----
  286.      RE_NO_BK_PARENS and RE_NO_BK_VBAR.  */
  287.   
  288.   int
  289. ! re_set_syntax (int syntax)
  290.   {
  291.     int ret;
  292.   
  293. ***************
  294. *** 133,139 ****
  295.     obscure_syntax = syntax;
  296.     return ret;
  297.   }
  298. ! 
  299.   /* re_compile_pattern takes a regular-expression string
  300.      and converts it into a buffer full of byte commands for matching.
  301.   
  302. --- 145,151 ----
  303.     obscure_syntax = syntax;
  304.     return ret;
  305.   }
  306. ! 
  307.   /* re_compile_pattern takes a regular-expression string
  308.      and converts it into a buffer full of byte commands for matching.
  309.   
  310. ***************
  311. *** 163,187 ****
  312.   
  313.   #define PATUNFETCH p--
  314.   
  315.   #define EXTEND_BUFFER \
  316.     { char *old_buffer = bufp->buffer; \
  317. !     if (bufp->allocated == (1<<16)) goto too_big; \
  318.       bufp->allocated *= 2; \
  319. !     if (bufp->allocated > (1<<16)) bufp->allocated = (1<<16); \
  320. !     if (!(bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated))) \
  321.         goto memory_exhausted; \
  322. !     c = bufp->buffer - old_buffer; \
  323. !     b += c; \
  324.       if (fixup_jump) \
  325. !       fixup_jump += c; \
  326.       if (laststart) \
  327. !       laststart += c; \
  328. !     begalt += c; \
  329.       if (pending_exact) \
  330. !       pending_exact += c; \
  331.     }
  332.   
  333. - static int store_jump (), insert_jump ();
  334.   
  335.   char *
  336.   re_compile_pattern (pattern, size, bufp)
  337. --- 175,248 ----
  338.   
  339.   #define PATUNFETCH p--
  340.   
  341. + #ifndef OS2
  342. + #define EXTEND_BUFFER                            \
  343. +   { char *old_buffer = bufp->buffer;                    \
  344. +     if (bufp->allocated == (1L<<16)) goto too_big;            \
  345. +     bufp->allocated *= 2;                        \
  346. +     if (bufp->allocated > (1L<<16)) bufp->allocated = (1L<<16);        \
  347. +     bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated);    \
  348. +     if (bufp->buffer == 0)                        \
  349. +       goto memory_exhausted;                        \
  350. +     b = (b - old_buffer) + bufp->buffer;                \
  351. +     if (fixup_jump)                            \
  352. +       fixup_jump = (fixup_jump - old_buffer) + bufp->buffer;        \
  353. +     if (laststart)                            \
  354. +       laststart = (laststart - old_buffer) + bufp->buffer;        \
  355. +     begalt = (begalt - old_buffer) + bufp->buffer;            \
  356. +     if (pending_exact)                            \
  357. +       pending_exact = (pending_exact - old_buffer) + bufp->buffer;    \
  358. +   }
  359. + #else
  360.   #define EXTEND_BUFFER                            \
  361.     { char *old_buffer = bufp->buffer;                    \
  362. !     if (bufp->allocated == (1L<<15)) goto too_big;                      \
  363.       bufp->allocated *= 2;                        \
  364. !     if (bufp->allocated > (1L<<15)) bufp->allocated = (1L<<15);         \
  365. !     bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated);    \
  366. !     if (bufp->buffer == 0)                        \
  367.         goto memory_exhausted;                        \
  368. !     b = (b - old_buffer) + bufp->buffer;                \
  369.       if (fixup_jump)                            \
  370. !       fixup_jump = (fixup_jump - old_buffer) + bufp->buffer;        \
  371.       if (laststart)                            \
  372. !       laststart = (laststart - old_buffer) + bufp->buffer;        \
  373. !     begalt = (begalt - old_buffer) + bufp->buffer;            \
  374.       if (pending_exact)                            \
  375. !       pending_exact = (pending_exact - old_buffer) + bufp->buffer;    \
  376. !   }
  377. ! #endif
  378. ! 
  379. ! /* Store where `from' points a jump operation to jump to where `to' points.
  380. !   `opcode' is the opcode to store. */
  381. ! 
  382. ! static void
  383. ! store_jump (char *from, char opcode, char *to)
  384. ! {
  385. !   from[0] = opcode;
  386. !   from[1] = (char) ((to - (from + 3)) & 0377);
  387. !   from[2] = (char) ((to - (from + 3)) >> 8);
  388. ! }
  389. ! 
  390. ! /* Open up space at char FROM, and insert there a jump to TO.
  391. !    CURRENT_END gives te end of the storage no in use,
  392. !    so we know how much data to copy up.
  393. !    OP is the opcode of the jump to insert.
  394. ! 
  395. !    If you call this function, you must zero out pending_exact.  */
  396. ! 
  397. ! static void
  398. ! insert_jump (char op, char *from, char *to, char *current_end)
  399. ! {
  400. !   register char *pto = current_end + 3;
  401. !   register char *pfrom = current_end;
  402. ! 
  403. !   while (pfrom != from)
  404. !     *--pto = *--pfrom;
  405. ! 
  406. !   store_jump (from, op, to);
  407.   }
  408.   
  409.   
  410.   char *
  411.   re_compile_pattern (pattern, size, bufp)
  412. ***************
  413. *** 254,260 ****
  414.   #endif
  415.   #endif
  416.   
  417. !   if (bufp->allocated == 0)
  418.       {
  419.         bufp->allocated = 28;
  420.         if (bufp->buffer)
  421. --- 315,321 ----
  422.   #endif
  423.   #endif
  424.   
  425. !   if (bufp->allocated < 28)
  426.       {
  427.         bufp->allocated = 28;
  428.         if (bufp->buffer)
  429. ***************
  430. *** 420,425 ****
  431. --- 481,495 ----
  432.         while (1)
  433.           {
  434.             PATFETCH (c);
  435. + 
  436. +           /* If awk, \ escapes characters when inside [...].  */
  437. +           if ((obscure_syntax & RE_AWK_CLASS_HACK) && c == '\\')
  438. +             {
  439. +               PATFETCH(c1);
  440. +               b[c1 / BYTEWIDTH] |= 1 << (c1 % BYTEWIDTH);
  441. +               continue;
  442. +             }
  443. + 
  444.             if (c == ']' && p != p1 + 1) break;
  445.             if (*p == '-' && p[1] != ']')
  446.           {
  447. ***************
  448. *** 587,596 ****
  449.           case '8':
  450.           case '9':
  451.             c1 = c - '0';
  452. !           if (c1 >= regnum)
  453.           goto normal_char;
  454.             for (stackt = stackp - 2;  stackt > stackb;  stackt -= 4)
  455. !          if (*stackt == c1)
  456.             goto normal_char;
  457.             laststart = b;
  458.             PATPUSH (duplicate);
  459. --- 657,666 ----
  460.           case '8':
  461.           case '9':
  462.             c1 = c - '0';
  463. !           if ((int) c1 >= regnum)
  464.           goto normal_char;
  465.             for (stackt = stackp - 2;  stackt > stackb;  stackt -= 4)
  466. !          if (*stackt == (int) c1)
  467.             goto normal_char;
  468.             laststart = b;
  469.             PATPUSH (duplicate);
  470. ***************
  471. *** 660,697 ****
  472.     return "Memory exhausted";
  473.   }
  474.   
  475. - /* Store where `from' points a jump operation to jump to where `to' points.
  476. -   `opcode' is the opcode to store. */
  477. - 
  478. - static int
  479. - store_jump (from, opcode, to)
  480. -      char *from, *to;
  481. -      char opcode;
  482. - {
  483. -   from[0] = opcode;
  484. -   from[1] = (to - (from + 3)) & 0377;
  485. -   from[2] = (to - (from + 3)) >> 8;
  486. - }
  487. - 
  488. - /* Open up space at char FROM, and insert there a jump to TO.
  489. -    CURRENT_END gives te end of the storage no in use,
  490. -    so we know how much data to copy up.
  491. -    OP is the opcode of the jump to insert.
  492. - 
  493. -    If you call this function, you must zero out pending_exact.  */
  494. - 
  495. - static int
  496. - insert_jump (op, from, to, current_end)
  497. -      char op;
  498. -      char *from, *to, *current_end;
  499. - {
  500. -   register char *pto = current_end + 3;
  501. -   register char *pfrom = current_end;
  502. -   while (pfrom != from)
  503. -     *--pto = *--pfrom;
  504. -   store_jump (from, op, to);
  505. - }
  506. - 
  507.   /* Given a pattern, compute a fastmap from it.
  508.    The fastmap records which of the (1 << BYTEWIDTH) possible characters
  509.    can start a string that matches the pattern.
  510. --- 730,735 ----
  511. ***************
  512. *** 706,716 ****
  513.        struct re_pattern_buffer *bufp;
  514.   {
  515.     unsigned char *pattern = (unsigned char *) bufp->buffer;
  516. !   int size = bufp->used;
  517.     register char *fastmap = bufp->fastmap;
  518.     register unsigned char *p = pattern;
  519.     register unsigned char *pend = pattern + size;
  520. !   register int j, k;
  521.     unsigned char *translate = (unsigned char *) bufp->translate;
  522.   
  523.     unsigned char *stackb[NFAILURES];
  524. --- 744,757 ----
  525.        struct re_pattern_buffer *bufp;
  526.   {
  527.     unsigned char *pattern = (unsigned char *) bufp->buffer;
  528. !   int size = (int) bufp->used;
  529.     register char *fastmap = bufp->fastmap;
  530.     register unsigned char *p = pattern;
  531.     register unsigned char *pend = pattern + size;
  532. !   register int j;
  533. ! #ifdef emacs
  534. !   register int k;
  535. ! #endif
  536.     unsigned char *translate = (unsigned char *) bufp->translate;
  537.   
  538.     unsigned char *stackb[NFAILURES];
  539. ***************
  540. *** 879,885 ****
  541.       break;
  542.       }
  543.   }
  544. ! 
  545.   /* Like re_search_2, below, but only one string is specified. */
  546.   
  547.   int
  548. --- 920,926 ----
  549.       break;
  550.       }
  551.   }
  552. ! 
  553.   /* Like re_search_2, below, but only one string is specified. */
  554.   
  555.   int
  556. ***************
  557. *** 986,996 ****
  558.   
  559.         val = re_match_2 (pbufp, string1, size1, string2, size2, startpos, regs, mstop);
  560.         if (0 <= val)
  561. !     {
  562.         if (val == -2)
  563.           return -2;
  564. -       return startpos;
  565. -     }
  566.   
  567.   #ifdef C_ALLOCA
  568.         alloca (0);
  569. --- 1027,1035 ----
  570.   
  571.         val = re_match_2 (pbufp, string1, size1, string2, size2, startpos, regs, mstop);
  572.         if (0 <= val)
  573. !     return startpos;
  574.         if (val == -2)
  575.       return -2;
  576.   
  577.   #ifdef C_ALLOCA
  578.         alloca (0);
  579. ***************
  580. *** 1002,1008 ****
  581.       }
  582.     return -1;
  583.   }
  584. ! 
  585.   #ifndef emacs   /* emacs never uses this */
  586.   int
  587.   re_match (pbufp, string, size, pos, regs)
  588. --- 1041,1047 ----
  589.       }
  590.     return -1;
  591.   }
  592. ! 
  593.   #ifndef emacs   /* emacs never uses this */
  594.   int
  595.   re_match (pbufp, string, size, pos, regs)
  596. ***************
  597. *** 1019,1025 ****
  598.   
  599.   int re_max_failures = 2000;
  600.   
  601. ! static int bcmp_translate();
  602.   /* Match the pattern described by PBUFP
  603.      against data which is the virtual concatenation of STRING1 and STRING2.
  604.      SIZE1 and SIZE2 are the sizes of the two data strings.
  605. --- 1058,1066 ----
  606.   
  607.   int re_max_failures = 2000;
  608.   
  609. ! static int bcmp_translate (unsigned char *s1, unsigned char *s2, int len,
  610. !                            unsigned char *translate);
  611. ! 
  612.   /* Match the pattern described by PBUFP
  613.      against data which is the virtual concatenation of STRING1 and STRING2.
  614.      SIZE1 and SIZE2 are the sizes of the two data strings.
  615. ***************
  616. *** 1037,1045 ****
  617.      of the substring which was matched.  */
  618.   
  619.   int
  620. ! re_match_2 (pbufp, string1, size1, string2, size2, pos, regs, mstop)
  621.        struct re_pattern_buffer *pbufp;
  622. !      unsigned char *string1, *string2;
  623.        int size1, size2;
  624.        int pos;
  625.        struct re_registers *regs;
  626. --- 1078,1086 ----
  627.      of the substring which was matched.  */
  628.   
  629.   int
  630. ! re_match_2 (pbufp, string1_arg, size1, string2_arg, size2, pos, regs, mstop)
  631.        struct re_pattern_buffer *pbufp;
  632. !      char *string1_arg, *string2_arg;
  633.        int size1, size2;
  634.        int pos;
  635.        struct re_registers *regs;
  636. ***************
  637. *** 1047,1052 ****
  638. --- 1088,1095 ----
  639.   {
  640.     register unsigned char *p = (unsigned char *) pbufp->buffer;
  641.     register unsigned char *pend = p + pbufp->used;
  642. +   unsigned char *string1 = (unsigned char *) string1_arg;
  643. +   unsigned char *string2 = (unsigned char *) string2_arg;
  644.     /* End of first string */
  645.     unsigned char *end1;
  646.     /* End of second string */
  647. ***************
  648. *** 1191,1202 ****
  649.   
  650.       case start_memory:
  651.         regstart[*p] = d;
  652. !        regstart_seg1[*p++] = (dend == end_match_1);
  653.         break;
  654.   
  655.       case stop_memory:
  656.         regend[*p] = d;
  657. !        regend_seg1[*p++] = (dend == end_match_1);
  658.         break;
  659.   
  660.       case duplicate:
  661. --- 1234,1245 ----
  662.   
  663.       case start_memory:
  664.         regstart[*p] = d;
  665. !           regstart_seg1[*p++] = (char) (dend == end_match_1);
  666.         break;
  667.   
  668.       case stop_memory:
  669.         regend[*p] = d;
  670. !           regend_seg1[*p++] = (char) (dend == end_match_1);
  671.         break;
  672.   
  673.       case duplicate:
  674. ***************
  675. *** 1341,1347 ****
  676.           register unsigned char *p1 = p + mcnt;
  677.           /* p1[0] ... p1[2] are an on_failure_jump.
  678.              Examine what follows that */
  679. !         if (p1[3] == (unsigned char) exactn && p1[5] != c)
  680.             p[-3] = (unsigned char) finalize_jump;
  681.           else if (p1[3] == (unsigned char) charset
  682.                || p1[3] == (unsigned char) charset_not)
  683. --- 1384,1390 ----
  684.           register unsigned char *p1 = p + mcnt;
  685.           /* p1[0] ... p1[2] are an on_failure_jump.
  686.              Examine what follows that */
  687. !                 if (p1[3] == (unsigned char) exactn && p1[5] != (char) c)
  688.             p[-3] = (unsigned char) finalize_jump;
  689.           else if (p1[3] == (unsigned char) charset
  690.                || p1[3] == (unsigned char) charset_not)
  691. ***************
  692. *** 1545,1554 ****
  693.   }
  694.   
  695.   static int
  696. ! bcmp_translate (s1, s2, len, translate)
  697. !      unsigned char *s1, *s2;
  698. !      register int len;
  699. !      unsigned char *translate;
  700.   {
  701.     register unsigned char *p1 = s1, *p2 = s2;
  702.     while (len)
  703. --- 1588,1594 ----
  704.   }
  705.   
  706.   static int
  707. ! bcmp_translate (unsigned char *s1, unsigned char *s2, int len, unsigned char *translate)
  708.   {
  709.     register unsigned char *p1 = s1, *p2 = s2;
  710.     while (len)
  711. ***************
  712. *** 1558,1564 ****
  713.       }
  714.     return 0;
  715.   }
  716. ! 
  717.   /* Entry points compatible with bsd4.2 regex library */
  718.   
  719.   #ifndef emacs
  720. --- 1598,1604 ----
  721.       }
  722.     return 0;
  723.   }
  724. ! 
  725.   /* Entry points compatible with bsd4.2 regex library */
  726.   
  727.   #ifndef emacs
  728. ***************
  729. *** 1596,1602 ****
  730.   }
  731.   
  732.   #endif /* emacs */
  733. ! 
  734.   #ifdef test
  735.   
  736.   #include <stdio.h>
  737. --- 1636,1642 ----
  738.   }
  739.   
  740.   #endif /* emacs */
  741. ! 
  742.   #ifdef test
  743.   
  744.   #include <stdio.h>
  745. ***************
  746. *** 1638,1651 ****
  747.       0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377
  748.     };
  749.   
  750. ! main (argc, argv)
  751. !      int argc;
  752. !      char **argv;
  753.   {
  754.     char pat[80];
  755.     struct re_pattern_buffer buf;
  756.     int i;
  757. -   char c;
  758.     char fastmap[(1 << BYTEWIDTH)];
  759.   
  760.     /* Allow a command argument to specify the style of syntax.  */
  761. --- 1678,1733 ----
  762.       0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377
  763.     };
  764.   
  765. ! #ifdef NOTDEF
  766. ! print_buf (bufp)
  767. !      struct re_pattern_buffer *bufp;
  768. ! {
  769. !   int i;
  770. ! 
  771. !   printf ("buf is :\n----------------\n");
  772. !   for (i = 0; i < bufp->used; i++)
  773. !     printchar (bufp->buffer[i]);
  774. ! 
  775. !   printf ("\n%d allocated, %d used.\n", bufp->allocated, bufp->used);
  776. ! 
  777. !   printf ("Allowed by fastmap: ");
  778. !   for (i = 0; i < (1 << BYTEWIDTH); i++)
  779. !     if (bufp->fastmap[i])
  780. !       printchar (i);
  781. !   printf ("\nAllowed by translate: ");
  782. !   if (bufp->translate)
  783. !     for (i = 0; i < (1 << BYTEWIDTH); i++)
  784. !       if (bufp->translate[i])
  785. !     printchar (i);
  786. !   printf ("\nfastmap is%s accurate\n", bufp->fastmap_accurate ? "" : "n't");
  787. !   printf ("can %s be null\n----------", bufp->can_be_null ? "" : "not");
  788. ! }
  789. ! #endif
  790. ! 
  791. ! void printchar (int c)
  792. ! {
  793. !   if (c < 041 || c >= 0177)
  794. !     {
  795. !       putchar ('\\');
  796. !       putchar (((c >> 6) & 3) + '0');
  797. !       putchar (((c >> 3) & 7) + '0');
  798. !       putchar ((c & 7) + '0');
  799. !     }
  800. !   else
  801. !     putchar (c);
  802. ! }
  803. ! 
  804. ! void error (char *string)
  805. ! {
  806. !   puts (string);
  807. !   exit (1);
  808. ! }
  809. ! 
  810. ! void main (int argc, char **argv)
  811.   {
  812.     char pat[80];
  813.     struct re_pattern_buffer buf;
  814.     int i;
  815.     char fastmap[(1 << BYTEWIDTH)];
  816.   
  817.     /* Allow a command argument to specify the style of syntax.  */
  818. ***************
  819. *** 1684,1736 ****
  820.         i = re_match (&buf, pat, strlen (pat), 0, 0);
  821.         printf ("Match value %d.\n", i);
  822.       }
  823. - }
  824. - 
  825. - #ifdef NOTDEF
  826. - print_buf (bufp)
  827. -      struct re_pattern_buffer *bufp;
  828. - {
  829. -   int i;
  830. - 
  831. -   printf ("buf is :\n----------------\n");
  832. -   for (i = 0; i < bufp->used; i++)
  833. -     printchar (bufp->buffer[i]);
  834. - 
  835. -   printf ("\n%d allocated, %d used.\n", bufp->allocated, bufp->used);
  836. - 
  837. -   printf ("Allowed by fastmap: ");
  838. -   for (i = 0; i < (1 << BYTEWIDTH); i++)
  839. -     if (bufp->fastmap[i])
  840. -       printchar (i);
  841. -   printf ("\nAllowed by translate: ");
  842. -   if (bufp->translate)
  843. -     for (i = 0; i < (1 << BYTEWIDTH); i++)
  844. -       if (bufp->translate[i])
  845. -     printchar (i);
  846. -   printf ("\nfastmap is%s accurate\n", bufp->fastmap_accurate ? "" : "n't");
  847. -   printf ("can %s be null\n----------", bufp->can_be_null ? "" : "not");
  848. - }
  849. - #endif
  850. - 
  851. - printchar (c)
  852. -      char c;
  853. - {
  854. -   if (c < 041 || c >= 0177)
  855. -     {
  856. -       putchar ('\\');
  857. -       putchar (((c >> 6) & 3) + '0');
  858. -       putchar (((c >> 3) & 7) + '0');
  859. -       putchar ((c & 7) + '0');
  860. -     }
  861. -   else
  862. -     putchar (c);
  863. - }
  864. - 
  865. - error (string)
  866. -      char *string;
  867. - {
  868. -   puts (string);
  869. -   exit (1);
  870.   }
  871.   
  872.   #endif /* test */
  873. --- 1766,1771 ----
  874. diff -cbBw orig/regex.h grep/regex.h
  875. *** orig/regex.h    Mon May 07 09:08:56 1990
  876. --- grep/regex.h    Sun Jan 19 18:59:04 1992
  877. ***************
  878. *** 1,4 ****
  879. ! /* Definitions for data structures callers pass the regex library.
  880.      Copyright (C) 1985, 1989 Free Software Foundation, Inc.
  881.   
  882.      This program is free software; you can redistribute it and/or modify
  883. --- 1,6 ----
  884. ! /* GNU regex library
  885. ! 
  886. !    Definitions for data structures callers pass the regex library.
  887.      Copyright (C) 1985, 1989 Free Software Foundation, Inc.
  888.   
  889.      This program is free software; you can redistribute it and/or modify
  890. ***************
  891. *** 18,24 ****
  892.   
  893.      In other words, you are welcome to use, share and improve this program.
  894.      You are forbidden to forbid anyone else to use, share and improve
  895. !    what you give them.   Help stamp out software-hoarding!  */
  896.   
  897.   
  898.   /* Define number of parens for which we record the beginnings and ends.
  899. --- 20,27 ----
  900.   
  901.      In other words, you are welcome to use, share and improve this program.
  902.      You are forbidden to forbid anyone else to use, share and improve
  903. !    what you give them.   Help stamp out software-hoarding!
  904. ! */
  905.   
  906.   
  907.   /* Define number of parens for which we record the beginnings and ends.
  908. ***************
  909. *** 61,69 ****
  910.       *, +, ? - only special when not after the beginning, (, or | */
  911.   #define RE_CONTEXT_INDEP_OPS 32
  912.   
  913.   /* Now define combinations of bits for the standard possibilities.  */
  914. ! #define RE_SYNTAX_AWK (RE_NO_BK_PARENS | RE_NO_BK_VBAR | RE_CONTEXT_INDEP_OPS)
  915. ! #define RE_SYNTAX_EGREP (RE_SYNTAX_AWK | RE_NEWLINE_OR)
  916.   #define RE_SYNTAX_GREP (RE_BK_PLUS_QM | RE_NEWLINE_OR)
  917.   #define RE_SYNTAX_EMACS 0
  918.   
  919. --- 64,79 ----
  920.       *, +, ? - only special when not after the beginning, (, or | */
  921.   #define RE_CONTEXT_INDEP_OPS 32
  922.   
  923. + /* 0 means that \ before anything inside [ and ] is taken as a real \.
  924. +    1 means that such a \ escapes the following character.  This is a
  925. +    special case for AWK. */
  926. + #define RE_AWK_CLASS_HACK 64
  927. + 
  928.   /* Now define combinations of bits for the standard possibilities.  */
  929. ! #define RE_SYNTAX_AWK \
  930. !   (RE_NO_BK_PARENS | RE_NO_BK_VBAR | RE_CONTEXT_INDEP_OPS | RE_AWK_CLASS_HACK)
  931. ! #define RE_SYNTAX_EGREP \
  932. !   (RE_NO_BK_PARENS | RE_NO_BK_VBAR | RE_CONTEXT_INDEP_OPS | RE_NEWLINE_OR)
  933.   #define RE_SYNTAX_GREP (RE_BK_PLUS_QM | RE_NEWLINE_OR)
  934.   #define RE_SYNTAX_EMACS 0
  935.   
  936. ***************
  937. *** 169,185 ****
  938.               followed by a byte which contains a syntax code, Sword or such like */
  939.       notsyntaxspec /* Matches any character whose syntax differs from the specified. */
  940.     };
  941. - 
  942. - extern char *re_compile_pattern ();
  943. - /* Is this really advertised? */
  944. - extern void re_compile_fastmap ();
  945. - extern int re_search (), re_search_2 ();
  946. - extern int re_match (), re_match_2 ();
  947.   
  948. ! /* 4.2 bsd compatibility (yuck) */
  949. ! extern char *re_comp ();
  950. ! extern int re_exec ();
  951.   
  952. ! #ifdef SYNTAX_TABLE
  953. ! extern char *re_syntax_table;
  954. ! #endif
  955. --- 179,203 ----
  956.                     followed by a byte which contains a syntax code, Sword or such like */
  957.     notsyntaxspec /* Matches any character whose syntax differs from the specified. */
  958.   };
  959.   
  960. ! extern char *re_compile_pattern(char *pattern, int size,
  961. !   struct re_pattern_buffer *bufp);
  962.   
  963. ! extern void re_compile_fastmap(struct re_pattern_buffer *bufp);
  964. ! 
  965. ! extern int re_search(struct re_pattern_buffer *pbufp, char *string, int size,
  966. !   int startpos, int range, struct re_registers *regs);
  967. ! 
  968. ! extern int re_search_2(struct re_pattern_buffer *pbufp, char *string1,
  969. !   int size1, char *string2, int size2, int startpos, int range,
  970. !   struct re_registers *regs, int mstop);
  971. ! 
  972. ! extern int re_match(struct re_pattern_buffer *pbufp, char *string, int size,
  973. !   int pos, struct re_registers *regs);
  974. ! 
  975. ! extern int re_match_2(struct re_pattern_buffer *pbufp, char *string1_arg, int size1,
  976. !   char *string2_arg, int size2, int pos, struct re_registers *regs, int mstop);
  977. ! 
  978. ! /* 4.2 bsd compatibility (yuck) */
  979. ! extern char *re_comp(char *s);
  980. ! extern int re_exec(char *s);
  981.