wikipeg 6.0.0 → 6.1.0

package/HISTORY.md

@@ -1,5 +1,18 @@
 # Release History
 
+## 6.1.0 (2026-02-13)
+* Add 'labeled expression parameter' which allows parameterizing a rule
+  by the (string) value of a labeled expression.  This is particularly
+  useful for parsing matched syntax elements, like XML tags.
+* Add the ability to assert that a parameter has a specific value.
+  Previously assertions were limited to truthy/falsey.
+* Add `optimizePureActions` option to the PEG compiler which enables an
+  optimization to skip execution of rule action blocks whose values
+  are never used.  A new `[pure]` rule attribute can enable or disable
+  this optimization on an individual rule.  For example,
+  `[pure=false]` ensures execution of that rule's action block(s) on a
+  successful match, even if the rule result is discarded.
+
 ## 6.0.0 (2025-08-14)
 * Bump minimum required PHP version to 8.1
 * Zero-or-more or one-or-more repetitions of character classes are now

package/README.md

@@ -128,6 +128,11 @@ object to `PEG.buildParser`. The following options are supported:
     determine that a rule can not match.  This can affect failure
     reporting, since we might be able to fail on a parent rule before
     actually recursing into the child responsible.
+  * `optimizePureActions` = if `true`, defaults to enabling a rule
+    optimization which skips executing rule action blocks if the
+    result of that rule will not be used.  This can be enabled or
+    disabled for individual rules via the `[pure]` rule attribute
+    described below.
   * `cacheInitHook` and `cacheRuleHook` — functions to generate custom cache
     control code
   * `allowedStartRules` — rules the parser will be allowed to start parsing from
@@ -561,6 +566,19 @@ Marks a rule as unreachable. If the `allowUselessChoice` option is
 false, this attribute permits a reference to the rule in a choice even
 if a previous option in the choice appears to always match.
 
+#### [pure]
+
+Marks a rule as not having side effects in its action blocks.  This
+allows action blocks in rules which have this attribute set to be
+skipped (not executed) when the value of the rule is not needed.
+
+#### [pure=false]
+
+Marks a rule as having side effects in its action blocks.  If the
+`optimizePureActions` option is given to the parser, this ensures that
+the action blocks for this rule are executed even if the value of
+the rule is not needed.
+
 Rule parameter syntax
 ---------------------
 
@@ -571,11 +589,12 @@ All parameters referenced in the grammar have an initial value and can
 be used before their first assignment.
 
 Parameters have a type detected at compile time: boolean, integer,
-string or reference. Initial values for each type are:
+string, reference, or labeled expression. Initial values for each type are:
   - boolean: false
   - integer: 0
   - string: ""
   - reference: null
+  - labeled expression: null (or the integer or string default value)
 
 The parameter namespace is global, but the value of a parameter reverts
 to its previous value after termination of the assigning rule reference.
@@ -590,6 +609,15 @@ Assert that the parameter "x" is true or nonzero
 
 Assert that the parameter "x" is false or zero
 
+#### & < *parameter* == *value* >
+
+Assert that the parameter "x" has the specified value.
+
+#### ! < *parameter* == *value* >
+#### & < *parameter* != *value* >
+
+Assert that the parameter "x" does not have the specified value.
+
 #### *rule* < *parameter* = true >
 
 Match a parsing expression of a rule recursively, and assign *parameter* to
@@ -615,6 +643,14 @@ Assign x = x + 1.
 
 String assignment.
 
+#### *rule* < *parameter* = $*label* >
+
+Assign the value of the given labeled expression to the parameter.
+
+Labeled expression parameters can't be intermixed with boolean
+assignments to the same parameter, but they can co-exist with
+integer or string assignments to the parameter.
+
 #### *rule* < & *parameter* = 1 >
 
 Create a reference (in/out) parameter and give it an initial value of 1.

package/VERSION

@@ -1 +1 @@
-6.0.0
+6.1.0

package/lib/compiler/language/php.js

@@ -43,8 +43,8 @@ let php = {
   maxFailPos: '$this->maxFailPos',
   assertionSuccess: 'false',
   inputLength: '$this->inputLength',
-  advanceInputChar: 'self::advanceChar($this->input, $this->currPos);',
-  consumeInputChar: 'self::consumeChar($this->input, $this->currPos);',
+  advanceInputChar: 'self::advanceChar($this->input, $this->currPos)',
+  consumeInputChar: 'self::consumeChar($this->input, $this->currPos)',
   result: '$result',
   actionArgPrefix: '$',
 

package/lib/compiler/passes/analyze-params.js

@@ -12,8 +12,14 @@ function analyzeParams(ast, options) {
 
   function registerParamType(name, type, location) {
     var paramInfo = getParamInfo(name);
-    if (paramInfo.type !== undefined) {
-      if (paramInfo.type !== type) {
+    if (
+      (paramInfo.type === 'labeled' && type === 'boolean') ||
+      (paramInfo.type === 'boolean' && type === 'labeled')
+    ){
+      throw new GrammarError("Labeled expression parameters can't also be boolean: " + name, location);
+    }
+    if (paramInfo.type !== undefined && paramInfo.type !== 'labeled') {
+      if (paramInfo.type !== type && type !== 'labeled') {
         throw new GrammarError("Type conflict in parameter " + name, location);
       }
     } else {
@@ -133,7 +139,17 @@ function analyzeParams(ast, options) {
         (new Traverser(ast, refScopeHandlers))
           .traverse(targetNode, assignment.name, refScope);
       }
-    }
+    },
+    parameter_and: function(node) {
+      if (node.assert) {
+        registerParamType(node.parameter, node.assert.type, node.location);
+      }
+    },
+    parameter_not: function(node) {
+      if (node.assert) {
+        registerParamType(node.parameter, node.assert.type, node.location);
+      }
+    },
   })(ast);
 
   // For every reference parameter, traverse the call graph of each start rule,

package/lib/compiler/passes/ast-to-code.js

@@ -6,7 +6,8 @@ var js      = require("../language/javascript"),
     objects = require('../../utils/objects'),
     classNode = require("../charsets").classNode,
     asts    = require("../asts"),
-    fs      = require("fs");
+    fs      = require("fs"),
+    GrammarError = require("../../grammar-error");
 
 function generateJavascript(ast, options) {
   /**
@@ -682,6 +683,8 @@ function generateJavascript(ast, options) {
       } else {
         return 'null';
       }
+    } else if (type === 'labeled') {
+      return 'null';
     } else {
       throw new Error('Unknown param type: ' + type);
     }
@@ -761,9 +764,31 @@ function generateJavascript(ast, options) {
     var negate = node.type === 'parameter_not';
     var reg = context.getResultReg(result);
     var paramExpression = makeParamExpression(node.paramInfo);
+    if (node.assert) {
+      if (node.assert.type === 'boolean') {
+        if (node.assert.value === false) {
+          negate = !negate;
+        }
+        if (!negate) {
+          paramExpression = language.toBool(paramExpression);
+        }
+      } else if (node.assert.type === 'string') {
+        paramExpression = `${paramExpression} === ${js.stringify(node.assert.value)}`;
+      } else if (node.assert.type === 'labeled') {
+        if (context.env[node.assert.value] === undefined) {
+          throw new GrammarError(
+            'Unknown label "' + node.assert.value + '" for labeled-expression assertion',
+            node.location
+          );
+        }
+        paramExpression = `${paramExpression} === ${context.env[node.assert.value]}`;
+      } else {
+        paramExpression = `${paramExpression} === ${node.assert.value}`;
+      }
+    }
     if (negate) {
       result.condition = `!(${paramExpression})`;
-    } else if (!node.paramInfo.value || node.paramInfo.value.type === 'boolean') {
+    } else if (node.assert || node.paramInfo.type === 'boolean') {
       result.condition = paramExpression;
     } else {
       result.condition = language.toBool(paramExpression);
@@ -1074,6 +1099,13 @@ function generateJavascript(ast, options) {
         let assignment = node.assignments[i];
         let newValue;
 
+        if (assignment.type === 'labeled' &&
+            context.env[assignment.value] === undefined) {
+          throw new GrammarError(
+            'Unknown label "' + assignment.value + '" for labeled-expression parameter',
+            node.location
+          );
+        }
         if (assignment.isref) {
           if (assignment.type === 'increment') {
             newValue = `${language.refParamValue(assignment.name)} + ${assignment.value}`;
@@ -1081,6 +1113,8 @@ function generateJavascript(ast, options) {
             newValue = assignment.value ? 'true' : 'false';
           } else if (assignment.type === 'string') {
             newValue = js.stringify(assignment.value);
+          } else if (assignment.type === 'labeled') {
+            newValue = context.env[assignment.value];
           } else {
             newValue = assignment.value;
           }
@@ -1097,6 +1131,8 @@ function generateJavascript(ast, options) {
               newValue = `${language.paramArgName(assignment.name)} + ${assignment.value}`;
             } else if (assignment.type === 'string') {
               newValue = js.stringify(assignment.value);
+            } else if (assignment.type === 'labeled') {
+              newValue = context.env[assignment.value];
             } else {
               newValue = assignment.value;
             }
@@ -1190,14 +1226,18 @@ function generateJavascript(ast, options) {
         result.block = [`${savedPos} = ${language.currPos};`];
       }
       var subresult = recurse(node.expression, newContext);
-      var funcId = makeActionFunc(node.code, newContext);
+      var canSkipAction = context.getDiscard() && node.pure;
+      var funcId = canSkipAction ? null :
+        makeActionFunc(node.code, newContext);
       result.append(subresult);
       if (node.alwaysMatch) {
         result.condition = 'true';
       }
       result.onSuccess([
         `${language.savedPos} = ${savedPos};`,
-        `${reg} = ${makeActionCall(funcId, newContext)};`
+        canSkipAction ?
+          `${reg} = true;` :
+          `${reg} = ${makeActionCall(funcId, newContext)};`,
       ]);
       freeReg(freePos, result);
       return result;

package/lib/compiler/passes/mark-pure.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var visitor        = require("../visitor"),
+    asts           = require("../asts");
+
+// Propagate `pure` attribute to `action` nodes
+
+function markPure(ast, options) {
+  options = options || {};
+  var pureDefault = false;
+  if (options.optimizePureActions) {
+    pureDefault = true;
+  }
+
+  const propagatePure = visitor.build({
+    rule: function(rule) {
+      var pure = asts.getRuleAttributeValue(
+        rule, 'pure', pureDefault
+      );
+      propagatePure(rule.expression, { pure });
+    },
+    action: function(node, result) {
+      node.pure = result.pure;
+    },
+  });
+  propagatePure(ast);
+}
+
+module.exports = markPure;

package/lib/compiler/passes/report-unknown-attributes.js

@@ -11,6 +11,7 @@ function reportUnknownAttributes(ast) {
     cache: 'boolean',
     empty: 'boolean',
     unreachable: 'boolean',
+    pure: 'boolean',
   };
 
   var check = visitor.build({

package/lib/compiler.js

@@ -20,6 +20,7 @@ var compiler = {
     },
     transform: {
       removeProxyRules:    require("./compiler/passes/remove-proxy-rules"),
+      markPure:            require("./compiler/passes/mark-pure"),
       inlineSimpleRules:   require("./compiler/passes/inline-simple-rules"),
       optimizeCharacterClass:
                            require("./compiler/passes/optimize-character-class"),

package/lib/parser.js

@@ -377,20 +377,23 @@ function peg$parse(input, options = {}) {
   var peg$c7 = {"type":"literal","value":"]","description":"\"]\""};
   var peg$c8 = {"type":"literal","value":"/","description":"\"/\""};
   var peg$c9 = {"type":"class","value":"[0-9]","description":"[0-9]"};
-  var peg$c10 = {"type":"literal","value":"@","description":"\"@\""};
-  var peg$c11 = {"type":"literal","value":":","description":"\":\""};
-  var peg$c12 = {"type":"literal","value":"<","description":"\"<\""};
-  var peg$c13 = {"type":"literal","value":"&","description":"\"&\""};
-  var peg$c14 = {"type":"literal","value":">","description":"\">\""};
-  var peg$c15 = {"type":"class","value":"\"$\", \"&\" or \"!\"","description":"\"$\", \"&\" or \"!\""};
-  var peg$c16 = {"type":"literal","value":"(","description":"\"(\""};
-  var peg$c17 = {"type":"literal","value":")","description":"\")\""};
-  var peg$c18 = {"type":"class","value":"\"?\", \"*\" or \"+\"","description":"\"?\", \"*\" or \"+\""};
-  var peg$c19 = {"type":"other","description":"literal"};
-  var peg$c20 = {"type":"other","description":"character class"};
-  var peg$c21 = {"type":"literal","value":".","description":"\".\""};
-  var peg$c22 = {"type":"class","value":"\"&\" or \"!\"","description":"\"&\" or \"!\""};
-  var peg$c23 = {"type":"literal","value":"++","description":"\"++\""};
+  var peg$c10 = {"type":"literal","value":"$","description":"\"$\""};
+  var peg$c11 = {"type":"literal","value":"@","description":"\"@\""};
+  var peg$c12 = {"type":"literal","value":":","description":"\":\""};
+  var peg$c13 = {"type":"literal","value":"<","description":"\"<\""};
+  var peg$c14 = {"type":"literal","value":"&","description":"\"&\""};
+  var peg$c15 = {"type":"literal","value":">","description":"\">\""};
+  var peg$c16 = {"type":"class","value":"\"$\", \"&\" or \"!\"","description":"\"$\", \"&\" or \"!\""};
+  var peg$c17 = {"type":"literal","value":"(","description":"\"(\""};
+  var peg$c18 = {"type":"literal","value":")","description":"\")\""};
+  var peg$c19 = {"type":"class","value":"\"?\", \"*\" or \"+\"","description":"\"?\", \"*\" or \"+\""};
+  var peg$c20 = {"type":"other","description":"literal"};
+  var peg$c21 = {"type":"other","description":"character class"};
+  var peg$c22 = {"type":"literal","value":".","description":"\".\""};
+  var peg$c23 = {"type":"class","value":"\"&\" or \"!\"","description":"\"&\" or \"!\""};
+  var peg$c24 = {"type":"literal","value":"==","description":"\"==\""};
+  var peg$c25 = {"type":"literal","value":"!=","description":"\"!=\""};
+  var peg$c26 = {"type":"literal","value":"++","description":"\"++\""};
 
   // actions
   function peg$a0(initializer, rules) {
@@ -555,7 +558,15 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a20(p, el) {
+  function peg$a20(name) {
+  
+        return {
+          type: "labeled",
+          value: name
+        };
+      
+  }
+  function peg$a21(p, el) {
   
         if (p !== null) {
           el.picked = true;
@@ -563,25 +574,25 @@ function peg$parse(input, options = {}) {
         return el;
       
   }
-  function peg$a21() {
+  function peg$a22() {
    return "\b";   
   }
-  function peg$a22() {
+  function peg$a23() {
    return "\f";   
   }
-  function peg$a23() {
+  function peg$a24() {
    return "\n";   
   }
-  function peg$a24() {
+  function peg$a25() {
    return "\r";   
   }
-  function peg$a25() {
+  function peg$a26() {
    return "\t";   
   }
-  function peg$a26() {
+  function peg$a27() {
    return "\x0B"; 
   }
-  function peg$a27(label, ampersand, parameter) {
+  function peg$a28(label, ampersand, parameter) {
   
         return {
           type:      "labeled_param",
@@ -592,7 +603,7 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a28(label, expression) {
+  function peg$a29(label, expression) {
   
         return {
           type:       "labeled",
@@ -602,7 +613,7 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a29(operator, expression) {
+  function peg$a30(operator, expression) {
   
         return {
           type:       OPS_TO_PREFIXED_TYPES[operator],
@@ -611,7 +622,7 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a30(expression, operator) {
+  function peg$a31(expression, operator) {
   
         return {
           type:       OPS_TO_SUFFIXED_TYPES[operator],
@@ -620,7 +631,7 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a31(value, ignoreCase) {
+  function peg$a32(value, ignoreCase) {
   
         return {
           type:       "literal",
@@ -630,7 +641,7 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a32(inverted, parts, ignoreCase) {
+  function peg$a33(inverted, parts, ignoreCase) {
   
         return {
           type:       "class",
@@ -642,10 +653,10 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a33() {
+  function peg$a34() {
    return { type: "any", location: location() }; 
   }
-  function peg$a34(name, assign) {
+  function peg$a35(name, assign) {
   
         return {
           type: "rule_ref",
@@ -655,7 +666,7 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a35(operator, code) {
+  function peg$a36(operator, code) {
   
         return {
           type:     OPS_TO_SEMANTIC_PREDICATE_TYPES[operator],
@@ -664,16 +675,24 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a36(operator, parameter) {
+  function peg$a37(operator, parameter, assert) {
   
+        var type = OPS_TO_PARAMETER_PREDICATE_TYPES[operator];
+        if (assert) {
+          if (assert[0] === "!=") {
+            type = OPS_INVERT[type];
+          }
+          assert = assert[1];
+        }
         return {
-          type:      OPS_TO_PARAMETER_PREDICATE_TYPES[operator],
+          type:      type,
           parameter: parameter,
+          assert:    assert,
           location:  location()
         };
       
   }
-  function peg$a37(begin, end) {
+  function peg$a38(begin, end) {
   
         if (begin.charCodeAt(0) > end.charCodeAt(0)) {
           error(
@@ -684,7 +703,7 @@ function peg$parse(input, options = {}) {
         return [begin, end];
       
   }
-  function peg$a38(ampersand, name, assign) {
+  function peg$a39(ampersand, name, assign) {
   
         var type, value;
         if (assign) {
@@ -702,7 +721,7 @@ function peg$parse(input, options = {}) {
         };
       
   }
-  function peg$a39() {
+  function peg$a40() {
   
         return {
           type: "increment",
@@ -735,6 +754,15 @@ function peg$parse(input, options = {}) {
       "!": "parameter_not"
     };
   
+    var OPS_INVERT = {
+      "parameter_and": "parameter_not",
+      "parameter_not": "parameter_and",
+      "semantic_and": "semantic_not",
+      "semantic_not": "semantic_and",
+      "simple_and": "simple_not",
+      "simple_not": "simple_and",
+    };
+  
   
 
   // generated
@@ -2366,6 +2394,10 @@ function peg$parse(input, options = {}) {
       break choice_1;
     }
     r1 = peg$parseParameterValueString(silence);
+    if (r1!==peg$FAILED) {
+      break choice_1;
+    }
+    r1 = peg$parseParameterValueLabeled(silence);
     } // choice_1
     return r1;
   }
@@ -2650,6 +2682,39 @@ function peg$parse(input, options = {}) {
     // free p2
     return r1;
   }
+  function peg$parseParameterValueLabeled(silence) {
+    var r1,p2,p3,r4,r5;
+    p2 = peg$currPos;
+    seq_1: {
+    p3 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 36) {
+      r4 = true;
+      peg$currPos += 1;
+    } else {
+      if (!silence) { peg$fail(peg$c10); }
+      r4 = peg$FAILED;
+      r1 = peg$FAILED;
+      break seq_1;
+    }
+    peg$discard__();
+    r5 = peg$parseIdentifier(silence);
+    // name <- r5
+    if (r5===peg$FAILED) {
+      peg$currPos = p3;
+      r1 = peg$FAILED;
+      break seq_1;
+    }
+    r1 = true;
+    } // seq_1
+    if (r1!==peg$FAILED) {
+      peg$savedPos = p2;
+      r1 = peg$a20(r5);
+    }
+    // free r4
+    // free p3
+    // free p2
+    return r1;
+  }
   function peg$parsePickedSequenceElement(silence) {
     var r1,p2,p3,r4,r5;
     p2 = peg$currPos;
@@ -2678,7 +2743,7 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a20(r4, r5);
+      r1 = peg$a21(r4, r5);
     }
     // free p3
     // free p2
@@ -2713,7 +2778,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a21();
+      r1 = peg$a22();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -2724,7 +2789,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a22();
+      r1 = peg$a23();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -2735,7 +2800,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a23();
+      r1 = peg$a24();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -2746,7 +2811,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a24();
+      r1 = peg$a25();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -2757,7 +2822,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a25();
+      r1 = peg$a26();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -2768,7 +2833,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a26();
+      r1 = peg$a27();
     } else {
       r1 = peg$FAILED;
     }
@@ -2998,7 +3063,7 @@ function peg$parse(input, options = {}) {
       r1 = "@";
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c10); }
+      if (!silence) { peg$fail(peg$c11); }
       r1 = peg$FAILED;
     }
     return r1;
@@ -4146,7 +4211,7 @@ function peg$parse(input, options = {}) {
       r5 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c11); }
+      if (!silence) { peg$fail(peg$c12); }
       r5 = peg$FAILED;
       peg$currPos = p3;
       r1 = peg$FAILED;
@@ -4157,7 +4222,7 @@ function peg$parse(input, options = {}) {
       r6 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c12); }
+      if (!silence) { peg$fail(peg$c13); }
       r6 = peg$FAILED;
       peg$currPos = p3;
       r1 = peg$FAILED;
@@ -4168,7 +4233,7 @@ function peg$parse(input, options = {}) {
       r7 = "&";
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c13); }
+      if (!silence) { peg$fail(peg$c14); }
       r7 = peg$FAILED;
       r7 = null;
     }
@@ -4186,7 +4251,7 @@ function peg$parse(input, options = {}) {
       r9 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c14); }
+      if (!silence) { peg$fail(peg$c15); }
       r9 = peg$FAILED;
       peg$currPos = p3;
       r1 = peg$FAILED;
@@ -4196,7 +4261,7 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a27(r4, r7, r8);
+      r1 = peg$a28(r4, r7, r8);
     }
     // free r5,r6,r9
     // free p3
@@ -4219,7 +4284,7 @@ function peg$parse(input, options = {}) {
       r5 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c11); }
+      if (!silence) { peg$fail(peg$c12); }
       r5 = peg$FAILED;
       peg$currPos = p3;
       r1 = peg$FAILED;
@@ -4237,7 +4302,7 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a28(r4, r6);
+      r1 = peg$a29(r4, r6);
     }
     // free r5
     // free p3
@@ -4268,7 +4333,7 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a29(r4, r5);
+      r1 = peg$a30(r4, r5);
       break choice_1;
     }
     // free p3
@@ -4306,7 +4371,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a21();
+      r1 = peg$a22();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -4317,7 +4382,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a22();
+      r1 = peg$a23();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -4328,7 +4393,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a23();
+      r1 = peg$a24();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -4339,7 +4404,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a24();
+      r1 = peg$a25();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -4350,7 +4415,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a25();
+      r1 = peg$a26();
       break choice_1;
     } else {
       r1 = peg$FAILED;
@@ -4361,7 +4426,7 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a26();
+      r1 = peg$a27();
     } else {
       r1 = peg$FAILED;
     }
@@ -4458,7 +4523,7 @@ function peg$parse(input, options = {}) {
       peg$currPos++;
     } else {
       r1 = peg$FAILED;
-      if (!silence) { peg$fail(peg$c15); }
+      if (!silence) { peg$fail(peg$c16); }
     }
     return r1;
   }
@@ -4486,7 +4551,7 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a30(r4, r5);
+      r1 = peg$a31(r4, r5);
       break choice_1;
     }
     // free p3
@@ -4575,7 +4640,7 @@ function peg$parse(input, options = {}) {
       r3 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c16); }
+      if (!silence) { peg$fail(peg$c17); }
       r3 = peg$FAILED;
       r1 = peg$FAILED;
       break seq_1;
@@ -4592,7 +4657,7 @@ function peg$parse(input, options = {}) {
       r4 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c17); }
+      if (!silence) { peg$fail(peg$c18); }
       r4 = peg$FAILED;
       peg$currPos = p2;
       r1 = peg$FAILED;
@@ -4610,7 +4675,7 @@ function peg$parse(input, options = {}) {
       peg$currPos++;
     } else {
       r1 = peg$FAILED;
-      if (!silence) { peg$fail(peg$c18); }
+      if (!silence) { peg$fail(peg$c19); }
     }
     return r1;
   }
@@ -4697,9 +4762,9 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a31(r4, r5);
+      r1 = peg$a32(r4, r5);
     } else {
-      if (!silence) { peg$fail(peg$c19); }
+      if (!silence) { peg$fail(peg$c20); }
     }
     // free p3
     // free p2
@@ -4764,9 +4829,9 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a32(r5, r6, r8);
+      r1 = peg$a33(r5, r6, r8);
     } else {
-      if (!silence) { peg$fail(peg$c20); }
+      if (!silence) { peg$fail(peg$c21); }
     }
     // free r4,r7
     // free p3
@@ -4780,9 +4845,9 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 1;
       peg$savedPos = p2;
-      r1 = peg$a33();
+      r1 = peg$a34();
     } else {
-      if (!silence) { peg$fail(peg$c21); }
+      if (!silence) { peg$fail(peg$c22); }
       r1 = peg$FAILED;
     }
     // free p2
@@ -4862,7 +4927,7 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a34(r4, r5);
+      r1 = peg$a35(r4, r5);
     }
     // free r6
     // free p3
@@ -4892,14 +4957,14 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a35(r4, r5);
+      r1 = peg$a36(r4, r5);
     }
     // free p3
     // free p2
     return r1;
   }
   function peg$parseParameterPredicateExpression(silence) {
-    var r1,p2,p3,r4,r5,r6,r7;
+    var r1,p2,p3,r4,r5,r6,r7,p8,r9,r10;
     p2 = peg$currPos;
     seq_1: {
     p3 = peg$currPos;
@@ -4914,7 +4979,7 @@ function peg$parse(input, options = {}) {
       r5 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c12); }
+      if (!silence) { peg$fail(peg$c13); }
       r5 = peg$FAILED;
       peg$currPos = p3;
       r1 = peg$FAILED;
@@ -4929,12 +4994,35 @@ function peg$parse(input, options = {}) {
       break seq_1;
     }
     peg$discard__();
+    seq_2: {
+    p8 = peg$currPos;
+    r9 = peg$parseEqualityOperator(silence);
+    if (r9===peg$FAILED) {
+      r7 = peg$FAILED;
+      break seq_2;
+    }
+    peg$discard__();
+    r10 = peg$parseParameterValue(silence);
+    if (r10===peg$FAILED) {
+      peg$currPos = p8;
+      r7 = peg$FAILED;
+      break seq_2;
+    }
+    peg$discard__();
+    r7 = [r9,r10];
+    } // seq_2
+    if (r7===peg$FAILED) {
+      r7 = null;
+    }
+    // free r9,r10
+    // free p8
+    // assert <- r7
     if (input.charCodeAt(peg$currPos) === 62) {
-      r7 = true;
+      r10 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c14); }
-      r7 = peg$FAILED;
+      if (!silence) { peg$fail(peg$c15); }
+      r10 = peg$FAILED;
       peg$currPos = p3;
       r1 = peg$FAILED;
       break seq_1;
@@ -4943,9 +5031,9 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a36(r4, r6);
+      r1 = peg$a37(r4, r6, r7);
     }
-    // free r5,r7
+    // free r5,r10
     // free p3
     // free p2
     return r1;
@@ -4981,7 +5069,7 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a37(r4, r6);
+      r1 = peg$a38(r4, r6);
     }
     // free r5
     // free p3
@@ -5074,7 +5162,7 @@ function peg$parse(input, options = {}) {
       r4 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c12); }
+      if (!silence) { peg$fail(peg$c13); }
       r4 = peg$FAILED;
       r1 = peg$FAILED;
       break seq_1;
@@ -5125,7 +5213,7 @@ function peg$parse(input, options = {}) {
       r9 = true;
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c14); }
+      if (!silence) { peg$fail(peg$c15); }
       r9 = peg$FAILED;
       peg$currPos = p3;
       r1 = peg$FAILED;
@@ -5343,7 +5431,7 @@ function peg$parse(input, options = {}) {
       peg$currPos++;
     } else {
       r1 = peg$FAILED;
-      if (!silence) { peg$fail(peg$c22); }
+      if (!silence) { peg$fail(peg$c23); }
     }
     return r1;
   }
@@ -5354,10 +5442,61 @@ function peg$parse(input, options = {}) {
       peg$currPos++;
     } else {
       r1 = peg$FAILED;
-      if (!silence) { peg$fail(peg$c22); }
+      if (!silence) { peg$fail(peg$c23); }
     }
     return r1;
   }
+  function peg$parseEqualityOperator(silence) {
+    var r1,p2,r3,r4;
+    choice_1: {
+    seq_1: {
+    p2 = peg$currPos;
+    r1 = input.substr(peg$currPos,2);
+    if (r1 === "==") {
+      peg$currPos += 2;
+    } else {
+      if (!silence) { peg$fail(peg$c24); }
+      r1 = peg$FAILED;
+      r1 = peg$FAILED;
+      break seq_1;
+    }
+    if (input.charCodeAt(peg$currPos) === 61) {
+      r3 = true;
+      peg$currPos += 1;
+    } else {
+      if (!silence) { peg$fail(peg$c1); }
+      r3 = peg$FAILED;
+      r3 = null;
+    }
+    } // seq_1
+    if (r1!==peg$FAILED) {
+      break choice_1;
+    }
+    // free p2
+    seq_2: {
+    p2 = peg$currPos;
+    r1 = input.substr(peg$currPos,2);
+    if (r1 === "!=") {
+      peg$currPos += 2;
+    } else {
+      if (!silence) { peg$fail(peg$c25); }
+      r1 = peg$FAILED;
+      r1 = peg$FAILED;
+      break seq_2;
+    }
+    if (input.charCodeAt(peg$currPos) === 61) {
+      r4 = true;
+      peg$currPos += 1;
+    } else {
+      if (!silence) { peg$fail(peg$c1); }
+      r4 = peg$FAILED;
+      r4 = null;
+    }
+    } // seq_2
+    // free p2
+    } // choice_1
+    return r1;
+  }
   function peg$parseParameterAssignment(silence) {
     var r1,p2,p3,r4,r5,r6,p7,r8;
     p2 = peg$currPos;
@@ -5367,7 +5506,7 @@ function peg$parse(input, options = {}) {
       r4 = "&";
       peg$currPos += 1;
     } else {
-      if (!silence) { peg$fail(peg$c13); }
+      if (!silence) { peg$fail(peg$c14); }
       r4 = peg$FAILED;
       r4 = null;
     }
@@ -5415,7 +5554,7 @@ function peg$parse(input, options = {}) {
     } // seq_1
     if (r1!==peg$FAILED) {
       peg$savedPos = p2;
-      r1 = peg$a38(r4, r5, r6);
+      r1 = peg$a39(r4, r5, r6);
     }
     // free r8
     // free p3
@@ -5429,9 +5568,9 @@ function peg$parse(input, options = {}) {
       r1 = true;
       peg$currPos += 2;
       peg$savedPos = p2;
-      r1 = peg$a39();
+      r1 = peg$a40();
     } else {
-      if (!silence) { peg$fail(peg$c23); }
+      if (!silence) { peg$fail(peg$c26); }
       r1 = peg$FAILED;
     }
     // free p2

package/lib/peg.js

@@ -4,7 +4,7 @@ var objects = require("./utils/objects");
 
 var PEG = {
   /* WikiPEG version (uses semantic versioning). */
-  VERSION: "6.0.0",
+  VERSION: "6.1.0",
 
   GrammarError: require("./grammar-error"),
   parser:       require("./parser"),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wikipeg",
-	"version": "6.0.0",
+	"version": "6.1.0",
 	"description": "Parser generator for JavaScript and PHP",
 	"license": "MIT",
 	"homepage": "https://gerrit.wikimedia.org/r/plugins/gitiles/wikipeg/",