/[pcre]/code/trunk/pcregrep.c
ViewVC logotype

Contents of /code/trunk/pcregrep.c

Parent Directory Parent Directory | Revision Log Revision Log


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

Properties

Name Value
svn:eol-style native
svn:keywords "Author Date Id Revision Url"

  ViewVC Help
Powered by ViewVC 1.1.5