/************************************************* * pcregrep program * *************************************************/ /* This is a grep program that uses the PCRE regular expression library to do its pattern matching. On a Unix or Win32 system it can recurse into directories. Copyright (c) 1997-2005 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the University of Cambridge nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ----------------------------------------------------------------------------- */ #include #include #include #include #include #include #include #include #include "config.h" #include "pcre.h" #define FALSE 0 #define TRUE 1 typedef int BOOL; #define VERSION "4.1 05-Sep-2005" #define MAX_PATTERN_COUNT 100 #if BUFSIZ > 8192 #define MBUFTHIRD BUFSIZ #else #define MBUFTHIRD 8192 #endif /************************************************* * Global variables * *************************************************/ static char *pattern_filename = NULL; static char *stdin_name = (char *)"(standard input)"; static int pattern_count = 0; static pcre **pattern_list; static pcre_extra **hints_list; static char *include_pattern = NULL; static char *exclude_pattern = NULL; static pcre *include_compiled = NULL; static pcre *exclude_compiled = NULL; static int after_context = 0; static int before_context = 0; static int both_context = 0; static BOOL count_only = FALSE; static BOOL filenames = TRUE; static BOOL filenames_only = FALSE; static BOOL filenames_nomatch_only = FALSE; static BOOL hyphenpending = FALSE; static BOOL invert = FALSE; static BOOL multiline = FALSE; static BOOL number = FALSE; static BOOL quiet = FALSE; static BOOL recurse = FALSE; static BOOL silent = FALSE; static BOOL whole_lines = FALSE; static BOOL word_match = FALSE; /* Structure for options and list of them */ enum { OP_NODATA, OP_STRING, OP_NUMBER }; typedef struct option_item { int type; int one_char; void *dataptr; const char *long_name; const char *help_text; } option_item; static option_item optionlist[] = { { OP_NODATA, -1, NULL, "", " terminate options" }, { OP_NODATA, -1, NULL, "help", "display this help and exit" }, { OP_NUMBER, 'A', &after_context, "after-context=number", "set number of following context lines" }, { OP_NUMBER, 'B', &before_context, "before-context=number", "set number of prior context lines" }, { OP_NUMBER, 'C', &both_context, "context=number", "set number of context lines, before & after" }, { OP_NODATA, 'c', NULL, "count", "print only a count of matching lines per FILE" }, { OP_STRING, 'f', &pattern_filename, "file=path", "read patterns from file" }, { OP_NODATA, 'h', NULL, "no-filename", "suppress the prefixing filename on output" }, { OP_NODATA, 'i', NULL, "ignore-case", "ignore case distinctions" }, { OP_NODATA, 'l', NULL, "files-with-matches", "print only FILE names containing matches" }, { OP_NODATA, 'L', NULL, "files-without-match","print only FILE names not containing matches" }, { OP_STRING, -1, &stdin_name, "label=name", "set name for standard input" }, { OP_NODATA, 'M', NULL, "multiline", "run in multiline mode" }, { OP_NODATA, 'n', NULL, "line-number", "print line number with output lines" }, { OP_NODATA, 'q', NULL, "quiet", "suppress output, just set return code" }, { OP_NODATA, 'r', NULL, "recursive", "recursively scan sub-directories" }, { OP_STRING, -1, &exclude_pattern, "exclude=pattern","exclude matching files when recursing" }, { OP_STRING, -1, &include_pattern, "include=pattern","include matching files when recursing" }, { OP_NODATA, 's', NULL, "no-messages", "suppress error messages" }, { OP_NODATA, 'u', NULL, "utf-8", "use UTF-8 mode" }, { OP_NODATA, 'V', NULL, "version", "print version information and exit" }, { OP_NODATA, 'v', NULL, "invert-match", "select non-matching lines" }, { OP_NODATA, 'w', NULL, "word-regex(p)", "force PATTERN to match only as a word" }, { OP_NODATA, 'x', NULL, "line-regex(p)", "force PATTERN to match only whole lines" }, { OP_NODATA, 0, NULL, NULL, NULL } }; /************************************************* * Functions for directory scanning * *************************************************/ /* These functions are defined so that they can be made system specific, although at present the only ones are for Unix, Win32, and for "no directory recursion support". */ /************* Directory scanning in Unix ***********/ #if IS_UNIX #include #include #include typedef DIR directory_type; static int isdirectory(char *filename) { struct stat statbuf; if (stat(filename, &statbuf) < 0) return 0; /* In the expectation that opening as a file will fail */ return ((statbuf.st_mode & S_IFMT) == S_IFDIR)? '/' : 0; } static directory_type * opendirectory(char *filename) { return opendir(filename); } static char * readdirectory(directory_type *dir) { for (;;) { struct dirent *dent = readdir(dir); if (dent == NULL) return NULL; if (strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0) return dent->d_name; } return NULL; /* Keep compiler happy; never executed */ } static void closedirectory(directory_type *dir) { closedir(dir); } /************* Directory scanning in Win32 ***********/ /* I (Philip Hazel) have no means of testing this code. It was contributed by Lionel Fourquaux. David Burgess added a patch to define INVALID_FILE_ATTRIBUTES when it did not exist. */ #elif HAVE_WIN32API #ifndef STRICT # define STRICT #endif #ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN #endif #ifndef INVALID_FILE_ATTRIBUTES #define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF #endif #include typedef struct directory_type { HANDLE handle; BOOL first; WIN32_FIND_DATA data; } directory_type; int isdirectory(char *filename) { DWORD attr = GetFileAttributes(filename); if (attr == INVALID_FILE_ATTRIBUTES) return 0; return ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) ? '/' : 0; } directory_type * opendirectory(char *filename) { size_t len; char *pattern; directory_type *dir; DWORD err; len = strlen(filename); pattern = (char *) malloc(len + 3); dir = (directory_type *) malloc(sizeof(*dir)); if ((pattern == NULL) || (dir == NULL)) { fprintf(stderr, "pcregrep: malloc failed\n"); exit(2); } memcpy(pattern, filename, len); memcpy(&(pattern[len]), "\\*", 3); dir->handle = FindFirstFile(pattern, &(dir->data)); if (dir->handle != INVALID_HANDLE_VALUE) { free(pattern); dir->first = TRUE; return dir; } err = GetLastError(); free(pattern); free(dir); errno = (err == ERROR_ACCESS_DENIED) ? EACCES : ENOENT; return NULL; } char * readdirectory(directory_type *dir) { for (;;) { if (!dir->first) { if (!FindNextFile(dir->handle, &(dir->data))) return NULL; } else { dir->first = FALSE; } if (strcmp(dir->data.cFileName, ".") != 0 && strcmp(dir->data.cFileName, "..") != 0) return dir->data.cFileName; } #ifndef _MSC_VER return NULL; /* Keep compiler happy; never executed */ #endif } void closedirectory(directory_type *dir) { FindClose(dir->handle); free(dir); } /************* Directory scanning when we can't do it ***********/ /* The type is void, and apart from isdirectory(), the functions do nothing. */ #else typedef void directory_type; int isdirectory(char *filename) { return FALSE; } directory_type * opendirectory(char *filename) {} char *readdirectory(directory_type *dir) {} void closedirectory(directory_type *dir) {} #endif #if ! HAVE_STRERROR /************************************************* * Provide strerror() for non-ANSI libraries * *************************************************/ /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror() in their libraries, but can provide the same facility by this simple alternative function. */ extern int sys_nerr; extern char *sys_errlist[]; char * strerror(int n) { if (n < 0 || n >= sys_nerr) return "unknown error number"; return sys_errlist[n]; } #endif /* HAVE_STRERROR */ /************************************************* * Print the previous "after" lines * *************************************************/ /* This is called if we are about to lose said lines because of buffer filling, and at the end of the file. Arguments: lastmatchnumber the number of the last matching line, plus one lastmatchrestart where we restarted after the last match endptr end of available data printname filename for printing Returns: nothing */ static void do_after_lines(int lastmatchnumber, char *lastmatchrestart, char *endptr, char *printname) { if (after_context > 0 && lastmatchnumber > 0) { int count = 0; while (lastmatchrestart < endptr && count++ < after_context) { char *pp = lastmatchrestart; if (printname != NULL) fprintf(stdout, "%s-", printname); if (number) fprintf(stdout, "%d-", lastmatchnumber++); while (*pp != '\n') pp++; fprintf(stdout, "%.*s", pp - lastmatchrestart + 1, lastmatchrestart); lastmatchrestart = pp + 1; } hyphenpending = TRUE; } } /************************************************* * Grep an individual file * *************************************************/ /* This is called from grep_or_recurse() below. It uses a buffer that is three times the value of MBUFTHIRD. The matching point is never allowed to stray into the top third of the buffer, thus keeping more of the file available for context printing or for multiline scanning. For large files, the pointer will be in the middle third most of the time, so the bottom third is available for "before" context printing. Arguments: in the fopened FILE stream printname the file name if it is to be printed for each match or NULL if the file name is not to be printed it cannot be NULL if filenames[_nomatch]_only is set Returns: 0 if there was at least one match 1 otherwise (no matches) */ static int pcregrep(FILE *in, char *printname) { int rc = 1; int linenumber = 1; int lastmatchnumber = 0; int count = 0; int offsets[99]; char *lastmatchrestart = NULL; char buffer[3*MBUFTHIRD]; char *ptr = buffer; char *endptr; size_t bufflength; BOOL endhyphenpending = FALSE; /* Do the first read into the start of the buffer and set up the pointer to end of what we have. */ bufflength = fread(buffer, 1, 3*MBUFTHIRD, in); endptr = buffer + bufflength; /* Loop while the current pointer is not at the end of the file. For large files, endptr will be at the end of the buffer when we are in the middle of the file, but ptr will never get there, because as soon as it gets over 2/3 of the way, the buffer is shifted left and re-filled. */ while (ptr < endptr) { int i; BOOL match = FALSE; char *t = ptr; size_t length, linelength; /* At this point, ptr is at the start of a line. We need to find the length of the subject string to pass to pcre_exec(). In multiline mode, it is the length remainder of the data in the buffer. Otherwise, it is the length of the next line. After matching, we always advance by the length of the next line. In multiline mode the PCRE_FIRSTLINE option is used for compiling, so that any match is constrained to be in the first line. */ linelength = 0; while (t < endptr && *t++ != '\n') linelength++; length = multiline? endptr - ptr : linelength; /* Run through all the patterns until one matches. Note that we don't include the final newline in the subject string. */ for (i = 0; !match && i < pattern_count; i++) { match = pcre_exec(pattern_list[i], hints_list[i], ptr, length, 0, 0, offsets, 99) >= 0; } /* If it's a match or a not-match (as required), print what's wanted. */ if (match != invert) { BOOL hyphenprinted = FALSE; if (filenames_nomatch_only) return 1; if (count_only) count++; else if (filenames_only) { fprintf(stdout, "%s\n", printname); return 0; } else if (quiet) return 0; else { /* See if there is a requirement to print some "after" lines from a previous match. We never print any overlaps. */ if (after_context > 0 && lastmatchnumber > 0) { int linecount = 0; char *p = lastmatchrestart; while (p < ptr && linecount < after_context) { while (*p != '\n') p++; p++; linecount++; } /* It is important to advance lastmatchrestart during this printing so that it interacts correctly with any "before" printing below. */ while (lastmatchrestart < p) { char *pp = lastmatchrestart; if (printname != NULL) fprintf(stdout, "%s-", printname); if (number) fprintf(stdout, "%d-", lastmatchnumber++); while (*pp != '\n') pp++; fprintf(stdout, "%.*s", pp - lastmatchrestart + 1, lastmatchrestart); lastmatchrestart = pp + 1; } if (lastmatchrestart != ptr) hyphenpending = TRUE; } /* If there were non-contiguous lines printed above, insert hyphens. */ if (hyphenpending) { fprintf(stdout, "--\n"); hyphenpending = FALSE; hyphenprinted = TRUE; } /* See if there is a requirement to print some "before" lines for this match. Again, don't print overlaps. */ if (before_context > 0) { int linecount = 0; char *p = ptr; while (p > buffer && (lastmatchnumber == 0 || p > lastmatchrestart) && linecount++ < before_context) { p--; while (p > buffer && p[-1] != '\n') p--; } if (lastmatchnumber > 0 && p > lastmatchrestart && !hyphenprinted) fprintf(stdout, "--\n"); while (p < ptr) { char *pp = p; if (printname != NULL) fprintf(stdout, "%s-", printname); if (number) fprintf(stdout, "%d-", linenumber - linecount--); while (*pp != '\n') pp++; fprintf(stdout, "%.*s", pp - p + 1, p); p = pp + 1; } } /* Now print the matching line(s); ensure we set hyphenpending at the end of the file if any context lines are being output. */ if (after_context > 0 || before_context > 0) endhyphenpending = TRUE; if (printname != NULL) fprintf(stdout, "%s:", printname); if (number) fprintf(stdout, "%d:", linenumber); /* In multiline mode, we want to print to the end of the line in which the end of the matched string is found, so we adjust linelength and the line number appropriately. Because the PCRE_FIRSTLINE option is set, the start of the match will always be before the first \n character. */ if (multiline) { char *endmatch = ptr + offsets[1]; t = ptr; while (t < endmatch) { if (*t++ == '\n') linenumber++; } while (endmatch < endptr && *endmatch != '\n') endmatch++; linelength = endmatch - ptr; } fprintf(stdout, "%.*s\n", linelength, ptr); } rc = 0; /* Had some success */ /* Remember where the last match happened for after_context. We remember where we are about to restart, and that line's number. */ lastmatchrestart = ptr + linelength + 1; lastmatchnumber = linenumber + 1; } /* Advance to after the newline and increment the line number. */ ptr += linelength + 1; linenumber++; /* If we haven't yet reached the end of the file (the buffer is full), and the current point is in the top 1/3 of the buffer, slide the buffer down by 1/3 and refill it. Before we do this, if some unprinted "after" lines are about to be lost, print them. */ if (bufflength >= sizeof(buffer) && ptr > buffer + 2*MBUFTHIRD) { if (after_context > 0 && lastmatchnumber > 0 && lastmatchrestart < buffer + MBUFTHIRD) { do_after_lines(lastmatchnumber, lastmatchrestart, endptr, printname); lastmatchnumber = 0; } /* Now do the shuffle */ memmove(buffer, buffer + MBUFTHIRD, 2*MBUFTHIRD); ptr -= MBUFTHIRD; bufflength = 2*MBUFTHIRD + fread(buffer + 2*MBUFTHIRD, 1, MBUFTHIRD, in); endptr = buffer + bufflength; /* Adjust any last match point */ if (lastmatchnumber > 0) lastmatchrestart -= MBUFTHIRD; } } /* Loop through the whole file */ /* End of file; print final "after" lines if wanted; do_after_lines sets hyphenpending if it prints something. */ do_after_lines(lastmatchnumber, lastmatchrestart, endptr, printname); hyphenpending |= endhyphenpending; /* Print the file name if we are looking for those without matches and there were none. If we found a match, we won't have got this far. */ if (filenames_nomatch_only) { fprintf(stdout, "%s\n", printname); return 0; } /* Print the match count if wanted */ if (count_only) { if (printname != NULL) fprintf(stdout, "%s:", printname); fprintf(stdout, "%d\n", count); } return rc; } /************************************************* * Grep a file or recurse into a directory * *************************************************/ /* Given a path name, if it's a directory, scan all the files if we are recursing; if it's a file, grep it. Arguments: pathname the path to investigate dir_recurse TRUE if recursing is wanted (-r) show_filenames TRUE if file names are wanted for multiple files, except for the only file at top level when not filenames_only only_one_at_top TRUE if the path is the only one at toplevel Returns: 0 if there was at least one match 1 if there were no matches 2 there was some kind of error However, file opening failures are suppressed if "silent" is set. */ static int grep_or_recurse(char *pathname, BOOL dir_recurse, BOOL show_filenames, BOOL only_one_at_top) { int rc = 1; int sep; FILE *in; char *printname; /* If the file name is "-" we scan stdin */ if (strcmp(pathname, "-") == 0) { return pcregrep(stdin, (filenames_only || filenames_nomatch_only || (show_filenames && !only_one_at_top))? stdin_name : NULL); } /* If the file is a directory and we are recursing, scan each file within it, subject to any include or exclude patterns that were set. The scanning code is localized so it can be made system-specific. */ if ((sep = isdirectory(pathname)) != 0 && dir_recurse) { char buffer[1024]; char *nextfile; directory_type *dir = opendirectory(pathname); if (dir == NULL) { if (!silent) fprintf(stderr, "pcregrep: Failed to open directory %s: %s\n", pathname, strerror(errno)); return 2; } while ((nextfile = readdirectory(dir)) != NULL) { int frc, blen; sprintf(buffer, "%.512s%c%.128s", pathname, sep, nextfile); blen = strlen(buffer); if (exclude_compiled != NULL && pcre_exec(exclude_compiled, NULL, buffer, blen, 0, 0, NULL, 0) >= 0) continue; if (include_compiled != NULL && pcre_exec(include_compiled, NULL, buffer, blen, 0, 0, NULL, 0) < 0) continue; frc = grep_or_recurse(buffer, dir_recurse, TRUE, FALSE); if (frc > 1) rc = frc; else if (frc == 0 && rc == 1) rc = 0; } closedirectory(dir); return rc; } /* If the file is not a directory, or we are not recursing, scan it. If this is the first and only argument at top level, we don't show the file name (unless we are only showing the file name). Otherwise, control is via the show_filenames variable. */ in = fopen(pathname, "r"); if (in == NULL) { if (!silent) fprintf(stderr, "pcregrep: Failed to open %s: %s\n", pathname, strerror(errno)); return 2; } printname = (filenames_only || filenames_nomatch_only || (show_filenames && !only_one_at_top))? pathname : NULL; rc = pcregrep(in, printname); fclose(in); return rc; } /************************************************* * Usage function * *************************************************/ static int usage(int rc) { fprintf(stderr, "Usage: pcregrep [-LMVcfhilnqrsvwx] [long-options] [pattern] [file1 file2 ...]\n"); fprintf(stderr, "Type `pcregrep --help' for more information.\n"); return rc; } /************************************************* * Help function * *************************************************/ static void help(void) { option_item *op; printf("Usage: pcregrep [OPTION]... [PATTERN] [FILE1 FILE2 ...]\n"); printf("Search for PATTERN in each FILE or standard input.\n"); printf("PATTERN must be present if -f is not used.\n"); printf("\"-\" can be used as a file name to mean STDIN.\n"); printf("Example: pcregrep -i 'hello.*world' menu.h main.c\n\n"); printf("Options:\n"); for (op = optionlist; op->one_char != 0; op++) { int n; char s[4]; if (op->one_char > 0) sprintf(s, "-%c,", op->one_char); else strcpy(s, " "); printf(" %s --%s%n", s, op->long_name, &n); n = 30 - n; if (n < 1) n = 1; printf("%.*s%s\n", n, " ", op->help_text); } printf("\nWhen reading patterns from a file instead of using a command line option,\n"); printf("trailing white space is removed and blank lines are ignored.\n"); printf("There is a maximum of %d patterns.\n", MAX_PATTERN_COUNT); printf("\nWith no FILEs, read standard input. If fewer than two FILEs given, assume -h.\n"); printf("Exit status is 0 if any matches, 1 if no matches, and 2 if trouble.\n"); } /************************************************* * Handle a single-letter, no data option * *************************************************/ static int handle_option(int letter, int options) { switch(letter) { case -1: help(); exit(0); case 'c': count_only = TRUE; break; case 'h': filenames = FALSE; break; case 'i': options |= PCRE_CASELESS; break; case 'l': filenames_only = TRUE; break; case 'L': filenames_nomatch_only = TRUE; break; case 'M': multiline = TRUE; options |= PCRE_MULTILINE|PCRE_FIRSTLINE; break; case 'n': number = TRUE; break; case 'q': quiet = TRUE; break; case 'r': recurse = TRUE; break; case 's': silent = TRUE; break; case 'u': options |= PCRE_UTF8; break; case 'v': invert = TRUE; break; case 'w': word_match = TRUE; break; case 'x': whole_lines = TRUE; break; case 'V': fprintf(stderr, "pcregrep version %s using ", VERSION); fprintf(stderr, "PCRE version %s\n", pcre_version()); exit(0); break; default: fprintf(stderr, "pcregrep: Unknown option -%c\n", letter); exit(usage(2)); } return options; } /************************************************* * Main program * *************************************************/ /* Returns 0 if something matched, 1 if nothing matched, 2 after an error. */ int main(int argc, char **argv) { int i, j; int rc = 1; int options = 0; int errptr; const char *error; BOOL only_one_at_top; /* Process the options */ for (i = 1; i < argc; i++) { option_item *op = NULL; char *option_data = (char *)""; /* default to keep compiler happy */ BOOL longop; BOOL longopwasequals = FALSE; if (argv[i][0] != '-') break; /* If we hit an argument that is just "-", it may be a reference to STDIN, but only if we have previously had -f to define the patterns. */ if (argv[i][1] == 0) { if (pattern_filename != NULL) break; else exit(usage(2)); } /* Handle a long name option, or -- to terminate the options */ if (argv[i][1] == '-') { char *arg = argv[i] + 2; char *argequals = strchr(arg, '='); if (*arg == 0) /* -- terminates options */ { i++; break; /* out of the options-handling loop */ } longop = TRUE; /* Some long options have data that follows after =, for example file=name. Some options have variations in the long name spelling: specifically, we allow "regexp" because GNU grep allows it, though I personally go along with Jeff Friedl in preferring "regex" without the "p". These options are entered in the table as "regex(p)". No option is in both these categories, fortunately. */ for (op = optionlist; op->one_char != 0; op++) { char *opbra = strchr(op->long_name, '('); char *equals = strchr(op->long_name, '='); if (opbra == NULL) /* Not a (p) case */ { if (equals == NULL) /* Not thing=data case */ { if (strcmp(arg, op->long_name) == 0) break; } else /* Special case xxx=data */ { int oplen = equals - op->long_name; int arglen = (argequals == NULL)? strlen(arg) : argequals - arg; if (oplen == arglen && strncmp(arg, op->long_name, oplen) == 0) { option_data = arg + arglen; if (*option_data == '=') { option_data++; longopwasequals = TRUE; } break; } } } else /* Special case xxxx(p) */ { char buff1[24]; char buff2[24]; int baselen = opbra - op->long_name; sprintf(buff1, "%.*s", baselen, op->long_name); sprintf(buff2, "%s%.*s", buff1, strlen(op->long_name) - baselen - 2, opbra + 1); if (strcmp(arg, buff1) == 0 || strcmp(arg, buff2) == 0) break; } } if (op->one_char == 0) { fprintf(stderr, "pcregrep: Unknown option %s\n", argv[i]); exit(usage(2)); } } /* One-char options; many that have no data may be in a single argument; we continue till we hit the last one or one that needs data. */ else { char *s = argv[i] + 1; longop = FALSE; while (*s != 0) { for (op = optionlist; op->one_char != 0; op++) { if (*s == op->one_char) break; } if (op->one_char == 0) { fprintf(stderr, "pcregrep: Unknown option letter '%c' in \"%s\"\n", *s, argv[i]); exit(usage(2)); } if (op->type != OP_NODATA || s[1] == 0) { option_data = s+1; break; } options = handle_option(*s++, options); } } /* At this point we should have op pointing to a matched option */ if (op->type == OP_NODATA) options = handle_option(op->one_char, options); else { if (*option_data == 0) { if (i >= argc - 1 || longopwasequals) { fprintf(stderr, "pcregrep: Data missing after %s\n", argv[i]); exit(usage(2)); } option_data = argv[++i]; } if (op->type == OP_STRING) *((char **)op->dataptr) = option_data; else { char *endptr; int n = strtoul(option_data, &endptr, 10); if (*endptr != 0) { if (longop) fprintf(stderr, "pcregrep: Malformed number \"%s\" after --%s\n", option_data, op->long_name); else fprintf(stderr, "pcregrep: Malformed number \"%s\" after -%c\n", option_data, op->one_char); exit(usage(2)); } *((int *)op->dataptr) = n; } } } /* Options have been decoded. If -C was used, its value is used as a default for -A and -B. */ if (both_context > 0) { if (after_context == 0) after_context = both_context; if (before_context == 0) before_context = both_context; } pattern_list = (pcre **)malloc(MAX_PATTERN_COUNT * sizeof(pcre *)); hints_list = (pcre_extra **)malloc(MAX_PATTERN_COUNT * sizeof(pcre_extra *)); if (pattern_list == NULL || hints_list == NULL) { fprintf(stderr, "pcregrep: malloc failed\n"); return 2; } /* Compile the regular expression(s). */ if (pattern_filename != NULL) { FILE *f = fopen(pattern_filename, "r"); char buffer[MBUFTHIRD + 16]; char *rdstart; int adjust = 0; if (f == NULL) { fprintf(stderr, "pcregrep: Failed to open %s: %s\n", pattern_filename, strerror(errno)); return 2; } if (whole_lines) { strcpy(buffer, "^(?:"); adjust = 4; } else if (word_match) { strcpy(buffer, "\\b"); adjust = 2; } rdstart = buffer + adjust; while (fgets(rdstart, MBUFTHIRD, f) != NULL) { char *s = rdstart + (int)strlen(rdstart); if (pattern_count >= MAX_PATTERN_COUNT) { fprintf(stderr, "pcregrep: Too many patterns in file (max %d)\n", MAX_PATTERN_COUNT); return 2; } while (s > rdstart && isspace((unsigned char)(s[-1]))) s--; if (s == rdstart) continue; if (whole_lines) strcpy(s, ")$"); else if (word_match)strcpy(s, "\\b"); else *s = 0; pattern_list[pattern_count] = pcre_compile(buffer, options, &error, &errptr, NULL); if (pattern_list[pattern_count++] == NULL) { fprintf(stderr, "pcregrep: Error in regex number %d at offset %d: %s\n", pattern_count, errptr - adjust, error); return 2; } } fclose(f); } /* If no file name, a single regex must be given inline. */ else { char buffer[MBUFTHIRD + 16]; char *pat; int adjust = 0; if (i >= argc) return usage(2); if (whole_lines) { sprintf(buffer, "^(?:%.*s)$", MBUFTHIRD, argv[i++]); pat = buffer; adjust = 4; } else if (word_match) { sprintf(buffer, "\\b%.*s\\b", MBUFTHIRD, argv[i++]); pat = buffer; adjust = 2; } else pat = argv[i++]; pattern_list[0] = pcre_compile(pat, options, &error, &errptr, NULL); if (pattern_list[0] == NULL) { fprintf(stderr, "pcregrep: Error in regex at offset %d: %s\n", errptr - adjust, error); return 2; } pattern_count++; } /* Study the regular expressions, as we will be running them many times */ for (j = 0; j < pattern_count; j++) { hints_list[j] = pcre_study(pattern_list[j], 0, &error); if (error != NULL) { char s[16]; if (pattern_count == 1) s[0] = 0; else sprintf(s, " number %d", j); fprintf(stderr, "pcregrep: Error while studying regex%s: %s\n", s, error); return 2; } } /* If there are include or exclude patterns, compile them. */ if (exclude_pattern != NULL) { exclude_compiled = pcre_compile(exclude_pattern, 0, &error, &errptr, NULL); if (exclude_compiled == NULL) { fprintf(stderr, "pcregrep: Error in 'exclude' regex at offset %d: %s\n", errptr, error); return 2; } } if (include_pattern != NULL) { include_compiled = pcre_compile(include_pattern, 0, &error, &errptr, NULL); if (include_compiled == NULL) { fprintf(stderr, "pcregrep: Error in 'include' regex at offset %d: %s\n", errptr, error); return 2; } } /* If there are no further arguments, do the business on stdin and exit */ if (i >= argc) return pcregrep(stdin, (filenames_only || filenames_nomatch_only)? stdin_name : NULL); /* Otherwise, work through the remaining arguments as files or directories. Pass in the fact that there is only one argument at top level - this suppresses the file name if the argument is not a directory and filenames_only is not set. */ only_one_at_top = (i == argc - 1); for (; i < argc; i++) { int frc = grep_or_recurse(argv[i], recurse, filenames, only_one_at_top); if (frc > 1) rc = frc; else if (frc == 0 && rc == 1) rc = 0; } return rc; } /* End of pcregrep */