From b29060f38b30e6e379769582a0cf7cc3e9ae5056 Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Fri, 15 Jan 2021 02:05:17 -0800 Subject: [PATCH] Cleaned up and simplified global state setting stuff (e.g. --verbose) --- bp.c | 154 +++++++++++++++++++++++--------------------------- file_loader.c | 12 +++- file_loader.h | 5 +- json.c | 6 +- json.h | 2 +- types.h | 9 --- vm.c | 64 ++++++++++----------- 7 files changed, 119 insertions(+), 133 deletions(-) diff --git a/bp.c b/bp.c index 941a2b0..5f5158c 100644 --- a/bp.c +++ b/bp.c @@ -39,10 +39,21 @@ static const char *usage = ( " -c --context set number of lines of context to print (all: the whole file, 0: only the match, 1: the line, N: N lines of context)\n" " -g --grammar use the specified file as a grammar\n"); +// Flag-configurable options: #define USE_DEFAULT_CONTEXT -2 #define ALL_CONTEXT -1 -static int print_color = 0; -static int print_line_numbers = 0; +static int context_lines = USE_DEFAULT_CONTEXT; +static unsigned int print_color = 0; +static unsigned int print_line_numbers = 0; +static unsigned int ignorecase = 0; +static unsigned int verbose = 0; +static enum { + MODE_NORMAL, + MODE_LISTFILES, + MODE_INPLACE, + MODE_JSON, + MODE_EXPLAIN, +} mode = MODE_NORMAL; __attribute__((nonnull)) static char *getflag(const char *flag, char *argv[], int *i); @@ -91,16 +102,16 @@ static int is_text_file(const char *filename) // // Print matches in JSON format. // -static int print_matches_as_json(def_t *defs, file_t *f, vm_op_t *pattern, unsigned int flags) +static int print_matches_as_json(def_t *defs, file_t *f, vm_op_t *pattern) { int matches = 0; - for (match_t *m = NULL; (m = next_match(defs, f, m, pattern, flags)); ) { + for (match_t *m = NULL; (m = next_match(defs, f, m, pattern, ignorecase)); ) { if (++matches > 1) printf(",\n"); - printf("{\"filename\":\"%s\",", f->filename ? f->filename : "-"); + printf("{\"filename\":\"%s\",", f->filename); printf("\"tree\":{\"rule\":\"text\",\"start\":%d,\"end\":%ld,\"children\":[", 0, f->end - f->contents); - json_match(f->contents, m, (flags & BP_VERBOSE) ? 1 : 0); + json_match(f->contents, m, verbose); printf("]}}\n"); } return matches; @@ -109,10 +120,10 @@ static int print_matches_as_json(def_t *defs, file_t *f, vm_op_t *pattern, unsig // // Print matches in a visual explanation style // -static int explain_matches(def_t *defs, file_t *f, vm_op_t *pattern, unsigned int flags) +static int explain_matches(def_t *defs, file_t *f, vm_op_t *pattern) { int matches = 0; - for (match_t *m = NULL; (m = next_match(defs, f, m, pattern, flags)); ) { + for (match_t *m = NULL; (m = next_match(defs, f, m, pattern, ignorecase)); ) { if (++matches == 1) { if (print_color) printf("\033[0;1;4;33m%s\033[0m\n", f->filename); @@ -130,21 +141,21 @@ static int explain_matches(def_t *defs, file_t *f, vm_op_t *pattern, unsigned in // Replace a file's contents with the text version of a match. // (Useful for replacements) // -static int inplace_modify_file(def_t *defs, file_t *f, vm_op_t *pattern, int context, unsigned int flags) +static int inplace_modify_file(def_t *defs, file_t *f, vm_op_t *pattern) { // Need to do this before matching: intern_file(f); printer_t pr = { .file = f, - .context_lines = context, + .context_lines = context_lines, .use_color = 0, .print_line_numbers = 0, }; FILE *inplace_file = NULL; // Lazy-open this on the first match int matches = 0; - for (match_t *m = NULL; (m = next_match(defs, f, m, pattern, flags)); ) { + for (match_t *m = NULL; (m = next_match(defs, f, m, pattern, ignorecase)); ) { ++matches; if (print_errors(&pr, m) > 0) exit(1); @@ -166,18 +177,18 @@ static int inplace_modify_file(def_t *defs, file_t *f, vm_op_t *pattern, int con // // Print all the matches in a file. // -static int print_matches(def_t *defs, file_t *f, vm_op_t *pattern, int context, unsigned int flags) +static int print_matches(def_t *defs, file_t *f, vm_op_t *pattern) { static int printed_filenames = 0; int matches = 0; printer_t pr = { .file = f, - .context_lines = context, + .context_lines = context_lines, .use_color = print_color, .print_line_numbers = print_line_numbers, }; - for (match_t *m = NULL; (m = next_match(defs, f, m, pattern, flags)); ) { + for (match_t *m = NULL; (m = next_match(defs, f, m, pattern, ignorecase)); ) { if (print_errors(&pr, m) > 0) exit(1); @@ -205,27 +216,27 @@ static int print_matches(def_t *defs, file_t *f, vm_op_t *pattern, int context, // For a given filename, open the file and attempt to match the given pattern // against it, printing any results according to the flags. // -static int process_file(def_t *defs, const char *filename, vm_op_t *pattern, int context, unsigned int flags) +static int process_file(def_t *defs, const char *filename, vm_op_t *pattern) { file_t *f = load_file(NULL, filename); check(f, "Could not open file: %s", filename); int matches = 0; - if (flags & BP_EXPLAIN) { - matches += explain_matches(defs, f, pattern, flags); - } else if (flags & BP_LISTFILES) { - match_t *m = next_match(defs, f, NULL, pattern, flags); + if (mode == MODE_EXPLAIN) { + matches += explain_matches(defs, f, pattern); + } else if (mode == MODE_LISTFILES) { + match_t *m = next_match(defs, f, NULL, pattern, ignorecase); if (m) { recycle_if_unused(&m); printf("%s\n", f->filename); matches += 1; } - } else if (flags & BP_JSON) { - matches += print_matches_as_json(defs, f, pattern, flags); - } else if (flags & BP_INPLACE) { - matches += inplace_modify_file(defs, f, pattern, context, flags); + } else if (mode == MODE_JSON) { + matches += print_matches_as_json(defs, f, pattern); + } else if (mode == MODE_INPLACE) { + matches += inplace_modify_file(defs, f, pattern); } else { - matches += print_matches(defs, f, pattern, context, flags); + matches += print_matches(defs, f, pattern); } #ifdef DEBUG_HEAP @@ -240,33 +251,24 @@ static int process_file(def_t *defs, const char *filename, vm_op_t *pattern, int int main(int argc, char *argv[]) { - unsigned int flags = 0; - int context = USE_DEFAULT_CONTEXT; char *flag = NULL; - char path[PATH_MAX] = {0}; def_t *defs = NULL; - file_t *loaded_files = NULL; // Define an opcode that is just a reference to the rule `pattern` file_t *pat_file = spoof_file(&loaded_files, "", "pattern"); - vm_op_t *pattern = bp_pattern(pat_file, pat_file->contents); + vm_op_t *pattern = bp_pattern(loaded_files, pat_file->contents); // Define an opcode that is just a reference to the rule `replacement` file_t *rep_file = spoof_file(&loaded_files, "", "replacement"); vm_op_t *replacement = bp_pattern(rep_file, rep_file->contents); // Load builtins: - if (access("/etc/xdg/bp/builtins.bp", R_OK) != -1) { - file_t *f = load_file(&loaded_files, "/etc/xdg/bp/builtins.bp"); - defs = load_grammar(defs, f); - } - sprintf(path, "%s/.config/bp/builtins.bp", getenv("HOME")); - if (access(path, R_OK) != -1) { - file_t *f = load_file(&loaded_files, path); - defs = load_grammar(defs, f); - } + file_t *xdg_file = load_file(&loaded_files, "/etc/xdg/bp/builtins.bp"); + if (xdg_file) defs = load_grammar(defs, xdg_file); + file_t *local_file = load_file(&loaded_files, "%s/.config/bp/builtins.bp", getenv("HOME")); + if (local_file) defs = load_grammar(defs, local_file); int i, npatterns = 0; check(argc > 1, "%s", usage); @@ -279,18 +281,18 @@ int main(int argc, char *argv[]) printf("%s\n", usage); return 0; } else if (streq(argv[i], "--verbose")) { - flags |= BP_VERBOSE; + verbose = 1; } else if (streq(argv[i], "--explain")) { - flags |= BP_EXPLAIN; + mode = MODE_EXPLAIN; } else if (streq(argv[i], "--json")) { - flags |= BP_JSON; + mode = MODE_JSON; } else if (streq(argv[i], "--inplace")) { - flags |= BP_INPLACE; - context = ALL_CONTEXT; + mode = MODE_INPLACE; + context_lines = ALL_CONTEXT; } else if (streq(argv[i], "--ignore-case")) { - flags |= BP_IGNORECASE; + ignorecase = 1; } else if (streq(argv[i], "--list-files")) { - flags |= BP_LISTFILES; + mode = MODE_LISTFILES; } else if (FLAG("--replace") || FLAG("-r")) { // TODO: spoof file as sprintf("pattern => '%s'", flag) // except that would require handling edge cases like quotation marks etc. @@ -299,17 +301,14 @@ int main(int argc, char *argv[]) check(rep, "Replacement failed to compile: %s", flag); defs = with_def(defs, replace_file, strlen("replacement"), "replacement", rep); pattern = replacement; - if (context == USE_DEFAULT_CONTEXT) context = 1; + if (context_lines == USE_DEFAULT_CONTEXT) + context_lines = ALL_CONTEXT; } else if (FLAG("--grammar") || FLAG("-g")) { file_t *f = load_file(&loaded_files, flag); - if (f == NULL) { - sprintf(path, "%s/.config/bp/%s.bp", getenv("HOME"), flag); - f = load_file(&loaded_files, path); - } - if (f == NULL) { - sprintf(path, "/etc/xdg/bp/%s.bp", flag); - f = load_file(&loaded_files, path); - } + if (f == NULL) + f = load_file(&loaded_files, "%s/.config/bp/%s.bp", getenv("HOME"), flag); + if (f == NULL) + f = load_file(&loaded_files, "/etc/xdg/bp/%s.bp", flag); check(f != NULL, "Couldn't find grammar: %s", flag); defs = load_grammar(defs, f); // Keep in memory for debug output } else if (FLAG("--define") || FLAG("-d")) { @@ -347,19 +346,21 @@ int main(int argc, char *argv[]) ++npatterns; } else if (FLAG("--context") || FLAG("-c")) { if (streq(flag, "all")) - context = ALL_CONTEXT; + context_lines = ALL_CONTEXT; + else if (streq(flag, "none")) + context_lines = 0; else - context = (int)strtol(flag, NULL, 10); + context_lines = (int)strtol(flag, NULL, 10); } else if (argv[i][0] == '-' && argv[i][1] && argv[i][1] != '-') { // single-char flags for (char *c = &argv[i][1]; *c; ++c) { switch (*c) { case 'h': goto flag_help; // -h - case 'v': flags |= BP_VERBOSE; break; // -v - case 'e': flags |= BP_EXPLAIN; break; // -e - case 'j': flags |= BP_JSON; break; // -j - case 'I': flags |= BP_INPLACE; context = ALL_CONTEXT; break; // -I - case 'i': flags |= BP_IGNORECASE; break; // -i - case 'l': flags |= BP_LISTFILES; break; // -l + case 'v': verbose = 1; break; // -v + case 'e': mode = MODE_EXPLAIN; break; // -e + case 'j': mode = MODE_JSON; break; // -j + case 'I': mode = MODE_INPLACE; break; // -I + case 'i': ignorecase = 1; break; // -i + case 'l': mode = MODE_LISTFILES; break; // -l default: printf("Unrecognized flag: -%c\n\n%s\n", *c, usage); return 1; @@ -379,22 +380,9 @@ int main(int argc, char *argv[]) } } - if (((flags & BP_JSON) != 0) + ((flags & BP_EXPLAIN) != 0) + ((flags & BP_LISTFILES) != 0) > 1) { - printf("Please choose no more than one of the flags: -j/--json, -e/--explain, and -l/--list-files.\n" - "They are mutually contradictory.\n"); - return 1; - } - - if (context < 0) { - if (context == USE_DEFAULT_CONTEXT) context = 1; - else if (context != ALL_CONTEXT) context = 0; - } - - if (flags & BP_INPLACE && context != ALL_CONTEXT) { - printf("--inplace and --context are mutually exclusive.\n" - "Please drop one of the two arguments and try again.\n"); - return 1; - } + if (mode == MODE_INPLACE) context_lines = ALL_CONTEXT; + if (context_lines == USE_DEFAULT_CONTEXT) context_lines = 1; + if (context_lines < 0 && context_lines != ALL_CONTEXT) context_lines = 0; if (isatty(STDOUT_FILENO)) { print_color = 1; @@ -402,11 +390,11 @@ int main(int argc, char *argv[]) } int found = 0; - if (flags & BP_JSON) printf("["); + if (mode == MODE_JSON) printf("["); if (i < argc) { // Files pass in as command line args: for (int nfiles = 0; i < argc; nfiles++, i++) { - found += process_file(defs, argv[i], pattern, context, flags); + found += process_file(defs, argv[i], pattern); } } else if (isatty(STDIN_FILENO)) { // No files, no piped in input, so use * **/*: @@ -415,14 +403,14 @@ int main(int argc, char *argv[]) glob("**/*", GLOB_APPEND, NULL, &globbuf); for (size_t i = 0; i < globbuf.gl_pathc; i++) { if (is_text_file(globbuf.gl_pathv[i])) - found += process_file(defs, globbuf.gl_pathv[i], pattern, context, flags); + found += process_file(defs, globbuf.gl_pathv[i], pattern); } globfree(&globbuf); } else { // Piped in input: - found += process_file(defs, NULL, pattern, context, flags); + found += process_file(defs, NULL, pattern); } - if (flags & BP_JSON) printf("]\n"); + if (mode == MODE_JSON) printf("]\n"); #ifdef DEBUG_HEAP // This code frees up all residual heap-allocated memory. Since the program diff --git a/file_loader.c b/file_loader.c index 48e81e4..acbf8a6 100644 --- a/file_loader.c +++ b/file_loader.c @@ -42,10 +42,16 @@ static void populate_lines(file_t *f) // // Read an entire file into memory. // -file_t *load_file(file_t **files, const char *filename) +file_t *load_file(file_t **files, const char *fmt, ...) { - if (filename == NULL) filename = "-"; - int fd = streq(filename, "-") ? STDIN_FILENO : open(filename, O_RDONLY); + char filename[PATH_MAX+1] = {0}; + va_list args; + va_start(args, fmt); + check(vsnprintf(filename, PATH_MAX, fmt, args) <= PATH_MAX, + "File name is too large"); + va_end(args); + + int fd = filename[0] == '\0' ? STDIN_FILENO : open(filename, O_RDONLY); if (fd < 0) return NULL; size_t length; file_t *f = new(file_t); diff --git a/file_loader.h b/file_loader.h index 91480b2..cfe8701 100644 --- a/file_loader.h +++ b/file_loader.h @@ -17,7 +17,8 @@ typedef struct file_s { unsigned int mmapped:1; } file_t; -file_t *load_file(file_t **files, const char *filename); +__attribute__((format(printf,2,3))) +file_t *load_file(file_t **files, const char *fmt, ...); __attribute__((nonnull(3), returns_nonnull)) file_t *spoof_file(file_t **files, const char *filename, const char *text); __attribute__((nonnull)) @@ -30,7 +31,7 @@ __attribute__((pure, nonnull)) size_t get_char_number(file_t *f, const char *p); __attribute__((pure, nonnull)) const char *get_line(file_t *f, size_t line_number); -__attribute__((nonnull(1,2,3), format(printf, 5, 6))) +__attribute__((nonnull(1,2,3), format(printf,5,6))) void fprint_line(FILE *dest, file_t *f, const char *start, const char *end, const char *fmt, ...); #endif diff --git a/json.c b/json.c index 22905cc..6933e02 100644 --- a/json.c +++ b/json.c @@ -7,14 +7,14 @@ #include "types.h" __attribute__((nonnull)) -static int _json_match(const char *text, match_t *m, int comma, int verbose); +static int _json_match(const char *text, match_t *m, int comma, unsigned int verbose); // // Helper function for json_match(). // `comma` is used to track whether a comma will need to be printed before the // next object or not. // -static int _json_match(const char *text, match_t *m, int comma, int verbose) +static int _json_match(const char *text, match_t *m, int comma, unsigned int verbose) { if (!verbose) { if (m->op->type != VM_REF) { @@ -49,7 +49,7 @@ static int _json_match(const char *text, match_t *m, int comma, int verbose) // // Print a match object as a JSON object. // -void json_match(const char *text, match_t *m, int verbose) +void json_match(const char *text, match_t *m, unsigned int verbose) { _json_match(text, m, 0, verbose); } diff --git a/json.h b/json.h index 8bd972e..65fa718 100644 --- a/json.h +++ b/json.h @@ -5,7 +5,7 @@ #define JSON__H __attribute__((nonnull)) -void json_match(const char *text, match_t *m, int verbose); +void json_match(const char *text, match_t *m, unsigned int verbose); #endif // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1 diff --git a/types.h b/types.h index 244b4b7..27b3d8e 100644 --- a/types.h +++ b/types.h @@ -8,15 +8,6 @@ #include "file_loader.h" -enum BPFlag { - BP_VERBOSE = 1 << 0, - BP_IGNORECASE = 1 << 1, - BP_EXPLAIN = 1 << 2, - BP_JSON = 1 << 3, - BP_LISTFILES = 1 << 4, - BP_INPLACE = 1 << 5, -}; - // // BP virtual machine opcodes (these must be kept in sync with the names in vm.c) // diff --git a/vm.c b/vm.c index 346a61a..c9221a3 100644 --- a/vm.c +++ b/vm.c @@ -36,7 +36,7 @@ static match_t *in_use_matches = NULL; __attribute__((nonnull, pure)) static inline const char *next_char(file_t *f, const char *str); __attribute__((nonnull)) -static const char *match_backref(const char *str, vm_op_t *op, match_t *cap, unsigned int flags); +static const char *match_backref(const char *str, vm_op_t *op, match_t *cap, unsigned int ignorecase); __attribute__((nonnull)) static match_t *get_capture_by_num(match_t *m, int *n); __attribute__((nonnull, pure)) @@ -66,7 +66,7 @@ static inline const char *next_char(file_t *f, const char *str) // Attempt to match text against a previously captured value. // Return the character position after the backref has matched, or NULL if no match has occurred. // -static const char *match_backref(const char *str, vm_op_t *op, match_t *cap, unsigned int flags) +static const char *match_backref(const char *str, vm_op_t *op, match_t *cap, unsigned int ignorecase) { check(op->type == VM_BACKREF, "Attempt to match backref against something that's not a backref"); if (cap->op->type == VM_REPLACE) { @@ -87,7 +87,7 @@ static const char *match_backref(const char *str, vm_op_t *op, match_t *cap, uns ++r; match_t *value = get_capture(cap, &r); if (value != NULL) { - str = match_backref(str, op, value, flags); + str = match_backref(str, op, value, ignorecase); if (str == NULL) return NULL; } } @@ -96,22 +96,22 @@ static const char *match_backref(const char *str, vm_op_t *op, match_t *cap, uns for (match_t *child = cap->child; child; child = child->nextsibling) { if (child->start > prev) { size_t len = (size_t)(child->start - prev); - if ((flags & BP_IGNORECASE) ? memicmp(str, prev, len) != 0 - : memcmp(str, prev, len) != 0) { + if (ignorecase ? memicmp(str, prev, len) != 0 + : memcmp(str, prev, len) != 0) { return NULL; } str += len; prev = child->start; } if (child->start < prev) continue; - str = match_backref(str, op, child, flags); + str = match_backref(str, op, child, ignorecase); if (str == NULL) return NULL; prev = child->end; } if (cap->end > prev) { size_t len = (size_t)(cap->end - prev); - if ((flags & BP_IGNORECASE) ? memicmp(str, prev, len) != 0 - : memcmp(str, prev, len) != 0) { + if (ignorecase ? memicmp(str, prev, len) != 0 + : memcmp(str, prev, len) != 0) { return NULL; } str += len; @@ -124,7 +124,7 @@ static const char *match_backref(const char *str, vm_op_t *op, match_t *cap, uns // // Find the next match after prev (or the first match if prev is NULL) // -match_t *next_match(def_t *defs, file_t *f, match_t *prev, vm_op_t *op, unsigned int flags) +match_t *next_match(def_t *defs, file_t *f, match_t *prev, vm_op_t *op, unsigned int ignorecase) { const char *str; if (prev) { @@ -134,7 +134,7 @@ match_t *next_match(def_t *defs, file_t *f, match_t *prev, vm_op_t *op, unsigned str = f->contents; } for (; str < f->end; ++str) { - match_t *m = match(defs, f, str, op, flags); + match_t *m = match(defs, f, str, op, ignorecase); if (m) return m; } return NULL; @@ -145,7 +145,7 @@ match_t *next_match(def_t *defs, file_t *f, match_t *prev, vm_op_t *op, unsigned // a match struct, or NULL if no match is found. // The returned value should be free()'d to avoid memory leaking. // -match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned int flags) +match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned int ignorecase) { switch (op->type) { case VM_LEFTRECURSION: { @@ -158,7 +158,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in ++op->args.leftrec.visits; return op->args.leftrec.match; } else { - return match(defs, f, str, op->args.leftrec.fallback, flags); + return match(defs, f, str, op->args.leftrec.fallback, ignorecase); } } case VM_ANYCHAR: { @@ -172,8 +172,8 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in } case VM_STRING: { if (&str[op->len] > f->end) return NULL; - if ((flags & BP_IGNORECASE) ? memicmp(str, op->args.s, (size_t)op->len) != 0 - : memcmp(str, op->args.s, (size_t)op->len) != 0) + if (ignorecase ? memicmp(str, op->args.s, (size_t)op->len) != 0 + : memcmp(str, op->args.s, (size_t)op->len) != 0) return NULL; match_t *m = new_match(); m->op = op; @@ -192,7 +192,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in return m; } case VM_NOT: { - match_t *m = match(defs, f, str, op->args.pat, flags); + match_t *m = match(defs, f, str, op->args.pat, ignorecase); if (m != NULL) { recycle_if_unused(&m); return NULL; @@ -219,7 +219,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in for (const char *prev = NULL; prev < str; ) { prev = str; if (pat) { - match_t *p = match(defs, f, str, pat, flags); + match_t *p = match(defs, f, str, pat, ignorecase); if (p != NULL) { ADD_OWNER(*dest, p); m->end = p->end; @@ -230,7 +230,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in return m; } if (skip) { - match_t *s = match(defs, f, str, skip, flags); + match_t *s = match(defs, f, str, skip, ignorecase); if (s != NULL) { ADD_OWNER(*dest, s); dest = &s->nextsibling; @@ -261,11 +261,11 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in // Separator match_t *sep = NULL; if (op->args.repetitions.sep != NULL && reps > 0) { - sep = match(defs, f, str, op->args.repetitions.sep, flags); + sep = match(defs, f, str, op->args.repetitions.sep, ignorecase); if (sep == NULL) break; str = sep->end; } - match_t *p = match(defs, f, str, op->args.repetitions.repeat_pat, flags); + match_t *p = match(defs, f, str, op->args.repetitions.repeat_pat, ignorecase); if (p == NULL) { str = start; recycle_if_unused(&sep); @@ -306,7 +306,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in ssize_t backtrack = op->args.pat->len; check(backtrack != -1, "'<' is only allowed for fixed-length operations"); if (str - backtrack < f->contents) return NULL; - match_t *before = match(defs, f, str - backtrack, op->args.pat, flags); + match_t *before = match(defs, f, str - backtrack, op->args.pat, ignorecase); if (before == NULL) return NULL; match_t *m = new_match(); m->start = str; @@ -316,7 +316,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in return m; } case VM_BEFORE: { - match_t *after = match(defs, f, str, op->args.pat, flags); + match_t *after = match(defs, f, str, op->args.pat, ignorecase); if (after == NULL) return NULL; match_t *m = new_match(); m->start = str; @@ -326,7 +326,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in return m; } case VM_CAPTURE: { - match_t *p = match(defs, f, str, op->args.pat, flags); + match_t *p = match(defs, f, str, op->args.pat, ignorecase); if (p == NULL) return NULL; match_t *m = new_match(); m->start = str; @@ -336,18 +336,18 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in return m; } case VM_OTHERWISE: { - match_t *m = match(defs, f, str, op->args.multiple.first, flags); - if (m == NULL) m = match(defs, f, str, op->args.multiple.second, flags); + match_t *m = match(defs, f, str, op->args.multiple.first, ignorecase); + if (m == NULL) m = match(defs, f, str, op->args.multiple.second, ignorecase); return m; } case VM_CHAIN: { - match_t *m1 = match(defs, f, str, op->args.multiple.first, flags); + match_t *m1 = match(defs, f, str, op->args.multiple.first, ignorecase); if (m1 == NULL) return NULL; match_t *m2; { // Push backrefs and run matching, then cleanup def_t *defs2 = with_backrefs(defs, f, m1); - m2 = match(defs2, f, m1->end, op->args.multiple.second, flags); + m2 = match(defs2, f, m1->end, op->args.multiple.second, ignorecase); free_defs(&defs2, defs); } @@ -364,7 +364,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in return m; } case VM_EQUAL: case VM_NOT_EQUAL: { - match_t *m1 = match(defs, f, str, op->args.multiple.first, flags); + match_t *m1 = match(defs, f, str, op->args.multiple.first, ignorecase); if (m1 == NULL) return NULL; // == matches iff the text of matches @@ -376,7 +376,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in .nlines=1 + get_line_number(f, m1->end)-get_line_number(f, m1->start), .mmapped=f->mmapped, }; - match_t *m2 = match(defs, &inner, str, op->args.multiple.second, flags); + match_t *m2 = match(defs, &inner, str, op->args.multiple.second, ignorecase); if ((m2 == NULL) == (op->type == VM_EQUAL)) { recycle_if_unused(&m1); if (m2 != NULL) recycle_if_unused(&m2); @@ -397,7 +397,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in case VM_REPLACE: { match_t *p = NULL; if (op->args.replace.pat) { - p = match(defs, f, str, op->args.replace.pat, flags); + p = match(defs, f, str, op->args.replace.pat, ignorecase); if (p == NULL) return NULL; } match_t *m = new_match(); @@ -437,7 +437,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in }; const char *prev = str; - match_t *m = match(&defs2, f, str, ref, flags); + match_t *m = match(&defs2, f, str, ref, ignorecase); if (m == NULL) return NULL; while (rec_op.args.leftrec.visits > 0) { @@ -445,7 +445,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in REMOVE_OWNERSHIP(rec_op.args.leftrec.match); ADD_OWNER(rec_op.args.leftrec.match, m); prev = m->end; - match_t *m2 = match(&defs2, f, str, ref, flags); + match_t *m2 = match(&defs2, f, str, ref, ignorecase); if (m2 == NULL) break; if (m2->end <= prev) { recycle_if_unused(&m2); @@ -465,7 +465,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, vm_op_t *op, unsigned in return m; } case VM_BACKREF: { - const char *end = match_backref(str, op, op->args.backref, flags); + const char *end = match_backref(str, op, op->args.backref, ignorecase); if (end == NULL) return NULL; match_t *m = new_match(); m->op = op;