Annotation of embedaddon/pcre/pcregrep.c, revision 1.1.1.1
1.1 misho 1: /*************************************************
2: * pcregrep program *
3: *************************************************/
4:
5: /* This is a grep program that uses the PCRE regular expression library to do
6: its pattern matching. On a Unix or Win32 system it can recurse into
7: directories.
8:
9: Copyright (c) 1997-2011 University of Cambridge
10:
11: -----------------------------------------------------------------------------
12: Redistribution and use in source and binary forms, with or without
13: modification, are permitted provided that the following conditions are met:
14:
15: * Redistributions of source code must retain the above copyright notice,
16: this list of conditions and the following disclaimer.
17:
18: * Redistributions in binary form must reproduce the above copyright
19: notice, this list of conditions and the following disclaimer in the
20: documentation and/or other materials provided with the distribution.
21:
22: * Neither the name of the University of Cambridge nor the names of its
23: contributors may be used to endorse or promote products derived from
24: this software without specific prior written permission.
25:
26: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30: LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31: CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32: SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35: ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36: POSSIBILITY OF SUCH DAMAGE.
37: -----------------------------------------------------------------------------
38: */
39:
40: #ifdef HAVE_CONFIG_H
41: #include "config.h"
42: #endif
43:
44: #include <ctype.h>
45: #include <locale.h>
46: #include <stdio.h>
47: #include <string.h>
48: #include <stdlib.h>
49: #include <errno.h>
50:
51: #include <sys/types.h>
52: #include <sys/stat.h>
53:
54: #ifdef HAVE_UNISTD_H
55: #include <unistd.h>
56: #endif
57:
58: #ifdef SUPPORT_LIBZ
59: #include <zlib.h>
60: #endif
61:
62: #ifdef SUPPORT_LIBBZ2
63: #include <bzlib.h>
64: #endif
65:
66: #include "pcre.h"
67:
68: #define FALSE 0
69: #define TRUE 1
70:
71: typedef int BOOL;
72:
73: #define MAX_PATTERN_COUNT 100
74: #define OFFSET_SIZE 99
75:
76: #if BUFSIZ > 8192
77: #define PATBUFSIZE BUFSIZ
78: #else
79: #define PATBUFSIZE 8192
80: #endif
81:
82: /* Values for the "filenames" variable, which specifies options for file name
83: output. The order is important; it is assumed that a file name is wanted for
84: all values greater than FN_DEFAULT. */
85:
86: enum { FN_NONE, FN_DEFAULT, FN_MATCH_ONLY, FN_NOMATCH_ONLY, FN_FORCE };
87:
88: /* File reading styles */
89:
90: enum { FR_PLAIN, FR_LIBZ, FR_LIBBZ2 };
91:
92: /* Actions for the -d and -D options */
93:
94: enum { dee_READ, dee_SKIP, dee_RECURSE };
95: enum { DEE_READ, DEE_SKIP };
96:
97: /* Actions for special processing options (flag bits) */
98:
99: #define PO_WORD_MATCH 0x0001
100: #define PO_LINE_MATCH 0x0002
101: #define PO_FIXED_STRINGS 0x0004
102:
103: /* Line ending types */
104:
105: enum { EL_LF, EL_CR, EL_CRLF, EL_ANY, EL_ANYCRLF };
106:
107: /* In newer versions of gcc, with FORTIFY_SOURCE set (the default in some
108: environments), a warning is issued if the value of fwrite() is ignored.
109: Unfortunately, casting to (void) does not suppress the warning. To get round
110: this, we use a macro that compiles a fudge. Oddly, this does not also seem to
111: apply to fprintf(). */
112:
113: #define FWRITE(a,b,c,d) if (fwrite(a,b,c,d)) {}
114:
115:
116:
117: /*************************************************
118: * Global variables *
119: *************************************************/
120:
121: /* Jeffrey Friedl has some debugging requirements that are not part of the
122: regular code. */
123:
124: #ifdef JFRIEDL_DEBUG
125: static int S_arg = -1;
126: static unsigned int jfriedl_XR = 0; /* repeat regex attempt this many times */
127: static unsigned int jfriedl_XT = 0; /* replicate text this many times */
128: static const char *jfriedl_prefix = "";
129: static const char *jfriedl_postfix = "";
130: #endif
131:
132: static int endlinetype;
133:
134: static char *colour_string = (char *)"1;31";
135: static char *colour_option = NULL;
136: static char *dee_option = NULL;
137: static char *DEE_option = NULL;
138: static char *main_buffer = NULL;
139: static char *newline = NULL;
140: static char *pattern_filename = NULL;
141: static char *stdin_name = (char *)"(standard input)";
142: static char *locale = NULL;
143:
144: static const unsigned char *pcretables = NULL;
145:
146: static int pattern_count = 0;
147: static pcre **pattern_list = NULL;
148: static pcre_extra **hints_list = NULL;
149:
150: static char *include_pattern = NULL;
151: static char *exclude_pattern = NULL;
152: static char *include_dir_pattern = NULL;
153: static char *exclude_dir_pattern = NULL;
154:
155: static pcre *include_compiled = NULL;
156: static pcre *exclude_compiled = NULL;
157: static pcre *include_dir_compiled = NULL;
158: static pcre *exclude_dir_compiled = NULL;
159:
160: static int after_context = 0;
161: static int before_context = 0;
162: static int both_context = 0;
163: static int bufthird = PCREGREP_BUFSIZE;
164: static int bufsize = 3*PCREGREP_BUFSIZE;
165: static int dee_action = dee_READ;
166: static int DEE_action = DEE_READ;
167: static int error_count = 0;
168: static int filenames = FN_DEFAULT;
169: static int only_matching = -1;
170: static int process_options = 0;
171:
172: #ifdef SUPPORT_PCREGREP_JIT
173: static int study_options = PCRE_STUDY_JIT_COMPILE;
174: #else
175: static int study_options = 0;
176: #endif
177:
178: static unsigned long int match_limit = 0;
179: static unsigned long int match_limit_recursion = 0;
180:
181: static BOOL count_only = FALSE;
182: static BOOL do_colour = FALSE;
183: static BOOL file_offsets = FALSE;
184: static BOOL hyphenpending = FALSE;
185: static BOOL invert = FALSE;
186: static BOOL line_buffered = FALSE;
187: static BOOL line_offsets = FALSE;
188: static BOOL multiline = FALSE;
189: static BOOL number = FALSE;
190: static BOOL omit_zero_count = FALSE;
191: static BOOL resource_error = FALSE;
192: static BOOL quiet = FALSE;
193: static BOOL silent = FALSE;
194: static BOOL utf8 = FALSE;
195:
196: /* Structure for options and list of them */
197:
198: enum { OP_NODATA, OP_STRING, OP_OP_STRING, OP_NUMBER, OP_LONGNUMBER,
199: OP_OP_NUMBER, OP_PATLIST };
200:
201: typedef struct option_item {
202: int type;
203: int one_char;
204: void *dataptr;
205: const char *long_name;
206: const char *help_text;
207: } option_item;
208:
209: /* Options without a single-letter equivalent get a negative value. This can be
210: used to identify them. */
211:
212: #define N_COLOUR (-1)
213: #define N_EXCLUDE (-2)
214: #define N_EXCLUDE_DIR (-3)
215: #define N_HELP (-4)
216: #define N_INCLUDE (-5)
217: #define N_INCLUDE_DIR (-6)
218: #define N_LABEL (-7)
219: #define N_LOCALE (-8)
220: #define N_NULL (-9)
221: #define N_LOFFSETS (-10)
222: #define N_FOFFSETS (-11)
223: #define N_LBUFFER (-12)
224: #define N_M_LIMIT (-13)
225: #define N_M_LIMIT_REC (-14)
226: #define N_BUFSIZE (-15)
227: #define N_NOJIT (-16)
228:
229: static option_item optionlist[] = {
230: { OP_NODATA, N_NULL, NULL, "", " terminate options" },
231: { OP_NODATA, N_HELP, NULL, "help", "display this help and exit" },
232: { OP_NUMBER, 'A', &after_context, "after-context=number", "set number of following context lines" },
233: { OP_NUMBER, 'B', &before_context, "before-context=number", "set number of prior context lines" },
234: { OP_NUMBER, N_BUFSIZE,&bufthird, "buffer-size=number", "set processing buffer size parameter" },
235: { OP_OP_STRING, N_COLOUR, &colour_option, "color=option", "matched text color option" },
236: { OP_OP_STRING, N_COLOUR, &colour_option, "colour=option", "matched text colour option" },
237: { OP_NUMBER, 'C', &both_context, "context=number", "set number of context lines, before & after" },
238: { OP_NODATA, 'c', NULL, "count", "print only a count of matching lines per FILE" },
239: { OP_STRING, 'D', &DEE_option, "devices=action","how to handle devices, FIFOs, and sockets" },
240: { OP_STRING, 'd', &dee_option, "directories=action", "how to handle directories" },
241: { OP_PATLIST, 'e', NULL, "regex(p)=pattern", "specify pattern (may be used more than once)" },
242: { OP_NODATA, 'F', NULL, "fixed-strings", "patterns are sets of newline-separated strings" },
243: { OP_STRING, 'f', &pattern_filename, "file=path", "read patterns from file" },
244: { OP_NODATA, N_FOFFSETS, NULL, "file-offsets", "output file offsets, not text" },
245: { OP_NODATA, 'H', NULL, "with-filename", "force the prefixing filename on output" },
246: { OP_NODATA, 'h', NULL, "no-filename", "suppress the prefixing filename on output" },
247: { OP_NODATA, 'i', NULL, "ignore-case", "ignore case distinctions" },
248: #ifdef SUPPORT_PCREGREP_JIT
249: { OP_NODATA, N_NOJIT, NULL, "no-jit", "do not use just-in-time compiler optimization" },
250: #else
251: { OP_NODATA, N_NOJIT, NULL, "no-jit", "ignored: this pcregrep does not support JIT" },
252: #endif
253: { OP_NODATA, 'l', NULL, "files-with-matches", "print only FILE names containing matches" },
254: { OP_NODATA, 'L', NULL, "files-without-match","print only FILE names not containing matches" },
255: { OP_STRING, N_LABEL, &stdin_name, "label=name", "set name for standard input" },
256: { OP_NODATA, N_LBUFFER, NULL, "line-buffered", "use line buffering" },
257: { OP_NODATA, N_LOFFSETS, NULL, "line-offsets", "output line numbers and offsets, not text" },
258: { OP_STRING, N_LOCALE, &locale, "locale=locale", "use the named locale" },
259: { OP_LONGNUMBER, N_M_LIMIT, &match_limit, "match-limit=number", "set PCRE match limit option" },
260: { OP_LONGNUMBER, N_M_LIMIT_REC, &match_limit_recursion, "recursion-limit=number", "set PCRE match recursion limit option" },
261: { OP_NODATA, 'M', NULL, "multiline", "run in multiline mode" },
262: { OP_STRING, 'N', &newline, "newline=type", "set newline type (CR, LF, CRLF, ANYCRLF or ANY)" },
263: { OP_NODATA, 'n', NULL, "line-number", "print line number with output lines" },
264: { OP_OP_NUMBER, 'o', &only_matching, "only-matching=n", "show only the part of the line that matched" },
265: { OP_NODATA, 'q', NULL, "quiet", "suppress output, just set return code" },
266: { OP_NODATA, 'r', NULL, "recursive", "recursively scan sub-directories" },
267: { OP_STRING, N_EXCLUDE,&exclude_pattern, "exclude=pattern","exclude matching files when recursing" },
268: { OP_STRING, N_INCLUDE,&include_pattern, "include=pattern","include matching files when recursing" },
269: { OP_STRING, N_EXCLUDE_DIR,&exclude_dir_pattern, "exclude-dir=pattern","exclude matching directories when recursing" },
270: { OP_STRING, N_INCLUDE_DIR,&include_dir_pattern, "include-dir=pattern","include matching directories when recursing" },
271:
272: /* These two were accidentally implemented with underscores instead of
273: hyphens in the option names. As this was not discovered for several releases,
274: the incorrect versions are left in the table for compatibility. However, the
275: --help function misses out any option that has an underscore in its name. */
276:
277: { OP_STRING, N_EXCLUDE_DIR,&exclude_dir_pattern, "exclude_dir=pattern","exclude matching directories when recursing" },
278: { OP_STRING, N_INCLUDE_DIR,&include_dir_pattern, "include_dir=pattern","include matching directories when recursing" },
279:
280: #ifdef JFRIEDL_DEBUG
281: { OP_OP_NUMBER, 'S', &S_arg, "jeffS", "replace matched (sub)string with X" },
282: #endif
283: { OP_NODATA, 's', NULL, "no-messages", "suppress error messages" },
284: { OP_NODATA, 'u', NULL, "utf-8", "use UTF-8 mode" },
285: { OP_NODATA, 'V', NULL, "version", "print version information and exit" },
286: { OP_NODATA, 'v', NULL, "invert-match", "select non-matching lines" },
287: { OP_NODATA, 'w', NULL, "word-regex(p)", "force patterns to match only as words" },
288: { OP_NODATA, 'x', NULL, "line-regex(p)", "force patterns to match only whole lines" },
289: { OP_NODATA, 0, NULL, NULL, NULL }
290: };
291:
292: /* Tables for prefixing and suffixing patterns, according to the -w, -x, and -F
293: options. These set the 1, 2, and 4 bits in process_options, respectively. Note
294: that the combination of -w and -x has the same effect as -x on its own, so we
295: can treat them as the same. */
296:
297: static const char *prefix[] = {
298: "", "\\b", "^(?:", "^(?:", "\\Q", "\\b\\Q", "^(?:\\Q", "^(?:\\Q" };
299:
300: static const char *suffix[] = {
301: "", "\\b", ")$", ")$", "\\E", "\\E\\b", "\\E)$", "\\E)$" };
302:
303: /* UTF-8 tables - used only when the newline setting is "any". */
304:
305: const int utf8_table3[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
306:
307: const char utf8_table4[] = {
308: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
309: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
310: 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
311: 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
312:
313:
314:
315: /*************************************************
316: * Exit from the program *
317: *************************************************/
318:
319: /* If there has been a resource error, give a suitable message.
320:
321: Argument: the return code
322: Returns: does not return
323: */
324:
325: static void
326: pcregrep_exit(int rc)
327: {
328: if (resource_error)
329: {
330: fprintf(stderr, "pcregrep: Error %d, %d or %d means that a resource limit "
331: "was exceeded.\n", PCRE_ERROR_MATCHLIMIT, PCRE_ERROR_RECURSIONLIMIT,
332: PCRE_ERROR_JIT_STACKLIMIT);
333: fprintf(stderr, "pcregrep: Check your regex for nested unlimited loops.\n");
334: }
335:
336: exit(rc);
337: }
338:
339:
340: /*************************************************
341: * OS-specific functions *
342: *************************************************/
343:
344: /* These functions are defined so that they can be made system specific,
345: although at present the only ones are for Unix, Win32, and for "no support". */
346:
347:
348: /************* Directory scanning in Unix ***********/
349:
350: #if defined HAVE_SYS_STAT_H && defined HAVE_DIRENT_H && defined HAVE_SYS_TYPES_H
351: #include <sys/types.h>
352: #include <sys/stat.h>
353: #include <dirent.h>
354:
355: typedef DIR directory_type;
356:
357: static int
358: isdirectory(char *filename)
359: {
360: struct stat statbuf;
361: if (stat(filename, &statbuf) < 0)
362: return 0; /* In the expectation that opening as a file will fail */
363: return ((statbuf.st_mode & S_IFMT) == S_IFDIR)? '/' : 0;
364: }
365:
366: static directory_type *
367: opendirectory(char *filename)
368: {
369: return opendir(filename);
370: }
371:
372: static char *
373: readdirectory(directory_type *dir)
374: {
375: for (;;)
376: {
377: struct dirent *dent = readdir(dir);
378: if (dent == NULL) return NULL;
379: if (strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0)
380: return dent->d_name;
381: }
382: /* Control never reaches here */
383: }
384:
385: static void
386: closedirectory(directory_type *dir)
387: {
388: closedir(dir);
389: }
390:
391:
392: /************* Test for regular file in Unix **********/
393:
394: static int
395: isregfile(char *filename)
396: {
397: struct stat statbuf;
398: if (stat(filename, &statbuf) < 0)
399: return 1; /* In the expectation that opening as a file will fail */
400: return (statbuf.st_mode & S_IFMT) == S_IFREG;
401: }
402:
403:
404: /************* Test for a terminal in Unix **********/
405:
406: static BOOL
407: is_stdout_tty(void)
408: {
409: return isatty(fileno(stdout));
410: }
411:
412: static BOOL
413: is_file_tty(FILE *f)
414: {
415: return isatty(fileno(f));
416: }
417:
418:
419: /************* Directory scanning in Win32 ***********/
420:
421: /* I (Philip Hazel) have no means of testing this code. It was contributed by
422: Lionel Fourquaux. David Burgess added a patch to define INVALID_FILE_ATTRIBUTES
423: when it did not exist. David Byron added a patch that moved the #include of
424: <windows.h> to before the INVALID_FILE_ATTRIBUTES definition rather than after.
425: The double test below stops gcc 4.4.4 grumbling that HAVE_WINDOWS_H is
426: undefined when it is indeed undefined. */
427:
428: #elif defined HAVE_WINDOWS_H && HAVE_WINDOWS_H
429:
430: #ifndef STRICT
431: # define STRICT
432: #endif
433: #ifndef WIN32_LEAN_AND_MEAN
434: # define WIN32_LEAN_AND_MEAN
435: #endif
436:
437: #include <windows.h>
438:
439: #ifndef INVALID_FILE_ATTRIBUTES
440: #define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
441: #endif
442:
443: typedef struct directory_type
444: {
445: HANDLE handle;
446: BOOL first;
447: WIN32_FIND_DATA data;
448: } directory_type;
449:
450: int
451: isdirectory(char *filename)
452: {
453: DWORD attr = GetFileAttributes(filename);
454: if (attr == INVALID_FILE_ATTRIBUTES)
455: return 0;
456: return ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) ? '/' : 0;
457: }
458:
459: directory_type *
460: opendirectory(char *filename)
461: {
462: size_t len;
463: char *pattern;
464: directory_type *dir;
465: DWORD err;
466: len = strlen(filename);
467: pattern = (char *) malloc(len + 3);
468: dir = (directory_type *) malloc(sizeof(*dir));
469: if ((pattern == NULL) || (dir == NULL))
470: {
471: fprintf(stderr, "pcregrep: malloc failed\n");
472: pcregrep_exit(2);
473: }
474: memcpy(pattern, filename, len);
475: memcpy(&(pattern[len]), "\\*", 3);
476: dir->handle = FindFirstFile(pattern, &(dir->data));
477: if (dir->handle != INVALID_HANDLE_VALUE)
478: {
479: free(pattern);
480: dir->first = TRUE;
481: return dir;
482: }
483: err = GetLastError();
484: free(pattern);
485: free(dir);
486: errno = (err == ERROR_ACCESS_DENIED) ? EACCES : ENOENT;
487: return NULL;
488: }
489:
490: char *
491: readdirectory(directory_type *dir)
492: {
493: for (;;)
494: {
495: if (!dir->first)
496: {
497: if (!FindNextFile(dir->handle, &(dir->data)))
498: return NULL;
499: }
500: else
501: {
502: dir->first = FALSE;
503: }
504: if (strcmp(dir->data.cFileName, ".") != 0 && strcmp(dir->data.cFileName, "..") != 0)
505: return dir->data.cFileName;
506: }
507: #ifndef _MSC_VER
508: return NULL; /* Keep compiler happy; never executed */
509: #endif
510: }
511:
512: void
513: closedirectory(directory_type *dir)
514: {
515: FindClose(dir->handle);
516: free(dir);
517: }
518:
519:
520: /************* Test for regular file in Win32 **********/
521:
522: /* I don't know how to do this, or if it can be done; assume all paths are
523: regular if they are not directories. */
524:
525: int isregfile(char *filename)
526: {
527: return !isdirectory(filename);
528: }
529:
530:
531: /************* Test for a terminal in Win32 **********/
532:
533: /* I don't know how to do this; assume never */
534:
535: static BOOL
536: is_stdout_tty(void)
537: {
538: return FALSE;
539: }
540:
541: static BOOL
542: is_file_tty(FILE *f)
543: {
544: return FALSE;
545: }
546:
547:
548: /************* Directory scanning when we can't do it ***********/
549:
550: /* The type is void, and apart from isdirectory(), the functions do nothing. */
551:
552: #else
553:
554: typedef void directory_type;
555:
556: int isdirectory(char *filename) { return 0; }
557: directory_type * opendirectory(char *filename) { return (directory_type*)0;}
558: char *readdirectory(directory_type *dir) { return (char*)0;}
559: void closedirectory(directory_type *dir) {}
560:
561:
562: /************* Test for regular when we can't do it **********/
563:
564: /* Assume all files are regular. */
565:
566: int isregfile(char *filename) { return 1; }
567:
568:
569: /************* Test for a terminal when we can't do it **********/
570:
571: static BOOL
572: is_stdout_tty(void)
573: {
574: return FALSE;
575: }
576:
577: static BOOL
578: is_file_tty(FILE *f)
579: {
580: return FALSE;
581: }
582:
583: #endif
584:
585:
586:
587: #ifndef HAVE_STRERROR
588: /*************************************************
589: * Provide strerror() for non-ANSI libraries *
590: *************************************************/
591:
592: /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
593: in their libraries, but can provide the same facility by this simple
594: alternative function. */
595:
596: extern int sys_nerr;
597: extern char *sys_errlist[];
598:
599: char *
600: strerror(int n)
601: {
602: if (n < 0 || n >= sys_nerr) return "unknown error number";
603: return sys_errlist[n];
604: }
605: #endif /* HAVE_STRERROR */
606:
607:
608:
609: /*************************************************
610: * Read one line of input *
611: *************************************************/
612:
613: /* Normally, input is read using fread() into a large buffer, so many lines may
614: be read at once. However, doing this for tty input means that no output appears
615: until a lot of input has been typed. Instead, tty input is handled line by
616: line. We cannot use fgets() for this, because it does not stop at a binary
617: zero, and therefore there is no way of telling how many characters it has read,
618: because there may be binary zeros embedded in the data.
619:
620: Arguments:
621: buffer the buffer to read into
622: length the maximum number of characters to read
623: f the file
624:
625: Returns: the number of characters read, zero at end of file
626: */
627:
628: static int
629: read_one_line(char *buffer, int length, FILE *f)
630: {
631: int c;
632: int yield = 0;
633: while ((c = fgetc(f)) != EOF)
634: {
635: buffer[yield++] = c;
636: if (c == '\n' || yield >= length) break;
637: }
638: return yield;
639: }
640:
641:
642:
643: /*************************************************
644: * Find end of line *
645: *************************************************/
646:
647: /* The length of the endline sequence that is found is set via lenptr. This may
648: be zero at the very end of the file if there is no line-ending sequence there.
649:
650: Arguments:
651: p current position in line
652: endptr end of available data
653: lenptr where to put the length of the eol sequence
654:
655: Returns: pointer after the last byte of the line,
656: including the newline byte(s)
657: */
658:
659: static char *
660: end_of_line(char *p, char *endptr, int *lenptr)
661: {
662: switch(endlinetype)
663: {
664: default: /* Just in case */
665: case EL_LF:
666: while (p < endptr && *p != '\n') p++;
667: if (p < endptr)
668: {
669: *lenptr = 1;
670: return p + 1;
671: }
672: *lenptr = 0;
673: return endptr;
674:
675: case EL_CR:
676: while (p < endptr && *p != '\r') p++;
677: if (p < endptr)
678: {
679: *lenptr = 1;
680: return p + 1;
681: }
682: *lenptr = 0;
683: return endptr;
684:
685: case EL_CRLF:
686: for (;;)
687: {
688: while (p < endptr && *p != '\r') p++;
689: if (++p >= endptr)
690: {
691: *lenptr = 0;
692: return endptr;
693: }
694: if (*p == '\n')
695: {
696: *lenptr = 2;
697: return p + 1;
698: }
699: }
700: break;
701:
702: case EL_ANYCRLF:
703: while (p < endptr)
704: {
705: int extra = 0;
706: register int c = *((unsigned char *)p);
707:
708: if (utf8 && c >= 0xc0)
709: {
710: int gcii, gcss;
711: extra = utf8_table4[c & 0x3f]; /* Number of additional bytes */
712: gcss = 6*extra;
713: c = (c & utf8_table3[extra]) << gcss;
714: for (gcii = 1; gcii <= extra; gcii++)
715: {
716: gcss -= 6;
717: c |= (p[gcii] & 0x3f) << gcss;
718: }
719: }
720:
721: p += 1 + extra;
722:
723: switch (c)
724: {
725: case 0x0a: /* LF */
726: *lenptr = 1;
727: return p;
728:
729: case 0x0d: /* CR */
730: if (p < endptr && *p == 0x0a)
731: {
732: *lenptr = 2;
733: p++;
734: }
735: else *lenptr = 1;
736: return p;
737:
738: default:
739: break;
740: }
741: } /* End of loop for ANYCRLF case */
742:
743: *lenptr = 0; /* Must have hit the end */
744: return endptr;
745:
746: case EL_ANY:
747: while (p < endptr)
748: {
749: int extra = 0;
750: register int c = *((unsigned char *)p);
751:
752: if (utf8 && c >= 0xc0)
753: {
754: int gcii, gcss;
755: extra = utf8_table4[c & 0x3f]; /* Number of additional bytes */
756: gcss = 6*extra;
757: c = (c & utf8_table3[extra]) << gcss;
758: for (gcii = 1; gcii <= extra; gcii++)
759: {
760: gcss -= 6;
761: c |= (p[gcii] & 0x3f) << gcss;
762: }
763: }
764:
765: p += 1 + extra;
766:
767: switch (c)
768: {
769: case 0x0a: /* LF */
770: case 0x0b: /* VT */
771: case 0x0c: /* FF */
772: *lenptr = 1;
773: return p;
774:
775: case 0x0d: /* CR */
776: if (p < endptr && *p == 0x0a)
777: {
778: *lenptr = 2;
779: p++;
780: }
781: else *lenptr = 1;
782: return p;
783:
784: case 0x85: /* NEL */
785: *lenptr = utf8? 2 : 1;
786: return p;
787:
788: case 0x2028: /* LS */
789: case 0x2029: /* PS */
790: *lenptr = 3;
791: return p;
792:
793: default:
794: break;
795: }
796: } /* End of loop for ANY case */
797:
798: *lenptr = 0; /* Must have hit the end */
799: return endptr;
800: } /* End of overall switch */
801: }
802:
803:
804:
805: /*************************************************
806: * Find start of previous line *
807: *************************************************/
808:
809: /* This is called when looking back for before lines to print.
810:
811: Arguments:
812: p start of the subsequent line
813: startptr start of available data
814:
815: Returns: pointer to the start of the previous line
816: */
817:
818: static char *
819: previous_line(char *p, char *startptr)
820: {
821: switch(endlinetype)
822: {
823: default: /* Just in case */
824: case EL_LF:
825: p--;
826: while (p > startptr && p[-1] != '\n') p--;
827: return p;
828:
829: case EL_CR:
830: p--;
831: while (p > startptr && p[-1] != '\n') p--;
832: return p;
833:
834: case EL_CRLF:
835: for (;;)
836: {
837: p -= 2;
838: while (p > startptr && p[-1] != '\n') p--;
839: if (p <= startptr + 1 || p[-2] == '\r') return p;
840: }
841: return p; /* But control should never get here */
842:
843: case EL_ANY:
844: case EL_ANYCRLF:
845: if (*(--p) == '\n' && p > startptr && p[-1] == '\r') p--;
846: if (utf8) while ((*p & 0xc0) == 0x80) p--;
847:
848: while (p > startptr)
849: {
850: register int c;
851: char *pp = p - 1;
852:
853: if (utf8)
854: {
855: int extra = 0;
856: while ((*pp & 0xc0) == 0x80) pp--;
857: c = *((unsigned char *)pp);
858: if (c >= 0xc0)
859: {
860: int gcii, gcss;
861: extra = utf8_table4[c & 0x3f]; /* Number of additional bytes */
862: gcss = 6*extra;
863: c = (c & utf8_table3[extra]) << gcss;
864: for (gcii = 1; gcii <= extra; gcii++)
865: {
866: gcss -= 6;
867: c |= (pp[gcii] & 0x3f) << gcss;
868: }
869: }
870: }
871: else c = *((unsigned char *)pp);
872:
873: if (endlinetype == EL_ANYCRLF) switch (c)
874: {
875: case 0x0a: /* LF */
876: case 0x0d: /* CR */
877: return p;
878:
879: default:
880: break;
881: }
882:
883: else switch (c)
884: {
885: case 0x0a: /* LF */
886: case 0x0b: /* VT */
887: case 0x0c: /* FF */
888: case 0x0d: /* CR */
889: case 0x85: /* NEL */
890: case 0x2028: /* LS */
891: case 0x2029: /* PS */
892: return p;
893:
894: default:
895: break;
896: }
897:
898: p = pp; /* Back one character */
899: } /* End of loop for ANY case */
900:
901: return startptr; /* Hit start of data */
902: } /* End of overall switch */
903: }
904:
905:
906:
907:
908:
909: /*************************************************
910: * Print the previous "after" lines *
911: *************************************************/
912:
913: /* This is called if we are about to lose said lines because of buffer filling,
914: and at the end of the file. The data in the line is written using fwrite() so
915: that a binary zero does not terminate it.
916:
917: Arguments:
918: lastmatchnumber the number of the last matching line, plus one
919: lastmatchrestart where we restarted after the last match
920: endptr end of available data
921: printname filename for printing
922:
923: Returns: nothing
924: */
925:
926: static void do_after_lines(int lastmatchnumber, char *lastmatchrestart,
927: char *endptr, char *printname)
928: {
929: if (after_context > 0 && lastmatchnumber > 0)
930: {
931: int count = 0;
932: while (lastmatchrestart < endptr && count++ < after_context)
933: {
934: int ellength;
935: char *pp = lastmatchrestart;
936: if (printname != NULL) fprintf(stdout, "%s-", printname);
937: if (number) fprintf(stdout, "%d-", lastmatchnumber++);
938: pp = end_of_line(pp, endptr, &ellength);
939: FWRITE(lastmatchrestart, 1, pp - lastmatchrestart, stdout);
940: lastmatchrestart = pp;
941: }
942: hyphenpending = TRUE;
943: }
944: }
945:
946:
947:
948: /*************************************************
949: * Apply patterns to subject till one matches *
950: *************************************************/
951:
952: /* This function is called to run through all patterns, looking for a match. It
953: is used multiple times for the same subject when colouring is enabled, in order
954: to find all possible matches.
955:
956: Arguments:
957: matchptr the start of the subject
958: length the length of the subject to match
959: startoffset where to start matching
960: offsets the offets vector to fill in
961: mrc address of where to put the result of pcre_exec()
962:
963: Returns: TRUE if there was a match
964: FALSE if there was no match
965: invert if there was a non-fatal error
966: */
967:
968: static BOOL
969: match_patterns(char *matchptr, size_t length, int startoffset, int *offsets,
970: int *mrc)
971: {
972: int i;
973: size_t slen = length;
974: const char *msg = "this text:\n\n";
975: if (slen > 200)
976: {
977: slen = 200;
978: msg = "text that starts:\n\n";
979: }
980: for (i = 0; i < pattern_count; i++)
981: {
982: *mrc = pcre_exec(pattern_list[i], hints_list[i], matchptr, (int)length,
983: startoffset, PCRE_NOTEMPTY, offsets, OFFSET_SIZE);
984: if (*mrc >= 0) return TRUE;
985: if (*mrc == PCRE_ERROR_NOMATCH) continue;
986: fprintf(stderr, "pcregrep: pcre_exec() gave error %d while matching ", *mrc);
987: if (pattern_count > 1) fprintf(stderr, "pattern number %d to ", i+1);
988: fprintf(stderr, "%s", msg);
989: FWRITE(matchptr, 1, slen, stderr); /* In case binary zero included */
990: fprintf(stderr, "\n\n");
991: if (*mrc == PCRE_ERROR_MATCHLIMIT || *mrc == PCRE_ERROR_RECURSIONLIMIT ||
992: *mrc == PCRE_ERROR_JIT_STACKLIMIT)
993: resource_error = TRUE;
994: if (error_count++ > 20)
995: {
996: fprintf(stderr, "pcregrep: Too many errors - abandoned.\n");
997: pcregrep_exit(2);
998: }
999: return invert; /* No more matching; don't show the line again */
1000: }
1001:
1002: return FALSE; /* No match, no errors */
1003: }
1004:
1005:
1006:
1007: /*************************************************
1008: * Grep an individual file *
1009: *************************************************/
1010:
1011: /* This is called from grep_or_recurse() below. It uses a buffer that is three
1012: times the value of bufthird. The matching point is never allowed to stray into
1013: the top third of the buffer, thus keeping more of the file available for
1014: context printing or for multiline scanning. For large files, the pointer will
1015: be in the middle third most of the time, so the bottom third is available for
1016: "before" context printing.
1017:
1018: Arguments:
1019: handle the fopened FILE stream for a normal file
1020: the gzFile pointer when reading is via libz
1021: the BZFILE pointer when reading is via libbz2
1022: frtype FR_PLAIN, FR_LIBZ, or FR_LIBBZ2
1023: filename the file name or NULL (for errors)
1024: printname the file name if it is to be printed for each match
1025: or NULL if the file name is not to be printed
1026: it cannot be NULL if filenames[_nomatch]_only is set
1027:
1028: Returns: 0 if there was at least one match
1029: 1 otherwise (no matches)
1030: 2 if an overlong line is encountered
1031: 3 if there is a read error on a .bz2 file
1032: */
1033:
1034: static int
1035: pcregrep(void *handle, int frtype, char *filename, char *printname)
1036: {
1037: int rc = 1;
1038: int linenumber = 1;
1039: int lastmatchnumber = 0;
1040: int count = 0;
1041: int filepos = 0;
1042: int offsets[OFFSET_SIZE];
1043: char *lastmatchrestart = NULL;
1044: char *ptr = main_buffer;
1045: char *endptr;
1046: size_t bufflength;
1047: BOOL endhyphenpending = FALSE;
1048: BOOL input_line_buffered = line_buffered;
1049: FILE *in = NULL; /* Ensure initialized */
1050:
1051: #ifdef SUPPORT_LIBZ
1052: gzFile ingz = NULL;
1053: #endif
1054:
1055: #ifdef SUPPORT_LIBBZ2
1056: BZFILE *inbz2 = NULL;
1057: #endif
1058:
1059:
1060: /* Do the first read into the start of the buffer and set up the pointer to end
1061: of what we have. In the case of libz, a non-zipped .gz file will be read as a
1062: plain file. However, if a .bz2 file isn't actually bzipped, the first read will
1063: fail. */
1064:
1065: #ifdef SUPPORT_LIBZ
1066: if (frtype == FR_LIBZ)
1067: {
1068: ingz = (gzFile)handle;
1069: bufflength = gzread (ingz, main_buffer, bufsize);
1070: }
1071: else
1072: #endif
1073:
1074: #ifdef SUPPORT_LIBBZ2
1075: if (frtype == FR_LIBBZ2)
1076: {
1077: inbz2 = (BZFILE *)handle;
1078: bufflength = BZ2_bzread(inbz2, main_buffer, bufsize);
1079: if ((int)bufflength < 0) return 2; /* Gotcha: bufflength is size_t; */
1080: } /* without the cast it is unsigned. */
1081: else
1082: #endif
1083:
1084: {
1085: in = (FILE *)handle;
1086: if (is_file_tty(in)) input_line_buffered = TRUE;
1087: bufflength = input_line_buffered?
1088: read_one_line(main_buffer, bufsize, in) :
1089: fread(main_buffer, 1, bufsize, in);
1090: }
1091:
1092: endptr = main_buffer + bufflength;
1093:
1094: /* Loop while the current pointer is not at the end of the file. For large
1095: files, endptr will be at the end of the buffer when we are in the middle of the
1096: file, but ptr will never get there, because as soon as it gets over 2/3 of the
1097: way, the buffer is shifted left and re-filled. */
1098:
1099: while (ptr < endptr)
1100: {
1101: int endlinelength;
1102: int mrc = 0;
1103: int startoffset = 0;
1104: BOOL match;
1105: char *matchptr = ptr;
1106: char *t = ptr;
1107: size_t length, linelength;
1108:
1109: /* At this point, ptr is at the start of a line. We need to find the length
1110: of the subject string to pass to pcre_exec(). In multiline mode, it is the
1111: length remainder of the data in the buffer. Otherwise, it is the length of
1112: the next line, excluding the terminating newline. After matching, we always
1113: advance by the length of the next line. In multiline mode the PCRE_FIRSTLINE
1114: option is used for compiling, so that any match is constrained to be in the
1115: first line. */
1116:
1117: t = end_of_line(t, endptr, &endlinelength);
1118: linelength = t - ptr - endlinelength;
1119: length = multiline? (size_t)(endptr - ptr) : linelength;
1120:
1121: /* Check to see if the line we are looking at extends right to the very end
1122: of the buffer without a line terminator. This means the line is too long to
1123: handle. */
1124:
1125: if (endlinelength == 0 && t == main_buffer + bufsize)
1126: {
1127: fprintf(stderr, "pcregrep: line %d%s%s is too long for the internal buffer\n"
1128: "pcregrep: check the --buffer-size option\n",
1129: linenumber,
1130: (filename == NULL)? "" : " of file ",
1131: (filename == NULL)? "" : filename);
1132: return 2;
1133: }
1134:
1135: /* Extra processing for Jeffrey Friedl's debugging. */
1136:
1137: #ifdef JFRIEDL_DEBUG
1138: if (jfriedl_XT || jfriedl_XR)
1139: {
1140: #include <sys/time.h>
1141: #include <time.h>
1142: struct timeval start_time, end_time;
1143: struct timezone dummy;
1144: int i;
1145:
1146: if (jfriedl_XT)
1147: {
1148: unsigned long newlen = length * jfriedl_XT + strlen(jfriedl_prefix) + strlen(jfriedl_postfix);
1149: const char *orig = ptr;
1150: ptr = malloc(newlen + 1);
1151: if (!ptr) {
1152: printf("out of memory");
1153: pcregrep_exit(2);
1154: }
1155: endptr = ptr;
1156: strcpy(endptr, jfriedl_prefix); endptr += strlen(jfriedl_prefix);
1157: for (i = 0; i < jfriedl_XT; i++) {
1158: strncpy(endptr, orig, length);
1159: endptr += length;
1160: }
1161: strcpy(endptr, jfriedl_postfix); endptr += strlen(jfriedl_postfix);
1162: length = newlen;
1163: }
1164:
1165: if (gettimeofday(&start_time, &dummy) != 0)
1166: perror("bad gettimeofday");
1167:
1168:
1169: for (i = 0; i < jfriedl_XR; i++)
1170: match = (pcre_exec(pattern_list[0], hints_list[0], ptr, length, 0,
1171: PCRE_NOTEMPTY, offsets, OFFSET_SIZE) >= 0);
1172:
1173: if (gettimeofday(&end_time, &dummy) != 0)
1174: perror("bad gettimeofday");
1175:
1176: double delta = ((end_time.tv_sec + (end_time.tv_usec / 1000000.0))
1177: -
1178: (start_time.tv_sec + (start_time.tv_usec / 1000000.0)));
1179:
1180: printf("%s TIMER[%.4f]\n", match ? "MATCH" : "FAIL", delta);
1181: return 0;
1182: }
1183: #endif
1184:
1185: /* We come back here after a match when the -o option (only_matching) is set,
1186: in order to find any further matches in the same line. */
1187:
1188: ONLY_MATCHING_RESTART:
1189:
1190: /* Run through all the patterns until one matches or there is an error other
1191: than NOMATCH. This code is in a subroutine so that it can be re-used for
1192: finding subsequent matches when colouring matched lines. */
1193:
1194: match = match_patterns(matchptr, length, startoffset, offsets, &mrc);
1195:
1196: /* If it's a match or a not-match (as required), do what's wanted. */
1197:
1198: if (match != invert)
1199: {
1200: BOOL hyphenprinted = FALSE;
1201:
1202: /* We've failed if we want a file that doesn't have any matches. */
1203:
1204: if (filenames == FN_NOMATCH_ONLY) return 1;
1205:
1206: /* Just count if just counting is wanted. */
1207:
1208: if (count_only) count++;
1209:
1210: /* If all we want is a file name, there is no need to scan any more lines
1211: in the file. */
1212:
1213: else if (filenames == FN_MATCH_ONLY)
1214: {
1215: fprintf(stdout, "%s\n", printname);
1216: return 0;
1217: }
1218:
1219: /* Likewise, if all we want is a yes/no answer. */
1220:
1221: else if (quiet) return 0;
1222:
1223: /* The --only-matching option prints just the substring that matched, or a
1224: captured portion of it, as long as this string is not empty, and the
1225: --file-offsets and --line-offsets options output offsets for the matching
1226: substring (they both force --only-matching = 0). None of these options
1227: prints any context. Afterwards, adjust the start and then jump back to look
1228: for further matches in the same line. If we are in invert mode, however,
1229: nothing is printed and we do not restart - this could still be useful
1230: because the return code is set. */
1231:
1232: else if (only_matching >= 0)
1233: {
1234: if (!invert)
1235: {
1236: if (printname != NULL) fprintf(stdout, "%s:", printname);
1237: if (number) fprintf(stdout, "%d:", linenumber);
1238: if (line_offsets)
1239: fprintf(stdout, "%d,%d\n", (int)(matchptr + offsets[0] - ptr),
1240: offsets[1] - offsets[0]);
1241: else if (file_offsets)
1242: fprintf(stdout, "%d,%d\n",
1243: (int)(filepos + matchptr + offsets[0] - ptr),
1244: offsets[1] - offsets[0]);
1245: else if (only_matching < mrc)
1246: {
1247: int plen = offsets[2*only_matching + 1] - offsets[2*only_matching];
1248: if (plen > 0)
1249: {
1250: if (do_colour) fprintf(stdout, "%c[%sm", 0x1b, colour_string);
1251: FWRITE(matchptr + offsets[only_matching*2], 1, plen, stdout);
1252: if (do_colour) fprintf(stdout, "%c[00m", 0x1b);
1253: fprintf(stdout, "\n");
1254: }
1255: }
1256: else if (printname != NULL || number) fprintf(stdout, "\n");
1257: match = FALSE;
1258: if (line_buffered) fflush(stdout);
1259: rc = 0; /* Had some success */
1260: startoffset = offsets[1]; /* Restart after the match */
1261: goto ONLY_MATCHING_RESTART;
1262: }
1263: }
1264:
1265: /* This is the default case when none of the above options is set. We print
1266: the matching lines(s), possibly preceded and/or followed by other lines of
1267: context. */
1268:
1269: else
1270: {
1271: /* See if there is a requirement to print some "after" lines from a
1272: previous match. We never print any overlaps. */
1273:
1274: if (after_context > 0 && lastmatchnumber > 0)
1275: {
1276: int ellength;
1277: int linecount = 0;
1278: char *p = lastmatchrestart;
1279:
1280: while (p < ptr && linecount < after_context)
1281: {
1282: p = end_of_line(p, ptr, &ellength);
1283: linecount++;
1284: }
1285:
1286: /* It is important to advance lastmatchrestart during this printing so
1287: that it interacts correctly with any "before" printing below. Print
1288: each line's data using fwrite() in case there are binary zeroes. */
1289:
1290: while (lastmatchrestart < p)
1291: {
1292: char *pp = lastmatchrestart;
1293: if (printname != NULL) fprintf(stdout, "%s-", printname);
1294: if (number) fprintf(stdout, "%d-", lastmatchnumber++);
1295: pp = end_of_line(pp, endptr, &ellength);
1296: FWRITE(lastmatchrestart, 1, pp - lastmatchrestart, stdout);
1297: lastmatchrestart = pp;
1298: }
1299: if (lastmatchrestart != ptr) hyphenpending = TRUE;
1300: }
1301:
1302: /* If there were non-contiguous lines printed above, insert hyphens. */
1303:
1304: if (hyphenpending)
1305: {
1306: fprintf(stdout, "--\n");
1307: hyphenpending = FALSE;
1308: hyphenprinted = TRUE;
1309: }
1310:
1311: /* See if there is a requirement to print some "before" lines for this
1312: match. Again, don't print overlaps. */
1313:
1314: if (before_context > 0)
1315: {
1316: int linecount = 0;
1317: char *p = ptr;
1318:
1319: while (p > main_buffer && (lastmatchnumber == 0 || p > lastmatchrestart) &&
1320: linecount < before_context)
1321: {
1322: linecount++;
1323: p = previous_line(p, main_buffer);
1324: }
1325:
1326: if (lastmatchnumber > 0 && p > lastmatchrestart && !hyphenprinted)
1327: fprintf(stdout, "--\n");
1328:
1329: while (p < ptr)
1330: {
1331: int ellength;
1332: char *pp = p;
1333: if (printname != NULL) fprintf(stdout, "%s-", printname);
1334: if (number) fprintf(stdout, "%d-", linenumber - linecount--);
1335: pp = end_of_line(pp, endptr, &ellength);
1336: FWRITE(p, 1, pp - p, stdout);
1337: p = pp;
1338: }
1339: }
1340:
1341: /* Now print the matching line(s); ensure we set hyphenpending at the end
1342: of the file if any context lines are being output. */
1343:
1344: if (after_context > 0 || before_context > 0)
1345: endhyphenpending = TRUE;
1346:
1347: if (printname != NULL) fprintf(stdout, "%s:", printname);
1348: if (number) fprintf(stdout, "%d:", linenumber);
1349:
1350: /* In multiline mode, we want to print to the end of the line in which
1351: the end of the matched string is found, so we adjust linelength and the
1352: line number appropriately, but only when there actually was a match
1353: (invert not set). Because the PCRE_FIRSTLINE option is set, the start of
1354: the match will always be before the first newline sequence. */
1355:
1356: if (multiline & !invert)
1357: {
1358: char *endmatch = ptr + offsets[1];
1359: t = ptr;
1360: while (t < endmatch)
1361: {
1362: t = end_of_line(t, endptr, &endlinelength);
1363: if (t < endmatch) linenumber++; else break;
1364: }
1365: linelength = t - ptr - endlinelength;
1366: }
1367:
1368: /*** NOTE: Use only fwrite() to output the data line, so that binary
1369: zeroes are treated as just another data character. */
1370:
1371: /* This extra option, for Jeffrey Friedl's debugging requirements,
1372: replaces the matched string, or a specific captured string if it exists,
1373: with X. When this happens, colouring is ignored. */
1374:
1375: #ifdef JFRIEDL_DEBUG
1376: if (S_arg >= 0 && S_arg < mrc)
1377: {
1378: int first = S_arg * 2;
1379: int last = first + 1;
1380: FWRITE(ptr, 1, offsets[first], stdout);
1381: fprintf(stdout, "X");
1382: FWRITE(ptr + offsets[last], 1, linelength - offsets[last], stdout);
1383: }
1384: else
1385: #endif
1386:
1387: /* We have to split the line(s) up if colouring, and search for further
1388: matches, but not of course if the line is a non-match. */
1389:
1390: if (do_colour && !invert)
1391: {
1392: int plength;
1393: FWRITE(ptr, 1, offsets[0], stdout);
1394: fprintf(stdout, "%c[%sm", 0x1b, colour_string);
1395: FWRITE(ptr + offsets[0], 1, offsets[1] - offsets[0], stdout);
1396: fprintf(stdout, "%c[00m", 0x1b);
1397: for (;;)
1398: {
1399: startoffset = offsets[1];
1400: if (startoffset >= (int)linelength + endlinelength ||
1401: !match_patterns(matchptr, length, startoffset, offsets, &mrc))
1402: break;
1403: FWRITE(matchptr + startoffset, 1, offsets[0] - startoffset, stdout);
1404: fprintf(stdout, "%c[%sm", 0x1b, colour_string);
1405: FWRITE(matchptr + offsets[0], 1, offsets[1] - offsets[0], stdout);
1406: fprintf(stdout, "%c[00m", 0x1b);
1407: }
1408:
1409: /* In multiline mode, we may have already printed the complete line
1410: and its line-ending characters (if they matched the pattern), so there
1411: may be no more to print. */
1412:
1413: plength = (int)((linelength + endlinelength) - startoffset);
1414: if (plength > 0) FWRITE(ptr + startoffset, 1, plength, stdout);
1415: }
1416:
1417: /* Not colouring; no need to search for further matches */
1418:
1419: else FWRITE(ptr, 1, linelength + endlinelength, stdout);
1420: }
1421:
1422: /* End of doing what has to be done for a match. If --line-buffered was
1423: given, flush the output. */
1424:
1425: if (line_buffered) fflush(stdout);
1426: rc = 0; /* Had some success */
1427:
1428: /* Remember where the last match happened for after_context. We remember
1429: where we are about to restart, and that line's number. */
1430:
1431: lastmatchrestart = ptr + linelength + endlinelength;
1432: lastmatchnumber = linenumber + 1;
1433: }
1434:
1435: /* For a match in multiline inverted mode (which of course did not cause
1436: anything to be printed), we have to move on to the end of the match before
1437: proceeding. */
1438:
1439: if (multiline && invert && match)
1440: {
1441: int ellength;
1442: char *endmatch = ptr + offsets[1];
1443: t = ptr;
1444: while (t < endmatch)
1445: {
1446: t = end_of_line(t, endptr, &ellength);
1447: if (t <= endmatch) linenumber++; else break;
1448: }
1449: endmatch = end_of_line(endmatch, endptr, &ellength);
1450: linelength = endmatch - ptr - ellength;
1451: }
1452:
1453: /* Advance to after the newline and increment the line number. The file
1454: offset to the current line is maintained in filepos. */
1455:
1456: ptr += linelength + endlinelength;
1457: filepos += (int)(linelength + endlinelength);
1458: linenumber++;
1459:
1460: /* If input is line buffered, and the buffer is not yet full, read another
1461: line and add it into the buffer. */
1462:
1463: if (input_line_buffered && bufflength < (size_t)bufsize)
1464: {
1465: int add = read_one_line(ptr, bufsize - (int)(ptr - main_buffer), in);
1466: bufflength += add;
1467: endptr += add;
1468: }
1469:
1470: /* If we haven't yet reached the end of the file (the buffer is full), and
1471: the current point is in the top 1/3 of the buffer, slide the buffer down by
1472: 1/3 and refill it. Before we do this, if some unprinted "after" lines are
1473: about to be lost, print them. */
1474:
1475: if (bufflength >= (size_t)bufsize && ptr > main_buffer + 2*bufthird)
1476: {
1477: if (after_context > 0 &&
1478: lastmatchnumber > 0 &&
1479: lastmatchrestart < main_buffer + bufthird)
1480: {
1481: do_after_lines(lastmatchnumber, lastmatchrestart, endptr, printname);
1482: lastmatchnumber = 0;
1483: }
1484:
1485: /* Now do the shuffle */
1486:
1487: memmove(main_buffer, main_buffer + bufthird, 2*bufthird);
1488: ptr -= bufthird;
1489:
1490: #ifdef SUPPORT_LIBZ
1491: if (frtype == FR_LIBZ)
1492: bufflength = 2*bufthird +
1493: gzread (ingz, main_buffer + 2*bufthird, bufthird);
1494: else
1495: #endif
1496:
1497: #ifdef SUPPORT_LIBBZ2
1498: if (frtype == FR_LIBBZ2)
1499: bufflength = 2*bufthird +
1500: BZ2_bzread(inbz2, main_buffer + 2*bufthird, bufthird);
1501: else
1502: #endif
1503:
1504: bufflength = 2*bufthird +
1505: (input_line_buffered?
1506: read_one_line(main_buffer + 2*bufthird, bufthird, in) :
1507: fread(main_buffer + 2*bufthird, 1, bufthird, in));
1508: endptr = main_buffer + bufflength;
1509:
1510: /* Adjust any last match point */
1511:
1512: if (lastmatchnumber > 0) lastmatchrestart -= bufthird;
1513: }
1514: } /* Loop through the whole file */
1515:
1516: /* End of file; print final "after" lines if wanted; do_after_lines sets
1517: hyphenpending if it prints something. */
1518:
1519: if (only_matching < 0 && !count_only)
1520: {
1521: do_after_lines(lastmatchnumber, lastmatchrestart, endptr, printname);
1522: hyphenpending |= endhyphenpending;
1523: }
1524:
1525: /* Print the file name if we are looking for those without matches and there
1526: were none. If we found a match, we won't have got this far. */
1527:
1528: if (filenames == FN_NOMATCH_ONLY)
1529: {
1530: fprintf(stdout, "%s\n", printname);
1531: return 0;
1532: }
1533:
1534: /* Print the match count if wanted */
1535:
1536: if (count_only)
1537: {
1538: if (count > 0 || !omit_zero_count)
1539: {
1540: if (printname != NULL && filenames != FN_NONE)
1541: fprintf(stdout, "%s:", printname);
1542: fprintf(stdout, "%d\n", count);
1543: }
1544: }
1545:
1546: return rc;
1547: }
1548:
1549:
1550:
1551: /*************************************************
1552: * Grep a file or recurse into a directory *
1553: *************************************************/
1554:
1555: /* Given a path name, if it's a directory, scan all the files if we are
1556: recursing; if it's a file, grep it.
1557:
1558: Arguments:
1559: pathname the path to investigate
1560: dir_recurse TRUE if recursing is wanted (-r or -drecurse)
1561: only_one_at_top TRUE if the path is the only one at toplevel
1562:
1563: Returns: 0 if there was at least one match
1564: 1 if there were no matches
1565: 2 there was some kind of error
1566:
1567: However, file opening failures are suppressed if "silent" is set.
1568: */
1569:
1570: static int
1571: grep_or_recurse(char *pathname, BOOL dir_recurse, BOOL only_one_at_top)
1572: {
1573: int rc = 1;
1574: int sep;
1575: int frtype;
1576: int pathlen;
1577: void *handle;
1578: FILE *in = NULL; /* Ensure initialized */
1579:
1580: #ifdef SUPPORT_LIBZ
1581: gzFile ingz = NULL;
1582: #endif
1583:
1584: #ifdef SUPPORT_LIBBZ2
1585: BZFILE *inbz2 = NULL;
1586: #endif
1587:
1588: /* If the file name is "-" we scan stdin */
1589:
1590: if (strcmp(pathname, "-") == 0)
1591: {
1592: return pcregrep(stdin, FR_PLAIN, stdin_name,
1593: (filenames > FN_DEFAULT || (filenames == FN_DEFAULT && !only_one_at_top))?
1594: stdin_name : NULL);
1595: }
1596:
1597: /* If the file is a directory, skip if skipping or if we are recursing, scan
1598: each file and directory within it, subject to any include or exclude patterns
1599: that were set. The scanning code is localized so it can be made
1600: system-specific. */
1601:
1602: if ((sep = isdirectory(pathname)) != 0)
1603: {
1604: if (dee_action == dee_SKIP) return 1;
1605: if (dee_action == dee_RECURSE)
1606: {
1607: char buffer[1024];
1608: char *nextfile;
1609: directory_type *dir = opendirectory(pathname);
1610:
1611: if (dir == NULL)
1612: {
1613: if (!silent)
1614: fprintf(stderr, "pcregrep: Failed to open directory %s: %s\n", pathname,
1615: strerror(errno));
1616: return 2;
1617: }
1618:
1619: while ((nextfile = readdirectory(dir)) != NULL)
1620: {
1621: int frc, nflen;
1622: sprintf(buffer, "%.512s%c%.128s", pathname, sep, nextfile);
1623: nflen = (int)(strlen(nextfile));
1624:
1625: if (isdirectory(buffer))
1626: {
1627: if (exclude_dir_compiled != NULL &&
1628: pcre_exec(exclude_dir_compiled, NULL, nextfile, nflen, 0, 0, NULL, 0) >= 0)
1629: continue;
1630:
1631: if (include_dir_compiled != NULL &&
1632: pcre_exec(include_dir_compiled, NULL, nextfile, nflen, 0, 0, NULL, 0) < 0)
1633: continue;
1634: }
1635: else
1636: {
1637: if (exclude_compiled != NULL &&
1638: pcre_exec(exclude_compiled, NULL, nextfile, nflen, 0, 0, NULL, 0) >= 0)
1639: continue;
1640:
1641: if (include_compiled != NULL &&
1642: pcre_exec(include_compiled, NULL, nextfile, nflen, 0, 0, NULL, 0) < 0)
1643: continue;
1644: }
1645:
1646: frc = grep_or_recurse(buffer, dir_recurse, FALSE);
1647: if (frc > 1) rc = frc;
1648: else if (frc == 0 && rc == 1) rc = 0;
1649: }
1650:
1651: closedirectory(dir);
1652: return rc;
1653: }
1654: }
1655:
1656: /* If the file is not a directory and not a regular file, skip it if that's
1657: been requested. */
1658:
1659: else if (!isregfile(pathname) && DEE_action == DEE_SKIP) return 1;
1660:
1661: /* Control reaches here if we have a regular file, or if we have a directory
1662: and recursion or skipping was not requested, or if we have anything else and
1663: skipping was not requested. The scan proceeds. If this is the first and only
1664: argument at top level, we don't show the file name, unless we are only showing
1665: the file name, or the filename was forced (-H). */
1666:
1667: pathlen = (int)(strlen(pathname));
1668:
1669: /* Open using zlib if it is supported and the file name ends with .gz. */
1670:
1671: #ifdef SUPPORT_LIBZ
1672: if (pathlen > 3 && strcmp(pathname + pathlen - 3, ".gz") == 0)
1673: {
1674: ingz = gzopen(pathname, "rb");
1675: if (ingz == NULL)
1676: {
1677: if (!silent)
1678: fprintf(stderr, "pcregrep: Failed to open %s: %s\n", pathname,
1679: strerror(errno));
1680: return 2;
1681: }
1682: handle = (void *)ingz;
1683: frtype = FR_LIBZ;
1684: }
1685: else
1686: #endif
1687:
1688: /* Otherwise open with bz2lib if it is supported and the name ends with .bz2. */
1689:
1690: #ifdef SUPPORT_LIBBZ2
1691: if (pathlen > 4 && strcmp(pathname + pathlen - 4, ".bz2") == 0)
1692: {
1693: inbz2 = BZ2_bzopen(pathname, "rb");
1694: handle = (void *)inbz2;
1695: frtype = FR_LIBBZ2;
1696: }
1697: else
1698: #endif
1699:
1700: /* Otherwise use plain fopen(). The label is so that we can come back here if
1701: an attempt to read a .bz2 file indicates that it really is a plain file. */
1702:
1703: #ifdef SUPPORT_LIBBZ2
1704: PLAIN_FILE:
1705: #endif
1706: {
1707: in = fopen(pathname, "rb");
1708: handle = (void *)in;
1709: frtype = FR_PLAIN;
1710: }
1711:
1712: /* All the opening methods return errno when they fail. */
1713:
1714: if (handle == NULL)
1715: {
1716: if (!silent)
1717: fprintf(stderr, "pcregrep: Failed to open %s: %s\n", pathname,
1718: strerror(errno));
1719: return 2;
1720: }
1721:
1722: /* Now grep the file */
1723:
1724: rc = pcregrep(handle, frtype, pathname, (filenames > FN_DEFAULT ||
1725: (filenames == FN_DEFAULT && !only_one_at_top))? pathname : NULL);
1726:
1727: /* Close in an appropriate manner. */
1728:
1729: #ifdef SUPPORT_LIBZ
1730: if (frtype == FR_LIBZ)
1731: gzclose(ingz);
1732: else
1733: #endif
1734:
1735: /* If it is a .bz2 file and the result is 3, it means that the first attempt to
1736: read failed. If the error indicates that the file isn't in fact bzipped, try
1737: again as a normal file. */
1738:
1739: #ifdef SUPPORT_LIBBZ2
1740: if (frtype == FR_LIBBZ2)
1741: {
1742: if (rc == 3)
1743: {
1744: int errnum;
1745: const char *err = BZ2_bzerror(inbz2, &errnum);
1746: if (errnum == BZ_DATA_ERROR_MAGIC)
1747: {
1748: BZ2_bzclose(inbz2);
1749: goto PLAIN_FILE;
1750: }
1751: else if (!silent)
1752: fprintf(stderr, "pcregrep: Failed to read %s using bzlib: %s\n",
1753: pathname, err);
1754: rc = 2; /* The normal "something went wrong" code */
1755: }
1756: BZ2_bzclose(inbz2);
1757: }
1758: else
1759: #endif
1760:
1761: /* Normal file close */
1762:
1763: fclose(in);
1764:
1765: /* Pass back the yield from pcregrep(). */
1766:
1767: return rc;
1768: }
1769:
1770:
1771:
1772:
1773: /*************************************************
1774: * Usage function *
1775: *************************************************/
1776:
1777: static int
1778: usage(int rc)
1779: {
1780: option_item *op;
1781: fprintf(stderr, "Usage: pcregrep [-");
1782: for (op = optionlist; op->one_char != 0; op++)
1783: {
1784: if (op->one_char > 0) fprintf(stderr, "%c", op->one_char);
1785: }
1786: fprintf(stderr, "] [long options] [pattern] [files]\n");
1787: fprintf(stderr, "Type `pcregrep --help' for more information and the long "
1788: "options.\n");
1789: return rc;
1790: }
1791:
1792:
1793:
1794:
1795: /*************************************************
1796: * Help function *
1797: *************************************************/
1798:
1799: static void
1800: help(void)
1801: {
1802: option_item *op;
1803:
1804: printf("Usage: pcregrep [OPTION]... [PATTERN] [FILE1 FILE2 ...]\n");
1805: printf("Search for PATTERN in each FILE or standard input.\n");
1806: printf("PATTERN must be present if neither -e nor -f is used.\n");
1807: printf("\"-\" can be used as a file name to mean STDIN.\n");
1808:
1809: #ifdef SUPPORT_LIBZ
1810: printf("Files whose names end in .gz are read using zlib.\n");
1811: #endif
1812:
1813: #ifdef SUPPORT_LIBBZ2
1814: printf("Files whose names end in .bz2 are read using bzlib2.\n");
1815: #endif
1816:
1817: #if defined SUPPORT_LIBZ || defined SUPPORT_LIBBZ2
1818: printf("Other files and the standard input are read as plain files.\n\n");
1819: #else
1820: printf("All files are read as plain files, without any interpretation.\n\n");
1821: #endif
1822:
1823: printf("Example: pcregrep -i 'hello.*world' menu.h main.c\n\n");
1824: printf("Options:\n");
1825:
1826: for (op = optionlist; op->one_char != 0; op++)
1827: {
1828: int n;
1829: char s[4];
1830:
1831: /* Two options were accidentally implemented and documented with underscores
1832: instead of hyphens in their names, something that was not noticed for quite a
1833: few releases. When fixing this, I left the underscored versions in the list
1834: in case people were using them. However, we don't want to display them in the
1835: help data. There are no other options that contain underscores, and we do not
1836: expect ever to implement such options. Therefore, just omit any option that
1837: contains an underscore. */
1838:
1839: if (strchr(op->long_name, '_') != NULL) continue;
1840:
1841: if (op->one_char > 0) sprintf(s, "-%c,", op->one_char); else strcpy(s, " ");
1842: n = 31 - printf(" %s --%s", s, op->long_name);
1843: if (n < 1) n = 1;
1844: printf("%.*s%s\n", n, " ", op->help_text);
1845: }
1846:
1847: printf("\nNumbers may be followed by K or M, e.g. --buffer-size=100K.\n");
1848: printf("The default value for --buffer-size is %d.\n", PCREGREP_BUFSIZE);
1849: printf("When reading patterns from a file instead of using a command line option,\n");
1850: printf("trailing white space is removed and blank lines are ignored.\n");
1851: printf("There is a maximum of %d patterns, each of maximum size %d bytes.\n",
1852: MAX_PATTERN_COUNT, PATBUFSIZE);
1853:
1854: printf("\nWith no FILEs, read standard input. If fewer than two FILEs given, assume -h.\n");
1855: printf("Exit status is 0 if any matches, 1 if no matches, and 2 if trouble.\n");
1856: }
1857:
1858:
1859:
1860:
1861: /*************************************************
1862: * Handle a single-letter, no data option *
1863: *************************************************/
1864:
1865: static int
1866: handle_option(int letter, int options)
1867: {
1868: switch(letter)
1869: {
1870: case N_FOFFSETS: file_offsets = TRUE; break;
1871: case N_HELP: help(); pcregrep_exit(0);
1872: case N_LBUFFER: line_buffered = TRUE; break;
1873: case N_LOFFSETS: line_offsets = number = TRUE; break;
1874: case N_NOJIT: study_options &= ~PCRE_STUDY_JIT_COMPILE; break;
1875: case 'c': count_only = TRUE; break;
1876: case 'F': process_options |= PO_FIXED_STRINGS; break;
1877: case 'H': filenames = FN_FORCE; break;
1878: case 'h': filenames = FN_NONE; break;
1879: case 'i': options |= PCRE_CASELESS; break;
1880: case 'l': omit_zero_count = TRUE; filenames = FN_MATCH_ONLY; break;
1881: case 'L': filenames = FN_NOMATCH_ONLY; break;
1882: case 'M': multiline = TRUE; options |= PCRE_MULTILINE|PCRE_FIRSTLINE; break;
1883: case 'n': number = TRUE; break;
1884: case 'o': only_matching = 0; break;
1885: case 'q': quiet = TRUE; break;
1886: case 'r': dee_action = dee_RECURSE; break;
1887: case 's': silent = TRUE; break;
1888: case 'u': options |= PCRE_UTF8; utf8 = TRUE; break;
1889: case 'v': invert = TRUE; break;
1890: case 'w': process_options |= PO_WORD_MATCH; break;
1891: case 'x': process_options |= PO_LINE_MATCH; break;
1892:
1893: case 'V':
1894: fprintf(stderr, "pcregrep version %s\n", pcre_version());
1895: pcregrep_exit(0);
1896: break;
1897:
1898: default:
1899: fprintf(stderr, "pcregrep: Unknown option -%c\n", letter);
1900: pcregrep_exit(usage(2));
1901: }
1902:
1903: return options;
1904: }
1905:
1906:
1907:
1908:
1909: /*************************************************
1910: * Construct printed ordinal *
1911: *************************************************/
1912:
1913: /* This turns a number into "1st", "3rd", etc. */
1914:
1915: static char *
1916: ordin(int n)
1917: {
1918: static char buffer[8];
1919: char *p = buffer;
1920: sprintf(p, "%d", n);
1921: while (*p != 0) p++;
1922: switch (n%10)
1923: {
1924: case 1: strcpy(p, "st"); break;
1925: case 2: strcpy(p, "nd"); break;
1926: case 3: strcpy(p, "rd"); break;
1927: default: strcpy(p, "th"); break;
1928: }
1929: return buffer;
1930: }
1931:
1932:
1933:
1934: /*************************************************
1935: * Compile a single pattern *
1936: *************************************************/
1937:
1938: /* When the -F option has been used, this is called for each substring.
1939: Otherwise it's called for each supplied pattern.
1940:
1941: Arguments:
1942: pattern the pattern string
1943: options the PCRE options
1944: filename the file name, or NULL for a command-line pattern
1945: count 0 if this is the only command line pattern, or
1946: number of the command line pattern, or
1947: linenumber for a pattern from a file
1948:
1949: Returns: TRUE on success, FALSE after an error
1950: */
1951:
1952: static BOOL
1953: compile_single_pattern(char *pattern, int options, char *filename, int count)
1954: {
1955: char buffer[PATBUFSIZE];
1956: const char *error;
1957: int errptr;
1958:
1959: if (pattern_count >= MAX_PATTERN_COUNT)
1960: {
1961: fprintf(stderr, "pcregrep: Too many %spatterns (max %d)\n",
1962: (filename == NULL)? "command-line " : "", MAX_PATTERN_COUNT);
1963: return FALSE;
1964: }
1965:
1966: sprintf(buffer, "%s%.*s%s", prefix[process_options], bufthird, pattern,
1967: suffix[process_options]);
1968: pattern_list[pattern_count] =
1969: pcre_compile(buffer, options, &error, &errptr, pcretables);
1970: if (pattern_list[pattern_count] != NULL)
1971: {
1972: pattern_count++;
1973: return TRUE;
1974: }
1975:
1976: /* Handle compile errors */
1977:
1978: errptr -= (int)strlen(prefix[process_options]);
1979: if (errptr > (int)strlen(pattern)) errptr = (int)strlen(pattern);
1980:
1981: if (filename == NULL)
1982: {
1983: if (count == 0)
1984: fprintf(stderr, "pcregrep: Error in command-line regex "
1985: "at offset %d: %s\n", errptr, error);
1986: else
1987: fprintf(stderr, "pcregrep: Error in %s command-line regex "
1988: "at offset %d: %s\n", ordin(count), errptr, error);
1989: }
1990: else
1991: {
1992: fprintf(stderr, "pcregrep: Error in regex in line %d of %s "
1993: "at offset %d: %s\n", count, filename, errptr, error);
1994: }
1995:
1996: return FALSE;
1997: }
1998:
1999:
2000:
2001: /*************************************************
2002: * Compile one supplied pattern *
2003: *************************************************/
2004:
2005: /* When the -F option has been used, each string may be a list of strings,
2006: separated by line breaks. They will be matched literally.
2007:
2008: Arguments:
2009: pattern the pattern string
2010: options the PCRE options
2011: filename the file name, or NULL for a command-line pattern
2012: count 0 if this is the only command line pattern, or
2013: number of the command line pattern, or
2014: linenumber for a pattern from a file
2015:
2016: Returns: TRUE on success, FALSE after an error
2017: */
2018:
2019: static BOOL
2020: compile_pattern(char *pattern, int options, char *filename, int count)
2021: {
2022: if ((process_options & PO_FIXED_STRINGS) != 0)
2023: {
2024: char *eop = pattern + strlen(pattern);
2025: char buffer[PATBUFSIZE];
2026: for(;;)
2027: {
2028: int ellength;
2029: char *p = end_of_line(pattern, eop, &ellength);
2030: if (ellength == 0)
2031: return compile_single_pattern(pattern, options, filename, count);
2032: sprintf(buffer, "%.*s", (int)(p - pattern - ellength), pattern);
2033: pattern = p;
2034: if (!compile_single_pattern(buffer, options, filename, count))
2035: return FALSE;
2036: }
2037: }
2038: else return compile_single_pattern(pattern, options, filename, count);
2039: }
2040:
2041:
2042:
2043: /*************************************************
2044: * Main program *
2045: *************************************************/
2046:
2047: /* Returns 0 if something matched, 1 if nothing matched, 2 after an error. */
2048:
2049: int
2050: main(int argc, char **argv)
2051: {
2052: int i, j;
2053: int rc = 1;
2054: int pcre_options = 0;
2055: int cmd_pattern_count = 0;
2056: int hint_count = 0;
2057: int errptr;
2058: BOOL only_one_at_top;
2059: char *patterns[MAX_PATTERN_COUNT];
2060: const char *locale_from = "--locale";
2061: const char *error;
2062:
2063: #ifdef SUPPORT_PCREGREP_JIT
2064: pcre_jit_stack *jit_stack = NULL;
2065: #endif
2066:
2067: /* Set the default line ending value from the default in the PCRE library;
2068: "lf", "cr", "crlf", and "any" are supported. Anything else is treated as "lf".
2069: Note that the return values from pcre_config(), though derived from the ASCII
2070: codes, are the same in EBCDIC environments, so we must use the actual values
2071: rather than escapes such as as '\r'. */
2072:
2073: (void)pcre_config(PCRE_CONFIG_NEWLINE, &i);
2074: switch(i)
2075: {
2076: default: newline = (char *)"lf"; break;
2077: case 13: newline = (char *)"cr"; break;
2078: case (13 << 8) | 10: newline = (char *)"crlf"; break;
2079: case -1: newline = (char *)"any"; break;
2080: case -2: newline = (char *)"anycrlf"; break;
2081: }
2082:
2083: /* Process the options */
2084:
2085: for (i = 1; i < argc; i++)
2086: {
2087: option_item *op = NULL;
2088: char *option_data = (char *)""; /* default to keep compiler happy */
2089: BOOL longop;
2090: BOOL longopwasequals = FALSE;
2091:
2092: if (argv[i][0] != '-') break;
2093:
2094: /* If we hit an argument that is just "-", it may be a reference to STDIN,
2095: but only if we have previously had -e or -f to define the patterns. */
2096:
2097: if (argv[i][1] == 0)
2098: {
2099: if (pattern_filename != NULL || pattern_count > 0) break;
2100: else pcregrep_exit(usage(2));
2101: }
2102:
2103: /* Handle a long name option, or -- to terminate the options */
2104:
2105: if (argv[i][1] == '-')
2106: {
2107: char *arg = argv[i] + 2;
2108: char *argequals = strchr(arg, '=');
2109:
2110: if (*arg == 0) /* -- terminates options */
2111: {
2112: i++;
2113: break; /* out of the options-handling loop */
2114: }
2115:
2116: longop = TRUE;
2117:
2118: /* Some long options have data that follows after =, for example file=name.
2119: Some options have variations in the long name spelling: specifically, we
2120: allow "regexp" because GNU grep allows it, though I personally go along
2121: with Jeffrey Friedl and Larry Wall in preferring "regex" without the "p".
2122: These options are entered in the table as "regex(p)". Options can be in
2123: both these categories. */
2124:
2125: for (op = optionlist; op->one_char != 0; op++)
2126: {
2127: char *opbra = strchr(op->long_name, '(');
2128: char *equals = strchr(op->long_name, '=');
2129:
2130: /* Handle options with only one spelling of the name */
2131:
2132: if (opbra == NULL) /* Does not contain '(' */
2133: {
2134: if (equals == NULL) /* Not thing=data case */
2135: {
2136: if (strcmp(arg, op->long_name) == 0) break;
2137: }
2138: else /* Special case xxx=data */
2139: {
2140: int oplen = (int)(equals - op->long_name);
2141: int arglen = (argequals == NULL)?
2142: (int)strlen(arg) : (int)(argequals - arg);
2143: if (oplen == arglen && strncmp(arg, op->long_name, oplen) == 0)
2144: {
2145: option_data = arg + arglen;
2146: if (*option_data == '=')
2147: {
2148: option_data++;
2149: longopwasequals = TRUE;
2150: }
2151: break;
2152: }
2153: }
2154: }
2155:
2156: /* Handle options with an alternate spelling of the name */
2157:
2158: else
2159: {
2160: char buff1[24];
2161: char buff2[24];
2162:
2163: int baselen = (int)(opbra - op->long_name);
2164: int fulllen = (int)(strchr(op->long_name, ')') - op->long_name + 1);
2165: int arglen = (argequals == NULL || equals == NULL)?
2166: (int)strlen(arg) : (int)(argequals - arg);
2167:
2168: sprintf(buff1, "%.*s", baselen, op->long_name);
2169: sprintf(buff2, "%s%.*s", buff1, fulllen - baselen - 2, opbra + 1);
2170:
2171: if (strncmp(arg, buff1, arglen) == 0 ||
2172: strncmp(arg, buff2, arglen) == 0)
2173: {
2174: if (equals != NULL && argequals != NULL)
2175: {
2176: option_data = argequals;
2177: if (*option_data == '=')
2178: {
2179: option_data++;
2180: longopwasequals = TRUE;
2181: }
2182: }
2183: break;
2184: }
2185: }
2186: }
2187:
2188: if (op->one_char == 0)
2189: {
2190: fprintf(stderr, "pcregrep: Unknown option %s\n", argv[i]);
2191: pcregrep_exit(usage(2));
2192: }
2193: }
2194:
2195: /* Jeffrey Friedl's debugging harness uses these additional options which
2196: are not in the right form for putting in the option table because they use
2197: only one hyphen, yet are more than one character long. By putting them
2198: separately here, they will not get displayed as part of the help() output,
2199: but I don't think Jeffrey will care about that. */
2200:
2201: #ifdef JFRIEDL_DEBUG
2202: else if (strcmp(argv[i], "-pre") == 0) {
2203: jfriedl_prefix = argv[++i];
2204: continue;
2205: } else if (strcmp(argv[i], "-post") == 0) {
2206: jfriedl_postfix = argv[++i];
2207: continue;
2208: } else if (strcmp(argv[i], "-XT") == 0) {
2209: sscanf(argv[++i], "%d", &jfriedl_XT);
2210: continue;
2211: } else if (strcmp(argv[i], "-XR") == 0) {
2212: sscanf(argv[++i], "%d", &jfriedl_XR);
2213: continue;
2214: }
2215: #endif
2216:
2217:
2218: /* One-char options; many that have no data may be in a single argument; we
2219: continue till we hit the last one or one that needs data. */
2220:
2221: else
2222: {
2223: char *s = argv[i] + 1;
2224: longop = FALSE;
2225: while (*s != 0)
2226: {
2227: for (op = optionlist; op->one_char != 0; op++)
2228: {
2229: if (*s == op->one_char) break;
2230: }
2231: if (op->one_char == 0)
2232: {
2233: fprintf(stderr, "pcregrep: Unknown option letter '%c' in \"%s\"\n",
2234: *s, argv[i]);
2235: pcregrep_exit(usage(2));
2236: }
2237:
2238: /* Check for a single-character option that has data: OP_OP_NUMBER
2239: is used for one that either has a numerical number or defaults, i.e. the
2240: data is optional. If a digit follows, there is data; if not, carry on
2241: with other single-character options in the same string. */
2242:
2243: option_data = s+1;
2244: if (op->type == OP_OP_NUMBER)
2245: {
2246: if (isdigit((unsigned char)s[1])) break;
2247: }
2248: else /* Check for end or a dataless option */
2249: {
2250: if (op->type != OP_NODATA || s[1] == 0) break;
2251: }
2252:
2253: /* Handle a single-character option with no data, then loop for the
2254: next character in the string. */
2255:
2256: pcre_options = handle_option(*s++, pcre_options);
2257: }
2258: }
2259:
2260: /* At this point we should have op pointing to a matched option. If the type
2261: is NO_DATA, it means that there is no data, and the option might set
2262: something in the PCRE options. */
2263:
2264: if (op->type == OP_NODATA)
2265: {
2266: pcre_options = handle_option(op->one_char, pcre_options);
2267: continue;
2268: }
2269:
2270: /* If the option type is OP_OP_STRING or OP_OP_NUMBER, it's an option that
2271: either has a value or defaults to something. It cannot have data in a
2272: separate item. At the moment, the only such options are "colo(u)r",
2273: "only-matching", and Jeffrey Friedl's special -S debugging option. */
2274:
2275: if (*option_data == 0 &&
2276: (op->type == OP_OP_STRING || op->type == OP_OP_NUMBER))
2277: {
2278: switch (op->one_char)
2279: {
2280: case N_COLOUR:
2281: colour_option = (char *)"auto";
2282: break;
2283:
2284: case 'o':
2285: only_matching = 0;
2286: break;
2287:
2288: #ifdef JFRIEDL_DEBUG
2289: case 'S':
2290: S_arg = 0;
2291: break;
2292: #endif
2293: }
2294: continue;
2295: }
2296:
2297: /* Otherwise, find the data string for the option. */
2298:
2299: if (*option_data == 0)
2300: {
2301: if (i >= argc - 1 || longopwasequals)
2302: {
2303: fprintf(stderr, "pcregrep: Data missing after %s\n", argv[i]);
2304: pcregrep_exit(usage(2));
2305: }
2306: option_data = argv[++i];
2307: }
2308:
2309: /* If the option type is OP_PATLIST, it's the -e option, which can be called
2310: multiple times to create a list of patterns. */
2311:
2312: if (op->type == OP_PATLIST)
2313: {
2314: if (cmd_pattern_count >= MAX_PATTERN_COUNT)
2315: {
2316: fprintf(stderr, "pcregrep: Too many command-line patterns (max %d)\n",
2317: MAX_PATTERN_COUNT);
2318: return 2;
2319: }
2320: patterns[cmd_pattern_count++] = option_data;
2321: }
2322:
2323: /* Otherwise, deal with single string or numeric data values. */
2324:
2325: else if (op->type != OP_NUMBER && op->type != OP_LONGNUMBER &&
2326: op->type != OP_OP_NUMBER)
2327: {
2328: *((char **)op->dataptr) = option_data;
2329: }
2330:
2331: /* Avoid the use of strtoul() because SunOS4 doesn't have it. This is used
2332: only for unpicking arguments, so just keep it simple. */
2333:
2334: else
2335: {
2336: unsigned long int n = 0;
2337: char *endptr = option_data;
2338: while (*endptr != 0 && isspace((unsigned char)(*endptr))) endptr++;
2339: while (isdigit((unsigned char)(*endptr)))
2340: n = n * 10 + (int)(*endptr++ - '0');
2341: if (toupper(*endptr) == 'K')
2342: {
2343: n *= 1024;
2344: endptr++;
2345: }
2346: else if (toupper(*endptr) == 'M')
2347: {
2348: n *= 1024*1024;
2349: endptr++;
2350: }
2351: if (*endptr != 0)
2352: {
2353: if (longop)
2354: {
2355: char *equals = strchr(op->long_name, '=');
2356: int nlen = (equals == NULL)? (int)strlen(op->long_name) :
2357: (int)(equals - op->long_name);
2358: fprintf(stderr, "pcregrep: Malformed number \"%s\" after --%.*s\n",
2359: option_data, nlen, op->long_name);
2360: }
2361: else
2362: fprintf(stderr, "pcregrep: Malformed number \"%s\" after -%c\n",
2363: option_data, op->one_char);
2364: pcregrep_exit(usage(2));
2365: }
2366: if (op->type == OP_LONGNUMBER)
2367: *((unsigned long int *)op->dataptr) = n;
2368: else
2369: *((int *)op->dataptr) = n;
2370: }
2371: }
2372:
2373: /* Options have been decoded. If -C was used, its value is used as a default
2374: for -A and -B. */
2375:
2376: if (both_context > 0)
2377: {
2378: if (after_context == 0) after_context = both_context;
2379: if (before_context == 0) before_context = both_context;
2380: }
2381:
2382: /* Only one of --only-matching, --file-offsets, or --line-offsets is permitted.
2383: However, the latter two set only_matching. */
2384:
2385: if ((only_matching >= 0 && (file_offsets || line_offsets)) ||
2386: (file_offsets && line_offsets))
2387: {
2388: fprintf(stderr, "pcregrep: Cannot mix --only-matching, --file-offsets "
2389: "and/or --line-offsets\n");
2390: pcregrep_exit(usage(2));
2391: }
2392:
2393: if (file_offsets || line_offsets) only_matching = 0;
2394:
2395: /* If a locale has not been provided as an option, see if the LC_CTYPE or
2396: LC_ALL environment variable is set, and if so, use it. */
2397:
2398: if (locale == NULL)
2399: {
2400: locale = getenv("LC_ALL");
2401: locale_from = "LCC_ALL";
2402: }
2403:
2404: if (locale == NULL)
2405: {
2406: locale = getenv("LC_CTYPE");
2407: locale_from = "LC_CTYPE";
2408: }
2409:
2410: /* If a locale has been provided, set it, and generate the tables the PCRE
2411: needs. Otherwise, pcretables==NULL, which causes the use of default tables. */
2412:
2413: if (locale != NULL)
2414: {
2415: if (setlocale(LC_CTYPE, locale) == NULL)
2416: {
2417: fprintf(stderr, "pcregrep: Failed to set locale %s (obtained from %s)\n",
2418: locale, locale_from);
2419: return 2;
2420: }
2421: pcretables = pcre_maketables();
2422: }
2423:
2424: /* Sort out colouring */
2425:
2426: if (colour_option != NULL && strcmp(colour_option, "never") != 0)
2427: {
2428: if (strcmp(colour_option, "always") == 0) do_colour = TRUE;
2429: else if (strcmp(colour_option, "auto") == 0) do_colour = is_stdout_tty();
2430: else
2431: {
2432: fprintf(stderr, "pcregrep: Unknown colour setting \"%s\"\n",
2433: colour_option);
2434: return 2;
2435: }
2436: if (do_colour)
2437: {
2438: char *cs = getenv("PCREGREP_COLOUR");
2439: if (cs == NULL) cs = getenv("PCREGREP_COLOR");
2440: if (cs != NULL) colour_string = cs;
2441: }
2442: }
2443:
2444: /* Interpret the newline type; the default settings are Unix-like. */
2445:
2446: if (strcmp(newline, "cr") == 0 || strcmp(newline, "CR") == 0)
2447: {
2448: pcre_options |= PCRE_NEWLINE_CR;
2449: endlinetype = EL_CR;
2450: }
2451: else if (strcmp(newline, "lf") == 0 || strcmp(newline, "LF") == 0)
2452: {
2453: pcre_options |= PCRE_NEWLINE_LF;
2454: endlinetype = EL_LF;
2455: }
2456: else if (strcmp(newline, "crlf") == 0 || strcmp(newline, "CRLF") == 0)
2457: {
2458: pcre_options |= PCRE_NEWLINE_CRLF;
2459: endlinetype = EL_CRLF;
2460: }
2461: else if (strcmp(newline, "any") == 0 || strcmp(newline, "ANY") == 0)
2462: {
2463: pcre_options |= PCRE_NEWLINE_ANY;
2464: endlinetype = EL_ANY;
2465: }
2466: else if (strcmp(newline, "anycrlf") == 0 || strcmp(newline, "ANYCRLF") == 0)
2467: {
2468: pcre_options |= PCRE_NEWLINE_ANYCRLF;
2469: endlinetype = EL_ANYCRLF;
2470: }
2471: else
2472: {
2473: fprintf(stderr, "pcregrep: Invalid newline specifier \"%s\"\n", newline);
2474: return 2;
2475: }
2476:
2477: /* Interpret the text values for -d and -D */
2478:
2479: if (dee_option != NULL)
2480: {
2481: if (strcmp(dee_option, "read") == 0) dee_action = dee_READ;
2482: else if (strcmp(dee_option, "recurse") == 0) dee_action = dee_RECURSE;
2483: else if (strcmp(dee_option, "skip") == 0) dee_action = dee_SKIP;
2484: else
2485: {
2486: fprintf(stderr, "pcregrep: Invalid value \"%s\" for -d\n", dee_option);
2487: return 2;
2488: }
2489: }
2490:
2491: if (DEE_option != NULL)
2492: {
2493: if (strcmp(DEE_option, "read") == 0) DEE_action = DEE_READ;
2494: else if (strcmp(DEE_option, "skip") == 0) DEE_action = DEE_SKIP;
2495: else
2496: {
2497: fprintf(stderr, "pcregrep: Invalid value \"%s\" for -D\n", DEE_option);
2498: return 2;
2499: }
2500: }
2501:
2502: /* Check the values for Jeffrey Friedl's debugging options. */
2503:
2504: #ifdef JFRIEDL_DEBUG
2505: if (S_arg > 9)
2506: {
2507: fprintf(stderr, "pcregrep: bad value for -S option\n");
2508: return 2;
2509: }
2510: if (jfriedl_XT != 0 || jfriedl_XR != 0)
2511: {
2512: if (jfriedl_XT == 0) jfriedl_XT = 1;
2513: if (jfriedl_XR == 0) jfriedl_XR = 1;
2514: }
2515: #endif
2516:
2517: /* Get memory for the main buffer, and to store the pattern and hints lists. */
2518:
2519: bufsize = 3*bufthird;
2520: main_buffer = (char *)malloc(bufsize);
2521: pattern_list = (pcre **)malloc(MAX_PATTERN_COUNT * sizeof(pcre *));
2522: hints_list = (pcre_extra **)malloc(MAX_PATTERN_COUNT * sizeof(pcre_extra *));
2523:
2524: if (main_buffer == NULL || pattern_list == NULL || hints_list == NULL)
2525: {
2526: fprintf(stderr, "pcregrep: malloc failed\n");
2527: goto EXIT2;
2528: }
2529:
2530: /* If no patterns were provided by -e, and there is no file provided by -f,
2531: the first argument is the one and only pattern, and it must exist. */
2532:
2533: if (cmd_pattern_count == 0 && pattern_filename == NULL)
2534: {
2535: if (i >= argc) return usage(2);
2536: patterns[cmd_pattern_count++] = argv[i++];
2537: }
2538:
2539: /* Compile the patterns that were provided on the command line, either by
2540: multiple uses of -e or as a single unkeyed pattern. */
2541:
2542: for (j = 0; j < cmd_pattern_count; j++)
2543: {
2544: if (!compile_pattern(patterns[j], pcre_options, NULL,
2545: (j == 0 && cmd_pattern_count == 1)? 0 : j + 1))
2546: goto EXIT2;
2547: }
2548:
2549: /* Compile the regular expressions that are provided in a file. */
2550:
2551: if (pattern_filename != NULL)
2552: {
2553: int linenumber = 0;
2554: FILE *f;
2555: char *filename;
2556: char buffer[PATBUFSIZE];
2557:
2558: if (strcmp(pattern_filename, "-") == 0)
2559: {
2560: f = stdin;
2561: filename = stdin_name;
2562: }
2563: else
2564: {
2565: f = fopen(pattern_filename, "r");
2566: if (f == NULL)
2567: {
2568: fprintf(stderr, "pcregrep: Failed to open %s: %s\n", pattern_filename,
2569: strerror(errno));
2570: goto EXIT2;
2571: }
2572: filename = pattern_filename;
2573: }
2574:
2575: while (fgets(buffer, PATBUFSIZE, f) != NULL)
2576: {
2577: char *s = buffer + (int)strlen(buffer);
2578: while (s > buffer && isspace((unsigned char)(s[-1]))) s--;
2579: *s = 0;
2580: linenumber++;
2581: if (buffer[0] == 0) continue; /* Skip blank lines */
2582: if (!compile_pattern(buffer, pcre_options, filename, linenumber))
2583: goto EXIT2;
2584: }
2585:
2586: if (f != stdin) fclose(f);
2587: }
2588:
2589: /* Study the regular expressions, as we will be running them many times. Unless
2590: JIT has been explicitly disabled, arrange a stack for it to use. */
2591:
2592: #ifdef SUPPORT_PCREGREP_JIT
2593: if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
2594: jit_stack = pcre_jit_stack_alloc(32*1024, 1024*1024);
2595: #endif
2596:
2597: for (j = 0; j < pattern_count; j++)
2598: {
2599: hints_list[j] = pcre_study(pattern_list[j], study_options, &error);
2600: if (error != NULL)
2601: {
2602: char s[16];
2603: if (pattern_count == 1) s[0] = 0; else sprintf(s, " number %d", j);
2604: fprintf(stderr, "pcregrep: Error while studying regex%s: %s\n", s, error);
2605: goto EXIT2;
2606: }
2607: hint_count++;
2608: #ifdef SUPPORT_PCREGREP_JIT
2609: if (jit_stack != NULL && hints_list[j] != NULL)
2610: pcre_assign_jit_stack(hints_list[j], NULL, jit_stack);
2611: #endif
2612: }
2613:
2614: /* If --match-limit or --recursion-limit was set, put the value(s) into the
2615: pcre_extra block for each pattern. */
2616:
2617: if (match_limit > 0 || match_limit_recursion > 0)
2618: {
2619: for (j = 0; j < pattern_count; j++)
2620: {
2621: if (hints_list[j] == NULL)
2622: {
2623: hints_list[j] = malloc(sizeof(pcre_extra));
2624: if (hints_list[j] == NULL)
2625: {
2626: fprintf(stderr, "pcregrep: malloc failed\n");
2627: pcregrep_exit(2);
2628: }
2629: }
2630: if (match_limit > 0)
2631: {
2632: hints_list[j]->flags |= PCRE_EXTRA_MATCH_LIMIT;
2633: hints_list[j]->match_limit = match_limit;
2634: }
2635: if (match_limit_recursion > 0)
2636: {
2637: hints_list[j]->flags |= PCRE_EXTRA_MATCH_LIMIT_RECURSION;
2638: hints_list[j]->match_limit_recursion = match_limit_recursion;
2639: }
2640: }
2641: }
2642:
2643: /* If there are include or exclude patterns, compile them. */
2644:
2645: if (exclude_pattern != NULL)
2646: {
2647: exclude_compiled = pcre_compile(exclude_pattern, 0, &error, &errptr,
2648: pcretables);
2649: if (exclude_compiled == NULL)
2650: {
2651: fprintf(stderr, "pcregrep: Error in 'exclude' regex at offset %d: %s\n",
2652: errptr, error);
2653: goto EXIT2;
2654: }
2655: }
2656:
2657: if (include_pattern != NULL)
2658: {
2659: include_compiled = pcre_compile(include_pattern, 0, &error, &errptr,
2660: pcretables);
2661: if (include_compiled == NULL)
2662: {
2663: fprintf(stderr, "pcregrep: Error in 'include' regex at offset %d: %s\n",
2664: errptr, error);
2665: goto EXIT2;
2666: }
2667: }
2668:
2669: if (exclude_dir_pattern != NULL)
2670: {
2671: exclude_dir_compiled = pcre_compile(exclude_dir_pattern, 0, &error, &errptr,
2672: pcretables);
2673: if (exclude_dir_compiled == NULL)
2674: {
2675: fprintf(stderr, "pcregrep: Error in 'exclude_dir' regex at offset %d: %s\n",
2676: errptr, error);
2677: goto EXIT2;
2678: }
2679: }
2680:
2681: if (include_dir_pattern != NULL)
2682: {
2683: include_dir_compiled = pcre_compile(include_dir_pattern, 0, &error, &errptr,
2684: pcretables);
2685: if (include_dir_compiled == NULL)
2686: {
2687: fprintf(stderr, "pcregrep: Error in 'include_dir' regex at offset %d: %s\n",
2688: errptr, error);
2689: goto EXIT2;
2690: }
2691: }
2692:
2693: /* If there are no further arguments, do the business on stdin and exit. */
2694:
2695: if (i >= argc)
2696: {
2697: rc = pcregrep(stdin, FR_PLAIN, stdin_name,
2698: (filenames > FN_DEFAULT)? stdin_name : NULL);
2699: goto EXIT;
2700: }
2701:
2702: /* Otherwise, work through the remaining arguments as files or directories.
2703: Pass in the fact that there is only one argument at top level - this suppresses
2704: the file name if the argument is not a directory and filenames are not
2705: otherwise forced. */
2706:
2707: only_one_at_top = i == argc - 1; /* Catch initial value of i */
2708:
2709: for (; i < argc; i++)
2710: {
2711: int frc = grep_or_recurse(argv[i], dee_action == dee_RECURSE,
2712: only_one_at_top);
2713: if (frc > 1) rc = frc;
2714: else if (frc == 0 && rc == 1) rc = 0;
2715: }
2716:
2717: EXIT:
2718: #ifdef SUPPORT_PCREGREP_JIT
2719: if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
2720: #endif
2721: if (main_buffer != NULL) free(main_buffer);
2722: if (pattern_list != NULL)
2723: {
2724: for (i = 0; i < pattern_count; i++) free(pattern_list[i]);
2725: free(pattern_list);
2726: }
2727: if (hints_list != NULL)
2728: {
2729: for (i = 0; i < hint_count; i++)
2730: {
2731: if (hints_list[i] != NULL) pcre_free_study(hints_list[i]);
2732: }
2733: free(hints_list);
2734: }
2735: pcregrep_exit(rc);
2736:
2737: EXIT2:
2738: rc = 2;
2739: goto EXIT;
2740: }
2741:
2742: /* End of pcregrep */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcregrep.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre