From 53f70b9eb98998f8104723f60b04b038800fdd8b Mon Sep 17 00:00:00 2001 From: David Majda Date: Thu, 19 Apr 2012 14:23:21 +0200 Subject: [PATCH] Move compiler passes and their tests into a subdirectory --- src/compiler/passes.js | 410 +----------- src/compiler/passes/compute-params.js | 101 +++ src/compiler/passes/compute-var-names.js | 125 ++++ src/compiler/passes/remove-proxy-rules.js | 71 ++ src/compiler/passes/report-left-recursion.js | 60 ++ src/compiler/passes/report-missing-rules.js | 41 ++ test/compiler/passes-test.js | 607 ------------------ test/compiler/passes/compute-params-test.js | 167 +++++ .../compiler/passes/compute-var-names-test.js | 231 +++++++ .../passes/remove-proxy-rules-test.js | 152 +++++ .../passes/report-left-recursion-test.js | 40 ++ .../passes/report-missing-rules-test.js | 37 ++ test/index.html | 6 +- test/run | 6 +- 14 files changed, 1041 insertions(+), 1013 deletions(-) create mode 100644 src/compiler/passes/compute-params.js create mode 100644 src/compiler/passes/compute-var-names.js create mode 100644 src/compiler/passes/remove-proxy-rules.js create mode 100644 src/compiler/passes/report-left-recursion.js create mode 100644 src/compiler/passes/report-missing-rules.js delete mode 100644 test/compiler/passes-test.js create mode 100644 test/compiler/passes/compute-params-test.js create mode 100644 test/compiler/passes/compute-var-names-test.js create mode 100644 test/compiler/passes/remove-proxy-rules-test.js create mode 100644 test/compiler/passes/report-left-recursion-test.js create mode 100644 test/compiler/passes/report-missing-rules-test.js diff --git a/src/compiler/passes.js b/src/compiler/passes.js index 773c40f..9ca5205 100644 --- a/src/compiler/passes.js +++ b/src/compiler/passes.js @@ -5,408 +5,10 @@ * or modify it as needed. If the pass encounters a semantic error, it throws * |PEG.GrammarError|. */ -PEG.compiler.passes = { - /* Checks that all referenced rules exist. */ - reportMissingRules: function(ast) { - function nop() {} +PEG.compiler.passes = {}; - function checkExpression(node) { check(node.expression); } - - function checkSubnodes(propertyName) { - return function(node) { each(node[propertyName], check); }; - } - - var check = buildNodeVisitor({ - grammar: checkSubnodes("rules"), - rule: checkExpression, - choice: checkSubnodes("alternatives"), - sequence: checkSubnodes("elements"), - labeled: checkExpression, - simple_and: checkExpression, - simple_not: checkExpression, - semantic_and: nop, - semantic_not: nop, - optional: checkExpression, - zero_or_more: checkExpression, - one_or_more: checkExpression, - action: checkExpression, - - rule_ref: - function(node) { - if (!findRuleByName(ast, node.name)) { - throw new PEG.GrammarError( - "Referenced rule \"" + node.name + "\" does not exist." - ); - } - }, - - literal: nop, - any: nop, - "class": nop - }); - - check(ast); - }, - - /* Checks that no left recursion is present. */ - reportLeftRecursion: function(ast) { - function nop() {} - - function checkExpression(node, appliedRules) { - check(node.expression, appliedRules); - } - - function checkSubnodes(propertyName) { - return function(node, appliedRules) { - each(node[propertyName], function(subnode) { - check(subnode, appliedRules); - }); - }; - } - - var check = buildNodeVisitor({ - grammar: checkSubnodes("rules"), - - rule: - function(node, appliedRules) { - check(node.expression, appliedRules.concat(node.name)); - }, - - choice: checkSubnodes("alternatives"), - - sequence: - function(node, appliedRules) { - if (node.elements.length > 0) { - check(node.elements[0], appliedRules); - } - }, - - labeled: checkExpression, - simple_and: checkExpression, - simple_not: checkExpression, - semantic_and: nop, - semantic_not: nop, - optional: checkExpression, - zero_or_more: checkExpression, - one_or_more: checkExpression, - action: checkExpression, - - rule_ref: - function(node, appliedRules) { - if (contains(appliedRules, node.name)) { - throw new PEG.GrammarError( - "Left recursion detected for rule \"" + node.name + "\"." - ); - } - check(findRuleByName(ast, node.name), appliedRules); - }, - - literal: nop, - any: nop, - "class": nop - }); - - check(ast, []); - }, - - /* - * Removes proxy rules -- that is, rules that only delegate to other rule. - */ - removeProxyRules: function(ast) { - function isProxyRule(node) { - return node.type === "rule" && node.expression.type === "rule_ref"; - } - - function replaceRuleRefs(ast, from, to) { - function nop() {} - - function replaceInExpression(node, from, to) { - replace(node.expression, from, to); - } - - function replaceInSubnodes(propertyName) { - return function(node, from, to) { - each(node[propertyName], function(subnode) { - replace(subnode, from, to); - }); - }; - } - - var replace = buildNodeVisitor({ - grammar: replaceInSubnodes("rules"), - rule: replaceInExpression, - choice: replaceInSubnodes("alternatives"), - sequence: replaceInSubnodes("elements"), - labeled: replaceInExpression, - simple_and: replaceInExpression, - simple_not: replaceInExpression, - semantic_and: nop, - semantic_not: nop, - optional: replaceInExpression, - zero_or_more: replaceInExpression, - one_or_more: replaceInExpression, - action: replaceInExpression, - - rule_ref: - function(node, from, to) { - if (node.name === from) { - node.name = to; - } - }, - - literal: nop, - any: nop, - "class": nop - }); - - replace(ast, from, to); - } - - var indices = []; - - each(ast.rules, function(rule, i) { - if (isProxyRule(rule)) { - replaceRuleRefs(ast, rule.name, rule.expression.name); - if (rule.name === ast.startRule) { - ast.startRule = rule.expression.name; - } - indices.push(i); - } - }); - - indices.reverse(); - - each(indices, function(index) { - ast.rules.splice(index, 1); - }); - }, - - /* - * Computes names of variables used for storing match results and parse - * positions in generated code. These variables are organized as two stacks. - * The following will hold after running this pass: - * - * * All nodes except "grammar" and "rule" nodes will have a |resultVar| - * property. It will contain a name of the variable that will store a - * match result of the expression represented by the node in generated - * code. - * - * * Some nodes will have a |posVar| property. It will contain a name of the - * variable that will store a parse position in generated code. - * - * * All "rule" nodes will contain |resultVars| and |posVars| properties. - * They will contain a list of values of |resultVar| and |posVar| - * properties used in rule's subnodes. (This is useful to declare - * variables in generated code.) - */ - computeVarNames: function(ast) { - function resultVar(index) { return "result" + index; } - function posVar(index) { return "pos" + index; } - - function computeLeaf(node, index) { - node.resultVar = resultVar(index.result); - - return { result: 0, pos: 0 }; - } - - function computeFromExpression(delta) { - return function(node, index) { - var depth = compute( - node.expression, - { - result: index.result + delta.result, - pos: index.pos + delta.pos - } - ); - - node.resultVar = resultVar(index.result); - if (delta.pos !== 0) { - node.posVar = posVar(index.pos); - } - - return { - result: depth.result + delta.result, - pos: depth.pos + delta.pos - }; - }; - } - - var compute = buildNodeVisitor({ - grammar: - function(node, index) { - each(node.rules, function(node) { - compute(node, index); - }); - }, - - rule: - function(node, index) { - var depth = compute(node.expression, index); - - node.resultVar = resultVar(index.result); - node.resultVars = map(range(depth.result + 1), resultVar); - node.posVars = map(range(depth.pos), posVar); - }, - - choice: - function(node, index) { - var depths = map(node.alternatives, function(alternative) { - return compute(alternative, index); - }); - - node.resultVar = resultVar(index.result); - - return { - result: Math.max.apply(null, pluck(depths, "result")), - pos: Math.max.apply(null, pluck(depths, "pos")) - }; - }, - - sequence: - function(node, index) { - var depths = map(node.elements, function(element, i) { - return compute( - element, - { result: index.result + i, pos: index.pos + 1 } - ); - }); - - node.resultVar = resultVar(index.result); - node.posVar = posVar(index.pos); - - return { - result: - node.elements.length > 0 - ? Math.max.apply( - null, - map(depths, function(d, i) { return i + d.result; }) - ) - : 0, - - pos: - node.elements.length > 0 - ? 1 + Math.max.apply(null, pluck(depths, "pos")) - : 1 - }; - }, - - labeled: computeFromExpression({ result: 0, pos: 0 }), - simple_and: computeFromExpression({ result: 0, pos: 1 }), - simple_not: computeFromExpression({ result: 0, pos: 1 }), - semantic_and: computeLeaf, - semantic_not: computeLeaf, - optional: computeFromExpression({ result: 0, pos: 0 }), - zero_or_more: computeFromExpression({ result: 1, pos: 0 }), - one_or_more: computeFromExpression({ result: 1, pos: 0 }), - action: computeFromExpression({ result: 0, pos: 1 }), - rule_ref: computeLeaf, - literal: computeLeaf, - any: computeLeaf, - "class": computeLeaf - }); - - compute(ast, { result: 0, pos: 0 }); - }, - - /* - * This pass walks through the AST and tracks what labels are visible at each - * point. For "action", "semantic_and" and "semantic_or" nodes it computes - * parameter names and values for the function used in generated code. (In the - * emitter, user's code is wrapped into a function that is immediately - * executed. Its parameter names correspond to visible labels and its - * parameter values to their captured values). Implicitly, this pass defines - * scoping rules for labels. - * - * After running this pass, all "action", "semantic_and" and "semantic_or" - * nodes will have a |params| property containing an object mapping parameter - * names to the expressions that will be used as their values. - */ - computeParams: function(ast) { - var envs = []; - - function scoped(f) { - envs.push({}); - f(); - envs.pop(); - } - - function nop() {} - - function computeForScopedExpression(node) { - scoped(function() { compute(node.expression); }); - } - - function computeParams(node) { - var env = envs[envs.length - 1], params = {}, name; - - for (name in env) { - params[name] = env[name]; - } - node.params = params; - } - - var compute = buildNodeVisitor({ - grammar: - function(node) { - each(node.rules, compute); - }, - - rule: computeForScopedExpression, - - choice: - function(node) { - scoped(function() { each(node.alternatives, compute); }); - }, - - sequence: - function(node) { - var env = envs[envs.length - 1], name; - - function fixup(name) { - each(pluck(node.elements, "resultVar"), function(resultVar, i) { - if ((new RegExp("^" + resultVar + "(\\[\\d+\\])*$")).test(env[name])) { - env[name] = node.resultVar + "[" + i + "]" - + env[name].substr(resultVar.length); - } - }); - } - - each(node.elements, compute); - - for (name in env) { - fixup(name); - } - }, - - labeled: - function(node) { - envs[envs.length - 1][node.label] = node.resultVar; - - scoped(function() { compute(node.expression); }); - }, - - simple_and: computeForScopedExpression, - simple_not: computeForScopedExpression, - semantic_and: computeParams, - semantic_not: computeParams, - optional: computeForScopedExpression, - zero_or_more: computeForScopedExpression, - one_or_more: computeForScopedExpression, - - action: - function(node) { - scoped(function() { - compute(node.expression); - computeParams(node); - }); - }, - - rule_ref: nop, - literal: nop, - any: nop, - "class": nop - }); - - compute(ast); - } -}; +// @include "passes/report-missing-rules.js" +// @include "passes/report-left-recursion.js" +// @include "passes/remove-proxy-rules.js" +// @include "passes/compute-var-names.js" +// @include "passes/compute-params.js" diff --git a/src/compiler/passes/compute-params.js b/src/compiler/passes/compute-params.js new file mode 100644 index 0000000..7c48ecd --- /dev/null +++ b/src/compiler/passes/compute-params.js @@ -0,0 +1,101 @@ +/* + * This pass walks through the AST and tracks what labels are visible at each + * point. For "action", "semantic_and" and "semantic_or" nodes it computes + * parameter names and values for the function used in generated code. (In the + * emitter, user's code is wrapped into a function that is immediately executed. + * Its parameter names correspond to visible labels and its parameter values to + * their captured values). Implicitly, this pass defines scoping rules for + * labels. + * + * After running this pass, all "action", "semantic_and" and "semantic_or" nodes + * will have a |params| property containing an object mapping parameter names to + * the expressions that will be used as their values. + */ +PEG.compiler.passes.computeParams = function(ast) { + var envs = []; + + function scoped(f) { + envs.push({}); + f(); + envs.pop(); + } + + function nop() {} + + function computeForScopedExpression(node) { + scoped(function() { compute(node.expression); }); + } + + function computeParams(node) { + var env = envs[envs.length - 1], params = {}, name; + + for (name in env) { + params[name] = env[name]; + } + node.params = params; + } + + var compute = buildNodeVisitor({ + grammar: + function(node) { + each(node.rules, compute); + }, + + rule: computeForScopedExpression, + + choice: + function(node) { + scoped(function() { each(node.alternatives, compute); }); + }, + + sequence: + function(node) { + var env = envs[envs.length - 1], name; + + function fixup(name) { + each(pluck(node.elements, "resultVar"), function(resultVar, i) { + if ((new RegExp("^" + resultVar + "(\\[\\d+\\])*$")).test(env[name])) { + env[name] = node.resultVar + "[" + i + "]" + + env[name].substr(resultVar.length); + } + }); + } + + each(node.elements, compute); + + for (name in env) { + fixup(name); + } + }, + + labeled: + function(node) { + envs[envs.length - 1][node.label] = node.resultVar; + + scoped(function() { compute(node.expression); }); + }, + + simple_and: computeForScopedExpression, + simple_not: computeForScopedExpression, + semantic_and: computeParams, + semantic_not: computeParams, + optional: computeForScopedExpression, + zero_or_more: computeForScopedExpression, + one_or_more: computeForScopedExpression, + + action: + function(node) { + scoped(function() { + compute(node.expression); + computeParams(node); + }); + }, + + rule_ref: nop, + literal: nop, + any: nop, + "class": nop + }); + + compute(ast); +}; diff --git a/src/compiler/passes/compute-var-names.js b/src/compiler/passes/compute-var-names.js new file mode 100644 index 0000000..d7f1613 --- /dev/null +++ b/src/compiler/passes/compute-var-names.js @@ -0,0 +1,125 @@ +/* + * Computes names of variables used for storing match results and parse + * positions in generated code. These variables are organized as two stacks. + * The following will hold after running this pass: + * + * * All nodes except "grammar" and "rule" nodes will have a |resultVar| + * property. It will contain a name of the variable that will store a match + * result of the expression represented by the node in generated code. + * + * * Some nodes will have a |posVar| property. It will contain a name of the + * variable that will store a parse position in generated code. + * + * * All "rule" nodes will contain |resultVars| and |posVars| properties. + * They will contain a list of values of |resultVar| and |posVar| properties + * used in rule's subnodes. (This is useful to declare variables in + * generated code.) + */ +PEG.compiler.passes.computeVarNames = function(ast) { + function resultVar(index) { return "result" + index; } + function posVar(index) { return "pos" + index; } + + function computeLeaf(node, index) { + node.resultVar = resultVar(index.result); + + return { result: 0, pos: 0 }; + } + + function computeFromExpression(delta) { + return function(node, index) { + var depth = compute( + node.expression, + { + result: index.result + delta.result, + pos: index.pos + delta.pos + } + ); + + node.resultVar = resultVar(index.result); + if (delta.pos !== 0) { + node.posVar = posVar(index.pos); + } + + return { + result: depth.result + delta.result, + pos: depth.pos + delta.pos + }; + }; + } + + var compute = buildNodeVisitor({ + grammar: + function(node, index) { + each(node.rules, function(node) { + compute(node, index); + }); + }, + + rule: + function(node, index) { + var depth = compute(node.expression, index); + + node.resultVar = resultVar(index.result); + node.resultVars = map(range(depth.result + 1), resultVar); + node.posVars = map(range(depth.pos), posVar); + }, + + choice: + function(node, index) { + var depths = map(node.alternatives, function(alternative) { + return compute(alternative, index); + }); + + node.resultVar = resultVar(index.result); + + return { + result: Math.max.apply(null, pluck(depths, "result")), + pos: Math.max.apply(null, pluck(depths, "pos")) + }; + }, + + sequence: + function(node, index) { + var depths = map(node.elements, function(element, i) { + return compute( + element, + { result: index.result + i, pos: index.pos + 1 } + ); + }); + + node.resultVar = resultVar(index.result); + node.posVar = posVar(index.pos); + + return { + result: + node.elements.length > 0 + ? Math.max.apply( + null, + map(depths, function(d, i) { return i + d.result; }) + ) + : 0, + + pos: + node.elements.length > 0 + ? 1 + Math.max.apply(null, pluck(depths, "pos")) + : 1 + }; + }, + + labeled: computeFromExpression({ result: 0, pos: 0 }), + simple_and: computeFromExpression({ result: 0, pos: 1 }), + simple_not: computeFromExpression({ result: 0, pos: 1 }), + semantic_and: computeLeaf, + semantic_not: computeLeaf, + optional: computeFromExpression({ result: 0, pos: 0 }), + zero_or_more: computeFromExpression({ result: 1, pos: 0 }), + one_or_more: computeFromExpression({ result: 1, pos: 0 }), + action: computeFromExpression({ result: 0, pos: 1 }), + rule_ref: computeLeaf, + literal: computeLeaf, + any: computeLeaf, + "class": computeLeaf + }); + + compute(ast, { result: 0, pos: 0 }); +}; diff --git a/src/compiler/passes/remove-proxy-rules.js b/src/compiler/passes/remove-proxy-rules.js new file mode 100644 index 0000000..862118f --- /dev/null +++ b/src/compiler/passes/remove-proxy-rules.js @@ -0,0 +1,71 @@ +/* + * Removes proxy rules -- that is, rules that only delegate to other rule. + */ +PEG.compiler.passes.removeProxyRules = function(ast) { + function isProxyRule(node) { + return node.type === "rule" && node.expression.type === "rule_ref"; + } + + function replaceRuleRefs(ast, from, to) { + function nop() {} + + function replaceInExpression(node, from, to) { + replace(node.expression, from, to); + } + + function replaceInSubnodes(propertyName) { + return function(node, from, to) { + each(node[propertyName], function(subnode) { + replace(subnode, from, to); + }); + }; + } + + var replace = buildNodeVisitor({ + grammar: replaceInSubnodes("rules"), + rule: replaceInExpression, + choice: replaceInSubnodes("alternatives"), + sequence: replaceInSubnodes("elements"), + labeled: replaceInExpression, + simple_and: replaceInExpression, + simple_not: replaceInExpression, + semantic_and: nop, + semantic_not: nop, + optional: replaceInExpression, + zero_or_more: replaceInExpression, + one_or_more: replaceInExpression, + action: replaceInExpression, + + rule_ref: + function(node, from, to) { + if (node.name === from) { + node.name = to; + } + }, + + literal: nop, + any: nop, + "class": nop + }); + + replace(ast, from, to); + } + + var indices = []; + + each(ast.rules, function(rule, i) { + if (isProxyRule(rule)) { + replaceRuleRefs(ast, rule.name, rule.expression.name); + if (rule.name === ast.startRule) { + ast.startRule = rule.expression.name; + } + indices.push(i); + } + }); + + indices.reverse(); + + each(indices, function(index) { + ast.rules.splice(index, 1); + }); +}; diff --git a/src/compiler/passes/report-left-recursion.js b/src/compiler/passes/report-left-recursion.js new file mode 100644 index 0000000..8c46b22 --- /dev/null +++ b/src/compiler/passes/report-left-recursion.js @@ -0,0 +1,60 @@ +/* Checks that no left recursion is present. */ +PEG.compiler.passes.reportLeftRecursion = function(ast) { + function nop() {} + + function checkExpression(node, appliedRules) { + check(node.expression, appliedRules); + } + + function checkSubnodes(propertyName) { + return function(node, appliedRules) { + each(node[propertyName], function(subnode) { + check(subnode, appliedRules); + }); + }; + } + + var check = buildNodeVisitor({ + grammar: checkSubnodes("rules"), + + rule: + function(node, appliedRules) { + check(node.expression, appliedRules.concat(node.name)); + }, + + choice: checkSubnodes("alternatives"), + + sequence: + function(node, appliedRules) { + if (node.elements.length > 0) { + check(node.elements[0], appliedRules); + } + }, + + labeled: checkExpression, + simple_and: checkExpression, + simple_not: checkExpression, + semantic_and: nop, + semantic_not: nop, + optional: checkExpression, + zero_or_more: checkExpression, + one_or_more: checkExpression, + action: checkExpression, + + rule_ref: + function(node, appliedRules) { + if (contains(appliedRules, node.name)) { + throw new PEG.GrammarError( + "Left recursion detected for rule \"" + node.name + "\"." + ); + } + check(findRuleByName(ast, node.name), appliedRules); + }, + + literal: nop, + any: nop, + "class": nop + }); + + check(ast, []); +}; diff --git a/src/compiler/passes/report-missing-rules.js b/src/compiler/passes/report-missing-rules.js new file mode 100644 index 0000000..d0a37ae --- /dev/null +++ b/src/compiler/passes/report-missing-rules.js @@ -0,0 +1,41 @@ +/* Checks that all referenced rules exist. */ +PEG.compiler.passes.reportMissingRules = function(ast) { + function nop() {} + + function checkExpression(node) { check(node.expression); } + + function checkSubnodes(propertyName) { + return function(node) { each(node[propertyName], check); }; + } + + var check = buildNodeVisitor({ + grammar: checkSubnodes("rules"), + rule: checkExpression, + choice: checkSubnodes("alternatives"), + sequence: checkSubnodes("elements"), + labeled: checkExpression, + simple_and: checkExpression, + simple_not: checkExpression, + semantic_and: nop, + semantic_not: nop, + optional: checkExpression, + zero_or_more: checkExpression, + one_or_more: checkExpression, + action: checkExpression, + + rule_ref: + function(node) { + if (!findRuleByName(ast, node.name)) { + throw new PEG.GrammarError( + "Referenced rule \"" + node.name + "\" does not exist." + ); + } + }, + + literal: nop, + any: nop, + "class": nop + }); + + check(ast); +}; diff --git a/test/compiler/passes-test.js b/test/compiler/passes-test.js deleted file mode 100644 index 9e9104b..0000000 --- a/test/compiler/passes-test.js +++ /dev/null @@ -1,607 +0,0 @@ -(function() { - -module("PEG.compiler.passes"); - -test("reports missing referenced rules", function() { - function testGrammar(grammar) { - raises( - function() { - var ast = PEG.parser.parse(grammar); - PEG.compiler.passes.reportMissingRules(ast); - }, - function(e) { - return e instanceof PEG.GrammarError - && e.message === "Referenced rule \"missing\" does not exist."; - } - ); - } - - var grammars = [ - 'start = missing', - 'start = missing / "a" / "b"', - 'start = "a" / "b" / missing', - 'start = missing "a" "b"', - 'start = "a" "b" missing', - 'start = label:missing', - 'start = &missing', - 'start = !missing', - 'start = missing?', - 'start = missing*', - 'start = missing+', - 'start = missing { }' - ]; - - for (var i = 0; i < grammars.length; i++) { testGrammar(grammars[i]); } -}); - -test("reports left recursion", function() { - function testGrammar(grammar) { - raises( - function() { - var ast = PEG.parser.parse(grammar); - PEG.compiler.passes.reportLeftRecursion(ast); - }, - function(e) { - return e instanceof PEG.GrammarError - && e.message === "Left recursion detected for rule \"start\"."; - } - ); - } - - var grammars = [ - /* Direct */ - 'start = start', - 'start = start / "a" / "b"', - 'start = "a" / "b" / start', - 'start = start "a" "b"', - 'start = label:start', - 'start = &start', - 'start = !start', - 'start = start?', - 'start = start*', - 'start = start+', - 'start = start { }', - - /* Indirect */ - 'start = stop; stop = start' - ]; - - for (var i = 0; i < grammars.length; i++) { testGrammar(grammars[i]); } -}); - -test("removes proxy rules", function() { - function simpleGrammar(rules, startRule) { - return { - type: "grammar", - initializer: null, - rules: rules, - startRule: startRule - }; - } - - var proxiedRule = { - type: "rule", - name: "proxied", - displayName: null, - expression: { type: "literal", value: "a", ignoreCase: false } - }; - - var proxiedRuleRef = { - type: "rule_ref", - name: "proxied" - }; - - function simpleGrammarWithStartAndProxied(startRuleExpression) { - return simpleGrammar( - [ - { - type: "rule", - name: "start", - displayName: null, - expression: startRuleExpression - }, - proxiedRule - ], - "start" - ); - } - - var cases = [ - { - grammar: 'start = proxy; proxy = proxied; proxied = "a"', - ast: simpleGrammar([proxiedRule], "proxied") - }, - { - grammar: 'start = proxy / "a" / "b"; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "choice", - alternatives: [ - proxiedRuleRef, - { type: "literal", value: "a", ignoreCase: false }, - { type: "literal", value: "b", ignoreCase: false } - ] - }) - }, - { - grammar: 'start = "a" / "b" / proxy; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "choice", - alternatives: [ - { type: "literal", value: "a", ignoreCase: false }, - { type: "literal", value: "b", ignoreCase: false }, - proxiedRuleRef - ] - }) - }, - { - grammar: 'start = proxy "a" "b"; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "sequence", - elements: [ - proxiedRuleRef, - { type: "literal", value: "a", ignoreCase: false }, - { type: "literal", value: "b", ignoreCase: false } - ] - }) - }, - { - grammar: 'start = "a" "b" proxy; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "sequence", - elements: [ - { type: "literal", value: "a", ignoreCase: false }, - { type: "literal", value: "b", ignoreCase: false }, - proxiedRuleRef - ] - }) - }, - { - grammar: 'start = label:proxy; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "labeled", - label: "label", - expression: proxiedRuleRef - }) - }, - { - grammar: 'start = &proxy; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "simple_and", - expression: proxiedRuleRef - }) - }, - { - grammar: 'start = !proxy; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "simple_not", - expression: proxiedRuleRef - }) - }, - { - grammar: 'start = proxy?; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "optional", - expression: proxiedRuleRef - }) - }, - { - grammar: 'start = proxy*; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "zero_or_more", - expression: proxiedRuleRef - }) - }, - { - grammar: 'start = proxy+; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "one_or_more", - expression: proxiedRuleRef - }) - }, - { - grammar: 'start = proxy { }; proxy = proxied; proxied = "a"', - ast: simpleGrammarWithStartAndProxied({ - type: "action", - code: " ", - expression: proxiedRuleRef - }) - } - ]; - - for (var i = 0; i < cases.length; i++) { - var ast = PEG.parser.parse(cases[i].grammar); - PEG.compiler.passes.removeProxyRules(ast); - - deepEqual(ast, cases[i].ast); - } -}); - -test("computes variable names", function() { - var leafDetails = { resultVar: "result0" }, - choiceDetails = { - resultVar: "result0", - alternatives: [ - { resultVar: "result0", posVar: "pos0" }, - { resultVar: "result0", posVar: "pos0" }, - { resultVar: "result0", posVar: "pos0" } - ] - }, - sequenceDetails = { - resultVar: "result0", - posVar: "pos0", - elements: [ - { resultVar: "result0", posVar: "pos1" }, - { resultVar: "result1", posVar: "pos1" }, - { resultVar: "result2", posVar: "pos1" } - ] - }; - - var cases = [ - /* Choice */ - { - grammar: 'start = &"a" / &"b" / &"c"', - resultVars: ["result0"], - posVars: ["pos0"], - details: choiceDetails - }, - { - grammar: 'start = &"a" / &"b"* / &"c"', - resultVars: ["result0", "result1"], - posVars: ["pos0"], - details: choiceDetails - }, - { - grammar: 'start = &"a" / &(&"b") / &"c"', - resultVars: ["result0"], - posVars: ["pos0", "pos1"], - details: choiceDetails - }, - - /* Sequence */ - { - grammar: 'start = ', - resultVars: ["result0"], - posVars: ["pos0"], - details: { resultVar: "result0", posVar: "pos0" } - }, - { - grammar: 'start = &"a" &"b" &"c"', - resultVars: ["result0", "result1", "result2"], - posVars: ["pos0", "pos1"], - details: sequenceDetails - }, - { - grammar: 'start = &"a" &"b" &"c"*', - resultVars: ["result0", "result1", "result2", "result3"], - posVars: ["pos0", "pos1"], - details: sequenceDetails - }, - { - grammar: 'start = &"a" &"b"* &"c"', - resultVars: ["result0", "result1", "result2"], - posVars: ["pos0", "pos1"], - details: sequenceDetails - }, - { - grammar: 'start = &"a" &("b"*)* &"c"', - resultVars: ["result0", "result1", "result2", "result3"], - posVars: ["pos0", "pos1"], - details: sequenceDetails - }, - { - grammar: 'start = &"a"* &"b" &"c"', - resultVars: ["result0", "result1", "result2"], - posVars: ["pos0", "pos1"], - details: sequenceDetails - }, - { - grammar: 'start = &("a"*)* &"b" &"c"', - resultVars: ["result0", "result1", "result2"], - posVars: ["pos0", "pos1"], - details: sequenceDetails - }, - { - grammar: 'start = &(("a"*)*)* &"b" &"c"', - resultVars: ["result0", "result1", "result2", "result3"], - posVars: ["pos0", "pos1"], - details: sequenceDetails - }, - { - grammar: 'start = &"a" &(&"b") &"c"', - resultVars: ["result0", "result1", "result2"], - posVars: ["pos0", "pos1", "pos2"], - details: sequenceDetails - }, - - /* Others */ - { - grammar: 'start = label:&"a"', - resultVars: ["result0"], - posVars: ["pos0"], - details: { - resultVar: "result0", - expression: { resultVar: "result0", posVar: "pos0" } - } - }, - { - grammar: 'start = &(&"a")', - resultVars: ["result0"], - posVars: ["pos0", "pos1"], - details: { - resultVar: "result0", - posVar: "pos0", - expression: { resultVar: "result0", posVar: "pos1" } - } - }, - { - grammar: 'start = !(&"a")', - resultVars: ["result0"], - posVars: ["pos0", "pos1"], - details: { - resultVar: "result0", - posVar: "pos0", - expression: { resultVar: "result0", posVar: "pos1" } - } - }, - { - grammar: 'start = &{ code }', - resultVars: ["result0"], - posVars: [], - details: leafDetails - }, - { - grammar: 'start = !{ code }', - resultVars: ["result0"], - posVars: [], - details: leafDetails - }, - { - grammar: 'start = (&"a")?', - resultVars: ["result0"], - posVars: ["pos0"], - details: { - resultVar: "result0", - expression: { resultVar: "result0", posVar: "pos0" } - } - }, - { - grammar: 'start = (&"a")*', - resultVars: ["result0", "result1"], - posVars: ["pos0"], - details: { - resultVar: "result0", - expression: { resultVar: "result1", posVar: "pos0" } - } - }, - { - grammar: 'start = (&"a")+', - resultVars: ["result0", "result1"], - posVars: ["pos0"], - details: { - resultVar: "result0", - expression: { resultVar: "result1", posVar: "pos0" } - } - }, - { - grammar: 'start = &"a" { code }', - resultVars: ["result0"], - posVars: ["pos0", "pos1"], - details: { - resultVar: "result0", - posVar: "pos0", - expression: { resultVar: "result0", posVar: "pos1" } - } - }, - { - grammar: 'start = a', - resultVars: ["result0"], - posVars: [], - details: leafDetails - }, - { - grammar: 'start = "a"', - resultVars: ["result0"], - posVars: [], - details: leafDetails - }, - { - grammar: 'start = .', - resultVars: ["result0"], - posVars: [], - details: leafDetails - }, - { - grammar: 'start = [a-z]', - resultVars: ["result0"], - posVars: [], - details: leafDetails - } - ]; - - function checkDetails(node, details) { - for (var key in details) { - if (Object.prototype.toString.call(details[key]) === "[object Array]") { - for (var i = 0; i < details[key].length; i++) { - checkDetails(node[key][i], details[key][i]); - } - } else if (typeof details[key] === "object") { - checkDetails(node[key], details[key]); - } else { - strictEqual(node[key], details[key]); - } - } - } - - for (var i = 0; i < cases.length; i++) { - var ast = PEG.parser.parse(cases[i].grammar); - PEG.compiler.passes.computeVarNames(ast); - - deepEqual(ast.rules[0].resultVars, cases[i].resultVars); - deepEqual(ast.rules[0].posVars, cases[i].posVars); - checkDetails(ast.rules[0].expression, cases[i].details); - } -}); - -test("computes params", function() { - function extractNode(node) { return node; } - function extractExpression(node) { return node.expression; } - - var cases = [ - /* Bacics */ - { - grammar: 'start = a:"a" { }', - extractor: extractNode, - params: { a: "result0" } - }, - { - grammar: 'start = a:"a" &{ }', - extractor: function(node) { return node.elements[1]; }, - params: { a: "result0" } - }, - { - grammar: 'start = a:"a" !{ }', - extractor: function(node) { return node.elements[1]; }, - params: { a: "result0" } - }, - - /* Recursive walk */ - { - grammar: 'start = a:"a" { } / "b" / "c"', - extractor: function(node) { return node.alternatives[0]; }, - params: { a: "result0" } - }, - { - grammar: 'start = "a" / "b" / c:"c" { }', - extractor: function(node) { return node.alternatives[2]; }, - params: { c: "result0" } - }, - { - grammar: 'start = (a:"a" { }) "b" "c"', - extractor: function(node) { return node.elements[0]; }, - params: { a: "result0" } - }, - { - grammar: 'start = "a" "b" (c:"c" { })', - extractor: function(node) { return node.elements[2]; }, - params: { c: "result2" } - }, - { - grammar: 'start = a:(b:"b" { })', - extractor: extractExpression, - params: { b: "result0" } - }, - { - grammar: 'start = &(a:"a" { })', - extractor: extractExpression, - params: { a: "result0" } - }, - { - grammar: 'start = !(a:"a" { })', - extractor: extractExpression, - params: { a: "result0" } - }, - { - grammar: 'start = (a:"a" { })?', - extractor: extractExpression, - params: { a: "result0" } - }, - { - grammar: 'start = (a:"a" { })*', - extractor: extractExpression, - params: { a: "result1" } - }, - { - grammar: 'start = (a:"a" { })+', - extractor: extractExpression, - params: { a: "result1" } - }, - { - grammar: 'start = (a:"a" { }) { }', - extractor: extractExpression, - params: { a: "result0" } - }, - - /* Scoping */ - { - grammar: 'start = (a:"a" / b:"b" / c:"c") { }', - extractor: extractNode, - params: { } - }, - { - grammar: 'start = a:(b:"b") { }', - extractor: extractNode, - params: { a: "result0" } - }, - { - grammar: 'start = &(a:"a") { }', - extractor: extractNode, - params: { } - }, - { - grammar: 'start = !(a:"a") { }', - extractor: extractNode, - params: { } - }, - { - grammar: 'start = (a:"a")? { }', - extractor: extractNode, - params: { } - }, - { - grammar: 'start = (a:"a")* { }', - extractor: extractNode, - params: { } - }, - { - grammar: 'start = (a:"a")+ { }', - extractor: extractNode, - params: { } - }, - { - grammar: 'start = (a:"a" { }) { }', - extractor: extractNode, - params: { } - }, - - /* Sequences */ - { - grammar: 'start = a:"a" b:"b" c:"c" { }', - extractor: extractNode, - params: { a: "result0[0]", b: "result0[1]", c: "result0[2]" } - }, - { - grammar: 'start = a:"a" (b:"b" c:"c" d:"d") e:"e"{ }', - extractor: extractNode, - params: { - a: "result0[0]", - b: "result0[1][0]", - c: "result0[1][1]", - d: "result0[1][2]", - e: "result0[2]" - } - }, - /* - * Regression tests for a bug where e.g. resultVar names like |result10| - * were incorrectly treated as names derived from |result1|, leading to - * incorrect substitution. - */ - { - grammar: 'start = ("a" "b" "c" "d" "e" "f" "g" "h" "i" j:"j" { })*', - extractor: extractExpression, - params: { j: "result1[9]" } // Buggy code put "result1[0]0" here. - } - ]; - - for (var i = 0; i < cases.length; i++) { - var ast = PEG.parser.parse(cases[i].grammar); - PEG.compiler.passes.computeVarNames(ast); - PEG.compiler.passes.computeParams(ast); - - deepEqual( - cases[i].extractor(ast.rules[0].expression).params, - cases[i].params - ); - } -}); - -})(); diff --git a/test/compiler/passes/compute-params-test.js b/test/compiler/passes/compute-params-test.js new file mode 100644 index 0000000..2f02afe --- /dev/null +++ b/test/compiler/passes/compute-params-test.js @@ -0,0 +1,167 @@ +(function() { + +module("PEG.compiler.passes.computeParams"); + +test("computes params", function() { + function extractNode(node) { return node; } + function extractExpression(node) { return node.expression; } + + var cases = [ + /* Bacics */ + { + grammar: 'start = a:"a" { }', + extractor: extractNode, + params: { a: "result0" } + }, + { + grammar: 'start = a:"a" &{ }', + extractor: function(node) { return node.elements[1]; }, + params: { a: "result0" } + }, + { + grammar: 'start = a:"a" !{ }', + extractor: function(node) { return node.elements[1]; }, + params: { a: "result0" } + }, + + /* Recursive walk */ + { + grammar: 'start = a:"a" { } / "b" / "c"', + extractor: function(node) { return node.alternatives[0]; }, + params: { a: "result0" } + }, + { + grammar: 'start = "a" / "b" / c:"c" { }', + extractor: function(node) { return node.alternatives[2]; }, + params: { c: "result0" } + }, + { + grammar: 'start = (a:"a" { }) "b" "c"', + extractor: function(node) { return node.elements[0]; }, + params: { a: "result0" } + }, + { + grammar: 'start = "a" "b" (c:"c" { })', + extractor: function(node) { return node.elements[2]; }, + params: { c: "result2" } + }, + { + grammar: 'start = a:(b:"b" { })', + extractor: extractExpression, + params: { b: "result0" } + }, + { + grammar: 'start = &(a:"a" { })', + extractor: extractExpression, + params: { a: "result0" } + }, + { + grammar: 'start = !(a:"a" { })', + extractor: extractExpression, + params: { a: "result0" } + }, + { + grammar: 'start = (a:"a" { })?', + extractor: extractExpression, + params: { a: "result0" } + }, + { + grammar: 'start = (a:"a" { })*', + extractor: extractExpression, + params: { a: "result1" } + }, + { + grammar: 'start = (a:"a" { })+', + extractor: extractExpression, + params: { a: "result1" } + }, + { + grammar: 'start = (a:"a" { }) { }', + extractor: extractExpression, + params: { a: "result0" } + }, + + /* Scoping */ + { + grammar: 'start = (a:"a" / b:"b" / c:"c") { }', + extractor: extractNode, + params: { } + }, + { + grammar: 'start = a:(b:"b") { }', + extractor: extractNode, + params: { a: "result0" } + }, + { + grammar: 'start = &(a:"a") { }', + extractor: extractNode, + params: { } + }, + { + grammar: 'start = !(a:"a") { }', + extractor: extractNode, + params: { } + }, + { + grammar: 'start = (a:"a")? { }', + extractor: extractNode, + params: { } + }, + { + grammar: 'start = (a:"a")* { }', + extractor: extractNode, + params: { } + }, + { + grammar: 'start = (a:"a")+ { }', + extractor: extractNode, + params: { } + }, + { + grammar: 'start = (a:"a" { }) { }', + extractor: extractNode, + params: { } + }, + + /* Sequences */ + { + grammar: 'start = a:"a" b:"b" c:"c" { }', + extractor: extractNode, + params: { a: "result0[0]", b: "result0[1]", c: "result0[2]" } + }, + { + grammar: 'start = a:"a" (b:"b" c:"c" d:"d") e:"e"{ }', + extractor: extractNode, + params: { + a: "result0[0]", + b: "result0[1][0]", + c: "result0[1][1]", + d: "result0[1][2]", + e: "result0[2]" + } + }, + /* + * Regression tests for a bug where e.g. resultVar names like |result10| + * were incorrectly treated as names derived from |result1|, leading to + * incorrect substitution. + */ + { + grammar: 'start = ("a" "b" "c" "d" "e" "f" "g" "h" "i" j:"j" { })*', + extractor: extractExpression, + params: { j: "result1[9]" } // Buggy code put "result1[0]0" here. + } + ]; + + for (var i = 0; i < cases.length; i++) { + var ast = PEG.parser.parse(cases[i].grammar); + PEG.compiler.passes.computeVarNames(ast); + PEG.compiler.passes.computeParams(ast); + + deepEqual( + cases[i].extractor(ast.rules[0].expression).params, + cases[i].params + ); + } +}); + +})(); diff --git a/test/compiler/passes/compute-var-names-test.js b/test/compiler/passes/compute-var-names-test.js new file mode 100644 index 0000000..1f75016 --- /dev/null +++ b/test/compiler/passes/compute-var-names-test.js @@ -0,0 +1,231 @@ +(function() { + +module("PEG.compiler.passes.computeVarNames"); + +test("computes variable names", function() { + var leafDetails = { resultVar: "result0" }, + choiceDetails = { + resultVar: "result0", + alternatives: [ + { resultVar: "result0", posVar: "pos0" }, + { resultVar: "result0", posVar: "pos0" }, + { resultVar: "result0", posVar: "pos0" } + ] + }, + sequenceDetails = { + resultVar: "result0", + posVar: "pos0", + elements: [ + { resultVar: "result0", posVar: "pos1" }, + { resultVar: "result1", posVar: "pos1" }, + { resultVar: "result2", posVar: "pos1" } + ] + }; + + var cases = [ + /* Choice */ + { + grammar: 'start = &"a" / &"b" / &"c"', + resultVars: ["result0"], + posVars: ["pos0"], + details: choiceDetails + }, + { + grammar: 'start = &"a" / &"b"* / &"c"', + resultVars: ["result0", "result1"], + posVars: ["pos0"], + details: choiceDetails + }, + { + grammar: 'start = &"a" / &(&"b") / &"c"', + resultVars: ["result0"], + posVars: ["pos0", "pos1"], + details: choiceDetails + }, + + /* Sequence */ + { + grammar: 'start = ', + resultVars: ["result0"], + posVars: ["pos0"], + details: { resultVar: "result0", posVar: "pos0" } + }, + { + grammar: 'start = &"a" &"b" &"c"', + resultVars: ["result0", "result1", "result2"], + posVars: ["pos0", "pos1"], + details: sequenceDetails + }, + { + grammar: 'start = &"a" &"b" &"c"*', + resultVars: ["result0", "result1", "result2", "result3"], + posVars: ["pos0", "pos1"], + details: sequenceDetails + }, + { + grammar: 'start = &"a" &"b"* &"c"', + resultVars: ["result0", "result1", "result2"], + posVars: ["pos0", "pos1"], + details: sequenceDetails + }, + { + grammar: 'start = &"a" &("b"*)* &"c"', + resultVars: ["result0", "result1", "result2", "result3"], + posVars: ["pos0", "pos1"], + details: sequenceDetails + }, + { + grammar: 'start = &"a"* &"b" &"c"', + resultVars: ["result0", "result1", "result2"], + posVars: ["pos0", "pos1"], + details: sequenceDetails + }, + { + grammar: 'start = &("a"*)* &"b" &"c"', + resultVars: ["result0", "result1", "result2"], + posVars: ["pos0", "pos1"], + details: sequenceDetails + }, + { + grammar: 'start = &(("a"*)*)* &"b" &"c"', + resultVars: ["result0", "result1", "result2", "result3"], + posVars: ["pos0", "pos1"], + details: sequenceDetails + }, + { + grammar: 'start = &"a" &(&"b") &"c"', + resultVars: ["result0", "result1", "result2"], + posVars: ["pos0", "pos1", "pos2"], + details: sequenceDetails + }, + + /* Others */ + { + grammar: 'start = label:&"a"', + resultVars: ["result0"], + posVars: ["pos0"], + details: { + resultVar: "result0", + expression: { resultVar: "result0", posVar: "pos0" } + } + }, + { + grammar: 'start = &(&"a")', + resultVars: ["result0"], + posVars: ["pos0", "pos1"], + details: { + resultVar: "result0", + posVar: "pos0", + expression: { resultVar: "result0", posVar: "pos1" } + } + }, + { + grammar: 'start = !(&"a")', + resultVars: ["result0"], + posVars: ["pos0", "pos1"], + details: { + resultVar: "result0", + posVar: "pos0", + expression: { resultVar: "result0", posVar: "pos1" } + } + }, + { + grammar: 'start = &{ code }', + resultVars: ["result0"], + posVars: [], + details: leafDetails + }, + { + grammar: 'start = !{ code }', + resultVars: ["result0"], + posVars: [], + details: leafDetails + }, + { + grammar: 'start = (&"a")?', + resultVars: ["result0"], + posVars: ["pos0"], + details: { + resultVar: "result0", + expression: { resultVar: "result0", posVar: "pos0" } + } + }, + { + grammar: 'start = (&"a")*', + resultVars: ["result0", "result1"], + posVars: ["pos0"], + details: { + resultVar: "result0", + expression: { resultVar: "result1", posVar: "pos0" } + } + }, + { + grammar: 'start = (&"a")+', + resultVars: ["result0", "result1"], + posVars: ["pos0"], + details: { + resultVar: "result0", + expression: { resultVar: "result1", posVar: "pos0" } + } + }, + { + grammar: 'start = &"a" { code }', + resultVars: ["result0"], + posVars: ["pos0", "pos1"], + details: { + resultVar: "result0", + posVar: "pos0", + expression: { resultVar: "result0", posVar: "pos1" } + } + }, + { + grammar: 'start = a', + resultVars: ["result0"], + posVars: [], + details: leafDetails + }, + { + grammar: 'start = "a"', + resultVars: ["result0"], + posVars: [], + details: leafDetails + }, + { + grammar: 'start = .', + resultVars: ["result0"], + posVars: [], + details: leafDetails + }, + { + grammar: 'start = [a-z]', + resultVars: ["result0"], + posVars: [], + details: leafDetails + } + ]; + + function checkDetails(node, details) { + for (var key in details) { + if (Object.prototype.toString.call(details[key]) === "[object Array]") { + for (var i = 0; i < details[key].length; i++) { + checkDetails(node[key][i], details[key][i]); + } + } else if (typeof details[key] === "object") { + checkDetails(node[key], details[key]); + } else { + strictEqual(node[key], details[key]); + } + } + } + + for (var i = 0; i < cases.length; i++) { + var ast = PEG.parser.parse(cases[i].grammar); + PEG.compiler.passes.computeVarNames(ast); + + deepEqual(ast.rules[0].resultVars, cases[i].resultVars); + deepEqual(ast.rules[0].posVars, cases[i].posVars); + checkDetails(ast.rules[0].expression, cases[i].details); + } +}); + +})(); diff --git a/test/compiler/passes/remove-proxy-rules-test.js b/test/compiler/passes/remove-proxy-rules-test.js new file mode 100644 index 0000000..ecb61f9 --- /dev/null +++ b/test/compiler/passes/remove-proxy-rules-test.js @@ -0,0 +1,152 @@ +(function() { + +module("PEG.compiler.passes.removeProxyRules"); + +test("removes proxy rules", function() { + function simpleGrammar(rules, startRule) { + return { + type: "grammar", + initializer: null, + rules: rules, + startRule: startRule + }; + } + + var proxiedRule = { + type: "rule", + name: "proxied", + displayName: null, + expression: { type: "literal", value: "a", ignoreCase: false } + }; + + var proxiedRuleRef = { + type: "rule_ref", + name: "proxied" + }; + + function simpleGrammarWithStartAndProxied(startRuleExpression) { + return simpleGrammar( + [ + { + type: "rule", + name: "start", + displayName: null, + expression: startRuleExpression + }, + proxiedRule + ], + "start" + ); + } + + var cases = [ + { + grammar: 'start = proxy; proxy = proxied; proxied = "a"', + ast: simpleGrammar([proxiedRule], "proxied") + }, + { + grammar: 'start = proxy / "a" / "b"; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "choice", + alternatives: [ + proxiedRuleRef, + { type: "literal", value: "a", ignoreCase: false }, + { type: "literal", value: "b", ignoreCase: false } + ] + }) + }, + { + grammar: 'start = "a" / "b" / proxy; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "choice", + alternatives: [ + { type: "literal", value: "a", ignoreCase: false }, + { type: "literal", value: "b", ignoreCase: false }, + proxiedRuleRef + ] + }) + }, + { + grammar: 'start = proxy "a" "b"; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "sequence", + elements: [ + proxiedRuleRef, + { type: "literal", value: "a", ignoreCase: false }, + { type: "literal", value: "b", ignoreCase: false } + ] + }) + }, + { + grammar: 'start = "a" "b" proxy; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "sequence", + elements: [ + { type: "literal", value: "a", ignoreCase: false }, + { type: "literal", value: "b", ignoreCase: false }, + proxiedRuleRef + ] + }) + }, + { + grammar: 'start = label:proxy; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "labeled", + label: "label", + expression: proxiedRuleRef + }) + }, + { + grammar: 'start = &proxy; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "simple_and", + expression: proxiedRuleRef + }) + }, + { + grammar: 'start = !proxy; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "simple_not", + expression: proxiedRuleRef + }) + }, + { + grammar: 'start = proxy?; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "optional", + expression: proxiedRuleRef + }) + }, + { + grammar: 'start = proxy*; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "zero_or_more", + expression: proxiedRuleRef + }) + }, + { + grammar: 'start = proxy+; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "one_or_more", + expression: proxiedRuleRef + }) + }, + { + grammar: 'start = proxy { }; proxy = proxied; proxied = "a"', + ast: simpleGrammarWithStartAndProxied({ + type: "action", + code: " ", + expression: proxiedRuleRef + }) + } + ]; + + for (var i = 0; i < cases.length; i++) { + var ast = PEG.parser.parse(cases[i].grammar); + PEG.compiler.passes.removeProxyRules(ast); + + deepEqual(ast, cases[i].ast); + } +}); + +})(); diff --git a/test/compiler/passes/report-left-recursion-test.js b/test/compiler/passes/report-left-recursion-test.js new file mode 100644 index 0000000..d41b12c --- /dev/null +++ b/test/compiler/passes/report-left-recursion-test.js @@ -0,0 +1,40 @@ +(function() { + +module("PEG.compiler.passes.reportLeftRecursion"); + +test("reports left recursion", function() { + function testGrammar(grammar) { + raises( + function() { + var ast = PEG.parser.parse(grammar); + PEG.compiler.passes.reportLeftRecursion(ast); + }, + function(e) { + return e instanceof PEG.GrammarError + && e.message === "Left recursion detected for rule \"start\"."; + } + ); + } + + var grammars = [ + /* Direct */ + 'start = start', + 'start = start / "a" / "b"', + 'start = "a" / "b" / start', + 'start = start "a" "b"', + 'start = label:start', + 'start = &start', + 'start = !start', + 'start = start?', + 'start = start*', + 'start = start+', + 'start = start { }', + + /* Indirect */ + 'start = stop; stop = start' + ]; + + for (var i = 0; i < grammars.length; i++) { testGrammar(grammars[i]); } +}); + +})(); diff --git a/test/compiler/passes/report-missing-rules-test.js b/test/compiler/passes/report-missing-rules-test.js new file mode 100644 index 0000000..17b6200 --- /dev/null +++ b/test/compiler/passes/report-missing-rules-test.js @@ -0,0 +1,37 @@ +(function() { + +module("PEG.compiler.passes.reportMissingRules"); + +test("reports missing referenced rules", function() { + function testGrammar(grammar) { + raises( + function() { + var ast = PEG.parser.parse(grammar); + PEG.compiler.passes.reportMissingRules(ast); + }, + function(e) { + return e instanceof PEG.GrammarError + && e.message === "Referenced rule \"missing\" does not exist."; + } + ); + } + + var grammars = [ + 'start = missing', + 'start = missing / "a" / "b"', + 'start = "a" / "b" / missing', + 'start = missing "a" "b"', + 'start = "a" "b" missing', + 'start = label:missing', + 'start = &missing', + 'start = !missing', + 'start = missing?', + 'start = missing*', + 'start = missing+', + 'start = missing { }' + ]; + + for (var i = 0; i < grammars.length; i++) { testGrammar(grammars[i]); } +}); + +})(); diff --git a/test/index.html b/test/index.html index 262b103..e6beba0 100644 --- a/test/index.html +++ b/test/index.html @@ -9,7 +9,11 @@ - + + + + +

PEG.js Test Suite

diff --git a/test/run b/test/run index 34d9159..d8fd56a 100755 --- a/test/run +++ b/test/run @@ -77,7 +77,11 @@ QUnit.done(function(details) { "helpers.js", "parser-test.js", "compiler-test.js", - "compiler/passes-test.js" + "compiler/passes/report-missing-rules-test.js", + "compiler/passes/report-left-recursion-test.js", + "compiler/passes/remove-proxy-rules-test.js", + "compiler/passes/compute-var-names-test.js", + "compiler/passes/compute-params-test.js" ].forEach(function(file) { eval("with (QUnit) {" + fs.readFileSync(__dirname + "/" + file, "utf8") + "}"); });