You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
956 lines
30 KiB
JavaScript
956 lines
30 KiB
JavaScript
/* PEG.js compiler. */
|
|
|
|
(function() {
|
|
|
|
function nop() {}
|
|
|
|
/* ===== PEG ===== */
|
|
|
|
/* no var */ PEG = {};
|
|
|
|
/*
|
|
* Generates a parser from a specified grammar and start rule and returns it.
|
|
*
|
|
* The grammar may be either an object or a string. If it is an object, it
|
|
* must contain AST of the parsing expressions (i.e. instances of |PEG.Grammar.*
|
|
* classes| for the grammar rules in its properties. If it is a string, it is
|
|
* parsed using |PEG.grammarParser| to obtain the grammar AST and thus it must
|
|
* be in a format that this parser accepts (see the source code for details).
|
|
*
|
|
* The start rule may be unspecified, in which case "start" is used.
|
|
*
|
|
* Throws |PEG.Grammar.GrammarError| if the grammar definition is not object nor
|
|
* string or if it contains an error. Note that not all errors are detected
|
|
* during the generation and some may protrude to the generated parser and cause
|
|
* its malfunction.
|
|
*/
|
|
PEG.buildParser = function(grammar, startRule) {
|
|
startRule = startRule || "start";
|
|
|
|
switch (typeof(grammar)) {
|
|
case "object":
|
|
var ast = grammar;
|
|
break;
|
|
case "string":
|
|
var ast = PEG.grammarParser.parse(grammar);
|
|
break;
|
|
default:
|
|
throw new PEG.Grammar.GrammarError("Grammar must be object or string.");
|
|
}
|
|
|
|
for (var key in ast) {
|
|
ast[key].checkReferencedRulesExist(ast);
|
|
}
|
|
if (ast[startRule] === undefined) {
|
|
throw new PEG.Grammar.GrammarError("Missing \"" + startRule + "\" rule.");
|
|
}
|
|
for (var key in ast) {
|
|
ast[key].checkNoLeftRecursion(ast, []);
|
|
}
|
|
|
|
return PEG.Compiler.compileParser(ast, startRule);
|
|
};
|
|
|
|
/* ===== PEG.ArrayUtils ===== */
|
|
|
|
/* Array manipulation utility functions. */
|
|
|
|
PEG.ArrayUtils = {
|
|
/*
|
|
* The code needs to be in sync with a code template in
|
|
* PEG.Grammar.Action.prototype.compile.
|
|
*/
|
|
contains: function(array, value) {
|
|
/*
|
|
* Stupid IE does not have Array.prototype.indexOf, otherwise this function
|
|
* would be a one-liner.
|
|
*/
|
|
var length = array.length;
|
|
for (var i = 0; i < length; i++) {
|
|
if (array[i] === value) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
|
|
each: function(array, callback) {
|
|
var length = array.length;
|
|
for (var i = 0; i < length; i++) {
|
|
callback(array[i]);
|
|
}
|
|
},
|
|
|
|
map: function(array, callback) {
|
|
var result = [];
|
|
var length = array.length;
|
|
for (var i = 0; i < length; i++) {
|
|
result[i] = callback(array[i]);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
/* ===== PEG.StringUtils ===== */
|
|
|
|
/* String manipulation utility functions. */
|
|
|
|
PEG.StringUtils = {
|
|
/*
|
|
* Surrounds the string with quotes and escapes characters inside so that the
|
|
* result is a valid JavaScript string.
|
|
*
|
|
* The code needs to be in sync with a code template in
|
|
* PEG.Grammar.Action.prototype.compile.
|
|
*/
|
|
quote: function(s) {
|
|
/*
|
|
* ECMA-262, 5th ed., 7.8.4: All characters may appear literally in a string
|
|
* literal except for the closing quote character, backslash, carriage
|
|
* return, line separator, paragraph separator, and line feed. Any character
|
|
* may appear in the form of an escape sequence.
|
|
*/
|
|
return '"' + s
|
|
.replace(/\\/g, '\\\\') // backslash
|
|
.replace(/"/g, '\\"') // closing quote character
|
|
.replace(/\r/g, '\\r') // carriage return
|
|
.replace(/\u2028/g, '\\u2028') // line separator
|
|
.replace(/\u2029/g, '\\u2029') // paragraph separator
|
|
.replace(/\n/g, '\\n') // line feed
|
|
+ '"';
|
|
}
|
|
|
|
};
|
|
|
|
/* ===== PEG.RegExpUtils ===== */
|
|
|
|
/* RegExp manipulation utility functions. */
|
|
|
|
PEG.RegExpUtils = {
|
|
/*
|
|
* Escapes characters inside the string so that it can be used as a list of
|
|
* characters in a character class of a regular expresion.
|
|
*/
|
|
quoteForClass: function(s) {
|
|
/* Based on ECMA-262, 5th ed., 7.8.5 & 15.10.1. */
|
|
return s
|
|
.replace(/\\/g, '\\\\') // backslash
|
|
.replace(/\0/g, '\\0') // null, IE needs this
|
|
.replace(/\//g, '\\/') // closing slash
|
|
.replace(/]/g, '\\]') // closing bracket
|
|
.replace(/-/g, '\\-') // dash
|
|
.replace(/\r/g, '\\r') // carriage return
|
|
.replace(/\u2028/g, '\\u2028') // line separator
|
|
.replace(/\u2029/g, '\\u2029') // paragraph separator
|
|
.replace(/\n/g, '\\n') // line feed
|
|
}
|
|
};
|
|
|
|
/* ===== PEG.Grammar ===== */
|
|
|
|
/* Namespace with grammar AST nodes. */
|
|
|
|
PEG.Grammar = {
|
|
/*
|
|
* Extends specified AST node classes with a function named |name|. The
|
|
* definition of the function is different for each node class and it is
|
|
* specified in the |functions| object, which contains the functions keyed by
|
|
* unqualified AST node names.
|
|
*
|
|
* Example:
|
|
*
|
|
* PEG.Grammar.extendNodes("foo", {
|
|
* Literal: function() { return 1; },
|
|
* Class: function() { return 2; }
|
|
* });
|
|
*
|
|
* This is is equivalent to:
|
|
*
|
|
* PEG.Grammar.Literal.prototype.foo = function() { return 1; };
|
|
* PEG.Grammar.Class.prototype.foo = function() { return 2; };
|
|
*/
|
|
extendNodes: function(name, functions) {
|
|
for (var nodeName in functions) {
|
|
PEG.Grammar[nodeName].prototype[name] = functions[nodeName];
|
|
}
|
|
}
|
|
};
|
|
|
|
/* ===== PEG.Grammar.GrammarError ===== */
|
|
|
|
/* Thrown when the grammar contains an error. */
|
|
|
|
PEG.Grammar.GrammarError = function(message) {
|
|
this.name = "PEG.Grammar.GrammarError";
|
|
this.message = message;
|
|
};
|
|
|
|
PEG.Grammar.GrammarError.prototype = Error.prototype;
|
|
|
|
/* ===== PEG.Grammar.* ===== */
|
|
|
|
PEG.Grammar.Rule = function(name, displayName, expression) {
|
|
this._name = name;
|
|
this._displayName = displayName;
|
|
this._expression = expression;
|
|
};
|
|
|
|
PEG.Grammar.Rule.prototype = {
|
|
getName: function() { return this._name; }
|
|
};
|
|
|
|
PEG.Grammar.Literal = function(value) { this._value = value; };
|
|
|
|
PEG.Grammar.Class = function(characters) { this._characters = characters; };
|
|
|
|
PEG.Grammar.Any = function() {};
|
|
|
|
PEG.Grammar.Sequence = function(elements) { this._elements = elements; };
|
|
|
|
PEG.Grammar.Choice = function(alternatives) {
|
|
this._alternatives = alternatives;
|
|
};
|
|
|
|
PEG.Grammar.ZeroOrMore = function(element) { this._element = element; };
|
|
|
|
PEG.Grammar.NotPredicate = function(expression) {
|
|
this._expression = expression;
|
|
};
|
|
|
|
PEG.Grammar.RuleRef = function(name) { this._name = name; };
|
|
|
|
PEG.Grammar.Action = function(expression, action) {
|
|
this._expression = expression;
|
|
this._action = action;
|
|
};
|
|
|
|
/* ===== Referenced Rule Existence Checks ===== */
|
|
|
|
PEG.Grammar.extendNodes("checkReferencedRulesExist", {
|
|
Rule:
|
|
function(grammar) {
|
|
this._expression.checkReferencedRulesExist(grammar);
|
|
},
|
|
|
|
Literal: nop,
|
|
Class: nop,
|
|
Any: nop,
|
|
|
|
Sequence:
|
|
function(grammar) {
|
|
PEG.ArrayUtils.each(this._elements, function(element) {
|
|
element.checkReferencedRulesExist(grammar);
|
|
});
|
|
},
|
|
|
|
Choice:
|
|
function(grammar) {
|
|
PEG.ArrayUtils.each(this._alternatives, function(alternative) {
|
|
alternative.checkReferencedRulesExist(grammar);
|
|
});
|
|
},
|
|
|
|
ZeroOrMore:
|
|
function(grammar) { this._element.checkReferencedRulesExist(grammar); },
|
|
|
|
NotPredicate:
|
|
function(grammar) { this._expression.checkReferencedRulesExist(grammar); },
|
|
|
|
RuleRef:
|
|
function(grammar) {
|
|
if (grammar[this._name] === undefined) {
|
|
throw new PEG.Grammar.GrammarError(
|
|
"Referenced rule \"" + this._name + "\" does not exist."
|
|
);
|
|
}
|
|
},
|
|
|
|
Action:
|
|
function(grammar) { this._expression.checkReferencedRulesExist(grammar); }
|
|
});
|
|
|
|
|
|
/* ===== Left Recursion Checks ===== */
|
|
|
|
PEG.Grammar.extendNodes("checkNoLeftRecursion", {
|
|
Rule:
|
|
function(grammar, appliedRules) {
|
|
this._expression.checkNoLeftRecursion(grammar, appliedRules.concat(this._name));
|
|
},
|
|
|
|
Literal: nop,
|
|
Class: nop,
|
|
Any: nop,
|
|
|
|
Sequence:
|
|
function(grammar, appliedRules) {
|
|
if (this._elements.length > 0) {
|
|
this._elements[0].checkNoLeftRecursion(grammar, appliedRules);
|
|
}
|
|
},
|
|
|
|
Choice:
|
|
function(grammar, appliedRules) {
|
|
PEG.ArrayUtils.each(this._alternatives, function(alternative) {
|
|
alternative.checkNoLeftRecursion(grammar, appliedRules);
|
|
});
|
|
},
|
|
|
|
ZeroOrMore:
|
|
function(grammar, appliedRules) {
|
|
this._element.checkNoLeftRecursion(grammar, appliedRules);
|
|
},
|
|
|
|
NotPredicate:
|
|
function(grammar, appliedRules) {
|
|
this._expression.checkNoLeftRecursion(grammar, appliedRules);
|
|
},
|
|
|
|
RuleRef:
|
|
function(grammar, appliedRules) {
|
|
if (PEG.ArrayUtils.contains(appliedRules, this._name)) {
|
|
throw new PEG.Grammar.GrammarError("Left recursion detected for rule \"" + this._name + "\".");
|
|
}
|
|
grammar[this._name].checkNoLeftRecursion(grammar, appliedRules);
|
|
},
|
|
|
|
Action:
|
|
function(grammar, appliedRules) {
|
|
this._expression.checkNoLeftRecursion(grammar, appliedRules);
|
|
}
|
|
});
|
|
|
|
/* ===== PEG.Compiler ===== */
|
|
|
|
PEG.Compiler = {
|
|
/*
|
|
* Takes parts of code, interpolates variables inside them and joins them with
|
|
* a newline.
|
|
*
|
|
* Variables are delimited with "${" and "}" and their names must be valid
|
|
* identifiers (i.e. they must match [a-zA-Z_][a-zA-Z0-9_]*). Variable values
|
|
* are specified as properties of the last parameter (if this is an object,
|
|
* otherwise empty variable set is assumed). Undefined variables result in
|
|
* throwing |Error|.
|
|
*
|
|
* There can be a filter specified after the variable name, prefixed with "|".
|
|
* The filter name must be a valid identifier. The only recognized filter
|
|
* right now is "string", which quotes the variable value as a JavaScript
|
|
* string. Unrecognized filters result in throwing |Error|.
|
|
*
|
|
* If any part has multiple lines and the first line is indented by some
|
|
* amount of whitespace (as defined by the /\s+/ JavaScript regular
|
|
* expression), second to last lines are indented by the same amount of
|
|
* whitespace. This results in nicely indented multiline code in variables
|
|
* without making the templates look ugly.
|
|
*
|
|
* Examples:
|
|
*
|
|
* PEG.Compiler.formatCode("foo", "bar"); // "foo\nbar"
|
|
* PEG.Compiler.formatCode(
|
|
* "foo", "${bar}",
|
|
* { bar: "baz" }
|
|
* ); // "foo\nbaz"
|
|
* PEG.Compiler.formatCode("foo", "${bar}"); // throws Error
|
|
* PEG.Compiler.formatCode(
|
|
* "foo", "${bar|string}",
|
|
* { bar: "baz" }
|
|
* ); // "foo\n\"baz\""
|
|
* PEG.Compiler.formatCode(
|
|
* "foo", "${bar|eeek}",
|
|
* { bar: "baz" }
|
|
* ); // throws Error
|
|
* PEG.Compiler.formatCode(
|
|
* "foo", "${bar}",
|
|
* { bar: " baz\nqux" }
|
|
* ); // "foo\n baz\n qux"
|
|
*/
|
|
formatCode: function() {
|
|
function interpolateVariablesInParts(parts) {
|
|
return PEG.ArrayUtils.map(parts, function(part) {
|
|
return part.replace(
|
|
/\$\{([a-zA-Z_][a-zA-Z0-9_]*)(\|([a-zA-Z_][a-zA-Z0-9_]*))?\}/g,
|
|
function(match, name, dummy, filter) {
|
|
var value = vars[name];
|
|
if (value === undefined) {
|
|
throw new Error("Undefined variable: \"" + name + "\".");
|
|
}
|
|
|
|
if (filter !== undefined && filter != "") { // JavaScript engines differ here.
|
|
if (filter === "string") {
|
|
return PEG.StringUtils.quote(value);
|
|
} else {
|
|
throw new Error("Unrecognized filter: \"" + filter + "\".");
|
|
}
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
function indentMultilineParts(parts) {
|
|
return PEG.ArrayUtils.map(parts, function(part) {
|
|
if (!/\n/.test(part)) { return part; }
|
|
|
|
var firstLineWhitespacePrefix = part.match(/^\s*/)[0];
|
|
var lines = part.split("\n");
|
|
var linesIndented = [lines[0]].concat(
|
|
PEG.ArrayUtils.map(lines.slice(1), function(line) {
|
|
return firstLineWhitespacePrefix + line;
|
|
})
|
|
);
|
|
return linesIndented.join("\n");
|
|
});
|
|
}
|
|
|
|
var args = Array.prototype.slice.call(arguments);
|
|
var vars = args[args.length - 1] instanceof Object ? args.pop() : {};
|
|
|
|
return indentMultilineParts(interpolateVariablesInParts(args)).join("\n");
|
|
},
|
|
|
|
_uniqueIdentifierCounters: {},
|
|
|
|
_resetUniqueIdentifierCounters: function() {
|
|
this._uniqueIdentifierCounters = {};
|
|
},
|
|
|
|
/* Generates a unique identifier with specified prefix. */
|
|
generateUniqueIdentifier: function(prefix) {
|
|
this._uniqueIdentifierCounters[prefix]
|
|
= this._uniqueIdentifierCounters[prefix] || 0;
|
|
return prefix + this._uniqueIdentifierCounters[prefix]++;
|
|
},
|
|
|
|
/*
|
|
* Generates a parser from a specified grammar and start rule.
|
|
*/
|
|
compileParser: function(grammar, startRule) {
|
|
/*
|
|
* This ensures that the same grammar and start rule always generate exactly
|
|
* the same parser.
|
|
*/
|
|
this._resetUniqueIdentifierCounters();
|
|
|
|
var parseFunctionDefinitions = [];
|
|
for (var key in grammar) {
|
|
parseFunctionDefinitions.push(grammar[key].compile());
|
|
}
|
|
|
|
var source = this.formatCode(
|
|
"(function(){",
|
|
" var result = {",
|
|
" _startRule: ${startRule|string},",
|
|
" ",
|
|
/* This needs to be in sync with PEG.StringUtils.quote. */
|
|
" _quoteString: function(s) {",
|
|
" /*",
|
|
" * ECMA-262, 5th ed., 7.8.4: All characters may appear literally in a string",
|
|
" * literal except for the closing quote character, backslash, carriage",
|
|
" * return, line separator, paragraph separator, and line feed. Any character",
|
|
" * may appear in the form of an escape sequence.",
|
|
" */",
|
|
" return '\"' + s",
|
|
" .replace(/\\\\/g, '\\\\\\\\') // backslash",
|
|
" .replace(/\"/g, '\\\\\"') // closing quote character",
|
|
" .replace(/\\r/g, '\\\\r') // carriage return",
|
|
" .replace(/\\u2028/g, '\\\\u2028') // line separator",
|
|
" .replace(/\\u2029/g, '\\\\u2029') // paragraph separator",
|
|
" .replace(/\\n/g, '\\\\n') // line feed",
|
|
" + '\"';",
|
|
" },",
|
|
" ",
|
|
/* This needs to be in sync with PEG.ArrayUtils.contains. */
|
|
" _arrayContains: function(array, value) {",
|
|
" /*",
|
|
" * Stupid IE does not have Array.prototype.indexOf, otherwise this function",
|
|
" * would be a one-liner.",
|
|
" */",
|
|
" var length = array.length;",
|
|
" for (var i = 0; i < length; i++) {",
|
|
" if (array[i] === value) {",
|
|
" return true;",
|
|
" }",
|
|
" }",
|
|
" return false;",
|
|
" },",
|
|
" ",
|
|
" _matchFailed: function(failure) {",
|
|
" if (this._pos > this._rightmostMatchFailuresPos) {",
|
|
" this._rightmostMatchFailuresPos = this._pos;",
|
|
" this._rightmostMatchFailuresExpected = [];",
|
|
" }",
|
|
" ",
|
|
" if (!this._arrayContains(this._rightmostMatchFailuresExpected, failure)) {",
|
|
" this._rightmostMatchFailuresExpected.push(failure);",
|
|
" }",
|
|
" },",
|
|
" ",
|
|
" ${parseFunctionDefinitions}",
|
|
" ",
|
|
" /*",
|
|
" * Parses the input with a generated parser. If the parsing is successfull,",
|
|
" * returns a value explicitly or implicitly specified by the grammar from",
|
|
" * which the parser was generated (see |PEG.buildParser|). If the parsing is",
|
|
" * unsuccessful, throws |PEG.grammarParser.SyntaxError| describing the error.",
|
|
" */",
|
|
" parse: function(input) {",
|
|
" var that = this;",
|
|
" ",
|
|
" function initialize() {",
|
|
" that._input = input;",
|
|
" that._pos = 0;",
|
|
" that._rightmostMatchFailuresPos = 0;",
|
|
" that._rightmostMatchFailuresExpected = [];",
|
|
" that._cache = {};",
|
|
" }",
|
|
" ",
|
|
" function buildErrorMessage() {",
|
|
" function buildExpected(failuresExpected) {",
|
|
" switch (failuresExpected.length) {",
|
|
" case 0:",
|
|
" return 'end of input';",
|
|
" case 1:",
|
|
" return failuresExpected[0];",
|
|
" default:",
|
|
" failuresExpected.sort();",
|
|
" return failuresExpected.slice(0, failuresExpected.length - 1).join(', ')",
|
|
" + ' or '",
|
|
" + failuresExpected[failuresExpected.length - 1];",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" var expected = buildExpected(that._rightmostMatchFailuresExpected);",
|
|
" var pos = Math.max(that._pos, that._rightmostMatchFailuresPos);",
|
|
" var actual = pos < that._input.length",
|
|
" ? that._quoteString(that._input.charAt(pos))",
|
|
" : 'end of input';",
|
|
" ",
|
|
" return 'Expected ' + expected + ' but ' + actual + ' found.';",
|
|
" }",
|
|
" ",
|
|
" function computeErrorPosition() {",
|
|
" /*",
|
|
" * The first idea was to use |String.split| to break the input up to the",
|
|
" * error position along newlines and derive the line and column from",
|
|
" * there. However IE's |split| implementation is so broken that it was",
|
|
" * enough to prevent it.",
|
|
" */",
|
|
" ",
|
|
" var input = that._input;",
|
|
" var pos = that._rightmostMatchFailuresPos;",
|
|
" var line = 1;",
|
|
" var column = 1;",
|
|
" var seenCR = false;",
|
|
" ",
|
|
" for (var i = 0; i < pos; i++) {",
|
|
" var ch = input.charAt(i);",
|
|
" if (ch === '\\n') {",
|
|
" if (!seenCR) { line++; }",
|
|
" column = 1;",
|
|
" seenCR = false;",
|
|
" } else if (ch === '\\r' | ch === '\\u2028' || ch === '\\u2029') {",
|
|
" line++;",
|
|
" column = 1;",
|
|
" seenCR = true;",
|
|
" } else {",
|
|
" column++;",
|
|
" seenCR = false;",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" return { line: line, column: column };",
|
|
" }",
|
|
" ",
|
|
" initialize();",
|
|
" ",
|
|
" var initialContext = {",
|
|
" reportMatchFailures: true",
|
|
" };",
|
|
" ",
|
|
" var result = this['_parse_' + this._startRule](initialContext);",
|
|
" ",
|
|
" /*",
|
|
" * The parser is now in one of the following three states:",
|
|
" *",
|
|
" * 1. The parser successfully parsed the whole input.",
|
|
" *",
|
|
" * - |result !== null|",
|
|
" * - |that._pos === input.length|",
|
|
" * - |that._rightmostMatchFailuresExpected.length| may or may not contain",
|
|
" * something",
|
|
" *",
|
|
" * 2. The parser successfully parsed only a part of the input.",
|
|
" *",
|
|
" * - |result !== null|",
|
|
" * - |that._pos < input.length|",
|
|
" * - |that._rightmostMatchFailuresExpected.length| may or may not contain",
|
|
" * something",
|
|
" *",
|
|
" * 3. The parser did not successfully parse any part of the input.",
|
|
" *",
|
|
" * - |result === null|",
|
|
" * - |that._pos === 0|",
|
|
" * - |that._rightmostMatchFailuresExpected.length| contains at least one failure",
|
|
" *",
|
|
" * All code following this comment (including called functions) must",
|
|
" * handle these states.",
|
|
" */",
|
|
" if (result === null || this._pos !== input.length) {",
|
|
" var errorPosition = computeErrorPosition();",
|
|
" throw new this.SyntaxError(",
|
|
" buildErrorMessage(),",
|
|
" errorPosition.line,",
|
|
" errorPosition.column",
|
|
" );",
|
|
" }",
|
|
" ",
|
|
" return result;",
|
|
" },",
|
|
" ",
|
|
" /* Returns the parser source code. */",
|
|
" toSource: function() { return this._source; }",
|
|
" };",
|
|
" ",
|
|
" /* Thrown when a parser encounters a syntax error. */",
|
|
" ",
|
|
" result.SyntaxError = function(message, line, column) {",
|
|
" this.name = 'SyntaxError';",
|
|
" this.message = message;",
|
|
" this.line = line;",
|
|
" this.column = column;",
|
|
" };",
|
|
" ",
|
|
" result.SyntaxError.prototype = Error.prototype;",
|
|
" ",
|
|
" return result;",
|
|
"})()",
|
|
{
|
|
parseFunctionDefinitions: parseFunctionDefinitions.join("\n\n"),
|
|
startRule: startRule
|
|
}
|
|
);
|
|
|
|
var result = eval(source);
|
|
result._source = source;
|
|
return result;
|
|
}
|
|
};
|
|
|
|
PEG.Grammar.Rule.prototype.compile = function() {
|
|
var resultVar = PEG.Compiler.generateUniqueIdentifier("result");
|
|
|
|
if (this._displayName !== null) {
|
|
var setReportMatchFailuresCode = PEG.Compiler.formatCode(
|
|
"var savedReportMatchFailures = context.reportMatchFailures;",
|
|
"context.reportMatchFailures = false;"
|
|
);
|
|
var restoreReportMatchFailuresCode = PEG.Compiler.formatCode(
|
|
"context.reportMatchFailures = savedReportMatchFailures;"
|
|
);
|
|
var reportMatchFailureCode = PEG.Compiler.formatCode(
|
|
"if (context.reportMatchFailures && ${resultVar} === null) {",
|
|
" this._matchFailed(${displayName|string});",
|
|
"}",
|
|
{
|
|
displayName: this._displayName,
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
} else {
|
|
var setReportMatchFailuresCode = "";
|
|
var restoreReportMatchFailuresCode = "";
|
|
var reportMatchFailureCode = "";
|
|
}
|
|
|
|
return PEG.Compiler.formatCode(
|
|
"_parse_${name}: function(context) {",
|
|
" var cacheKey = ${name|string} + '@' + this._pos;",
|
|
" var cachedResult = this._cache[cacheKey];",
|
|
" if (cachedResult !== undefined) {",
|
|
" this._pos = cachedResult.nextPos;",
|
|
" return cachedResult.result;",
|
|
" }",
|
|
" ",
|
|
" var pos = this._pos;",
|
|
" ",
|
|
" ${setReportMatchFailuresCode}",
|
|
" ${code}",
|
|
" ${restoreReportMatchFailuresCode}",
|
|
" ${reportMatchFailureCode}",
|
|
" ",
|
|
" this._cache[cacheKey] = {",
|
|
" nextPos: this._pos,",
|
|
" result: ${resultVar}",
|
|
" };",
|
|
" return ${resultVar};",
|
|
"},",
|
|
{
|
|
name: this._name,
|
|
setReportMatchFailuresCode: setReportMatchFailuresCode,
|
|
restoreReportMatchFailuresCode: restoreReportMatchFailuresCode,
|
|
reportMatchFailureCode: reportMatchFailureCode,
|
|
code: this._expression.compile(resultVar),
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
};
|
|
|
|
/*
|
|
* The contract for all code fragments generated by the following |compile|
|
|
* methods is as follows:
|
|
*
|
|
* * The code fragment should try to match a part of the input starting with the
|
|
* position indicated in |this._pos|. That position may point past the end of
|
|
* the input.
|
|
*
|
|
* * If the code fragment matches the input, it advances |this._pos| after the
|
|
* matched part of the input and sets variable with a name stored in
|
|
* |resultVar| to appropriate value, which is always non-null.
|
|
*
|
|
* * If the code fragment does not match the input, it does not change
|
|
* |this._pos| and it sets a variable with a name stored in |resultVar| to
|
|
* |null|.
|
|
*/
|
|
|
|
PEG.Grammar.Literal.prototype.compile = function(resultVar) {
|
|
return PEG.Compiler.formatCode(
|
|
"if (this._input.substr(this._pos, ${length}) === ${value|string}) {",
|
|
" var ${resultVar} = ${value|string};",
|
|
" this._pos += ${length};",
|
|
"} else {",
|
|
" var ${resultVar} = null;",
|
|
" if (context.reportMatchFailures) {",
|
|
" this._matchFailed(this._quoteString(${value|string}));",
|
|
" }",
|
|
"}",
|
|
{
|
|
value: this._value,
|
|
length: this._value.length,
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
};
|
|
|
|
PEG.Grammar.Class.prototype.compile = function(resultVar) {
|
|
/*
|
|
* Stupid IE considers regexps /[]/ and /[^]/ syntactically invalid, so we
|
|
* translate them into euqivalents it can handle.
|
|
*/
|
|
if (this._characters === "") {
|
|
var regexp = "/^(?!)/";
|
|
} else if (this._characters === "^") {
|
|
var regexp = "/^[\\S\\s]/";
|
|
} else {
|
|
var regexp = "/^[" + this._characters + "]/";
|
|
}
|
|
|
|
return PEG.Compiler.formatCode(
|
|
"if (this._input.substr(this._pos).match(${regexp}) !== null) {",
|
|
" var ${resultVar} = this._input.charAt(this._pos);",
|
|
" this._pos++;",
|
|
"} else {",
|
|
" var ${resultVar} = null;",
|
|
" if (context.reportMatchFailures) {",
|
|
" this._matchFailed('[' + ${characters|string} + ']');",
|
|
" }",
|
|
"}",
|
|
{
|
|
characters: this._characters,
|
|
regexp: regexp,
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
};
|
|
|
|
PEG.Grammar.Any.prototype.compile = function(resultVar) {
|
|
return PEG.Compiler.formatCode(
|
|
"if (this._input.length > this._pos) {",
|
|
" var ${resultVar} = this._input.charAt(this._pos);",
|
|
" this._pos++;",
|
|
"} else {",
|
|
" var ${resultVar} = null;",
|
|
" if (context.reportMatchFailures) {",
|
|
" this._matchFailed('any character');",
|
|
" }",
|
|
"}",
|
|
{ resultVar: resultVar }
|
|
);
|
|
};
|
|
|
|
PEG.Grammar.Sequence.prototype.compile = function(resultVar) {
|
|
var savedPosVar = PEG.Compiler.generateUniqueIdentifier("savedPos");
|
|
|
|
var elementResultVars = PEG.ArrayUtils.map(this._elements, function() {
|
|
return PEG.Compiler.generateUniqueIdentifier("result")
|
|
});
|
|
|
|
var code = PEG.Compiler.formatCode(
|
|
"var ${resultVar} = ${elementResultVarArray};",
|
|
{
|
|
resultVar: resultVar,
|
|
elementResultVarArray: "[" + elementResultVars.join(", ") + "]"
|
|
}
|
|
);
|
|
|
|
for (var i = this._elements.length - 1; i >= 0; i--) {
|
|
code = PEG.Compiler.formatCode(
|
|
"${elementCode}",
|
|
"if (${elementResultVar} !== null) {",
|
|
" ${code}",
|
|
"} else {",
|
|
" var ${resultVar} = null;",
|
|
" this._pos = ${savedPosVar};",
|
|
"}",
|
|
{
|
|
elementCode: this._elements[i].compile(elementResultVars[i]),
|
|
elementResultVar: elementResultVars[i],
|
|
code: code,
|
|
savedPosVar: savedPosVar,
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
}
|
|
|
|
return PEG.Compiler.formatCode(
|
|
"var ${savedPosVar} = this._pos;",
|
|
"${code}",
|
|
{
|
|
code: code,
|
|
savedPosVar: savedPosVar
|
|
}
|
|
);
|
|
};
|
|
|
|
PEG.Grammar.Choice.prototype.compile = function(resultVar) {
|
|
var code = PEG.Compiler.formatCode(
|
|
"var ${resultVar} = null;",
|
|
{ resultVar: resultVar }
|
|
);
|
|
|
|
for (var i = this._alternatives.length - 1; i >= 0; i--) {
|
|
var alternativeResultVar = PEG.Compiler.generateUniqueIdentifier("result");
|
|
code = PEG.Compiler.formatCode(
|
|
"${alternativeCode}",
|
|
"if (${alternativeResultVar} !== null) {",
|
|
" var ${resultVar} = ${alternativeResultVar};",
|
|
"} else {",
|
|
" ${code};",
|
|
"}",
|
|
{
|
|
alternativeCode: this._alternatives[i].compile(alternativeResultVar),
|
|
alternativeResultVar: alternativeResultVar,
|
|
code: code,
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
}
|
|
|
|
return code;
|
|
};
|
|
|
|
PEG.Grammar.ZeroOrMore.prototype.compile = function(resultVar) {
|
|
var elementResultVar = PEG.Compiler.generateUniqueIdentifier("result");
|
|
|
|
return PEG.Compiler.formatCode(
|
|
"var ${resultVar} = [];",
|
|
"${elementCode}",
|
|
"while (${elementResultVar} !== null) {",
|
|
" ${resultVar}.push(${elementResultVar});",
|
|
" ${elementCode}",
|
|
"}",
|
|
{
|
|
elementCode: this._element.compile(elementResultVar),
|
|
elementResultVar: elementResultVar,
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
};
|
|
|
|
PEG.Grammar.NotPredicate.prototype.compile = function(resultVar) {
|
|
var savedPosVar = PEG.Compiler.generateUniqueIdentifier("savedPos");
|
|
var savedReportMatchFailuresVar = PEG.Compiler.generateUniqueIdentifier("savedReportMatchFailuresVar");
|
|
var expressionResultVar = PEG.Compiler.generateUniqueIdentifier("result");
|
|
|
|
return PEG.Compiler.formatCode(
|
|
"var ${savedPosVar} = this._pos;",
|
|
"var ${savedReportMatchFailuresVar} = context.reportMatchFailures;",
|
|
"context.reportMatchFailures = false;",
|
|
"${expressionCode}",
|
|
"context.reportMatchFailures = ${savedReportMatchFailuresVar};",
|
|
"if (${expressionResultVar} === null) {",
|
|
" var ${resultVar} = '';",
|
|
"} else {",
|
|
" var ${resultVar} = null;",
|
|
" this._pos = ${savedPosVar};",
|
|
"}",
|
|
{
|
|
expressionCode: this._expression.compile(expressionResultVar),
|
|
expressionResultVar: expressionResultVar,
|
|
savedPosVar: savedPosVar,
|
|
savedReportMatchFailuresVar: savedReportMatchFailuresVar,
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
};
|
|
|
|
PEG.Grammar.RuleRef.prototype.compile = function(resultVar) {
|
|
return PEG.Compiler.formatCode(
|
|
"var ${resultVar} = this.${ruleMethod}(context);",
|
|
{
|
|
ruleMethod: "_parse_" + this._name,
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
};
|
|
|
|
PEG.Grammar.Action.prototype.compile = function(resultVar) {
|
|
var expressionResultVar = PEG.Compiler.generateUniqueIdentifier("result");
|
|
|
|
if (typeof(this._action) === "function") {
|
|
var actionFunction = this._action.toString();
|
|
} else {
|
|
var actionCode = this._action.replace(
|
|
/\$(\d+)/g,
|
|
function(match, digits) {
|
|
return PEG.Compiler.formatCode(
|
|
"(arguments[${index}])",
|
|
{ index: parseInt(digits) - 1 }
|
|
);
|
|
}
|
|
)
|
|
var actionFunction = PEG.Compiler.formatCode(
|
|
"function() { ${actionCode} }",
|
|
{ actionCode: actionCode }
|
|
);
|
|
}
|
|
|
|
/*
|
|
* In case of sequences, we splat their elements into function arguments one
|
|
* by one. Example:
|
|
*
|
|
* start: "a" "b" "c" { alert(arguments.length) } // => "3"
|
|
*/
|
|
var invokeFunctionName = this._expression instanceof PEG.Grammar.Sequence
|
|
? "apply"
|
|
: "call";
|
|
|
|
return PEG.Compiler.formatCode(
|
|
"${expressionCode}",
|
|
"var ${resultVar} = ${expressionResultVar} !== null",
|
|
" ? (${actionFunction}).${invokeFunctionName}(this, ${expressionResultVar})",
|
|
" : null;",
|
|
{
|
|
expressionCode: this._expression.compile(expressionResultVar),
|
|
expressionResultVar: expressionResultVar,
|
|
actionFunction: actionFunction,
|
|
invokeFunctionName: invokeFunctionName,
|
|
resultVar: resultVar
|
|
}
|
|
);
|
|
};
|
|
|
|
})();
|