home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / GNUGRE.ZIP / grep.patch < prev    next >
Text File  |  1992-07-18  |  7KB  |  252 lines
  1. diff -cbr orig/grep/dfa.c new/grep/dfa.c
  2. *** orig/grep/dfa.c    Tue May 05 19:32:05 1992
  3. --- new/grep/dfa.c    Thu Jun 18 15:42:18 1992
  4. ***************
  5. *** 31,36 ****
  6. --- 31,37 ----
  7.   #endif
  8.   
  9.   #include "dfa.h"
  10. + #include "regex.h"
  11.   
  12.   #if __STDC__
  13.   typedef void *ptr_t;
  14. diff -cbr orig/grep/dfa.h new/grep/dfa.h
  15. *** orig/grep/dfa.h    Mon May 04 13:43:28 1992
  16. --- new/grep/dfa.h    Thu Jun 18 15:45:13 1992
  17. ***************
  18. *** 48,53 ****
  19. --- 48,55 ----
  20.   #define ISLOWER(c) (isascii(c) && islower(c))
  21.   #endif
  22.   
  23. + #if 0 /* This is really defined in regex.h */
  24. + 
  25.   /* 1 means plain parentheses serve as grouping, and backslash
  26.        parentheses are needed for literal searching.
  27.      0 means backslash-parentheses are grouping, and plain parentheses
  28. ***************
  29. *** 84,89 ****
  30. --- 86,94 ----
  31.   #define RE_SYNTAX_EGREP (RE_SYNTAX_AWK | RE_NEWLINE_OR)
  32.   #define RE_SYNTAX_GREP (RE_BK_PLUS_QM | RE_NEWLINE_OR)
  33.   #define RE_SYNTAX_EMACS 0
  34. + 
  35. + #endif
  36. + 
  37.   
  38.   /* Number of bits in an unsigned char. */
  39.   #define CHARBITS 8
  40. diff -cbr orig/grep/grep.c new/grep/grep.c
  41. *** orig/grep/grep.c    Tue May 05 19:40:10 1992
  42. --- new/grep/grep.c    Thu Jun 18 16:11:12 1992
  43. ***************
  44. *** 38,47 ****
  45.   
  46.   #ifndef STDC_HEADERS
  47.   extern char *getenv();
  48. - #endif
  49.   extern int errno;
  50. - 
  51.   extern char *sys_errlist[];
  52.   
  53.   #include "dfa.h"
  54.   #include "regex.h"
  55. --- 38,46 ----
  56.   
  57.   #ifndef STDC_HEADERS
  58.   extern char *getenv();
  59.   extern int errno;
  60.   extern char *sys_errlist[];
  61. + #endif
  62.   
  63.   #include "dfa.h"
  64.   #include "regex.h"
  65. ***************
  66. *** 534,550 ****
  67.     return match_count;
  68.   }
  69.   
  70.   void
  71.   usage_and_die()
  72.   {
  73. !   fprintf(stderr, "\
  74. ! Usage: %s [-CVbchilnsvwx] [-num] [-A num] [-B num] [-f file]\n\
  75. !        [-e] expr [file...]\n", prog);
  76.     exit(ERROR);
  77.   }
  78.   
  79. - static char version[] = "GNU e?grep, version 1.6";
  80. - 
  81.   int
  82.   main(argc, argv)
  83.        int argc;
  84. --- 533,572 ----
  85.     return match_count;
  86.   }
  87.   
  88. + static char version[] = "GNU e?grep, version 1.6";
  89. + 
  90.   void
  91.   usage_and_die()
  92.   {
  93. !   printf("\n%s\n", version);
  94. !   printf("\nUsage: %s [-CVbchilnsvwx] [-<num>] [-A <num>] [-B <num>]"
  95. !          "\n       [-f file] [-e] expr [files]\n\n", prog);
  96. !   printf(
  97. !   "  -A <num>  print <num> lines of context after every matching line\n"
  98. !   "  -B <num>  print <num> lines of context before every matching line\n"
  99. !   "  -C        print 2 lines of context on each side of every match\n"
  100. !   "  -<num>    print <num> lines of context on each side\n"
  101. !   "  -V        print the version number on stderr\n"
  102. !   );
  103. !   printf(
  104. !   "  -b        print every match preceded by its byte offset\n"
  105. !   "  -c        print a total count of matching lines only\n"
  106. !   "  -e <expr> search for <expr>; useful if <expr> begins with -\n"
  107. !   "  -f <file> take <expr> from the given <file>\n"
  108. !   "  -h        don't display filenames on matches\n"
  109. !   "  -i        ignore case difference when comparing strings\n"
  110. !   );
  111. !   printf(
  112. !   "  -l        list files containing matches only\n"
  113. !   "  -n        print each match preceded by its line number\n"
  114. !   "  -s        run silently producing no output except error messages\n"
  115. !   "  -v        print only lines that contain no matches for the <expr>\n"
  116. !   "  -w        print only lines where the match is a complete word\n"
  117. !   "  -x        print only lines where the match is a whole line\n");
  118. ! 
  119.     exit(ERROR);
  120.   }
  121.   
  122.   int
  123.   main(argc, argv)
  124.        int argc;
  125. ***************
  126. *** 563,568 ****
  127. --- 585,595 ----
  128.     char translate[_NOTCHAR];    /* Translate table for case conversion
  129.                      (needed by the backtracking matcher). */
  130.   
  131. + #ifdef __EMX__
  132. +   _wildcard(&argc, &argv);
  133. +   setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
  134. + #endif
  135. + 
  136.     if (prog = index(argv[0], '/'))
  137.       ++prog;
  138.     else
  139. ***************
  140. *** 607,613 ****
  141.       break;
  142.   
  143.         case 'V':
  144. !     fprintf(stderr, "%s\n", version);
  145.       break;
  146.   
  147.         case 'b':
  148. --- 634,641 ----
  149.       break;
  150.   
  151.         case 'V':
  152. !         fprintf(stderr, "\n%s\n", version);
  153. !         exit(ERROR);
  154.       break;
  155.   
  156.         case 'b':
  157. ***************
  158. *** 725,730 ****
  159. --- 753,761 ----
  160.     else
  161.       regexp_len = strlen(the_regexp);
  162.   
  163. +   if (regex_errmesg = re_compile_pattern(the_regexp, regexp_len, ®ex))
  164. +     regerror(regex_errmesg);
  165. + 
  166.     if (whole_word || whole_line)
  167.       {
  168.         /* In the whole-word case, we use the pattern:
  169. ***************
  170. *** 734,766 ****
  171.        BUG: Using [A-Za-z_] is locale-dependent!  */
  172.   
  173.         char *n = malloc(regexp_len + 50);
  174. !       int i = 0;
  175.   
  176.   #ifdef EGREP
  177.         if (whole_word)
  178. !     strcpy(n, "(^|[^A-Za-z_])(");
  179. !       else
  180. !     strcpy(n, "^(");
  181.   #else
  182.         /* Todo:  Make *sure* this is the right syntax.  Down with grep! */
  183.         if (whole_word)
  184. !     strcpy(n, "\\(^\\|[^A-Za-z_]\\)\\(");
  185. !       else
  186. !     strcpy(n, "^\\(");
  187.   #endif
  188.         i = strlen(n);
  189.         bcopy(the_regexp, n + i, regexp_len);
  190.         i += regexp_len;
  191.   #ifdef EGREP
  192.         if (whole_word)
  193. !     strcpy(n + i, ")([^A-Za-z_]|$)");
  194. !       else
  195. !     strcpy(n + i, ")$");
  196.   #else
  197.         if (whole_word)
  198. !     strcpy(n + i, "\\)\\([^A-Za-z_]\\|$\\)");
  199. !       else
  200. !     strcpy(n + i, "\\)$");
  201.   #endif
  202.         i += strlen(n + i);
  203.         regcompile(n, i, ®, 1);
  204. --- 765,799 ----
  205.        BUG: Using [A-Za-z_] is locale-dependent!  */
  206.   
  207.         char *n = malloc(regexp_len + 50);
  208. !       int i;
  209.   
  210. +       n[0] = 0;
  211.   #ifdef EGREP
  212. +       if (whole_line)
  213. +     strcat(n, "^(");
  214.         if (whole_word)
  215. !     strcat(n, "(^|[^A-Za-z_])(");
  216.   #else
  217.         /* Todo:  Make *sure* this is the right syntax.  Down with grep! */
  218. +       if (whole_line)
  219. +     strcat(n, "^\\(");
  220.         if (whole_word)
  221. !     strcat(n, "\\(^\\|[^A-Za-z_]\\)\\(");
  222.   #endif
  223.         i = strlen(n);
  224.         bcopy(the_regexp, n + i, regexp_len);
  225.         i += regexp_len;
  226. +       n[i] = 0;
  227.   #ifdef EGREP
  228.         if (whole_word)
  229. !     strcat(n + i, ")([^A-Za-z_]|$)");
  230. !       if (whole_line)
  231. !     strcat(n + i, ")$");
  232.   #else
  233.         if (whole_word)
  234. !     strcat(n + i, "\\)\\([^A-Za-z_]\\|$\\)");
  235. !       if (whole_line)
  236. !     strcat(n + i, "\\)$");
  237.   #endif
  238.         i += strlen(n + i);
  239.         regcompile(n, i, ®, 1);
  240. ***************
  241. *** 768,776 ****
  242.     else
  243.       regcompile(the_regexp, regexp_len, ®, 1);
  244.   
  245. - 
  246. -   if (regex_errmesg = re_compile_pattern(the_regexp, regexp_len, ®ex))
  247. -     regerror(regex_errmesg);
  248.   
  249.     /*
  250.       Find the longest metacharacter-free string which must occur in the
  251. --- 801,806 ----
  252.