Renaming op -> pat in variable names

6 files changed, 253 insertions, 253 deletions

diff --git a/compiler.c b/compiler.c
index a3fcbb7..1ecea11 100644
--- a/compiler.c
+++ b/compiler.c
@@ -21,7 +21,7 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str);
 __attribute__((nonnull(1)))
 static pat_t *chain_together(file_t *f,pat_t *first, pat_t *second);
 __attribute__((nonnull(1,2,3,6)))
-static pat_t *new_range(file_t *f, const char *start, const char *end, ssize_t min, ssize_t max, pat_t *pat, pat_t *sep);
+static pat_t *new_range(file_t *f, const char *start, const char *end, ssize_t min, ssize_t max, pat_t *repeating, pat_t *sep);
 
 //
 // Allocate a new pattern for this file (ensuring it will be automatically
@@ -41,25 +41,25 @@ pat_t *new_pat(file_t *f, const char *start, enum pattype_e type)
 //
 // Helper function to initialize a range object.
 //
-static pat_t *new_range(file_t *f, const char *start, const char *end, ssize_t min, ssize_t max, pat_t *pat, pat_t *sep)
+static pat_t *new_range(file_t *f, const char *start, const char *end, ssize_t min, ssize_t max, pat_t *repeating, pat_t *sep)
 {
-    pat_t *op = new_pat(f, start, VM_REPEAT);
-    if (pat->len >= 0 && (sep == NULL || sep->len >= 0) && min == max && min >= 0)
-        op->len = pat->len * min + (sep == NULL || min == 0 ? 0 : sep->len * (min-1));
+    pat_t *range = new_pat(f, start, VM_REPEAT);
+    if (repeating->len >= 0 && (sep == NULL || sep->len >= 0) && min == max && min >= 0)
+        range->len = repeating->len * min + (sep == NULL || min == 0 ? 0 : sep->len * (min-1));
     else
-        op->len = -1;
-    op->args.repetitions.min = min;
-    op->args.repetitions.max = max;
-    op->args.repetitions.repeat_pat = pat;
-    op->args.repetitions.sep = sep;
-    if (!op->start) op->start = pat->start;
-    if (!op->end) op->end = pat->end;
+        range->len = -1;
+    range->args.repetitions.min = min;
+    range->args.repetitions.max = max;
+    range->args.repetitions.repeat_pat = repeating;
+    range->args.repetitions.sep = sep;
+    if (!range->start) range->start = repeating->start;
+    if (!range->end) range->end = repeating->end;
     if (sep) {
-        if (sep->start < op->start) op->start = sep->start;
-        if (sep->end > op->end) op->end = sep->end;
+        if (sep->start < range->start) range->start = sep->start;
+        if (sep->end > range->end) range->end = sep->end;
     }
-    op->end = end;
-    return op;
+    range->end = end;
+    return range;
 }
 
 //
@@ -108,12 +108,12 @@ static pat_t *expand_choices(file_t *f, pat_t *first)
         const char *replacement = xcalloc(sizeof(char), replace_len+1);
         memcpy((void*)replacement, repstr, replace_len);
         
-        pat_t *pat = first;
-        first = new_pat(f, pat->start, VM_REPLACE);
-        first->args.replace.pat = pat;
+        pat_t *replacepat = first;
+        first = new_pat(f, replacepat->start, VM_REPLACE);
+        first->args.replace.pat = replacepat;
         first->args.replace.text = replacement;
         first->args.replace.len = replace_len;
-        first->len = pat->len;
+        first->len = replacepat->len;
         first->end = str;
     }
 
@@ -156,35 +156,35 @@ static pat_t *chain_together(file_t *f, pat_t *first, pat_t *second)
 //
 pat_t *bp_simplepattern(file_t *f, const char *str)
 {
-    pat_t *op = _bp_simplepattern(f, str);
-    if (op == NULL) return op;
+    pat_t *pat = _bp_simplepattern(f, str);
+    if (pat == NULL) return pat;
 
-    check(op->end != NULL, "op->end is uninitialized!");
+    check(pat->end != NULL, "pat->end is uninitialized!");
 
     // Expand postfix operators (if any)
-    str = after_spaces(op->end);
+    str = after_spaces(pat->end);
     while (str+2 < f->end && (matchstr(&str, "!=") || matchstr(&str, "=="))) { // Equality <pat1>==<pat2> and inequality <pat1>!=<pat2>
         int equal = str[-2] == '=';
-        pat_t *first = op;
+        pat_t *first = pat;
         pat_t *second = bp_simplepattern(f, str);
         if (!second)
             file_err(f, str, str, "The '%c=' operator expects a pattern before and after.", equal?'=':'!');
         if (equal) {
             if (!(first->len == -1 || second->len == -1 || first->len == second->len))
-                file_err(f, op->start, second->end,
+                file_err(f, pat->start, second->end,
                   "These two patterns cannot possibly give the same result (different lengths: %ld != %ld)",
                   first->len, second->len);
         }
-        op = new_pat(f, str, equal ? VM_EQUAL : VM_NOT_EQUAL);
-        op->end = second->end;
-        op->len = first->len != -1 ? first->len : second->len;
-        op->args.multiple.first = first;
-        op->args.multiple.second = second;
-        str = op->end;
+        pat = new_pat(f, str, equal ? VM_EQUAL : VM_NOT_EQUAL);
+        pat->end = second->end;
+        pat->len = first->len != -1 ? first->len : second->len;
+        pat->args.multiple.first = first;
+        pat->args.multiple.second = second;
+        str = pat->end;
         str = after_spaces(str);
     }
 
-    return op;
+    return pat;
 }
 
 //
@@ -201,26 +201,26 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
         // Any char (dot)
         case '.': {
             if (*str == '.') { // ".."
-                pat_t *op = new_pat(f, start, VM_UPTO_AND);
+                pat_t *upto = new_pat(f, start, VM_UPTO_AND);
                 ++str;
                 pat_t *till = bp_simplepattern(f, str);
-                op->args.multiple.first = till;
+                upto->args.multiple.first = till;
                 if (till)
                     str = till->end;
                 if (matchchar(&str, '%')) {
                     pat_t *skip = bp_simplepattern(f, str);
                     if (!skip)
                         file_err(f, str, str, "There should be a pattern to skip here after the '%%'");
-                    op->args.multiple.second = skip;
+                    upto->args.multiple.second = skip;
                     str = skip->end;
                 }
-                op->end = str;
-                return op;
+                upto->end = str;
+                return upto;
             } else {
-                pat_t *op = new_pat(f, start, VM_ANYCHAR);
-                op->len = 1;
-                op->end = str;
-                return op;
+                pat_t *dot = new_pat(f, start, VM_ANYCHAR);
+                dot->len = 1;
+                dot->end = str;
+                return dot;
             }
         }
         // Char literals
@@ -232,42 +232,42 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
                     file_err(f, str, str, "There should be a character here after the '`'");
                 const char *opstart = str-1;
 
-                pat_t *op;
+                pat_t *pat;
                 ++str;
                 if (matchchar(&str, '-')) { // Range
                     char c2 = *str;
                     if (!c2 || c2 == '\n')
                         file_err(f, str, str, "There should be a character here to complete the character range.");
-                    op = new_pat(f, opstart, VM_RANGE);
+                    pat = new_pat(f, opstart, VM_RANGE);
                     if (c < c2) {
-                        op->args.range.low = (unsigned char)c;
-                        op->args.range.high = (unsigned char)c2;
+                        pat->args.range.low = (unsigned char)c;
+                        pat->args.range.high = (unsigned char)c2;
                     } else {
-                        op->args.range.low = (unsigned char)c2;
-                        op->args.range.high = (unsigned char)c;
+                        pat->args.range.low = (unsigned char)c2;
+                        pat->args.range.high = (unsigned char)c;
                     }
                     ++str;
                 } else {
-                    op = new_pat(f, opstart, VM_STRING);
+                    pat = new_pat(f, opstart, VM_STRING);
                     char *s = xcalloc(sizeof(char), 2);
                     s[0] = c;
-                    op->args.s = s;
+                    pat->args.s = s;
                 }
 
-                op->len = 1;
-                op->end = str;
+                pat->len = 1;
+                pat->end = str;
 
                 if (all == NULL) {
-                    all = op;
+                    all = pat;
                 } else {
                     pat_t *either = new_pat(f, all->start, VM_OTHERWISE);
-                    either->end = op->end;
+                    either->end = pat->end;
                     either->args.multiple.first = all;
-                    either->args.multiple.second = op;
+                    either->args.multiple.second = pat;
                     either->len = 1;
                     all = either;
                 }
-                op = NULL;
+                pat = NULL;
             } while (matchchar(&str, ','));
 
             return all;
@@ -278,12 +278,12 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
                 file_err(f, str, str, "There should be an escape sequence here after this backslash.");
 
             if (matchchar(&str, 'N')) { // \N (nodent)
-                pat_t *op = new_pat(f, start, VM_NODENT);
-                op->end = str;
-                return op;
+                pat_t *nodent = new_pat(f, start, VM_NODENT);
+                nodent->end = str;
+                return nodent;
             }
 
-            pat_t *op;
+            pat_t *esc;
             const char *opstart = str;
             unsigned char e = unescapechar(str, &str);
             if (*str == '-') { // Escape range (e.g. \x00-\xFF)
@@ -294,18 +294,18 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
                     file_err(f, seqstart, str+1, "This value isn't a valid escape sequence");
                 if (e2 < e)
                     file_err(f, start, str, "Escape ranges should be low-to-high, but this is high-to-low.");
-                op = new_pat(f, opstart, VM_RANGE);
-                op->args.range.low = e;
-                op->args.range.high = e2;
+                esc = new_pat(f, opstart, VM_RANGE);
+                esc->args.range.low = e;
+                esc->args.range.high = e2;
             } else {
-                op = new_pat(f, opstart, VM_STRING);
+                esc = new_pat(f, opstart, VM_STRING);
                 char *s = xcalloc(sizeof(char), 2);
                 s[0] = (char)e;
-                op->args.s = s;
+                esc->args.s = s;
             }
-            op->len = 1;
-            op->end = str;
-            return op;
+            esc->len = 1;
+            esc->end = str;
+            return esc;
         }
         // String literal
         case '"': case '\'': case '\002': {
@@ -326,25 +326,25 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
             // escaped string, so this is safe to do inplace.
             len = unescape_string(literal, literal, len);
 
-            pat_t *op = new_pat(f, start, VM_STRING);
-            op->len = (ssize_t)len;
-            op->args.s = literal;
+            pat_t *pat = new_pat(f, start, VM_STRING);
+            pat->len = (ssize_t)len;
+            pat->args.s = literal;
 
             if (!matchchar(&str, endquote))
                 file_err(f, start, str, "This string doesn't have a closing quote.");
 
-            op->end = str;
-            return op;
+            pat->end = str;
+            return pat;
         }
         // Not <pat>
         case '!': {
             pat_t *p = bp_simplepattern(f, str);
             if (!p) file_err(f, str, str, "There should be a pattern after this '!'");
-            pat_t *op = new_pat(f, start, VM_NOT);
-            op->len = 0;
-            op->args.pat = p;
-            op->end = p->end;
-            return op;
+            pat_t *not = new_pat(f, start, VM_NOT);
+            not->len = 0;
+            not->args.pat = p;
+            not->end = p->end;
+            return not;
         }
         // Number of repetitions: <N>(-<N> / - / + / "")
         case '0': case '1': case '2': case '3': case '4': case '5':
@@ -363,10 +363,10 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
             } else {
                 min = n1, max = n1;
             }
-            pat_t *pat = bp_simplepattern(f, str);
-            if (!pat)
+            pat_t *repeating = bp_simplepattern(f, str);
+            if (!repeating)
                 file_err(f, str, str, "There should be a pattern after this repetition count.");
-            str = pat->end;
+            str = repeating->end;
             pat_t *sep = NULL;
             if (matchchar(&str, '%')) {
                 sep = bp_simplepattern(f, str);
@@ -374,71 +374,71 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
                     file_err(f, str, str, "There should be a separator pattern after this '%%'");
                 str = sep->end;
             } else {
-                str = pat->end;
+                str = repeating->end;
             }
-            return new_range(f, start, str, min, max, pat, sep);
+            return new_range(f, start, str, min, max, repeating, sep);
         }
         // Lookbehind
         case '<': {
-            pat_t *pat = bp_simplepattern(f, str);
-            if (!pat)
+            pat_t *behind = bp_simplepattern(f, str);
+            if (!behind)
                 file_err(f, str, str, "There should be a pattern after this '<'");
-            str = pat->end;
-            if (pat->len == -1)
-                file_err(f, start, pat->end,
+            str = behind->end;
+            if (behind->len == -1)
+                file_err(f, start, behind->end,
                          "Sorry, variable-length lookbehind patterns like this are not supported.\n"
                          "Please use a fixed-length lookbehind pattern instead.");
-            str = pat->end;
-            pat_t *op = new_pat(f, start, VM_AFTER);
-            op->len = 0;
-            op->args.pat = pat;
-            op->end = str;
-            return op;
+            str = behind->end;
+            pat_t *pat = new_pat(f, start, VM_AFTER);
+            pat->len = 0;
+            pat->args.pat = behind;
+            pat->end = str;
+            return pat;
         }
         // Lookahead
         case '>': {
-            pat_t *pat = bp_simplepattern(f, str);
-            if (!pat)
+            pat_t *ahead = bp_simplepattern(f, str);
+            if (!ahead)
                 file_err(f, str, str, "There should be a pattern after this '>'");
-            str = pat->end;
-            pat_t *op = new_pat(f, start, VM_BEFORE);
-            op->len = 0;
-            op->args.pat = pat;
-            op->end = str;
-            return op;
+            str = ahead->end;
+            pat_t *pat = new_pat(f, start, VM_BEFORE);
+            pat->len = 0;
+            pat->args.pat = ahead;
+            pat->end = str;
+            return pat;
         }
         // Parentheses
         case '(': case '{': {
             char closing = c == '(' ? ')' : '}';
-            pat_t *op = bp_simplepattern(f, str);
-            if (!op)
+            pat_t *pat = bp_simplepattern(f, str);
+            if (!pat)
                 file_err(f, str, str, "There should be a valid pattern after this parenthesis.");
-            op = expand_choices(f, op);
-            str = op->end;
+            pat = expand_choices(f, pat);
+            str = pat->end;
             if (!matchchar(&str, closing))
                 file_err(f, start, str, "This parenthesis group isn't properly closed.");
-            op->start = start;
-            op->end = str;
-            return op;
+            pat->start = start;
+            pat->end = str;
+            return pat;
         }
         // Square brackets
         case '[': {
-            pat_t *pat = bp_simplepattern(f, str);
-            if (!pat)
+            pat_t *maybe = bp_simplepattern(f, str);
+            if (!maybe)
                 file_err(f, str, str, "There should be a valid pattern after this square bracket.");
-            pat = expand_choices(f, pat);
-            str = pat->end;
+            maybe = expand_choices(f, maybe);
+            str = maybe->end;
             if (!matchchar(&str, ']'))
                 file_err(f, start, str, "This square bracket group isn't properly closed.");
-            return new_range(f, start, str, 0, 1, pat, NULL);
+            return new_range(f, start, str, 0, 1, maybe, NULL);
         }
         // Repeating
         case '*': case '+': {
             ssize_t min = c == '*' ? 0 : 1;
-            pat_t *pat = bp_simplepattern(f, str);
-            if (!pat)
+            pat_t *repeating = bp_simplepattern(f, str);
+            if (!repeating)
                 file_err(f, str, str, "There should be a valid pattern here after the '%c'", c);
-            str = pat->end;
+            str = repeating->end;
             pat_t *sep = NULL;
             if (matchchar(&str, '%')) {
                 sep = bp_simplepattern(f, str);
@@ -446,23 +446,23 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
                     file_err(f, str, str, "There should be a separator pattern after the '%%' here.");
                 str = sep->end;
             }
-            return new_range(f, start, str, min, -1, pat, sep);
+            return new_range(f, start, str, min, -1, repeating, sep);
         }
         // Capture
         case '@': {
-            pat_t *op = new_pat(f, start, VM_CAPTURE);
+            pat_t *capture = new_pat(f, start, VM_CAPTURE);
             const char *a = *str == '!' ? &str[1] : after_name(str);
             if (a > str && after_spaces(a)[0] == '=' && after_spaces(a)[1] != '>') {
-                op->args.capture.name = strndup(str, (size_t)(a-str));
+                capture->args.capture.name = strndup(str, (size_t)(a-str));
                 str = after_spaces(a) + 1;
             }
-            pat_t *pat = bp_simplepattern(f, str);
-            if (!pat)
+            pat_t *captured = bp_simplepattern(f, str);
+            if (!captured)
                 file_err(f, str, str, "There should be a valid pattern here to capture after the '@'");
-            op->args.capture.capture_pat = pat;
-            op->len = pat->len;
-            op->end = pat->end;
-            return op;
+            capture->args.capture.capture_pat = captured;
+            capture->len = captured->len;
+            capture->end = captured->end;
+            return capture;
         }
         // Special rules:
         case '_': case '^': case '$': case '|': {
@@ -475,10 +475,10 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
                 if (matchchar(&str, ':')) return NULL; // Don't match definitions
                 name = strndup(&c, 1);
             }
-            pat_t *op = new_pat(f, start, VM_REF);
-            op->args.s = name;
-            op->end = str;
-            return op;
+            pat_t *ref = new_pat(f, start, VM_REF);
+            ref->args.s = name;
+            ref->end = str;
+            return ref;
         }
         default: {
             // Reference
@@ -488,10 +488,10 @@ static pat_t *_bp_simplepattern(file_t *f, const char *str)
             str = after_name(str);
             if (matchchar(&str, ':')) // Don't match definitions
                 return NULL;
-            pat_t *op = new_pat(f, start, VM_REF);
-            op->args.s = strndup(refname, (size_t)(str - refname));
-            op->end = str;
-            return op;
+            pat_t *ref = new_pat(f, start, VM_REF);
+            ref->args.s = strndup(refname, (size_t)(str - refname));
+            ref->end = str;
+            return ref;
         }
     }
     return NULL;
@@ -560,12 +560,12 @@ pat_t *bp_stringpattern(file_t *f, const char *str)
 // Given a pattern and a replacement string, compile the two into a BP
 // replace pattern.
 //
-pat_t *bp_replacement(file_t *f, pat_t *pat, const char *replacement)
+pat_t *bp_replacement(file_t *f, pat_t *replacepat, const char *replacement)
 {
-    pat_t *op = new_pat(f, pat->start, VM_REPLACE);
-    op->end = pat->end;
-    op->len = pat->len;
-    op->args.replace.pat = pat;
+    pat_t *pat = new_pat(f, replacepat->start, VM_REPLACE);
+    pat->end = replacepat->end;
+    pat->len = replacepat->len;
+    pat->args.replace.pat = replacepat;
     const char *p = replacement;
     for (; *p; p++) {
         if (*p == '\\') {
@@ -577,9 +577,9 @@ pat_t *bp_replacement(file_t *f, pat_t *pat, const char *replacement)
     size_t rlen = (size_t)(p-replacement);
     char *rcpy = xcalloc(sizeof(char), rlen + 1);
     memcpy(rcpy, replacement, rlen);
-    op->args.replace.text = rcpy;
-    op->args.replace.len = rlen;
-    return op;
+    pat->args.replace.text = rcpy;
+    pat->args.replace.len = rlen;
+    return pat;
 }
 
 //
@@ -587,9 +587,9 @@ pat_t *bp_replacement(file_t *f, pat_t *pat, const char *replacement)
 //
 pat_t *bp_pattern(file_t *f, const char *str)
 {
-    pat_t *op = bp_simplepattern(f, str);
-    if (op != NULL) op = expand_choices(f, op);
-    return op;
+    pat_t *pat = bp_simplepattern(f, str);
+    if (pat != NULL) pat = expand_choices(f, pat);
+    return pat;
 }
 
 //
@@ -602,14 +602,14 @@ def_t *bp_definition(file_t *f, const char *str)
     if (!str) return NULL;
     size_t namelen = (size_t)(str - name);
     if (!matchchar(&str, ':')) return NULL;
-    pat_t *pat = bp_pattern(f, str);
-    if (!pat) return NULL;
-    matchchar(&pat->end, ';'); // TODO: verify this is safe to mutate
+    pat_t *defpat = bp_pattern(f, str);
+    if (!defpat) return NULL;
+    matchchar(&defpat->end, ';'); // TODO: verify this is safe to mutate
     def_t *def = new(def_t);
     def->file = f;
     def->namelen = namelen;
     def->name = name;
-    def->pat = pat;
+    def->pat = defpat;
     return def;
 }
 
diff --git a/compiler.h b/compiler.h
index fae02cc..6761644 100644
--- a/compiler.h
+++ b/compiler.h
@@ -14,7 +14,7 @@ pat_t *bp_simplepattern(file_t *f, const char *str);
 __attribute__((nonnull(1,2)))
 pat_t *bp_stringpattern(file_t *f, const char *str);
 __attribute__((nonnull(1,2)))
-pat_t *bp_replacement(file_t *f, pat_t *pat, const char *replacement);
+pat_t *bp_replacement(file_t *f, pat_t *replacepat, const char *replacement);
 __attribute__((nonnull))
 pat_t *bp_pattern(file_t *f, const char *str);
 __attribute__((nonnull))
diff --git a/grammar.c b/grammar.c
index 44c8a2c..102eca8 100644
--- a/grammar.c
+++ b/grammar.c
@@ -13,14 +13,14 @@
 //
 // Return a new list of definitions with one added to the front
 //
-def_t *with_def(def_t *defs, file_t *f, size_t namelen, const char *name, pat_t *op)
+def_t *with_def(def_t *defs, file_t *f, size_t namelen, const char *name, pat_t *pat)
 {
     def_t *def = new(def_t);
     def->next = defs;
     def->file = f;
     def->namelen = namelen;
     def->name = name;
-    def->pat = op;
+    def->pat = pat;
     return def;
 }
 
@@ -38,10 +38,10 @@ def_t *load_grammar(def_t *defs, file_t *f)
         check(src > name, "Invalid name for definition: %s", name);
         size_t namelen = (size_t)(src - name);
         check(matchchar(&src, ':'), "Expected ':' in definition");
-        pat_t *op = bp_pattern(f, src);
-        if (op == NULL) break;
-        defs = with_def(defs, f, namelen, name, op);
-        src = op->end;
+        pat_t *pat = bp_pattern(f, src);
+        if (pat == NULL) break;
+        defs = with_def(defs, f, namelen, name, pat);
+        src = pat->end;
         src = after_spaces(src);
         if (matchchar(&src, ';'))
             src = after_spaces(src);
@@ -70,11 +70,11 @@ def_t *lookup(def_t *defs, const char *name)
 //
 def_t *with_backref(def_t *defs, file_t *f, const char *name, match_t *m)
 {
-    pat_t *op = new_pat(f, m->start, VM_BACKREF);
-    op->end = m->end;
-    op->len = -1; // TODO: maybe calculate this? (nontrivial because of replacements)
-    op->args.backref = m;
-    return with_def(defs, f, strlen(name), name, op);
+    pat_t *backref = new_pat(f, m->start, VM_BACKREF);
+    backref->end = m->end;
+    backref->len = -1; // TODO: maybe calculate this? (nontrivial because of replacements)
+    backref->args.backref = m;
+    return with_def(defs, f, strlen(name), name, backref);
 }
 
 //
diff --git a/grammar.h b/grammar.h
index 631a0e6..b8e93ff 100644
--- a/grammar.h
+++ b/grammar.h
@@ -8,7 +8,7 @@
 #include "types.h"
 
 __attribute__((nonnull(2,4,5), returns_nonnull))
-def_t *with_def(def_t *defs, file_t *f, size_t namelen, const char *name, pat_t *op);
+def_t *with_def(def_t *defs, file_t *f, size_t namelen, const char *name, pat_t *pat);
 __attribute__((nonnull(2,3,4), returns_nonnull))
 def_t *with_backref(def_t *defs, file_t *f, const char *name, match_t *m);
 __attribute__((nonnull(2)))
diff --git a/vm.c b/vm.c
index bddd9d2..b54f08d 100644
--- a/vm.c
+++ b/vm.c
@@ -123,7 +123,7 @@ static const char *match_backref(const char *str, match_t *cap, unsigned int ign
 //
 // 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, pat_t *op, unsigned int ignorecase)
+match_t *next_match(def_t *defs, file_t *f, match_t *prev, pat_t *pat, unsigned int ignorecase)
 {
     const char *str;
     if (prev) {
@@ -133,71 +133,71 @@ match_t *next_match(def_t *defs, file_t *f, match_t *prev, pat_t *op, unsigned i
         str = f->contents;
     }
     for (; str < f->end; ++str) {
-        match_t *m = match(defs, f, str, op, ignorecase);
+        match_t *m = match(defs, f, str, pat, ignorecase);
         if (m) return m;
     }
     return NULL;
 }
 
 //
-// Run virtual machine operation against a string and return
-// a match struct, or NULL if no match is found.
+// Attempt to match the given pattern against the input string and return a
+// match object, 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, pat_t *op, unsigned int ignorecase)
+match_t *match(def_t *defs, file_t *f, const char *str, pat_t *pat, unsigned int ignorecase)
 {
-    switch (op->type) {
+    switch (pat->type) {
         case VM_LEFTRECURSION: {
             // Left recursion occurs when a pattern directly or indirectly
             // invokes itself at the same position in the text. It's handled as
             // a special case, but if a pattern invokes itself at a later
             // point, it can be handled with normal recursion.
             // See: left-recursion.md for more details.
-            if (str == op->args.leftrec.at) {
-                ++op->args.leftrec.visits;
-                return op->args.leftrec.match;
+            if (str == pat->args.leftrec.at) {
+                ++pat->args.leftrec.visits;
+                return pat->args.leftrec.match;
             } else {
-                return match(defs, f, str, op->args.leftrec.fallback, ignorecase);
+                return match(defs, f, str, pat->args.leftrec.fallback, ignorecase);
             }
         }
         case VM_ANYCHAR: {
             if (str >= f->end || *str == '\n')
                 return NULL;
             match_t *m = new_match();
-            m->pat = op;
+            m->pat = pat;
             m->start = str;
             m->end = next_char(f, str);
             return m;
         }
         case VM_STRING: {
-            if (&str[op->len] > f->end) return NULL;
-            if (ignorecase ? memicmp(str, op->args.s, (size_t)op->len) != 0
-                           : memcmp(str, op->args.s, (size_t)op->len) != 0)
+            if (&str[pat->len] > f->end) return NULL;
+            if (ignorecase ? memicmp(str, pat->args.s, (size_t)pat->len) != 0
+                           : memcmp(str, pat->args.s, (size_t)pat->len) != 0)
                 return NULL;
             match_t *m = new_match();
-            m->pat = op;
+            m->pat = pat;
             m->start = str;
-            m->end = str + op->len;
+            m->end = str + pat->len;
             return m;
         }
         case VM_RANGE: {
             if (str >= f->end) return NULL;
-            if ((unsigned char)*str < op->args.range.low || (unsigned char)*str > op->args.range.high)
+            if ((unsigned char)*str < pat->args.range.low || (unsigned char)*str > pat->args.range.high)
                 return NULL;
             match_t *m = new_match();
-            m->pat = op;
+            m->pat = pat;
             m->start = str;
             m->end = str + 1;
             return m;
         }
         case VM_NOT: {
-            match_t *m = match(defs, f, str, op->args.pat, ignorecase);
+            match_t *m = match(defs, f, str, pat->args.pat, ignorecase);
             if (m != NULL) {
                 recycle_if_unused(&m);
                 return NULL;
             }
             m = new_match();
-            m->pat = op;
+            m->pat = pat;
             m->start = str;
             m->end = str;
             return m;
@@ -205,10 +205,10 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
         case VM_UPTO_AND: {
             match_t *m = new_match();
             m->start = str;
-            m->pat = op;
+            m->pat = pat;
 
-            pat_t *pat = op->args.multiple.first, *skip = op->args.multiple.second;
-            if (!pat && !skip) {
+            pat_t *target = pat->args.multiple.first, *skip = pat->args.multiple.second;
+            if (!target && !skip) {
                 while (str < f->end && *str != '\n') ++str;
                 m->end = str;
                 return m;
@@ -217,8 +217,8 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
             match_t **dest = &m->child;
             for (const char *prev = NULL; prev < str; ) {
                 prev = str;
-                if (pat) {
-                    match_t *p = match(defs, f, str, pat, ignorecase);
+                if (target) {
+                    match_t *p = match(defs, f, str, target, ignorecase);
                     if (p != NULL) {
                         ADD_OWNER(*dest, p);
                         m->end = p->end;
@@ -250,51 +250,51 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
             match_t *m = new_match();
             m->start = str;
             m->end = str;
-            m->pat = op;
+            m->pat = pat;
 
             match_t **dest = &m->child;
             size_t reps = 0;
-            ssize_t max = op->args.repetitions.max;
+            ssize_t max = pat->args.repetitions.max;
             for (reps = 0; max == -1 || reps < (size_t)max; ++reps) {
                 const char *start = str;
                 // Separator
-                match_t *sep = NULL;
-                if (op->args.repetitions.sep != NULL && reps > 0) {
-                    sep = match(defs, f, str, op->args.repetitions.sep, ignorecase);
-                    if (sep == NULL) break;
-                    str = sep->end;
+                match_t *msep = NULL;
+                if (pat->args.repetitions.sep != NULL && reps > 0) {
+                    msep = match(defs, f, str, pat->args.repetitions.sep, ignorecase);
+                    if (msep == NULL) break;
+                    str = msep->end;
                 }
-                match_t *p = match(defs, f, str, op->args.repetitions.repeat_pat, ignorecase);
-                if (p == NULL) {
+                match_t *mp = match(defs, f, str, pat->args.repetitions.repeat_pat, ignorecase);
+                if (mp == NULL) {
                     str = start;
-                    recycle_if_unused(&sep);
+                    recycle_if_unused(&msep);
                     break;
                 }
-                if (p->end == start && reps > 0) {
-                    // Since no forward progress was made on either `pat` or
-                    // `sep` and BP does not have mutable state, it's
-                    // guaranteed that no progress will be made on the next
-                    // loop either. We know that this will continue to loop
-                    // until reps==max, so let's just cut to the chase instead
-                    // of looping infinitely.
-                    recycle_if_unused(&sep);
-                    recycle_if_unused(&p);
-                    if (op->args.repetitions.max == -1)
+                if (mp->end == start && reps > 0) {
+                    // Since no forward progress was made on either
+                    // `repeat_pat` or `sep` and BP does not have mutable
+                    // state, it's guaranteed that no progress will be made on
+                    // the next loop either. We know that this will continue to
+                    // loop until reps==max, so let's just cut to the chase
+                    // instead of looping infinitely.
+                    recycle_if_unused(&msep);
+                    recycle_if_unused(&mp);
+                    if (pat->args.repetitions.max == -1)
                         reps = ~(size_t)0;
                     else
-                        reps = (size_t)op->args.repetitions.max;
+                        reps = (size_t)pat->args.repetitions.max;
                     break;
                 }
-                if (sep) {
-                    ADD_OWNER(*dest, sep);
-                    dest = &sep->nextsibling;
+                if (msep) {
+                    ADD_OWNER(*dest, msep);
+                    dest = &msep->nextsibling;
                 }
-                ADD_OWNER(*dest, p);
-                dest = &p->nextsibling;
-                str = p->end;
+                ADD_OWNER(*dest, mp);
+                dest = &mp->nextsibling;
+                str = mp->end;
             }
 
-            if (reps < (size_t)op->args.repetitions.min) {
+            if (reps < (size_t)pat->args.repetitions.min) {
                 recycle_if_unused(&m);
                 return NULL;
             }
@@ -302,45 +302,45 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
             return m;
         }
         case VM_AFTER: {
-            ssize_t backtrack = op->args.pat->len;
+            ssize_t backtrack = pat->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, ignorecase);
+            match_t *before = match(defs, f, str - backtrack, pat->args.pat, ignorecase);
             if (before == NULL) return NULL;
             match_t *m = new_match();
             m->start = str;
             m->end = str;
-            m->pat = op;
+            m->pat = pat;
             ADD_OWNER(m->child, before);
             return m;
         }
         case VM_BEFORE: {
-            match_t *after = match(defs, f, str, op->args.pat, ignorecase);
+            match_t *after = match(defs, f, str, pat->args.pat, ignorecase);
             if (after == NULL) return NULL;
             match_t *m = new_match();
             m->start = str;
             m->end = str;
-            m->pat = op;
+            m->pat = pat;
             ADD_OWNER(m->child, after);
             return m;
         }
         case VM_CAPTURE: {
-            match_t *p = match(defs, f, str, op->args.pat, ignorecase);
+            match_t *p = match(defs, f, str, pat->args.pat, ignorecase);
             if (p == NULL) return NULL;
             match_t *m = new_match();
             m->start = str;
             m->end = p->end;
-            m->pat = op;
+            m->pat = pat;
             ADD_OWNER(m->child, p);
             return m;
         }
         case VM_OTHERWISE: {
-            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);
+            match_t *m = match(defs, f, str, pat->args.multiple.first, ignorecase);
+            if (m == NULL) m = match(defs, f, str, pat->args.multiple.second, ignorecase);
             return m;
         }
         case VM_CHAIN: {
-            match_t *m1 = match(defs, f, str, op->args.multiple.first, ignorecase);
+            match_t *m1 = match(defs, f, str, pat->args.multiple.first, ignorecase);
             if (m1 == NULL) return NULL;
 
             match_t *m2;
@@ -349,7 +349,7 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
                 if (m1->pat->type == VM_CAPTURE && m1->pat->args.capture.name)
                     defs2 = with_backref(defs2, f, m1->pat->args.capture.name, m1);
                 // def_t *defs2 = with_backrefs(defs, f, m1);
-                m2 = match(defs2, f, m1->end, op->args.multiple.second, ignorecase);
+                m2 = match(defs2, f, m1->end, pat->args.multiple.second, ignorecase);
                 free_defs(&defs2, defs);
             }
 
@@ -360,13 +360,13 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
             match_t *m = new_match();
             m->start = str;
             m->end = m2->end;
-            m->pat = op;
+            m->pat = pat;
             ADD_OWNER(m->child, m1);
             ADD_OWNER(m1->nextsibling, m2);
             return m;
         }
         case VM_EQUAL: case VM_NOT_EQUAL: {
-            match_t *m1 = match(defs, f, str, op->args.multiple.first, ignorecase);
+            match_t *m1 = match(defs, f, str, pat->args.multiple.first, ignorecase);
             if (m1 == NULL) return NULL;
 
             // <p1>==<p2> matches iff the text of <p1> matches <p2>
@@ -378,8 +378,8 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
                 .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, ignorecase);
-            if ((m2 == NULL) == (op->type == VM_EQUAL)) {
+            match_t *m2 = match(defs, &inner, str, pat->args.multiple.second, ignorecase);
+            if ((m2 == NULL) == (pat->type == VM_EQUAL)) {
                 recycle_if_unused(&m1);
                 if (m2 != NULL) recycle_if_unused(&m2);
                 return NULL;
@@ -387,9 +387,9 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
             match_t *m = new_match();
             m->start = m1->start;
             m->end = m1->end;
-            m->pat = op;
+            m->pat = pat;
             ADD_OWNER(m->child, m1);
-            if (op->type == VM_EQUAL) {
+            if (pat->type == VM_EQUAL) {
                 ADD_OWNER(m1->nextsibling, m2);
             } else {
                 recycle_if_unused(&m2);
@@ -398,13 +398,13 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
         }
         case VM_REPLACE: {
             match_t *p = NULL;
-            if (op->args.replace.pat) {
-                p = match(defs, f, str, op->args.replace.pat, ignorecase);
+            if (pat->args.replace.pat) {
+                p = match(defs, f, str, pat->args.replace.pat, ignorecase);
                 if (p == NULL) return NULL;
             }
             match_t *m = new_match();
             m->start = str;
-            m->pat = op;
+            m->pat = pat;
             if (p) {
                 ADD_OWNER(m->child, p);
                 m->end = p->end;
@@ -414,8 +414,8 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
             return m;
         }
         case VM_REF: {
-            def_t *def = lookup(defs, op->args.s);
-            check(def != NULL, "Unknown identifier: '%s'", op->args.s);
+            def_t *def = lookup(defs, pat->args.s);
+            check(def != NULL, "Unknown identifier: '%s'", pat->args.s);
             pat_t *ref = def->pat;
 
             pat_t rec_op = {
@@ -470,17 +470,17 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
             // match results.
             // OPTIMIZE: remove this if necessary
             match_t *m2 = new_match();
-            m2->pat = op;
+            m2->pat = pat;
             m2->start = m->start;
             m2->end = m->end;
             ADD_OWNER(m2->child, m);
             return m2;
         }
         case VM_BACKREF: {
-            const char *end = match_backref(str, op->args.backref, ignorecase);
+            const char *end = match_backref(str, pat->args.backref, ignorecase);
             if (end == NULL) return NULL;
             match_t *m = new_match();
-            m->pat = op;
+            m->pat = pat;
             m->start = str;
             m->end = end;
             return m;
@@ -509,11 +509,11 @@ match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int
             match_t *m = new_match();
             m->start = start;
             m->end = &str[dents];
-            m->pat = op;
+            m->pat = pat;
             return m;
         }
         default: {
-            fprintf(stderr, "Unknown pattern type: %d", op->type);
+            fprintf(stderr, "Unknown pattern type: %d", pat->type);
             exit(1);
             return NULL;
         }
@@ -665,21 +665,21 @@ size_t free_all_matches(void)
 #endif
 
 //
-// Deallocate memory associated with an op
+// Deallocate memory referenced inside a pattern struct
 //
-void destroy_pat(pat_t *op)
+void destroy_pat(pat_t *pat)
 {
-    switch (op->type) {
+    switch (pat->type) {
         case VM_STRING: case VM_REF:
-            xfree(&op->args.s);
+            xfree(&pat->args.s);
             break;
         case VM_CAPTURE:
-            if (op->args.capture.name)
-                xfree(&op->args.capture.name);
+            if (pat->args.capture.name)
+                xfree(&pat->args.capture.name);
             break;
         case VM_REPLACE:
-            if (op->args.replace.text)
-                xfree(&op->args.replace.text);
+            if (pat->args.replace.text)
+                xfree(&pat->args.replace.text);
             break;
         default: break;
     }
diff --git a/vm.h b/vm.h
index a0b73b3..28c573e 100644
--- a/vm.h
+++ b/vm.h
@@ -9,13 +9,13 @@
 #include "types.h"
 
 __attribute__((nonnull(2,4)))
-match_t *next_match(def_t *defs, file_t *f, match_t *prev, pat_t *op, unsigned int flags);
+match_t *next_match(def_t *defs, file_t *f, match_t *prev, pat_t *pat, unsigned int flags);
 __attribute__((hot, nonnull(2,3,4)))
-match_t *match(def_t *defs, file_t *f, const char *str, pat_t *op, unsigned int flags);
+match_t *match(def_t *defs, file_t *f, const char *str, pat_t *pat, unsigned int flags);
 __attribute__((nonnull))
 match_t *get_capture(match_t *m, const char **id);
 __attribute__((nonnull))
-void destroy_pat(pat_t *op);
+void destroy_pat(pat_t *pat);
 match_t *new_match(void);
 __attribute__((nonnull))
 void recycle_if_unused(match_t **at_m);