Created
May 15, 2018 15:50
-
-
Save hypest/8f4a669a6ae28279a3769ee04446ae56 to your computer and use it in GitHub Desktop.
generated grammar parser from post.pegjs
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| const pegOptions = { | |
| cache: true, | |
| dependencies: {}, | |
| format: 'commonjs', | |
| optimize: 'speed', | |
| output: 'source', | |
| trace: false, | |
| }; |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /* | |
| * Generated by PEG.js 0.10.0. | |
| * | |
| * http://pegjs.org/ | |
| */ | |
| "use strict"; | |
| function peg$subclass(child, parent) { | |
| function ctor() { this.constructor = child; } | |
| ctor.prototype = parent.prototype; | |
| child.prototype = new ctor(); | |
| } | |
| function peg$SyntaxError(message, expected, found, location) { | |
| this.message = message; | |
| this.expected = expected; | |
| this.found = found; | |
| this.location = location; | |
| this.name = "SyntaxError"; | |
| if (typeof Error.captureStackTrace === "function") { | |
| Error.captureStackTrace(this, peg$SyntaxError); | |
| } | |
| } | |
| peg$subclass(peg$SyntaxError, Error); | |
| peg$SyntaxError.buildMessage = function(expected, found) { | |
| var DESCRIBE_EXPECTATION_FNS = { | |
| literal: function(expectation) { | |
| return "\"" + literalEscape(expectation.text) + "\""; | |
| }, | |
| "class": function(expectation) { | |
| var escapedParts = "", | |
| i; | |
| for (i = 0; i < expectation.parts.length; i++) { | |
| escapedParts += expectation.parts[i] instanceof Array | |
| ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1]) | |
| : classEscape(expectation.parts[i]); | |
| } | |
| return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]"; | |
| }, | |
| any: function(expectation) { | |
| return "any character"; | |
| }, | |
| end: function(expectation) { | |
| return "end of input"; | |
| }, | |
| other: function(expectation) { | |
| return expectation.description; | |
| } | |
| }; | |
| function hex(ch) { | |
| return ch.charCodeAt(0).toString(16).toUpperCase(); | |
| } | |
| function literalEscape(s) { | |
| return s | |
| .replace(/\\/g, '\\\\') | |
| .replace(/"/g, '\\"') | |
| .replace(/\0/g, '\\0') | |
| .replace(/\t/g, '\\t') | |
| .replace(/\n/g, '\\n') | |
| .replace(/\r/g, '\\r') | |
| .replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); }) | |
| .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); }); | |
| } | |
| function classEscape(s) { | |
| return s | |
| .replace(/\\/g, '\\\\') | |
| .replace(/\]/g, '\\]') | |
| .replace(/\^/g, '\\^') | |
| .replace(/-/g, '\\-') | |
| .replace(/\0/g, '\\0') | |
| .replace(/\t/g, '\\t') | |
| .replace(/\n/g, '\\n') | |
| .replace(/\r/g, '\\r') | |
| .replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); }) | |
| .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); }); | |
| } | |
| function describeExpectation(expectation) { | |
| return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); | |
| } | |
| function describeExpected(expected) { | |
| var descriptions = new Array(expected.length), | |
| i, j; | |
| for (i = 0; i < expected.length; i++) { | |
| descriptions[i] = describeExpectation(expected[i]); | |
| } | |
| descriptions.sort(); | |
| if (descriptions.length > 0) { | |
| for (i = 1, j = 1; i < descriptions.length; i++) { | |
| if (descriptions[i - 1] !== descriptions[i]) { | |
| descriptions[j] = descriptions[i]; | |
| j++; | |
| } | |
| } | |
| descriptions.length = j; | |
| } | |
| switch (descriptions.length) { | |
| case 1: | |
| return descriptions[0]; | |
| case 2: | |
| return descriptions[0] + " or " + descriptions[1]; | |
| default: | |
| return descriptions.slice(0, -1).join(", ") | |
| + ", or " | |
| + descriptions[descriptions.length - 1]; | |
| } | |
| } | |
| function describeFound(found) { | |
| return found ? "\"" + literalEscape(found) + "\"" : "end of input"; | |
| } | |
| return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; | |
| }; | |
| function peg$DefaultTracer() { | |
| this.indentLevel = 0; | |
| } | |
| peg$DefaultTracer.prototype.trace = function(event) { | |
| var that = this; | |
| function log(event) { | |
| function repeat(string, n) { | |
| var result = "", i; | |
| for (i = 0; i < n; i++) { | |
| result += string; | |
| } | |
| return result; | |
| } | |
| function pad(string, length) { | |
| return string + repeat(" ", length - string.length); | |
| } | |
| if (typeof console === "object") { | |
| console.log( | |
| event.location.start.line + ":" + event.location.start.column + "-" | |
| + event.location.end.line + ":" + event.location.end.column + " " | |
| + pad(event.type, 10) + " " | |
| + repeat(" ", that.indentLevel) + event.rule | |
| ); | |
| } | |
| } | |
| switch (event.type) { | |
| case "rule.enter": | |
| log(event); | |
| this.indentLevel++; | |
| break; | |
| case "rule.match": | |
| this.indentLevel--; | |
| log(event); | |
| break; | |
| case "rule.fail": | |
| this.indentLevel--; | |
| log(event); | |
| break; | |
| default: | |
| throw new Error("Invalid event type: " + event.type + "."); | |
| } | |
| }; | |
| function peg$parse(input, options) { | |
| options = options !== void 0 ? options : {}; | |
| var peg$FAILED = {}, | |
| peg$startRuleFunctions = { Block_List: peg$parseBlock_List }, | |
| peg$startRuleFunction = peg$parseBlock_List, | |
| peg$c0 = peg$anyExpectation(), | |
| peg$c1 = function(pre, b, html) { /** <?php return array( $b, $html ); ?> **/ return [ b, html ] }, | |
| peg$c2 = function(pre, bs, post) { /** <?php return peg_join_blocks( $pre, $bs, $post ); ?> **/ | |
| return joinBlocks( pre, bs, post ); | |
| }, | |
| peg$c3 = "<!--", | |
| peg$c4 = peg$literalExpectation("<!--", false), | |
| peg$c5 = "wp:", | |
| peg$c6 = peg$literalExpectation("wp:", false), | |
| peg$c7 = function(blockName, a) { | |
| /** <?php return $a; ?> **/ | |
| return a; | |
| }, | |
| peg$c8 = "/-->", | |
| peg$c9 = peg$literalExpectation("/-->", false), | |
| peg$c10 = function(blockName, attrs) { | |
| /** <?php | |
| return array( | |
| 'blockName' => $blockName, | |
| 'attrs' => $attrs, | |
| 'innerBlocks' => array(), | |
| 'innerHTML' => '', | |
| ); | |
| ?> **/ | |
| return { | |
| blockName: blockName, | |
| attrs: attrs, | |
| innerBlocks: [], | |
| innerHTML: '' | |
| }; | |
| }, | |
| peg$c11 = function(s, children, e) { | |
| /** <?php | |
| list( $innerHTML, $innerBlocks ) = peg_array_partition( $children, 'is_string' ); | |
| return array( | |
| 'blockName' => $s['blockName'], | |
| 'attrs' => $s['attrs'], | |
| 'innerBlocks' => $innerBlocks, | |
| 'innerHTML' => implode( '', $innerHTML ), | |
| ); | |
| ?> **/ | |
| var innerContent = partition( function( a ) { return 'string' === typeof a }, children ); | |
| var innerHTML = innerContent[ 0 ]; | |
| var innerBlocks = innerContent[ 1 ]; | |
| return { | |
| blockName: s.blockName, | |
| attrs: s.attrs, | |
| innerBlocks: innerBlocks, | |
| innerHTML: innerHTML.join( '' ) | |
| }; | |
| }, | |
| peg$c12 = "-->", | |
| peg$c13 = peg$literalExpectation("-->", false), | |
| peg$c14 = function(blockName, attrs) { | |
| /** <?php | |
| return array( | |
| 'blockName' => $blockName, | |
| 'attrs' => $attrs, | |
| ); | |
| ?> **/ | |
| return { | |
| blockName: blockName, | |
| attrs: attrs | |
| }; | |
| }, | |
| peg$c15 = "/wp:", | |
| peg$c16 = peg$literalExpectation("/wp:", false), | |
| peg$c17 = function(blockName) { | |
| /** <?php | |
| return array( | |
| 'blockName' => $blockName, | |
| ); | |
| ?> **/ | |
| return { | |
| blockName: blockName | |
| }; | |
| }, | |
| peg$c18 = "/", | |
| peg$c19 = peg$literalExpectation("/", false), | |
| peg$c20 = function(type) { | |
| /** <?php return "core/$type"; ?> **/ | |
| return 'core/' + type; | |
| }, | |
| peg$c21 = /^[a-z]/, | |
| peg$c22 = peg$classExpectation([["a", "z"]], false, false), | |
| peg$c23 = /^[a-z0-9_\-]/, | |
| peg$c24 = peg$classExpectation([["a", "z"], ["0", "9"], "_", "-"], false, false), | |
| peg$c25 = "{", | |
| peg$c26 = peg$literalExpectation("{", false), | |
| peg$c27 = "}", | |
| peg$c28 = peg$literalExpectation("}", false), | |
| peg$c29 = "", | |
| peg$c30 = function(attrs) { | |
| /** <?php return json_decode( $attrs, true ); ?> **/ | |
| return maybeJSON( attrs ); | |
| }, | |
| peg$c31 = /^[ \t\r\n]/, | |
| peg$c32 = peg$classExpectation([" ", "\t", "\r", "\n"], false, false), | |
| peg$currPos = 0, | |
| peg$savedPos = 0, | |
| peg$posDetailsCache = [{ line: 1, column: 1 }], | |
| peg$maxFailPos = 0, | |
| peg$maxFailExpected = [], | |
| peg$silentFails = 0, | |
| peg$tracer = "tracer" in options ? options.tracer : new peg$DefaultTracer(), | |
| peg$result; | |
| if ("startRule" in options) { | |
| if (!(options.startRule in peg$startRuleFunctions)) { | |
| throw new Error("Can't start parsing from rule \"" + options.startRule + "\"."); | |
| } | |
| peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; | |
| } | |
| function text() { | |
| return input.substring(peg$savedPos, peg$currPos); | |
| } | |
| function location() { | |
| return peg$computeLocation(peg$savedPos, peg$currPos); | |
| } | |
| function expected(description, location) { | |
| location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos) | |
| throw peg$buildStructuredError( | |
| [peg$otherExpectation(description)], | |
| input.substring(peg$savedPos, peg$currPos), | |
| location | |
| ); | |
| } | |
| function error(message, location) { | |
| location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos) | |
| throw peg$buildSimpleError(message, location); | |
| } | |
| function peg$literalExpectation(text, ignoreCase) { | |
| return { type: "literal", text: text, ignoreCase: ignoreCase }; | |
| } | |
| function peg$classExpectation(parts, inverted, ignoreCase) { | |
| return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase }; | |
| } | |
| function peg$anyExpectation() { | |
| return { type: "any" }; | |
| } | |
| function peg$endExpectation() { | |
| return { type: "end" }; | |
| } | |
| function peg$otherExpectation(description) { | |
| return { type: "other", description: description }; | |
| } | |
| function peg$computePosDetails(pos) { | |
| var details = peg$posDetailsCache[pos], p; | |
| if (details) { | |
| return details; | |
| } else { | |
| p = pos - 1; | |
| while (!peg$posDetailsCache[p]) { | |
| p--; | |
| } | |
| details = peg$posDetailsCache[p]; | |
| details = { | |
| line: details.line, | |
| column: details.column | |
| }; | |
| while (p < pos) { | |
| if (input.charCodeAt(p) === 10) { | |
| details.line++; | |
| details.column = 1; | |
| } else { | |
| details.column++; | |
| } | |
| p++; | |
| } | |
| peg$posDetailsCache[pos] = details; | |
| return details; | |
| } | |
| } | |
| function peg$computeLocation(startPos, endPos) { | |
| var startPosDetails = peg$computePosDetails(startPos), | |
| endPosDetails = peg$computePosDetails(endPos); | |
| return { | |
| start: { | |
| offset: startPos, | |
| line: startPosDetails.line, | |
| column: startPosDetails.column | |
| }, | |
| end: { | |
| offset: endPos, | |
| line: endPosDetails.line, | |
| column: endPosDetails.column | |
| } | |
| }; | |
| } | |
| function peg$fail(expected) { | |
| if (peg$currPos < peg$maxFailPos) { return; } | |
| if (peg$currPos > peg$maxFailPos) { | |
| peg$maxFailPos = peg$currPos; | |
| peg$maxFailExpected = []; | |
| } | |
| peg$maxFailExpected.push(expected); | |
| } | |
| function peg$buildSimpleError(message, location) { | |
| return new peg$SyntaxError(message, null, null, location); | |
| } | |
| function peg$buildStructuredError(expected, found, location) { | |
| return new peg$SyntaxError( | |
| peg$SyntaxError.buildMessage(expected, found), | |
| expected, | |
| found, | |
| location | |
| ); | |
| } | |
| function peg$parseBlock_List() { | |
| var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Block_List", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$currPos; | |
| s1 = peg$currPos; | |
| s2 = []; | |
| s3 = peg$currPos; | |
| s4 = peg$currPos; | |
| peg$silentFails++; | |
| s5 = peg$parseBlock(); | |
| peg$silentFails--; | |
| if (s5 === peg$FAILED) { | |
| s4 = void 0; | |
| } else { | |
| peg$currPos = s4; | |
| s4 = peg$FAILED; | |
| } | |
| if (s4 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s5 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s5 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s5 !== peg$FAILED) { | |
| s4 = [s4, s5]; | |
| s3 = s4; | |
| } else { | |
| peg$currPos = s3; | |
| s3 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s3; | |
| s3 = peg$FAILED; | |
| } | |
| while (s3 !== peg$FAILED) { | |
| s2.push(s3); | |
| s3 = peg$currPos; | |
| s4 = peg$currPos; | |
| peg$silentFails++; | |
| s5 = peg$parseBlock(); | |
| peg$silentFails--; | |
| if (s5 === peg$FAILED) { | |
| s4 = void 0; | |
| } else { | |
| peg$currPos = s4; | |
| s4 = peg$FAILED; | |
| } | |
| if (s4 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s5 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s5 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s5 !== peg$FAILED) { | |
| s4 = [s4, s5]; | |
| s3 = s4; | |
| } else { | |
| peg$currPos = s3; | |
| s3 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s3; | |
| s3 = peg$FAILED; | |
| } | |
| } | |
| if (s2 !== peg$FAILED) { | |
| s1 = input.substring(s1, peg$currPos); | |
| } else { | |
| s1 = s2; | |
| } | |
| if (s1 !== peg$FAILED) { | |
| s2 = []; | |
| s3 = peg$currPos; | |
| s4 = peg$parseBlock(); | |
| if (s4 !== peg$FAILED) { | |
| s5 = peg$currPos; | |
| s6 = []; | |
| s7 = peg$currPos; | |
| s8 = peg$currPos; | |
| peg$silentFails++; | |
| s9 = peg$parseBlock(); | |
| peg$silentFails--; | |
| if (s9 === peg$FAILED) { | |
| s8 = void 0; | |
| } else { | |
| peg$currPos = s8; | |
| s8 = peg$FAILED; | |
| } | |
| if (s8 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s9 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s9 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s9 !== peg$FAILED) { | |
| s8 = [s8, s9]; | |
| s7 = s8; | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| while (s7 !== peg$FAILED) { | |
| s6.push(s7); | |
| s7 = peg$currPos; | |
| s8 = peg$currPos; | |
| peg$silentFails++; | |
| s9 = peg$parseBlock(); | |
| peg$silentFails--; | |
| if (s9 === peg$FAILED) { | |
| s8 = void 0; | |
| } else { | |
| peg$currPos = s8; | |
| s8 = peg$FAILED; | |
| } | |
| if (s8 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s9 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s9 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s9 !== peg$FAILED) { | |
| s8 = [s8, s9]; | |
| s7 = s8; | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } | |
| if (s6 !== peg$FAILED) { | |
| s5 = input.substring(s5, peg$currPos); | |
| } else { | |
| s5 = s6; | |
| } | |
| if (s5 !== peg$FAILED) { | |
| peg$savedPos = s3; | |
| s4 = peg$c1(s1, s4, s5); | |
| s3 = s4; | |
| } else { | |
| peg$currPos = s3; | |
| s3 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s3; | |
| s3 = peg$FAILED; | |
| } | |
| while (s3 !== peg$FAILED) { | |
| s2.push(s3); | |
| s3 = peg$currPos; | |
| s4 = peg$parseBlock(); | |
| if (s4 !== peg$FAILED) { | |
| s5 = peg$currPos; | |
| s6 = []; | |
| s7 = peg$currPos; | |
| s8 = peg$currPos; | |
| peg$silentFails++; | |
| s9 = peg$parseBlock(); | |
| peg$silentFails--; | |
| if (s9 === peg$FAILED) { | |
| s8 = void 0; | |
| } else { | |
| peg$currPos = s8; | |
| s8 = peg$FAILED; | |
| } | |
| if (s8 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s9 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s9 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s9 !== peg$FAILED) { | |
| s8 = [s8, s9]; | |
| s7 = s8; | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| while (s7 !== peg$FAILED) { | |
| s6.push(s7); | |
| s7 = peg$currPos; | |
| s8 = peg$currPos; | |
| peg$silentFails++; | |
| s9 = peg$parseBlock(); | |
| peg$silentFails--; | |
| if (s9 === peg$FAILED) { | |
| s8 = void 0; | |
| } else { | |
| peg$currPos = s8; | |
| s8 = peg$FAILED; | |
| } | |
| if (s8 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s9 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s9 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s9 !== peg$FAILED) { | |
| s8 = [s8, s9]; | |
| s7 = s8; | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } | |
| if (s6 !== peg$FAILED) { | |
| s5 = input.substring(s5, peg$currPos); | |
| } else { | |
| s5 = s6; | |
| } | |
| if (s5 !== peg$FAILED) { | |
| peg$savedPos = s3; | |
| s4 = peg$c1(s1, s4, s5); | |
| s3 = s4; | |
| } else { | |
| peg$currPos = s3; | |
| s3 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s3; | |
| s3 = peg$FAILED; | |
| } | |
| } | |
| if (s2 !== peg$FAILED) { | |
| s3 = peg$currPos; | |
| s4 = []; | |
| if (input.length > peg$currPos) { | |
| s5 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s5 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| while (s5 !== peg$FAILED) { | |
| s4.push(s5); | |
| if (input.length > peg$currPos) { | |
| s5 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s5 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| } | |
| if (s4 !== peg$FAILED) { | |
| s3 = input.substring(s3, peg$currPos); | |
| } else { | |
| s3 = s4; | |
| } | |
| if (s3 !== peg$FAILED) { | |
| peg$savedPos = s0; | |
| s1 = peg$c2(s1, s2, s3); | |
| s0 = s1; | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Block_List", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Block_List", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseBlock() { | |
| var s0, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Block", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$parseBlock_Void(); | |
| if (s0 === peg$FAILED) { | |
| s0 = peg$parseBlock_Balanced(); | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Block", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Block", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseBlock_Void() { | |
| var s0, s1, s2, s3, s4, s5, s6, s7, s8, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Block_Void", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$currPos; | |
| if (input.substr(peg$currPos, 4) === peg$c3) { | |
| s1 = peg$c3; | |
| peg$currPos += 4; | |
| } else { | |
| s1 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c4); } | |
| } | |
| if (s1 !== peg$FAILED) { | |
| s2 = peg$parse__(); | |
| if (s2 !== peg$FAILED) { | |
| if (input.substr(peg$currPos, 3) === peg$c5) { | |
| s3 = peg$c5; | |
| peg$currPos += 3; | |
| } else { | |
| s3 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c6); } | |
| } | |
| if (s3 !== peg$FAILED) { | |
| s4 = peg$parseBlock_Name(); | |
| if (s4 !== peg$FAILED) { | |
| s5 = peg$parse__(); | |
| if (s5 !== peg$FAILED) { | |
| s6 = peg$currPos; | |
| s7 = peg$parseBlock_Attributes(); | |
| if (s7 !== peg$FAILED) { | |
| s8 = peg$parse__(); | |
| if (s8 !== peg$FAILED) { | |
| peg$savedPos = s6; | |
| s7 = peg$c7(s4, s7); | |
| s6 = s7; | |
| } else { | |
| peg$currPos = s6; | |
| s6 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s6; | |
| s6 = peg$FAILED; | |
| } | |
| if (s6 === peg$FAILED) { | |
| s6 = null; | |
| } | |
| if (s6 !== peg$FAILED) { | |
| if (input.substr(peg$currPos, 4) === peg$c8) { | |
| s7 = peg$c8; | |
| peg$currPos += 4; | |
| } else { | |
| s7 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c9); } | |
| } | |
| if (s7 !== peg$FAILED) { | |
| peg$savedPos = s0; | |
| s1 = peg$c10(s4, s6); | |
| s0 = s1; | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Block_Void", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Block_Void", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseBlock_Balanced() { | |
| var s0, s1, s2, s3, s4, s5, s6, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Block_Balanced", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$currPos; | |
| s1 = peg$parseBlock_Start(); | |
| if (s1 !== peg$FAILED) { | |
| s2 = []; | |
| s3 = peg$parseBlock(); | |
| if (s3 === peg$FAILED) { | |
| s3 = peg$currPos; | |
| s4 = peg$currPos; | |
| s5 = peg$currPos; | |
| peg$silentFails++; | |
| s6 = peg$parseBlock_End(); | |
| peg$silentFails--; | |
| if (s6 === peg$FAILED) { | |
| s5 = void 0; | |
| } else { | |
| peg$currPos = s5; | |
| s5 = peg$FAILED; | |
| } | |
| if (s5 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s6 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s6 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s6 !== | |
| peg$FAILED) { | |
| s5 = [s5, s6]; | |
| s4 = s5; | |
| } else { | |
| peg$currPos = s4; | |
| s4 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s4; | |
| s4 = peg$FAILED; | |
| } | |
| if (s4 !== peg$FAILED) { | |
| s3 = input.substring(s3, peg$currPos); | |
| } else { | |
| s3 = s4; | |
| } | |
| } | |
| while (s3 !== peg$FAILED) { | |
| s2.push(s3); | |
| s3 = peg$parseBlock(); | |
| if (s3 === peg$FAILED) { | |
| s3 = peg$currPos; | |
| s4 = peg$currPos; | |
| s5 = peg$currPos; | |
| peg$silentFails++; | |
| s6 = peg$parseBlock_End(); | |
| peg$silentFails--; | |
| if (s6 === peg$FAILED) { | |
| s5 = void 0; | |
| } else { | |
| peg$currPos = s5; | |
| s5 = peg$FAILED; | |
| } | |
| if (s5 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s6 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s6 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s6 !== peg$FAILED) { | |
| s5 = [s5, s6]; | |
| s4 = s5; | |
| } else { | |
| peg$currPos = s4; | |
| s4 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s4; | |
| s4 = peg$FAILED; | |
| } | |
| if (s4 !== peg$FAILED) { | |
| s3 = input.substring(s3, peg$currPos); | |
| } else { | |
| s3 = s4; | |
| } | |
| } | |
| } | |
| if (s2 !== peg$FAILED) { | |
| s3 = peg$parseBlock_End(); | |
| if (s3 !== peg$FAILED) { | |
| peg$savedPos = s0; | |
| s1 = peg$c11(s1, s2, s3); | |
| s0 = s1; | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Block_Balanced", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Block_Balanced", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseBlock_Start() { | |
| var s0, s1, s2, s3, s4, s5, s6, s7, s8, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Block_Start", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$currPos; | |
| if (input.substr(peg$currPos, 4) === peg$c3) { | |
| s1 = peg$c3; | |
| peg$currPos += 4; | |
| } else { | |
| s1 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c4); } | |
| } | |
| if (s1 !== peg$FAILED) { | |
| s2 = peg$parse__(); | |
| if (s2 !== peg$FAILED) { | |
| if (input.substr(peg$currPos, 3) === peg$c5) { | |
| s3 = peg$c5; | |
| peg$currPos += 3; | |
| } else { | |
| s3 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c6); } | |
| } | |
| if (s3 !== peg$FAILED) { | |
| s4 = peg$parseBlock_Name(); | |
| if (s4 !== peg$FAILED) { | |
| s5 = peg$parse__(); | |
| if (s5 !== peg$FAILED) { | |
| s6 = peg$currPos; | |
| s7 = peg$parseBlock_Attributes(); | |
| if (s7 !== peg$FAILED) { | |
| s8 = peg$parse__(); | |
| if (s8 !== peg$FAILED) { | |
| peg$savedPos = s6; | |
| s7 = peg$c7(s4, s7); | |
| s6 = s7; | |
| } else { | |
| peg$currPos = s6; | |
| s6 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s6; | |
| s6 = peg$FAILED; | |
| } | |
| if (s6 === peg$FAILED) { | |
| s6 = null; | |
| } | |
| if (s6 !== peg$FAILED) { | |
| if (input.substr(peg$currPos, 3) === peg$c12) { | |
| s7 = peg$c12; | |
| peg$currPos += 3; | |
| } else { | |
| s7 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c13); } | |
| } | |
| if (s7 !== peg$FAILED) { | |
| peg$savedPos = s0; | |
| s1 = peg$c14(s4, s6); | |
| s0 = s1; | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Block_Start", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Block_Start", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseBlock_End() { | |
| var s0, s1, s2, s3, s4, s5, s6, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Block_End", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$currPos; | |
| if (input.substr(peg$currPos, 4) === peg$c3) { | |
| s1 = peg$c3; | |
| peg$currPos += 4; | |
| } else { | |
| s1 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c4); } | |
| } | |
| if (s1 !== peg$FAILED) { | |
| s2 = peg$parse__(); | |
| if (s2 !== peg$FAILED) { | |
| if (input.substr(peg$currPos, 4) === peg$c15) { | |
| s3 = peg$c15; | |
| peg$currPos += 4; | |
| } else { | |
| s3 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c16); } | |
| } | |
| if (s3 !== peg$FAILED) { | |
| s4 = peg$parseBlock_Name(); | |
| if (s4 !== peg$FAILED) { | |
| s5 = peg$parse__(); | |
| if (s5 !== peg$FAILED) { | |
| if (input.substr(peg$currPos, 3) === peg$c12) { | |
| s6 = peg$c12; | |
| peg$currPos += 3; | |
| } else { | |
| s6 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c13); } | |
| } | |
| if (s6 !== peg$FAILED) { | |
| peg$savedPos = s0; | |
| s1 = peg$c17(s4); | |
| s0 = s1; | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s0; | |
| s0 = peg$FAILED; | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Block_End", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Block_End", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseBlock_Name() { | |
| var s0, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Block_Name", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$parseNamespaced_Block_Name(); | |
| if (s0 === peg$FAILED) { | |
| s0 = peg$parseCore_Block_Name(); | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Block_Name", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Block_Name", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseNamespaced_Block_Name() { | |
| var s0, s1, s2, s3, s4, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Namespaced_Block_Name", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$currPos; | |
| s1 = peg$currPos; | |
| s2 = peg$parseBlock_Name_Part(); | |
| if (s2 !== peg$FAILED) { | |
| if (input.charCodeAt(peg$currPos) === 47) { | |
| s3 = peg$c18; | |
| peg$currPos++; | |
| } else { | |
| s3 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c19); } | |
| } | |
| if (s3 !== peg$FAILED) { | |
| s4 = peg$parseBlock_Name_Part(); | |
| if (s4 !== peg$FAILED) { | |
| s2 = [s2, s3, s4]; | |
| s1 = s2; | |
| } else { | |
| peg$currPos = s1; | |
| s1 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s1; | |
| s1 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s1; | |
| s1 = peg$FAILED; | |
| } | |
| if (s1 !== peg$FAILED) { | |
| s0 = input.substring(s0, peg$currPos); | |
| } else { | |
| s0 = s1; | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Namespaced_Block_Name", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Namespaced_Block_Name", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseCore_Block_Name() { | |
| var s0, s1, s2, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Core_Block_Name", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$currPos; | |
| s1 = peg$currPos; | |
| s2 = peg$parseBlock_Name_Part(); | |
| if (s2 !== peg$FAILED) { | |
| s1 = input.substring(s1, peg$currPos); | |
| } else { | |
| s1 = s2; | |
| } | |
| if (s1 !== peg$FAILED) { | |
| peg$savedPos = s0; | |
| s1 = peg$c20(s1); | |
| } | |
| s0 = s1; | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Core_Block_Name", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Core_Block_Name", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseBlock_Name_Part() { | |
| var s0, s1, s2, s3, s4, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Block_Name_Part", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$currPos; | |
| s1 = peg$currPos; | |
| if (peg$c21.test(input.charAt(peg$currPos))) { | |
| s2 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s2 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c22); } | |
| } | |
| if (s2 !== peg$FAILED) { | |
| s3 = []; | |
| if (peg$c23.test(input.charAt(peg$currPos))) { | |
| s4 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s4 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c24); } | |
| } | |
| while (s4 !== peg$FAILED) { | |
| s3.push(s4); | |
| if (peg$c23.test(input.charAt(peg$currPos))) { | |
| s4 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s4 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c24); } | |
| } | |
| } | |
| if (s3 !== peg$FAILED) { | |
| s2 = [s2, s3]; | |
| s1 = s2; | |
| } else { | |
| peg$currPos = s1; | |
| s1 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s1; | |
| s1 = peg$FAILED; | |
| } | |
| if (s1 !== peg$FAILED) { | |
| s0 = input.substring(s0, peg$currPos); | |
| } else { | |
| s0 = s1; | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Block_Name_Part", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Block_Name_Part", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parseBlock_Attributes() { | |
| var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "Block_Attributes", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = peg$currPos; | |
| s1 = peg$currPos; | |
| s2 = peg$currPos; | |
| if (input.charCodeAt(peg$currPos) === 123) { | |
| s3 = peg$c25; | |
| peg$currPos++; | |
| } else { | |
| s3 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c26); } | |
| } | |
| if (s3 !== peg$FAILED) { | |
| s4 = []; | |
| s5 = peg$currPos; | |
| s6 = peg$currPos; | |
| peg$silentFails++; | |
| s7 = peg$currPos; | |
| if (input.charCodeAt(peg$currPos) === 125) { | |
| s8 = peg$c27; | |
| peg$currPos++; | |
| } else { | |
| s8 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c28); } | |
| } | |
| if (s8 !== peg$FAILED) { | |
| s9 = peg$parse__(); | |
| if (s9 !== peg$FAILED) { | |
| s10 = peg$c29; | |
| if (s10 !== peg$FAILED) { | |
| if (input.charCodeAt(peg$currPos) === 47) { | |
| s11 = peg$c18; | |
| peg$currPos++; | |
| } else { | |
| s11 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c19); } | |
| } | |
| if (s11 === peg$FAILED) { | |
| s11 = null; | |
| } | |
| if (s11 !== peg$FAILED) { | |
| if (input.substr(peg$currPos, 3) === peg$c12) { | |
| s12 = peg$c12; | |
| peg$currPos += 3; | |
| } else { | |
| s12 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c13); } | |
| } | |
| if (s12 !== peg$FAILED) { | |
| s8 = [s8, s9, s10, s11, s12]; | |
| s7 = s8; | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| peg$silentFails--; | |
| if (s7 === peg$FAILED) { | |
| s6 = void 0; | |
| } else { | |
| peg$currPos = s6; | |
| s6 = peg$FAILED; | |
| } | |
| if (s6 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s7 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s7 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s7 !== peg$FAILED) { | |
| s6 = [s6, s7]; | |
| s5 = s6; | |
| } else { | |
| peg$currPos = s5; | |
| s5 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s5; | |
| s5 = peg$FAILED; | |
| } | |
| while (s5 !== peg$FAILED) { | |
| s4.push(s5); | |
| s5 = peg$currPos; | |
| s6 = peg$currPos; | |
| peg$silentFails++; | |
| s7 = peg$currPos; | |
| if (input.charCodeAt(peg$currPos) === 125) { | |
| s8 = peg$c27; | |
| peg$currPos++; | |
| } else { | |
| s8 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c28); } | |
| } | |
| if (s8 !== peg$FAILED) { | |
| s9 = peg$parse__(); | |
| if (s9 !== peg$FAILED) { | |
| s10 = peg$c29; | |
| if (s10 !== peg$FAILED) { | |
| if (input.charCodeAt(peg$currPos) === 47) { | |
| s11 = peg$c18; | |
| peg$currPos++; | |
| } else { | |
| s11 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c19); } | |
| } | |
| if (s11 === peg$FAILED) { | |
| s11 = null; | |
| } | |
| if (s11 !== peg$FAILED) { | |
| if (input.substr(peg$currPos, 3) === peg$c12) { | |
| s12 = peg$c12; | |
| peg$currPos += 3; | |
| } else { | |
| s12 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c13); } | |
| } | |
| if (s12 !== peg$FAILED) { | |
| s8 = [s8, s9, s10, s11, s12]; | |
| s7 = s8; | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s7; | |
| s7 = peg$FAILED; | |
| } | |
| peg$silentFails--; | |
| if (s7 === peg$FAILED) { | |
| s6 = void 0; | |
| } else { | |
| peg$currPos = s6; | |
| s6 = peg$FAILED; | |
| } | |
| if (s6 !== peg$FAILED) { | |
| if (input.length > peg$currPos) { | |
| s7 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s7 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c0); } | |
| } | |
| if (s7 !== peg$FAILED) { | |
| s6 = [s6, s7]; | |
| s5 = s6; | |
| } else { | |
| peg$currPos = s5; | |
| s5 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s5; | |
| s5 = peg$FAILED; | |
| } | |
| } | |
| if (s4 !== peg$FAILED) { | |
| if (input.charCodeAt(peg$currPos) === 125) { | |
| s5 = peg$c27; | |
| peg$currPos++; | |
| } else { | |
| s5 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c28); } | |
| } | |
| if (s5 !== peg$FAILED) { | |
| s3 = [s3, s4, s5]; | |
| s2 = s3; | |
| } else { | |
| peg$currPos = s2; | |
| s2 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s2; | |
| s2 = peg$FAILED; | |
| } | |
| } else { | |
| peg$currPos = s2; | |
| s2 = peg$FAILED; | |
| } | |
| if (s2 !== peg$FAILED) { | |
| s1 = input.substring(s1, peg$currPos); | |
| } else { | |
| s1 = s2; | |
| } | |
| if (s1 !== peg$FAILED) { | |
| peg$savedPos = s0; | |
| s1 = peg$c30(s1); | |
| } | |
| s0 = s1; | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "Block_Attributes", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "Block_Attributes", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| function peg$parse__() { | |
| var s0, s1, | |
| startPos = peg$currPos; | |
| peg$tracer.trace({ | |
| type: "rule.enter", | |
| rule: "__", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| s0 = []; | |
| if (peg$c31.test(input.charAt(peg$currPos))) { | |
| s1 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s1 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c32); } | |
| } | |
| if (s1 !== peg$FAILED) { | |
| while (s1 !== peg$FAILED) { | |
| s0.push(s1); | |
| if (peg$c31.test(input.charAt(peg$currPos))) { | |
| s1 = input.charAt(peg$currPos); | |
| peg$currPos++; | |
| } else { | |
| s1 = peg$FAILED; | |
| if (peg$silentFails === 0) { peg$fail(peg$c32); } | |
| } | |
| } | |
| } else { | |
| s0 = peg$FAILED; | |
| } | |
| if (s0 !== peg$FAILED) { | |
| peg$tracer.trace({ | |
| type: "rule.match", | |
| rule: "__", | |
| result: s0, | |
| location: peg$computeLocation(startPos, peg$currPos) | |
| }); | |
| } else { | |
| peg$tracer.trace({ | |
| type: "rule.fail", | |
| rule: "__", | |
| location: peg$computeLocation(startPos, startPos) | |
| }); | |
| } | |
| return s0; | |
| } | |
| /* | |
| * | |
| * _____ _ _ | |
| * / ____| | | | | | |
| * | | __ _ _| |_ ___ _ __ | |__ ___ _ __ __ _ | |
| * | | |_ | | | | __/ _ \ '_ \| '_ \ / _ \ '__/ _` | | |
| * | |__| | |_| | || __/ | | | |_) | __/ | | (_| | | |
| * \_____|\__,_|\__\___|_| |_|_.__/ \___|_| \__, | | |
| * __/ | | |
| * GRAMMAR |___/ | |
| * | |
| * | |
| * Welcome to the grammar file for Gutenberg posts! | |
| * | |
| * Please don't be distracted by the functions at the top | |
| * here - they're just helpers for the grammar below. We | |
| * try to keep them as minimal and simple as possible, | |
| * but the parser generator forces us to declare them at | |
| * the beginning of the file. | |
| * | |
| * What follows is the official specification grammar for | |
| * documents created or edited in Gutenberg. It starts at | |
| * the top-level rule `Block_List` | |
| * | |
| * The grammar is defined by a series of _rules_ and ways | |
| * to return matches on those rules. It's a _PEG_, a | |
| * parsing expression grammar, which simply means that for | |
| * each of our rules we have a set of sub-rules to match | |
| * on and the generated parser will try them in order | |
| * until it finds the first match. | |
| * | |
| * This grammar is a _specification_ (with as little actual | |
| * code as we can get away with) which is used by the | |
| * parser generator to generate the actual _parser_ which | |
| * is used by Gutenberg. We generate two parsers: one in | |
| * JavaScript for use the browser and one in PHP for | |
| * WordPress itself. PEG parser generators are available | |
| * in many languages, though different libraries may require | |
| * some translation of this grammar into their syntax. | |
| * | |
| * For more information: | |
| * @see https://pegjs.org | |
| * @see https://en.wikipedia.org/wiki/Parsing_expression_grammar | |
| * | |
| */ | |
| /** <?php | |
| // The `maybeJSON` function is not needed in PHP because its return semantics | |
| // are the same as `json_decode` | |
| // array arguments are backwards because of PHP | |
| if ( ! function_exists( 'peg_array_partition' ) ) { | |
| function peg_array_partition( $array, $predicate ) { | |
| $truthy = array(); | |
| $falsey = array(); | |
| foreach ( $array as $item ) { | |
| call_user_func( $predicate, $item ) | |
| ? $truthy[] = $item | |
| : $falsey[] = $item; | |
| } | |
| return array( $truthy, $falsey ); | |
| } | |
| } | |
| if ( ! function_exists( 'peg_join_blocks' ) ) { | |
| function peg_join_blocks( $pre, $tokens, $post ) { | |
| $blocks = array(); | |
| if ( ! empty( $pre ) ) { | |
| $blocks[] = array( 'attrs' => array(), 'innerHTML' => $pre ); | |
| } | |
| foreach ( $tokens as $token ) { | |
| list( $token, $html ) = $token; | |
| $blocks[] = $token; | |
| if ( ! empty( $html ) ) { | |
| $blocks[] = array( 'attrs' => array(), 'innerHTML' => $html ); | |
| } | |
| } | |
| if ( ! empty( $post ) ) { | |
| $blocks[] = array( 'attrs' => array(), 'innerHTML' => $post ); | |
| } | |
| return $blocks; | |
| } | |
| } | |
| ?> **/ | |
| function freeform( s ) { | |
| return s.length && { | |
| attrs: {}, | |
| innerHTML: s | |
| }; | |
| } | |
| function joinBlocks( pre, tokens, post ) { | |
| var blocks = [], i, l, html, item, token; | |
| if ( pre.length ) { | |
| blocks.push( freeform( pre ) ); | |
| } | |
| for ( i = 0, l = tokens.length; i < l; i++ ) { | |
| item = tokens[ i ]; | |
| token = item[ 0 ]; | |
| html = item[ 1 ]; | |
| blocks.push( token ); | |
| if ( html.length ) { | |
| blocks.push( freeform( html ) ); | |
| } | |
| } | |
| if ( post.length ) { | |
| blocks.push( freeform( post ) ); | |
| } | |
| return blocks; | |
| } | |
| function maybeJSON( s ) { | |
| try { | |
| return JSON.parse( s ); | |
| } catch (e) { | |
| return null; | |
| } | |
| } | |
| function partition( predicate, list ) { | |
| var i, l, item; | |
| var truthy = []; | |
| var falsey = []; | |
| // nod to performance over a simpler reduce | |
| // and clone model we could have taken here | |
| for ( i = 0, l = list.length; i < l; i++ ) { | |
| item = list[ i ]; | |
| predicate( item ) | |
| ? truthy.push( item ) | |
| : falsey.push( item ) | |
| }; | |
| return [ truthy, falsey ]; | |
| } | |
| peg$result = peg$startRuleFunction(); | |
| if (peg$result !== peg$FAILED && peg$currPos === input.length) { | |
| return peg$result; | |
| } else { | |
| if (peg$result !== peg$FAILED && peg$currPos < input.length) { | |
| peg$fail(peg$endExpectation()); | |
| } | |
| throw peg$buildStructuredError( | |
| peg$maxFailExpected, | |
| peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, | |
| peg$maxFailPos < input.length | |
| ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) | |
| : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) | |
| ); | |
| } | |
| } | |
| module.exports = { | |
| SyntaxError: peg$SyntaxError, | |
| DefaultTracer: peg$DefaultTracer, | |
| parse: peg$parse | |
| }; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment