Mercurial > repos > tabletprog
comparison peg.js @ 0:3d1b8e96f5dc
Initial commit
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Sun, 18 Mar 2012 12:03:04 -0700 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:3d1b8e96f5dc |
---|---|
1 /* PEG.js 0.6.2 (http://pegjs.majda.cz/) */ | |
2 | |
3 (function() { | |
4 | |
5 var undefined; | |
6 | |
7 var PEG = { | |
8 /* PEG.js version. */ | |
9 VERSION: "0.6.2", | |
10 | |
11 /* | |
12 * Generates a parser from a specified grammar and returns it. | |
13 * | |
14 * The grammar must be a string in the format described by the metagramar in | |
15 * the parser.pegjs file. | |
16 * | |
17 * Throws |PEG.parser.SyntaxError| if the grammar contains a syntax error or | |
18 * |PEG.GrammarError| if it contains a semantic error. Note that not all | |
19 * errors are detected during the generation and some may protrude to the | |
20 * generated parser and cause its malfunction. | |
21 */ | |
22 buildParser: function(grammar) { | |
23 return PEG.compiler.compile(PEG.parser.parse(grammar)); | |
24 } | |
25 }; | |
26 | |
27 /* Thrown when the grammar contains an error. */ | |
28 | |
29 PEG.GrammarError = function(message) { | |
30 this.name = "PEG.GrammarError"; | |
31 this.message = message; | |
32 }; | |
33 | |
34 PEG.GrammarError.prototype = Error.prototype; | |
35 | |
36 function contains(array, value) { | |
37 /* | |
38 * Stupid IE does not have Array.prototype.indexOf, otherwise this function | |
39 * would be a one-liner. | |
40 */ | |
41 var length = array.length; | |
42 for (var i = 0; i < length; i++) { | |
43 if (array[i] === value) { | |
44 return true; | |
45 } | |
46 } | |
47 return false; | |
48 } | |
49 | |
50 function each(array, callback) { | |
51 var length = array.length; | |
52 for (var i = 0; i < length; i++) { | |
53 callback(array[i]); | |
54 } | |
55 } | |
56 | |
57 function map(array, callback) { | |
58 var result = []; | |
59 var length = array.length; | |
60 for (var i = 0; i < length; i++) { | |
61 result[i] = callback(array[i]); | |
62 } | |
63 return result; | |
64 } | |
65 | |
66 /* | |
67 * Returns a string padded on the left to a desired length with a character. | |
68 * | |
69 * The code needs to be in sync with th code template in the compilation | |
70 * function for "action" nodes. | |
71 */ | |
72 function padLeft(input, padding, length) { | |
73 var result = input; | |
74 | |
75 var padLength = length - input.length; | |
76 for (var i = 0; i < padLength; i++) { | |
77 result = padding + result; | |
78 } | |
79 | |
80 return result; | |
81 } | |
82 | |
83 /* | |
84 * Returns an escape sequence for given character. Uses \x for characters <= | |
85 * 0xFF to save space, \u for the rest. | |
86 * | |
87 * The code needs to be in sync with th code template in the compilation | |
88 * function for "action" nodes. | |
89 */ | |
90 function escape(ch) { | |
91 var charCode = ch.charCodeAt(0); | |
92 | |
93 if (charCode <= 0xFF) { | |
94 var escapeChar = 'x'; | |
95 var length = 2; | |
96 } else { | |
97 var escapeChar = 'u'; | |
98 var length = 4; | |
99 } | |
100 | |
101 return '\\' + escapeChar + padLeft(charCode.toString(16).toUpperCase(), '0', length); | |
102 } | |
103 | |
104 /* | |
105 * Surrounds the string with quotes and escapes characters inside so that the | |
106 * result is a valid JavaScript string. | |
107 * | |
108 * The code needs to be in sync with th code template in the compilation | |
109 * function for "action" nodes. | |
110 */ | |
111 function quote(s) { | |
112 /* | |
113 * ECMA-262, 5th ed., 7.8.4: All characters may appear literally in a string | |
114 * literal except for the closing quote character, backslash, carriage return, | |
115 * line separator, paragraph separator, and line feed. Any character may | |
116 * appear in the form of an escape sequence. | |
117 * | |
118 * For portability, we also escape escape all non-ASCII characters. | |
119 */ | |
120 return '"' + s | |
121 .replace(/\\/g, '\\\\') // backslash | |
122 .replace(/"/g, '\\"') // closing quote character | |
123 .replace(/\r/g, '\\r') // carriage return | |
124 .replace(/\n/g, '\\n') // line feed | |
125 .replace(/[\x80-\uFFFF]/g, escape) // non-ASCII characters | |
126 + '"'; | |
127 }; | |
128 | |
129 /* | |
130 * Escapes characters inside the string so that it can be used as a list of | |
131 * characters in a character class of a regular expression. | |
132 */ | |
133 function quoteForRegexpClass(s) { | |
134 /* | |
135 * Based on ECMA-262, 5th ed., 7.8.5 & 15.10.1. | |
136 * | |
137 * For portability, we also escape escape all non-ASCII characters. | |
138 */ | |
139 return s | |
140 .replace(/\\/g, '\\\\') // backslash | |
141 .replace(/\0/g, '\\0') // null, IE needs this | |
142 .replace(/\//g, '\\/') // closing slash | |
143 .replace(/]/g, '\\]') // closing bracket | |
144 .replace(/-/g, '\\-') // dash | |
145 .replace(/\r/g, '\\r') // carriage return | |
146 .replace(/\n/g, '\\n') // line feed | |
147 .replace(/[\x80-\uFFFF]/g, escape) // non-ASCII characters | |
148 } | |
149 | |
150 /* | |
151 * Builds a node visitor -- a function which takes a node and any number of | |
152 * other parameters, calls an appropriate function according to the node type, | |
153 * passes it all its parameters and returns its value. The functions for various | |
154 * node types are passed in a parameter to |buildNodeVisitor| as a hash. | |
155 */ | |
156 function buildNodeVisitor(functions) { | |
157 return function(node) { | |
158 return functions[node.type].apply(null, arguments); | |
159 } | |
160 } | |
161 PEG.parser = (function(){ | |
162 /* Generated by PEG.js 0.6.2 (http://pegjs.majda.cz/). */ | |
163 | |
164 var result = { | |
165 /* | |
166 * Parses the input with a generated parser. If the parsing is successfull, | |
167 * returns a value explicitly or implicitly specified by the grammar from | |
168 * which the parser was generated (see |PEG.buildParser|). If the parsing is | |
169 * unsuccessful, throws |PEG.parser.SyntaxError| describing the error. | |
170 */ | |
171 parse: function(input, startRule) { | |
172 var parseFunctions = { | |
173 "__": parse___, | |
174 "action": parse_action, | |
175 "and": parse_and, | |
176 "braced": parse_braced, | |
177 "bracketDelimitedCharacter": parse_bracketDelimitedCharacter, | |
178 "choice": parse_choice, | |
179 "class": parse_class, | |
180 "classCharacter": parse_classCharacter, | |
181 "classCharacterRange": parse_classCharacterRange, | |
182 "colon": parse_colon, | |
183 "comment": parse_comment, | |
184 "digit": parse_digit, | |
185 "dot": parse_dot, | |
186 "doubleQuotedCharacter": parse_doubleQuotedCharacter, | |
187 "doubleQuotedLiteral": parse_doubleQuotedLiteral, | |
188 "eol": parse_eol, | |
189 "eolChar": parse_eolChar, | |
190 "eolEscapeSequence": parse_eolEscapeSequence, | |
191 "equals": parse_equals, | |
192 "grammar": parse_grammar, | |
193 "hexDigit": parse_hexDigit, | |
194 "hexEscapeSequence": parse_hexEscapeSequence, | |
195 "identifier": parse_identifier, | |
196 "initializer": parse_initializer, | |
197 "labeled": parse_labeled, | |
198 "letter": parse_letter, | |
199 "literal": parse_literal, | |
200 "lowerCaseLetter": parse_lowerCaseLetter, | |
201 "lparen": parse_lparen, | |
202 "multiLineComment": parse_multiLineComment, | |
203 "nonBraceCharacter": parse_nonBraceCharacter, | |
204 "nonBraceCharacters": parse_nonBraceCharacters, | |
205 "not": parse_not, | |
206 "plus": parse_plus, | |
207 "prefixed": parse_prefixed, | |
208 "primary": parse_primary, | |
209 "question": parse_question, | |
210 "rparen": parse_rparen, | |
211 "rule": parse_rule, | |
212 "semicolon": parse_semicolon, | |
213 "sequence": parse_sequence, | |
214 "simpleBracketDelimitedCharacter": parse_simpleBracketDelimitedCharacter, | |
215 "simpleDoubleQuotedCharacter": parse_simpleDoubleQuotedCharacter, | |
216 "simpleEscapeSequence": parse_simpleEscapeSequence, | |
217 "simpleSingleQuotedCharacter": parse_simpleSingleQuotedCharacter, | |
218 "singleLineComment": parse_singleLineComment, | |
219 "singleQuotedCharacter": parse_singleQuotedCharacter, | |
220 "singleQuotedLiteral": parse_singleQuotedLiteral, | |
221 "slash": parse_slash, | |
222 "star": parse_star, | |
223 "suffixed": parse_suffixed, | |
224 "unicodeEscapeSequence": parse_unicodeEscapeSequence, | |
225 "upperCaseLetter": parse_upperCaseLetter, | |
226 "whitespace": parse_whitespace, | |
227 "zeroEscapeSequence": parse_zeroEscapeSequence | |
228 }; | |
229 | |
230 if (startRule !== undefined) { | |
231 if (parseFunctions[startRule] === undefined) { | |
232 throw new Error("Invalid rule name: " + quote(startRule) + "."); | |
233 } | |
234 } else { | |
235 startRule = "grammar"; | |
236 } | |
237 | |
238 var pos = 0; | |
239 var reportMatchFailures = true; | |
240 var rightmostMatchFailuresPos = 0; | |
241 var rightmostMatchFailuresExpected = []; | |
242 var cache = {}; | |
243 | |
244 function padLeft(input, padding, length) { | |
245 var result = input; | |
246 | |
247 var padLength = length - input.length; | |
248 for (var i = 0; i < padLength; i++) { | |
249 result = padding + result; | |
250 } | |
251 | |
252 return result; | |
253 } | |
254 | |
255 function escape(ch) { | |
256 var charCode = ch.charCodeAt(0); | |
257 | |
258 if (charCode <= 0xFF) { | |
259 var escapeChar = 'x'; | |
260 var length = 2; | |
261 } else { | |
262 var escapeChar = 'u'; | |
263 var length = 4; | |
264 } | |
265 | |
266 return '\\' + escapeChar + padLeft(charCode.toString(16).toUpperCase(), '0', length); | |
267 } | |
268 | |
269 function quote(s) { | |
270 /* | |
271 * ECMA-262, 5th ed., 7.8.4: All characters may appear literally in a | |
272 * string literal except for the closing quote character, backslash, | |
273 * carriage return, line separator, paragraph separator, and line feed. | |
274 * Any character may appear in the form of an escape sequence. | |
275 */ | |
276 return '"' + s | |
277 .replace(/\\/g, '\\\\') // backslash | |
278 .replace(/"/g, '\\"') // closing quote character | |
279 .replace(/\r/g, '\\r') // carriage return | |
280 .replace(/\n/g, '\\n') // line feed | |
281 .replace(/[\x80-\uFFFF]/g, escape) // non-ASCII characters | |
282 + '"'; | |
283 } | |
284 | |
285 function matchFailed(failure) { | |
286 if (pos < rightmostMatchFailuresPos) { | |
287 return; | |
288 } | |
289 | |
290 if (pos > rightmostMatchFailuresPos) { | |
291 rightmostMatchFailuresPos = pos; | |
292 rightmostMatchFailuresExpected = []; | |
293 } | |
294 | |
295 rightmostMatchFailuresExpected.push(failure); | |
296 } | |
297 | |
298 function parse_grammar() { | |
299 var cacheKey = 'grammar@' + pos; | |
300 var cachedResult = cache[cacheKey]; | |
301 if (cachedResult) { | |
302 pos = cachedResult.nextPos; | |
303 return cachedResult.result; | |
304 } | |
305 | |
306 | |
307 var savedPos0 = pos; | |
308 var savedPos1 = pos; | |
309 var result3 = parse___(); | |
310 if (result3 !== null) { | |
311 var result7 = parse_initializer(); | |
312 var result4 = result7 !== null ? result7 : ''; | |
313 if (result4 !== null) { | |
314 var result6 = parse_rule(); | |
315 if (result6 !== null) { | |
316 var result5 = []; | |
317 while (result6 !== null) { | |
318 result5.push(result6); | |
319 var result6 = parse_rule(); | |
320 } | |
321 } else { | |
322 var result5 = null; | |
323 } | |
324 if (result5 !== null) { | |
325 var result1 = [result3, result4, result5]; | |
326 } else { | |
327 var result1 = null; | |
328 pos = savedPos1; | |
329 } | |
330 } else { | |
331 var result1 = null; | |
332 pos = savedPos1; | |
333 } | |
334 } else { | |
335 var result1 = null; | |
336 pos = savedPos1; | |
337 } | |
338 var result2 = result1 !== null | |
339 ? (function(initializer, rules) { | |
340 var rulesConverted = {}; | |
341 each(rules, function(rule) { rulesConverted[rule.name] = rule; }); | |
342 | |
343 return { | |
344 type: "grammar", | |
345 initializer: initializer !== "" ? initializer : null, | |
346 rules: rulesConverted, | |
347 startRule: rules[0].name | |
348 } | |
349 })(result1[1], result1[2]) | |
350 : null; | |
351 if (result2 !== null) { | |
352 var result0 = result2; | |
353 } else { | |
354 var result0 = null; | |
355 pos = savedPos0; | |
356 } | |
357 | |
358 | |
359 | |
360 cache[cacheKey] = { | |
361 nextPos: pos, | |
362 result: result0 | |
363 }; | |
364 return result0; | |
365 } | |
366 | |
367 function parse_initializer() { | |
368 var cacheKey = 'initializer@' + pos; | |
369 var cachedResult = cache[cacheKey]; | |
370 if (cachedResult) { | |
371 pos = cachedResult.nextPos; | |
372 return cachedResult.result; | |
373 } | |
374 | |
375 | |
376 var savedPos0 = pos; | |
377 var savedPos1 = pos; | |
378 var result3 = parse_action(); | |
379 if (result3 !== null) { | |
380 var result5 = parse_semicolon(); | |
381 var result4 = result5 !== null ? result5 : ''; | |
382 if (result4 !== null) { | |
383 var result1 = [result3, result4]; | |
384 } else { | |
385 var result1 = null; | |
386 pos = savedPos1; | |
387 } | |
388 } else { | |
389 var result1 = null; | |
390 pos = savedPos1; | |
391 } | |
392 var result2 = result1 !== null | |
393 ? (function(code) { | |
394 return { | |
395 type: "initializer", | |
396 code: code | |
397 }; | |
398 })(result1[0]) | |
399 : null; | |
400 if (result2 !== null) { | |
401 var result0 = result2; | |
402 } else { | |
403 var result0 = null; | |
404 pos = savedPos0; | |
405 } | |
406 | |
407 | |
408 | |
409 cache[cacheKey] = { | |
410 nextPos: pos, | |
411 result: result0 | |
412 }; | |
413 return result0; | |
414 } | |
415 | |
416 function parse_rule() { | |
417 var cacheKey = 'rule@' + pos; | |
418 var cachedResult = cache[cacheKey]; | |
419 if (cachedResult) { | |
420 pos = cachedResult.nextPos; | |
421 return cachedResult.result; | |
422 } | |
423 | |
424 | |
425 var savedPos0 = pos; | |
426 var savedPos1 = pos; | |
427 var result3 = parse_identifier(); | |
428 if (result3 !== null) { | |
429 var result10 = parse_literal(); | |
430 if (result10 !== null) { | |
431 var result4 = result10; | |
432 } else { | |
433 if (input.substr(pos, 0) === "") { | |
434 var result9 = ""; | |
435 pos += 0; | |
436 } else { | |
437 var result9 = null; | |
438 if (reportMatchFailures) { | |
439 matchFailed("\"\""); | |
440 } | |
441 } | |
442 if (result9 !== null) { | |
443 var result4 = result9; | |
444 } else { | |
445 var result4 = null;; | |
446 }; | |
447 } | |
448 if (result4 !== null) { | |
449 var result5 = parse_equals(); | |
450 if (result5 !== null) { | |
451 var result6 = parse_choice(); | |
452 if (result6 !== null) { | |
453 var result8 = parse_semicolon(); | |
454 var result7 = result8 !== null ? result8 : ''; | |
455 if (result7 !== null) { | |
456 var result1 = [result3, result4, result5, result6, result7]; | |
457 } else { | |
458 var result1 = null; | |
459 pos = savedPos1; | |
460 } | |
461 } else { | |
462 var result1 = null; | |
463 pos = savedPos1; | |
464 } | |
465 } else { | |
466 var result1 = null; | |
467 pos = savedPos1; | |
468 } | |
469 } else { | |
470 var result1 = null; | |
471 pos = savedPos1; | |
472 } | |
473 } else { | |
474 var result1 = null; | |
475 pos = savedPos1; | |
476 } | |
477 var result2 = result1 !== null | |
478 ? (function(name, displayName, expression) { | |
479 return { | |
480 type: "rule", | |
481 name: name, | |
482 displayName: displayName !== "" ? displayName : null, | |
483 expression: expression | |
484 }; | |
485 })(result1[0], result1[1], result1[3]) | |
486 : null; | |
487 if (result2 !== null) { | |
488 var result0 = result2; | |
489 } else { | |
490 var result0 = null; | |
491 pos = savedPos0; | |
492 } | |
493 | |
494 | |
495 | |
496 cache[cacheKey] = { | |
497 nextPos: pos, | |
498 result: result0 | |
499 }; | |
500 return result0; | |
501 } | |
502 | |
503 function parse_choice() { | |
504 var cacheKey = 'choice@' + pos; | |
505 var cachedResult = cache[cacheKey]; | |
506 if (cachedResult) { | |
507 pos = cachedResult.nextPos; | |
508 return cachedResult.result; | |
509 } | |
510 | |
511 | |
512 var savedPos0 = pos; | |
513 var savedPos1 = pos; | |
514 var result3 = parse_sequence(); | |
515 if (result3 !== null) { | |
516 var result4 = []; | |
517 var savedPos2 = pos; | |
518 var result6 = parse_slash(); | |
519 if (result6 !== null) { | |
520 var result7 = parse_sequence(); | |
521 if (result7 !== null) { | |
522 var result5 = [result6, result7]; | |
523 } else { | |
524 var result5 = null; | |
525 pos = savedPos2; | |
526 } | |
527 } else { | |
528 var result5 = null; | |
529 pos = savedPos2; | |
530 } | |
531 while (result5 !== null) { | |
532 result4.push(result5); | |
533 var savedPos2 = pos; | |
534 var result6 = parse_slash(); | |
535 if (result6 !== null) { | |
536 var result7 = parse_sequence(); | |
537 if (result7 !== null) { | |
538 var result5 = [result6, result7]; | |
539 } else { | |
540 var result5 = null; | |
541 pos = savedPos2; | |
542 } | |
543 } else { | |
544 var result5 = null; | |
545 pos = savedPos2; | |
546 } | |
547 } | |
548 if (result4 !== null) { | |
549 var result1 = [result3, result4]; | |
550 } else { | |
551 var result1 = null; | |
552 pos = savedPos1; | |
553 } | |
554 } else { | |
555 var result1 = null; | |
556 pos = savedPos1; | |
557 } | |
558 var result2 = result1 !== null | |
559 ? (function(head, tail) { | |
560 if (tail.length > 0) { | |
561 var alternatives = [head].concat(map( | |
562 tail, | |
563 function(element) { return element[1]; } | |
564 )); | |
565 return { | |
566 type: "choice", | |
567 alternatives: alternatives | |
568 } | |
569 } else { | |
570 return head; | |
571 } | |
572 })(result1[0], result1[1]) | |
573 : null; | |
574 if (result2 !== null) { | |
575 var result0 = result2; | |
576 } else { | |
577 var result0 = null; | |
578 pos = savedPos0; | |
579 } | |
580 | |
581 | |
582 | |
583 cache[cacheKey] = { | |
584 nextPos: pos, | |
585 result: result0 | |
586 }; | |
587 return result0; | |
588 } | |
589 | |
590 function parse_sequence() { | |
591 var cacheKey = 'sequence@' + pos; | |
592 var cachedResult = cache[cacheKey]; | |
593 if (cachedResult) { | |
594 pos = cachedResult.nextPos; | |
595 return cachedResult.result; | |
596 } | |
597 | |
598 | |
599 var savedPos1 = pos; | |
600 var savedPos2 = pos; | |
601 var result8 = []; | |
602 var result10 = parse_labeled(); | |
603 while (result10 !== null) { | |
604 result8.push(result10); | |
605 var result10 = parse_labeled(); | |
606 } | |
607 if (result8 !== null) { | |
608 var result9 = parse_action(); | |
609 if (result9 !== null) { | |
610 var result6 = [result8, result9]; | |
611 } else { | |
612 var result6 = null; | |
613 pos = savedPos2; | |
614 } | |
615 } else { | |
616 var result6 = null; | |
617 pos = savedPos2; | |
618 } | |
619 var result7 = result6 !== null | |
620 ? (function(elements, code) { | |
621 var expression = elements.length != 1 | |
622 ? { | |
623 type: "sequence", | |
624 elements: elements | |
625 } | |
626 : elements[0]; | |
627 return { | |
628 type: "action", | |
629 expression: expression, | |
630 code: code | |
631 }; | |
632 })(result6[0], result6[1]) | |
633 : null; | |
634 if (result7 !== null) { | |
635 var result5 = result7; | |
636 } else { | |
637 var result5 = null; | |
638 pos = savedPos1; | |
639 } | |
640 if (result5 !== null) { | |
641 var result0 = result5; | |
642 } else { | |
643 var savedPos0 = pos; | |
644 var result2 = []; | |
645 var result4 = parse_labeled(); | |
646 while (result4 !== null) { | |
647 result2.push(result4); | |
648 var result4 = parse_labeled(); | |
649 } | |
650 var result3 = result2 !== null | |
651 ? (function(elements) { | |
652 return elements.length != 1 | |
653 ? { | |
654 type: "sequence", | |
655 elements: elements | |
656 } | |
657 : elements[0]; | |
658 })(result2) | |
659 : null; | |
660 if (result3 !== null) { | |
661 var result1 = result3; | |
662 } else { | |
663 var result1 = null; | |
664 pos = savedPos0; | |
665 } | |
666 if (result1 !== null) { | |
667 var result0 = result1; | |
668 } else { | |
669 var result0 = null;; | |
670 }; | |
671 } | |
672 | |
673 | |
674 | |
675 cache[cacheKey] = { | |
676 nextPos: pos, | |
677 result: result0 | |
678 }; | |
679 return result0; | |
680 } | |
681 | |
682 function parse_labeled() { | |
683 var cacheKey = 'labeled@' + pos; | |
684 var cachedResult = cache[cacheKey]; | |
685 if (cachedResult) { | |
686 pos = cachedResult.nextPos; | |
687 return cachedResult.result; | |
688 } | |
689 | |
690 | |
691 var savedPos0 = pos; | |
692 var savedPos1 = pos; | |
693 var result5 = parse_identifier(); | |
694 if (result5 !== null) { | |
695 var result6 = parse_colon(); | |
696 if (result6 !== null) { | |
697 var result7 = parse_prefixed(); | |
698 if (result7 !== null) { | |
699 var result3 = [result5, result6, result7]; | |
700 } else { | |
701 var result3 = null; | |
702 pos = savedPos1; | |
703 } | |
704 } else { | |
705 var result3 = null; | |
706 pos = savedPos1; | |
707 } | |
708 } else { | |
709 var result3 = null; | |
710 pos = savedPos1; | |
711 } | |
712 var result4 = result3 !== null | |
713 ? (function(label, expression) { | |
714 return { | |
715 type: "labeled", | |
716 label: label, | |
717 expression: expression | |
718 }; | |
719 })(result3[0], result3[2]) | |
720 : null; | |
721 if (result4 !== null) { | |
722 var result2 = result4; | |
723 } else { | |
724 var result2 = null; | |
725 pos = savedPos0; | |
726 } | |
727 if (result2 !== null) { | |
728 var result0 = result2; | |
729 } else { | |
730 var result1 = parse_prefixed(); | |
731 if (result1 !== null) { | |
732 var result0 = result1; | |
733 } else { | |
734 var result0 = null;; | |
735 }; | |
736 } | |
737 | |
738 | |
739 | |
740 cache[cacheKey] = { | |
741 nextPos: pos, | |
742 result: result0 | |
743 }; | |
744 return result0; | |
745 } | |
746 | |
747 function parse_prefixed() { | |
748 var cacheKey = 'prefixed@' + pos; | |
749 var cachedResult = cache[cacheKey]; | |
750 if (cachedResult) { | |
751 pos = cachedResult.nextPos; | |
752 return cachedResult.result; | |
753 } | |
754 | |
755 | |
756 var savedPos6 = pos; | |
757 var savedPos7 = pos; | |
758 var result20 = parse_and(); | |
759 if (result20 !== null) { | |
760 var result21 = parse_action(); | |
761 if (result21 !== null) { | |
762 var result18 = [result20, result21]; | |
763 } else { | |
764 var result18 = null; | |
765 pos = savedPos7; | |
766 } | |
767 } else { | |
768 var result18 = null; | |
769 pos = savedPos7; | |
770 } | |
771 var result19 = result18 !== null | |
772 ? (function(code) { | |
773 return { | |
774 type: "semantic_and", | |
775 code: code | |
776 }; | |
777 })(result18[1]) | |
778 : null; | |
779 if (result19 !== null) { | |
780 var result17 = result19; | |
781 } else { | |
782 var result17 = null; | |
783 pos = savedPos6; | |
784 } | |
785 if (result17 !== null) { | |
786 var result0 = result17; | |
787 } else { | |
788 var savedPos4 = pos; | |
789 var savedPos5 = pos; | |
790 var result15 = parse_and(); | |
791 if (result15 !== null) { | |
792 var result16 = parse_suffixed(); | |
793 if (result16 !== null) { | |
794 var result13 = [result15, result16]; | |
795 } else { | |
796 var result13 = null; | |
797 pos = savedPos5; | |
798 } | |
799 } else { | |
800 var result13 = null; | |
801 pos = savedPos5; | |
802 } | |
803 var result14 = result13 !== null | |
804 ? (function(expression) { | |
805 return { | |
806 type: "simple_and", | |
807 expression: expression | |
808 }; | |
809 })(result13[1]) | |
810 : null; | |
811 if (result14 !== null) { | |
812 var result12 = result14; | |
813 } else { | |
814 var result12 = null; | |
815 pos = savedPos4; | |
816 } | |
817 if (result12 !== null) { | |
818 var result0 = result12; | |
819 } else { | |
820 var savedPos2 = pos; | |
821 var savedPos3 = pos; | |
822 var result10 = parse_not(); | |
823 if (result10 !== null) { | |
824 var result11 = parse_action(); | |
825 if (result11 !== null) { | |
826 var result8 = [result10, result11]; | |
827 } else { | |
828 var result8 = null; | |
829 pos = savedPos3; | |
830 } | |
831 } else { | |
832 var result8 = null; | |
833 pos = savedPos3; | |
834 } | |
835 var result9 = result8 !== null | |
836 ? (function(code) { | |
837 return { | |
838 type: "semantic_not", | |
839 code: code | |
840 }; | |
841 })(result8[1]) | |
842 : null; | |
843 if (result9 !== null) { | |
844 var result7 = result9; | |
845 } else { | |
846 var result7 = null; | |
847 pos = savedPos2; | |
848 } | |
849 if (result7 !== null) { | |
850 var result0 = result7; | |
851 } else { | |
852 var savedPos0 = pos; | |
853 var savedPos1 = pos; | |
854 var result5 = parse_not(); | |
855 if (result5 !== null) { | |
856 var result6 = parse_suffixed(); | |
857 if (result6 !== null) { | |
858 var result3 = [result5, result6]; | |
859 } else { | |
860 var result3 = null; | |
861 pos = savedPos1; | |
862 } | |
863 } else { | |
864 var result3 = null; | |
865 pos = savedPos1; | |
866 } | |
867 var result4 = result3 !== null | |
868 ? (function(expression) { | |
869 return { | |
870 type: "simple_not", | |
871 expression: expression | |
872 }; | |
873 })(result3[1]) | |
874 : null; | |
875 if (result4 !== null) { | |
876 var result2 = result4; | |
877 } else { | |
878 var result2 = null; | |
879 pos = savedPos0; | |
880 } | |
881 if (result2 !== null) { | |
882 var result0 = result2; | |
883 } else { | |
884 var result1 = parse_suffixed(); | |
885 if (result1 !== null) { | |
886 var result0 = result1; | |
887 } else { | |
888 var result0 = null;; | |
889 }; | |
890 }; | |
891 }; | |
892 }; | |
893 } | |
894 | |
895 | |
896 | |
897 cache[cacheKey] = { | |
898 nextPos: pos, | |
899 result: result0 | |
900 }; | |
901 return result0; | |
902 } | |
903 | |
904 function parse_suffixed() { | |
905 var cacheKey = 'suffixed@' + pos; | |
906 var cachedResult = cache[cacheKey]; | |
907 if (cachedResult) { | |
908 pos = cachedResult.nextPos; | |
909 return cachedResult.result; | |
910 } | |
911 | |
912 | |
913 var savedPos4 = pos; | |
914 var savedPos5 = pos; | |
915 var result15 = parse_primary(); | |
916 if (result15 !== null) { | |
917 var result16 = parse_question(); | |
918 if (result16 !== null) { | |
919 var result13 = [result15, result16]; | |
920 } else { | |
921 var result13 = null; | |
922 pos = savedPos5; | |
923 } | |
924 } else { | |
925 var result13 = null; | |
926 pos = savedPos5; | |
927 } | |
928 var result14 = result13 !== null | |
929 ? (function(expression) { | |
930 return { | |
931 type: "optional", | |
932 expression: expression | |
933 }; | |
934 })(result13[0]) | |
935 : null; | |
936 if (result14 !== null) { | |
937 var result12 = result14; | |
938 } else { | |
939 var result12 = null; | |
940 pos = savedPos4; | |
941 } | |
942 if (result12 !== null) { | |
943 var result0 = result12; | |
944 } else { | |
945 var savedPos2 = pos; | |
946 var savedPos3 = pos; | |
947 var result10 = parse_primary(); | |
948 if (result10 !== null) { | |
949 var result11 = parse_star(); | |
950 if (result11 !== null) { | |
951 var result8 = [result10, result11]; | |
952 } else { | |
953 var result8 = null; | |
954 pos = savedPos3; | |
955 } | |
956 } else { | |
957 var result8 = null; | |
958 pos = savedPos3; | |
959 } | |
960 var result9 = result8 !== null | |
961 ? (function(expression) { | |
962 return { | |
963 type: "zero_or_more", | |
964 expression: expression | |
965 }; | |
966 })(result8[0]) | |
967 : null; | |
968 if (result9 !== null) { | |
969 var result7 = result9; | |
970 } else { | |
971 var result7 = null; | |
972 pos = savedPos2; | |
973 } | |
974 if (result7 !== null) { | |
975 var result0 = result7; | |
976 } else { | |
977 var savedPos0 = pos; | |
978 var savedPos1 = pos; | |
979 var result5 = parse_primary(); | |
980 if (result5 !== null) { | |
981 var result6 = parse_plus(); | |
982 if (result6 !== null) { | |
983 var result3 = [result5, result6]; | |
984 } else { | |
985 var result3 = null; | |
986 pos = savedPos1; | |
987 } | |
988 } else { | |
989 var result3 = null; | |
990 pos = savedPos1; | |
991 } | |
992 var result4 = result3 !== null | |
993 ? (function(expression) { | |
994 return { | |
995 type: "one_or_more", | |
996 expression: expression | |
997 }; | |
998 })(result3[0]) | |
999 : null; | |
1000 if (result4 !== null) { | |
1001 var result2 = result4; | |
1002 } else { | |
1003 var result2 = null; | |
1004 pos = savedPos0; | |
1005 } | |
1006 if (result2 !== null) { | |
1007 var result0 = result2; | |
1008 } else { | |
1009 var result1 = parse_primary(); | |
1010 if (result1 !== null) { | |
1011 var result0 = result1; | |
1012 } else { | |
1013 var result0 = null;; | |
1014 }; | |
1015 }; | |
1016 }; | |
1017 } | |
1018 | |
1019 | |
1020 | |
1021 cache[cacheKey] = { | |
1022 nextPos: pos, | |
1023 result: result0 | |
1024 }; | |
1025 return result0; | |
1026 } | |
1027 | |
1028 function parse_primary() { | |
1029 var cacheKey = 'primary@' + pos; | |
1030 var cachedResult = cache[cacheKey]; | |
1031 if (cachedResult) { | |
1032 pos = cachedResult.nextPos; | |
1033 return cachedResult.result; | |
1034 } | |
1035 | |
1036 | |
1037 var savedPos4 = pos; | |
1038 var savedPos5 = pos; | |
1039 var result17 = parse_identifier(); | |
1040 if (result17 !== null) { | |
1041 var savedPos6 = pos; | |
1042 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
1043 reportMatchFailures = false; | |
1044 var savedPos7 = pos; | |
1045 var result23 = parse_literal(); | |
1046 if (result23 !== null) { | |
1047 var result20 = result23; | |
1048 } else { | |
1049 if (input.substr(pos, 0) === "") { | |
1050 var result22 = ""; | |
1051 pos += 0; | |
1052 } else { | |
1053 var result22 = null; | |
1054 if (reportMatchFailures) { | |
1055 matchFailed("\"\""); | |
1056 } | |
1057 } | |
1058 if (result22 !== null) { | |
1059 var result20 = result22; | |
1060 } else { | |
1061 var result20 = null;; | |
1062 }; | |
1063 } | |
1064 if (result20 !== null) { | |
1065 var result21 = parse_equals(); | |
1066 if (result21 !== null) { | |
1067 var result19 = [result20, result21]; | |
1068 } else { | |
1069 var result19 = null; | |
1070 pos = savedPos7; | |
1071 } | |
1072 } else { | |
1073 var result19 = null; | |
1074 pos = savedPos7; | |
1075 } | |
1076 reportMatchFailures = savedReportMatchFailuresVar0; | |
1077 if (result19 === null) { | |
1078 var result18 = ''; | |
1079 } else { | |
1080 var result18 = null; | |
1081 pos = savedPos6; | |
1082 } | |
1083 if (result18 !== null) { | |
1084 var result15 = [result17, result18]; | |
1085 } else { | |
1086 var result15 = null; | |
1087 pos = savedPos5; | |
1088 } | |
1089 } else { | |
1090 var result15 = null; | |
1091 pos = savedPos5; | |
1092 } | |
1093 var result16 = result15 !== null | |
1094 ? (function(name) { | |
1095 return { | |
1096 type: "rule_ref", | |
1097 name: name | |
1098 }; | |
1099 })(result15[0]) | |
1100 : null; | |
1101 if (result16 !== null) { | |
1102 var result14 = result16; | |
1103 } else { | |
1104 var result14 = null; | |
1105 pos = savedPos4; | |
1106 } | |
1107 if (result14 !== null) { | |
1108 var result0 = result14; | |
1109 } else { | |
1110 var savedPos3 = pos; | |
1111 var result12 = parse_literal(); | |
1112 var result13 = result12 !== null | |
1113 ? (function(value) { | |
1114 return { | |
1115 type: "literal", | |
1116 value: value | |
1117 }; | |
1118 })(result12) | |
1119 : null; | |
1120 if (result13 !== null) { | |
1121 var result11 = result13; | |
1122 } else { | |
1123 var result11 = null; | |
1124 pos = savedPos3; | |
1125 } | |
1126 if (result11 !== null) { | |
1127 var result0 = result11; | |
1128 } else { | |
1129 var savedPos2 = pos; | |
1130 var result9 = parse_dot(); | |
1131 var result10 = result9 !== null | |
1132 ? (function() { return { type: "any" }; })() | |
1133 : null; | |
1134 if (result10 !== null) { | |
1135 var result8 = result10; | |
1136 } else { | |
1137 var result8 = null; | |
1138 pos = savedPos2; | |
1139 } | |
1140 if (result8 !== null) { | |
1141 var result0 = result8; | |
1142 } else { | |
1143 var result7 = parse_class(); | |
1144 if (result7 !== null) { | |
1145 var result0 = result7; | |
1146 } else { | |
1147 var savedPos0 = pos; | |
1148 var savedPos1 = pos; | |
1149 var result4 = parse_lparen(); | |
1150 if (result4 !== null) { | |
1151 var result5 = parse_choice(); | |
1152 if (result5 !== null) { | |
1153 var result6 = parse_rparen(); | |
1154 if (result6 !== null) { | |
1155 var result2 = [result4, result5, result6]; | |
1156 } else { | |
1157 var result2 = null; | |
1158 pos = savedPos1; | |
1159 } | |
1160 } else { | |
1161 var result2 = null; | |
1162 pos = savedPos1; | |
1163 } | |
1164 } else { | |
1165 var result2 = null; | |
1166 pos = savedPos1; | |
1167 } | |
1168 var result3 = result2 !== null | |
1169 ? (function(expression) { return expression; })(result2[1]) | |
1170 : null; | |
1171 if (result3 !== null) { | |
1172 var result1 = result3; | |
1173 } else { | |
1174 var result1 = null; | |
1175 pos = savedPos0; | |
1176 } | |
1177 if (result1 !== null) { | |
1178 var result0 = result1; | |
1179 } else { | |
1180 var result0 = null;; | |
1181 }; | |
1182 }; | |
1183 }; | |
1184 }; | |
1185 } | |
1186 | |
1187 | |
1188 | |
1189 cache[cacheKey] = { | |
1190 nextPos: pos, | |
1191 result: result0 | |
1192 }; | |
1193 return result0; | |
1194 } | |
1195 | |
1196 function parse_action() { | |
1197 var cacheKey = 'action@' + pos; | |
1198 var cachedResult = cache[cacheKey]; | |
1199 if (cachedResult) { | |
1200 pos = cachedResult.nextPos; | |
1201 return cachedResult.result; | |
1202 } | |
1203 | |
1204 var savedReportMatchFailures = reportMatchFailures; | |
1205 reportMatchFailures = false; | |
1206 var savedPos0 = pos; | |
1207 var savedPos1 = pos; | |
1208 var result3 = parse_braced(); | |
1209 if (result3 !== null) { | |
1210 var result4 = parse___(); | |
1211 if (result4 !== null) { | |
1212 var result1 = [result3, result4]; | |
1213 } else { | |
1214 var result1 = null; | |
1215 pos = savedPos1; | |
1216 } | |
1217 } else { | |
1218 var result1 = null; | |
1219 pos = savedPos1; | |
1220 } | |
1221 var result2 = result1 !== null | |
1222 ? (function(braced) { return braced.substr(1, braced.length - 2); })(result1[0]) | |
1223 : null; | |
1224 if (result2 !== null) { | |
1225 var result0 = result2; | |
1226 } else { | |
1227 var result0 = null; | |
1228 pos = savedPos0; | |
1229 } | |
1230 reportMatchFailures = savedReportMatchFailures; | |
1231 if (reportMatchFailures && result0 === null) { | |
1232 matchFailed("action"); | |
1233 } | |
1234 | |
1235 cache[cacheKey] = { | |
1236 nextPos: pos, | |
1237 result: result0 | |
1238 }; | |
1239 return result0; | |
1240 } | |
1241 | |
1242 function parse_braced() { | |
1243 var cacheKey = 'braced@' + pos; | |
1244 var cachedResult = cache[cacheKey]; | |
1245 if (cachedResult) { | |
1246 pos = cachedResult.nextPos; | |
1247 return cachedResult.result; | |
1248 } | |
1249 | |
1250 | |
1251 var savedPos0 = pos; | |
1252 var savedPos1 = pos; | |
1253 if (input.substr(pos, 1) === "{") { | |
1254 var result3 = "{"; | |
1255 pos += 1; | |
1256 } else { | |
1257 var result3 = null; | |
1258 if (reportMatchFailures) { | |
1259 matchFailed("\"{\""); | |
1260 } | |
1261 } | |
1262 if (result3 !== null) { | |
1263 var result4 = []; | |
1264 var result8 = parse_braced(); | |
1265 if (result8 !== null) { | |
1266 var result6 = result8; | |
1267 } else { | |
1268 var result7 = parse_nonBraceCharacter(); | |
1269 if (result7 !== null) { | |
1270 var result6 = result7; | |
1271 } else { | |
1272 var result6 = null;; | |
1273 }; | |
1274 } | |
1275 while (result6 !== null) { | |
1276 result4.push(result6); | |
1277 var result8 = parse_braced(); | |
1278 if (result8 !== null) { | |
1279 var result6 = result8; | |
1280 } else { | |
1281 var result7 = parse_nonBraceCharacter(); | |
1282 if (result7 !== null) { | |
1283 var result6 = result7; | |
1284 } else { | |
1285 var result6 = null;; | |
1286 }; | |
1287 } | |
1288 } | |
1289 if (result4 !== null) { | |
1290 if (input.substr(pos, 1) === "}") { | |
1291 var result5 = "}"; | |
1292 pos += 1; | |
1293 } else { | |
1294 var result5 = null; | |
1295 if (reportMatchFailures) { | |
1296 matchFailed("\"}\""); | |
1297 } | |
1298 } | |
1299 if (result5 !== null) { | |
1300 var result1 = [result3, result4, result5]; | |
1301 } else { | |
1302 var result1 = null; | |
1303 pos = savedPos1; | |
1304 } | |
1305 } else { | |
1306 var result1 = null; | |
1307 pos = savedPos1; | |
1308 } | |
1309 } else { | |
1310 var result1 = null; | |
1311 pos = savedPos1; | |
1312 } | |
1313 var result2 = result1 !== null | |
1314 ? (function(parts) { | |
1315 return "{" + parts.join("") + "}"; | |
1316 })(result1[1]) | |
1317 : null; | |
1318 if (result2 !== null) { | |
1319 var result0 = result2; | |
1320 } else { | |
1321 var result0 = null; | |
1322 pos = savedPos0; | |
1323 } | |
1324 | |
1325 | |
1326 | |
1327 cache[cacheKey] = { | |
1328 nextPos: pos, | |
1329 result: result0 | |
1330 }; | |
1331 return result0; | |
1332 } | |
1333 | |
1334 function parse_nonBraceCharacters() { | |
1335 var cacheKey = 'nonBraceCharacters@' + pos; | |
1336 var cachedResult = cache[cacheKey]; | |
1337 if (cachedResult) { | |
1338 pos = cachedResult.nextPos; | |
1339 return cachedResult.result; | |
1340 } | |
1341 | |
1342 | |
1343 var savedPos0 = pos; | |
1344 var result3 = parse_nonBraceCharacter(); | |
1345 if (result3 !== null) { | |
1346 var result1 = []; | |
1347 while (result3 !== null) { | |
1348 result1.push(result3); | |
1349 var result3 = parse_nonBraceCharacter(); | |
1350 } | |
1351 } else { | |
1352 var result1 = null; | |
1353 } | |
1354 var result2 = result1 !== null | |
1355 ? (function(chars) { return chars.join(""); })(result1) | |
1356 : null; | |
1357 if (result2 !== null) { | |
1358 var result0 = result2; | |
1359 } else { | |
1360 var result0 = null; | |
1361 pos = savedPos0; | |
1362 } | |
1363 | |
1364 | |
1365 | |
1366 cache[cacheKey] = { | |
1367 nextPos: pos, | |
1368 result: result0 | |
1369 }; | |
1370 return result0; | |
1371 } | |
1372 | |
1373 function parse_nonBraceCharacter() { | |
1374 var cacheKey = 'nonBraceCharacter@' + pos; | |
1375 var cachedResult = cache[cacheKey]; | |
1376 if (cachedResult) { | |
1377 pos = cachedResult.nextPos; | |
1378 return cachedResult.result; | |
1379 } | |
1380 | |
1381 | |
1382 if (input.substr(pos).match(/^[^{}]/) !== null) { | |
1383 var result0 = input.charAt(pos); | |
1384 pos++; | |
1385 } else { | |
1386 var result0 = null; | |
1387 if (reportMatchFailures) { | |
1388 matchFailed("[^{}]"); | |
1389 } | |
1390 } | |
1391 | |
1392 | |
1393 | |
1394 cache[cacheKey] = { | |
1395 nextPos: pos, | |
1396 result: result0 | |
1397 }; | |
1398 return result0; | |
1399 } | |
1400 | |
1401 function parse_equals() { | |
1402 var cacheKey = 'equals@' + pos; | |
1403 var cachedResult = cache[cacheKey]; | |
1404 if (cachedResult) { | |
1405 pos = cachedResult.nextPos; | |
1406 return cachedResult.result; | |
1407 } | |
1408 | |
1409 | |
1410 var savedPos0 = pos; | |
1411 var savedPos1 = pos; | |
1412 if (input.substr(pos, 1) === "=") { | |
1413 var result3 = "="; | |
1414 pos += 1; | |
1415 } else { | |
1416 var result3 = null; | |
1417 if (reportMatchFailures) { | |
1418 matchFailed("\"=\""); | |
1419 } | |
1420 } | |
1421 if (result3 !== null) { | |
1422 var result4 = parse___(); | |
1423 if (result4 !== null) { | |
1424 var result1 = [result3, result4]; | |
1425 } else { | |
1426 var result1 = null; | |
1427 pos = savedPos1; | |
1428 } | |
1429 } else { | |
1430 var result1 = null; | |
1431 pos = savedPos1; | |
1432 } | |
1433 var result2 = result1 !== null | |
1434 ? (function() { return "="; })() | |
1435 : null; | |
1436 if (result2 !== null) { | |
1437 var result0 = result2; | |
1438 } else { | |
1439 var result0 = null; | |
1440 pos = savedPos0; | |
1441 } | |
1442 | |
1443 | |
1444 | |
1445 cache[cacheKey] = { | |
1446 nextPos: pos, | |
1447 result: result0 | |
1448 }; | |
1449 return result0; | |
1450 } | |
1451 | |
1452 function parse_colon() { | |
1453 var cacheKey = 'colon@' + pos; | |
1454 var cachedResult = cache[cacheKey]; | |
1455 if (cachedResult) { | |
1456 pos = cachedResult.nextPos; | |
1457 return cachedResult.result; | |
1458 } | |
1459 | |
1460 | |
1461 var savedPos0 = pos; | |
1462 var savedPos1 = pos; | |
1463 if (input.substr(pos, 1) === ":") { | |
1464 var result3 = ":"; | |
1465 pos += 1; | |
1466 } else { | |
1467 var result3 = null; | |
1468 if (reportMatchFailures) { | |
1469 matchFailed("\":\""); | |
1470 } | |
1471 } | |
1472 if (result3 !== null) { | |
1473 var result4 = parse___(); | |
1474 if (result4 !== null) { | |
1475 var result1 = [result3, result4]; | |
1476 } else { | |
1477 var result1 = null; | |
1478 pos = savedPos1; | |
1479 } | |
1480 } else { | |
1481 var result1 = null; | |
1482 pos = savedPos1; | |
1483 } | |
1484 var result2 = result1 !== null | |
1485 ? (function() { return ":"; })() | |
1486 : null; | |
1487 if (result2 !== null) { | |
1488 var result0 = result2; | |
1489 } else { | |
1490 var result0 = null; | |
1491 pos = savedPos0; | |
1492 } | |
1493 | |
1494 | |
1495 | |
1496 cache[cacheKey] = { | |
1497 nextPos: pos, | |
1498 result: result0 | |
1499 }; | |
1500 return result0; | |
1501 } | |
1502 | |
1503 function parse_semicolon() { | |
1504 var cacheKey = 'semicolon@' + pos; | |
1505 var cachedResult = cache[cacheKey]; | |
1506 if (cachedResult) { | |
1507 pos = cachedResult.nextPos; | |
1508 return cachedResult.result; | |
1509 } | |
1510 | |
1511 | |
1512 var savedPos0 = pos; | |
1513 var savedPos1 = pos; | |
1514 if (input.substr(pos, 1) === ";") { | |
1515 var result3 = ";"; | |
1516 pos += 1; | |
1517 } else { | |
1518 var result3 = null; | |
1519 if (reportMatchFailures) { | |
1520 matchFailed("\";\""); | |
1521 } | |
1522 } | |
1523 if (result3 !== null) { | |
1524 var result4 = parse___(); | |
1525 if (result4 !== null) { | |
1526 var result1 = [result3, result4]; | |
1527 } else { | |
1528 var result1 = null; | |
1529 pos = savedPos1; | |
1530 } | |
1531 } else { | |
1532 var result1 = null; | |
1533 pos = savedPos1; | |
1534 } | |
1535 var result2 = result1 !== null | |
1536 ? (function() { return ";"; })() | |
1537 : null; | |
1538 if (result2 !== null) { | |
1539 var result0 = result2; | |
1540 } else { | |
1541 var result0 = null; | |
1542 pos = savedPos0; | |
1543 } | |
1544 | |
1545 | |
1546 | |
1547 cache[cacheKey] = { | |
1548 nextPos: pos, | |
1549 result: result0 | |
1550 }; | |
1551 return result0; | |
1552 } | |
1553 | |
1554 function parse_slash() { | |
1555 var cacheKey = 'slash@' + pos; | |
1556 var cachedResult = cache[cacheKey]; | |
1557 if (cachedResult) { | |
1558 pos = cachedResult.nextPos; | |
1559 return cachedResult.result; | |
1560 } | |
1561 | |
1562 | |
1563 var savedPos0 = pos; | |
1564 var savedPos1 = pos; | |
1565 if (input.substr(pos, 1) === "/") { | |
1566 var result3 = "/"; | |
1567 pos += 1; | |
1568 } else { | |
1569 var result3 = null; | |
1570 if (reportMatchFailures) { | |
1571 matchFailed("\"/\""); | |
1572 } | |
1573 } | |
1574 if (result3 !== null) { | |
1575 var result4 = parse___(); | |
1576 if (result4 !== null) { | |
1577 var result1 = [result3, result4]; | |
1578 } else { | |
1579 var result1 = null; | |
1580 pos = savedPos1; | |
1581 } | |
1582 } else { | |
1583 var result1 = null; | |
1584 pos = savedPos1; | |
1585 } | |
1586 var result2 = result1 !== null | |
1587 ? (function() { return "/"; })() | |
1588 : null; | |
1589 if (result2 !== null) { | |
1590 var result0 = result2; | |
1591 } else { | |
1592 var result0 = null; | |
1593 pos = savedPos0; | |
1594 } | |
1595 | |
1596 | |
1597 | |
1598 cache[cacheKey] = { | |
1599 nextPos: pos, | |
1600 result: result0 | |
1601 }; | |
1602 return result0; | |
1603 } | |
1604 | |
1605 function parse_and() { | |
1606 var cacheKey = 'and@' + pos; | |
1607 var cachedResult = cache[cacheKey]; | |
1608 if (cachedResult) { | |
1609 pos = cachedResult.nextPos; | |
1610 return cachedResult.result; | |
1611 } | |
1612 | |
1613 | |
1614 var savedPos0 = pos; | |
1615 var savedPos1 = pos; | |
1616 if (input.substr(pos, 1) === "&") { | |
1617 var result3 = "&"; | |
1618 pos += 1; | |
1619 } else { | |
1620 var result3 = null; | |
1621 if (reportMatchFailures) { | |
1622 matchFailed("\"&\""); | |
1623 } | |
1624 } | |
1625 if (result3 !== null) { | |
1626 var result4 = parse___(); | |
1627 if (result4 !== null) { | |
1628 var result1 = [result3, result4]; | |
1629 } else { | |
1630 var result1 = null; | |
1631 pos = savedPos1; | |
1632 } | |
1633 } else { | |
1634 var result1 = null; | |
1635 pos = savedPos1; | |
1636 } | |
1637 var result2 = result1 !== null | |
1638 ? (function() { return "&"; })() | |
1639 : null; | |
1640 if (result2 !== null) { | |
1641 var result0 = result2; | |
1642 } else { | |
1643 var result0 = null; | |
1644 pos = savedPos0; | |
1645 } | |
1646 | |
1647 | |
1648 | |
1649 cache[cacheKey] = { | |
1650 nextPos: pos, | |
1651 result: result0 | |
1652 }; | |
1653 return result0; | |
1654 } | |
1655 | |
1656 function parse_not() { | |
1657 var cacheKey = 'not@' + pos; | |
1658 var cachedResult = cache[cacheKey]; | |
1659 if (cachedResult) { | |
1660 pos = cachedResult.nextPos; | |
1661 return cachedResult.result; | |
1662 } | |
1663 | |
1664 | |
1665 var savedPos0 = pos; | |
1666 var savedPos1 = pos; | |
1667 if (input.substr(pos, 1) === "!") { | |
1668 var result3 = "!"; | |
1669 pos += 1; | |
1670 } else { | |
1671 var result3 = null; | |
1672 if (reportMatchFailures) { | |
1673 matchFailed("\"!\""); | |
1674 } | |
1675 } | |
1676 if (result3 !== null) { | |
1677 var result4 = parse___(); | |
1678 if (result4 !== null) { | |
1679 var result1 = [result3, result4]; | |
1680 } else { | |
1681 var result1 = null; | |
1682 pos = savedPos1; | |
1683 } | |
1684 } else { | |
1685 var result1 = null; | |
1686 pos = savedPos1; | |
1687 } | |
1688 var result2 = result1 !== null | |
1689 ? (function() { return "!"; })() | |
1690 : null; | |
1691 if (result2 !== null) { | |
1692 var result0 = result2; | |
1693 } else { | |
1694 var result0 = null; | |
1695 pos = savedPos0; | |
1696 } | |
1697 | |
1698 | |
1699 | |
1700 cache[cacheKey] = { | |
1701 nextPos: pos, | |
1702 result: result0 | |
1703 }; | |
1704 return result0; | |
1705 } | |
1706 | |
1707 function parse_question() { | |
1708 var cacheKey = 'question@' + pos; | |
1709 var cachedResult = cache[cacheKey]; | |
1710 if (cachedResult) { | |
1711 pos = cachedResult.nextPos; | |
1712 return cachedResult.result; | |
1713 } | |
1714 | |
1715 | |
1716 var savedPos0 = pos; | |
1717 var savedPos1 = pos; | |
1718 if (input.substr(pos, 1) === "?") { | |
1719 var result3 = "?"; | |
1720 pos += 1; | |
1721 } else { | |
1722 var result3 = null; | |
1723 if (reportMatchFailures) { | |
1724 matchFailed("\"?\""); | |
1725 } | |
1726 } | |
1727 if (result3 !== null) { | |
1728 var result4 = parse___(); | |
1729 if (result4 !== null) { | |
1730 var result1 = [result3, result4]; | |
1731 } else { | |
1732 var result1 = null; | |
1733 pos = savedPos1; | |
1734 } | |
1735 } else { | |
1736 var result1 = null; | |
1737 pos = savedPos1; | |
1738 } | |
1739 var result2 = result1 !== null | |
1740 ? (function() { return "?"; })() | |
1741 : null; | |
1742 if (result2 !== null) { | |
1743 var result0 = result2; | |
1744 } else { | |
1745 var result0 = null; | |
1746 pos = savedPos0; | |
1747 } | |
1748 | |
1749 | |
1750 | |
1751 cache[cacheKey] = { | |
1752 nextPos: pos, | |
1753 result: result0 | |
1754 }; | |
1755 return result0; | |
1756 } | |
1757 | |
1758 function parse_star() { | |
1759 var cacheKey = 'star@' + pos; | |
1760 var cachedResult = cache[cacheKey]; | |
1761 if (cachedResult) { | |
1762 pos = cachedResult.nextPos; | |
1763 return cachedResult.result; | |
1764 } | |
1765 | |
1766 | |
1767 var savedPos0 = pos; | |
1768 var savedPos1 = pos; | |
1769 if (input.substr(pos, 1) === "*") { | |
1770 var result3 = "*"; | |
1771 pos += 1; | |
1772 } else { | |
1773 var result3 = null; | |
1774 if (reportMatchFailures) { | |
1775 matchFailed("\"*\""); | |
1776 } | |
1777 } | |
1778 if (result3 !== null) { | |
1779 var result4 = parse___(); | |
1780 if (result4 !== null) { | |
1781 var result1 = [result3, result4]; | |
1782 } else { | |
1783 var result1 = null; | |
1784 pos = savedPos1; | |
1785 } | |
1786 } else { | |
1787 var result1 = null; | |
1788 pos = savedPos1; | |
1789 } | |
1790 var result2 = result1 !== null | |
1791 ? (function() { return "*"; })() | |
1792 : null; | |
1793 if (result2 !== null) { | |
1794 var result0 = result2; | |
1795 } else { | |
1796 var result0 = null; | |
1797 pos = savedPos0; | |
1798 } | |
1799 | |
1800 | |
1801 | |
1802 cache[cacheKey] = { | |
1803 nextPos: pos, | |
1804 result: result0 | |
1805 }; | |
1806 return result0; | |
1807 } | |
1808 | |
1809 function parse_plus() { | |
1810 var cacheKey = 'plus@' + pos; | |
1811 var cachedResult = cache[cacheKey]; | |
1812 if (cachedResult) { | |
1813 pos = cachedResult.nextPos; | |
1814 return cachedResult.result; | |
1815 } | |
1816 | |
1817 | |
1818 var savedPos0 = pos; | |
1819 var savedPos1 = pos; | |
1820 if (input.substr(pos, 1) === "+") { | |
1821 var result3 = "+"; | |
1822 pos += 1; | |
1823 } else { | |
1824 var result3 = null; | |
1825 if (reportMatchFailures) { | |
1826 matchFailed("\"+\""); | |
1827 } | |
1828 } | |
1829 if (result3 !== null) { | |
1830 var result4 = parse___(); | |
1831 if (result4 !== null) { | |
1832 var result1 = [result3, result4]; | |
1833 } else { | |
1834 var result1 = null; | |
1835 pos = savedPos1; | |
1836 } | |
1837 } else { | |
1838 var result1 = null; | |
1839 pos = savedPos1; | |
1840 } | |
1841 var result2 = result1 !== null | |
1842 ? (function() { return "+"; })() | |
1843 : null; | |
1844 if (result2 !== null) { | |
1845 var result0 = result2; | |
1846 } else { | |
1847 var result0 = null; | |
1848 pos = savedPos0; | |
1849 } | |
1850 | |
1851 | |
1852 | |
1853 cache[cacheKey] = { | |
1854 nextPos: pos, | |
1855 result: result0 | |
1856 }; | |
1857 return result0; | |
1858 } | |
1859 | |
1860 function parse_lparen() { | |
1861 var cacheKey = 'lparen@' + pos; | |
1862 var cachedResult = cache[cacheKey]; | |
1863 if (cachedResult) { | |
1864 pos = cachedResult.nextPos; | |
1865 return cachedResult.result; | |
1866 } | |
1867 | |
1868 | |
1869 var savedPos0 = pos; | |
1870 var savedPos1 = pos; | |
1871 if (input.substr(pos, 1) === "(") { | |
1872 var result3 = "("; | |
1873 pos += 1; | |
1874 } else { | |
1875 var result3 = null; | |
1876 if (reportMatchFailures) { | |
1877 matchFailed("\"(\""); | |
1878 } | |
1879 } | |
1880 if (result3 !== null) { | |
1881 var result4 = parse___(); | |
1882 if (result4 !== null) { | |
1883 var result1 = [result3, result4]; | |
1884 } else { | |
1885 var result1 = null; | |
1886 pos = savedPos1; | |
1887 } | |
1888 } else { | |
1889 var result1 = null; | |
1890 pos = savedPos1; | |
1891 } | |
1892 var result2 = result1 !== null | |
1893 ? (function() { return "("; })() | |
1894 : null; | |
1895 if (result2 !== null) { | |
1896 var result0 = result2; | |
1897 } else { | |
1898 var result0 = null; | |
1899 pos = savedPos0; | |
1900 } | |
1901 | |
1902 | |
1903 | |
1904 cache[cacheKey] = { | |
1905 nextPos: pos, | |
1906 result: result0 | |
1907 }; | |
1908 return result0; | |
1909 } | |
1910 | |
1911 function parse_rparen() { | |
1912 var cacheKey = 'rparen@' + pos; | |
1913 var cachedResult = cache[cacheKey]; | |
1914 if (cachedResult) { | |
1915 pos = cachedResult.nextPos; | |
1916 return cachedResult.result; | |
1917 } | |
1918 | |
1919 | |
1920 var savedPos0 = pos; | |
1921 var savedPos1 = pos; | |
1922 if (input.substr(pos, 1) === ")") { | |
1923 var result3 = ")"; | |
1924 pos += 1; | |
1925 } else { | |
1926 var result3 = null; | |
1927 if (reportMatchFailures) { | |
1928 matchFailed("\")\""); | |
1929 } | |
1930 } | |
1931 if (result3 !== null) { | |
1932 var result4 = parse___(); | |
1933 if (result4 !== null) { | |
1934 var result1 = [result3, result4]; | |
1935 } else { | |
1936 var result1 = null; | |
1937 pos = savedPos1; | |
1938 } | |
1939 } else { | |
1940 var result1 = null; | |
1941 pos = savedPos1; | |
1942 } | |
1943 var result2 = result1 !== null | |
1944 ? (function() { return ")"; })() | |
1945 : null; | |
1946 if (result2 !== null) { | |
1947 var result0 = result2; | |
1948 } else { | |
1949 var result0 = null; | |
1950 pos = savedPos0; | |
1951 } | |
1952 | |
1953 | |
1954 | |
1955 cache[cacheKey] = { | |
1956 nextPos: pos, | |
1957 result: result0 | |
1958 }; | |
1959 return result0; | |
1960 } | |
1961 | |
1962 function parse_dot() { | |
1963 var cacheKey = 'dot@' + pos; | |
1964 var cachedResult = cache[cacheKey]; | |
1965 if (cachedResult) { | |
1966 pos = cachedResult.nextPos; | |
1967 return cachedResult.result; | |
1968 } | |
1969 | |
1970 | |
1971 var savedPos0 = pos; | |
1972 var savedPos1 = pos; | |
1973 if (input.substr(pos, 1) === ".") { | |
1974 var result3 = "."; | |
1975 pos += 1; | |
1976 } else { | |
1977 var result3 = null; | |
1978 if (reportMatchFailures) { | |
1979 matchFailed("\".\""); | |
1980 } | |
1981 } | |
1982 if (result3 !== null) { | |
1983 var result4 = parse___(); | |
1984 if (result4 !== null) { | |
1985 var result1 = [result3, result4]; | |
1986 } else { | |
1987 var result1 = null; | |
1988 pos = savedPos1; | |
1989 } | |
1990 } else { | |
1991 var result1 = null; | |
1992 pos = savedPos1; | |
1993 } | |
1994 var result2 = result1 !== null | |
1995 ? (function() { return "."; })() | |
1996 : null; | |
1997 if (result2 !== null) { | |
1998 var result0 = result2; | |
1999 } else { | |
2000 var result0 = null; | |
2001 pos = savedPos0; | |
2002 } | |
2003 | |
2004 | |
2005 | |
2006 cache[cacheKey] = { | |
2007 nextPos: pos, | |
2008 result: result0 | |
2009 }; | |
2010 return result0; | |
2011 } | |
2012 | |
2013 function parse_identifier() { | |
2014 var cacheKey = 'identifier@' + pos; | |
2015 var cachedResult = cache[cacheKey]; | |
2016 if (cachedResult) { | |
2017 pos = cachedResult.nextPos; | |
2018 return cachedResult.result; | |
2019 } | |
2020 | |
2021 var savedReportMatchFailures = reportMatchFailures; | |
2022 reportMatchFailures = false; | |
2023 var savedPos0 = pos; | |
2024 var savedPos1 = pos; | |
2025 var result13 = parse_letter(); | |
2026 if (result13 !== null) { | |
2027 var result3 = result13; | |
2028 } else { | |
2029 if (input.substr(pos, 1) === "_") { | |
2030 var result12 = "_"; | |
2031 pos += 1; | |
2032 } else { | |
2033 var result12 = null; | |
2034 if (reportMatchFailures) { | |
2035 matchFailed("\"_\""); | |
2036 } | |
2037 } | |
2038 if (result12 !== null) { | |
2039 var result3 = result12; | |
2040 } else { | |
2041 if (input.substr(pos, 1) === "$") { | |
2042 var result11 = "$"; | |
2043 pos += 1; | |
2044 } else { | |
2045 var result11 = null; | |
2046 if (reportMatchFailures) { | |
2047 matchFailed("\"$\""); | |
2048 } | |
2049 } | |
2050 if (result11 !== null) { | |
2051 var result3 = result11; | |
2052 } else { | |
2053 var result3 = null;; | |
2054 }; | |
2055 }; | |
2056 } | |
2057 if (result3 !== null) { | |
2058 var result4 = []; | |
2059 var result10 = parse_letter(); | |
2060 if (result10 !== null) { | |
2061 var result6 = result10; | |
2062 } else { | |
2063 var result9 = parse_digit(); | |
2064 if (result9 !== null) { | |
2065 var result6 = result9; | |
2066 } else { | |
2067 if (input.substr(pos, 1) === "_") { | |
2068 var result8 = "_"; | |
2069 pos += 1; | |
2070 } else { | |
2071 var result8 = null; | |
2072 if (reportMatchFailures) { | |
2073 matchFailed("\"_\""); | |
2074 } | |
2075 } | |
2076 if (result8 !== null) { | |
2077 var result6 = result8; | |
2078 } else { | |
2079 if (input.substr(pos, 1) === "$") { | |
2080 var result7 = "$"; | |
2081 pos += 1; | |
2082 } else { | |
2083 var result7 = null; | |
2084 if (reportMatchFailures) { | |
2085 matchFailed("\"$\""); | |
2086 } | |
2087 } | |
2088 if (result7 !== null) { | |
2089 var result6 = result7; | |
2090 } else { | |
2091 var result6 = null;; | |
2092 }; | |
2093 }; | |
2094 }; | |
2095 } | |
2096 while (result6 !== null) { | |
2097 result4.push(result6); | |
2098 var result10 = parse_letter(); | |
2099 if (result10 !== null) { | |
2100 var result6 = result10; | |
2101 } else { | |
2102 var result9 = parse_digit(); | |
2103 if (result9 !== null) { | |
2104 var result6 = result9; | |
2105 } else { | |
2106 if (input.substr(pos, 1) === "_") { | |
2107 var result8 = "_"; | |
2108 pos += 1; | |
2109 } else { | |
2110 var result8 = null; | |
2111 if (reportMatchFailures) { | |
2112 matchFailed("\"_\""); | |
2113 } | |
2114 } | |
2115 if (result8 !== null) { | |
2116 var result6 = result8; | |
2117 } else { | |
2118 if (input.substr(pos, 1) === "$") { | |
2119 var result7 = "$"; | |
2120 pos += 1; | |
2121 } else { | |
2122 var result7 = null; | |
2123 if (reportMatchFailures) { | |
2124 matchFailed("\"$\""); | |
2125 } | |
2126 } | |
2127 if (result7 !== null) { | |
2128 var result6 = result7; | |
2129 } else { | |
2130 var result6 = null;; | |
2131 }; | |
2132 }; | |
2133 }; | |
2134 } | |
2135 } | |
2136 if (result4 !== null) { | |
2137 var result5 = parse___(); | |
2138 if (result5 !== null) { | |
2139 var result1 = [result3, result4, result5]; | |
2140 } else { | |
2141 var result1 = null; | |
2142 pos = savedPos1; | |
2143 } | |
2144 } else { | |
2145 var result1 = null; | |
2146 pos = savedPos1; | |
2147 } | |
2148 } else { | |
2149 var result1 = null; | |
2150 pos = savedPos1; | |
2151 } | |
2152 var result2 = result1 !== null | |
2153 ? (function(head, tail) { | |
2154 return head + tail.join(""); | |
2155 })(result1[0], result1[1]) | |
2156 : null; | |
2157 if (result2 !== null) { | |
2158 var result0 = result2; | |
2159 } else { | |
2160 var result0 = null; | |
2161 pos = savedPos0; | |
2162 } | |
2163 reportMatchFailures = savedReportMatchFailures; | |
2164 if (reportMatchFailures && result0 === null) { | |
2165 matchFailed("identifier"); | |
2166 } | |
2167 | |
2168 cache[cacheKey] = { | |
2169 nextPos: pos, | |
2170 result: result0 | |
2171 }; | |
2172 return result0; | |
2173 } | |
2174 | |
2175 function parse_literal() { | |
2176 var cacheKey = 'literal@' + pos; | |
2177 var cachedResult = cache[cacheKey]; | |
2178 if (cachedResult) { | |
2179 pos = cachedResult.nextPos; | |
2180 return cachedResult.result; | |
2181 } | |
2182 | |
2183 var savedReportMatchFailures = reportMatchFailures; | |
2184 reportMatchFailures = false; | |
2185 var savedPos0 = pos; | |
2186 var savedPos1 = pos; | |
2187 var result6 = parse_doubleQuotedLiteral(); | |
2188 if (result6 !== null) { | |
2189 var result3 = result6; | |
2190 } else { | |
2191 var result5 = parse_singleQuotedLiteral(); | |
2192 if (result5 !== null) { | |
2193 var result3 = result5; | |
2194 } else { | |
2195 var result3 = null;; | |
2196 }; | |
2197 } | |
2198 if (result3 !== null) { | |
2199 var result4 = parse___(); | |
2200 if (result4 !== null) { | |
2201 var result1 = [result3, result4]; | |
2202 } else { | |
2203 var result1 = null; | |
2204 pos = savedPos1; | |
2205 } | |
2206 } else { | |
2207 var result1 = null; | |
2208 pos = savedPos1; | |
2209 } | |
2210 var result2 = result1 !== null | |
2211 ? (function(literal) { return literal; })(result1[0]) | |
2212 : null; | |
2213 if (result2 !== null) { | |
2214 var result0 = result2; | |
2215 } else { | |
2216 var result0 = null; | |
2217 pos = savedPos0; | |
2218 } | |
2219 reportMatchFailures = savedReportMatchFailures; | |
2220 if (reportMatchFailures && result0 === null) { | |
2221 matchFailed("literal"); | |
2222 } | |
2223 | |
2224 cache[cacheKey] = { | |
2225 nextPos: pos, | |
2226 result: result0 | |
2227 }; | |
2228 return result0; | |
2229 } | |
2230 | |
2231 function parse_doubleQuotedLiteral() { | |
2232 var cacheKey = 'doubleQuotedLiteral@' + pos; | |
2233 var cachedResult = cache[cacheKey]; | |
2234 if (cachedResult) { | |
2235 pos = cachedResult.nextPos; | |
2236 return cachedResult.result; | |
2237 } | |
2238 | |
2239 | |
2240 var savedPos0 = pos; | |
2241 var savedPos1 = pos; | |
2242 if (input.substr(pos, 1) === "\"") { | |
2243 var result3 = "\""; | |
2244 pos += 1; | |
2245 } else { | |
2246 var result3 = null; | |
2247 if (reportMatchFailures) { | |
2248 matchFailed("\"\\\"\""); | |
2249 } | |
2250 } | |
2251 if (result3 !== null) { | |
2252 var result4 = []; | |
2253 var result6 = parse_doubleQuotedCharacter(); | |
2254 while (result6 !== null) { | |
2255 result4.push(result6); | |
2256 var result6 = parse_doubleQuotedCharacter(); | |
2257 } | |
2258 if (result4 !== null) { | |
2259 if (input.substr(pos, 1) === "\"") { | |
2260 var result5 = "\""; | |
2261 pos += 1; | |
2262 } else { | |
2263 var result5 = null; | |
2264 if (reportMatchFailures) { | |
2265 matchFailed("\"\\\"\""); | |
2266 } | |
2267 } | |
2268 if (result5 !== null) { | |
2269 var result1 = [result3, result4, result5]; | |
2270 } else { | |
2271 var result1 = null; | |
2272 pos = savedPos1; | |
2273 } | |
2274 } else { | |
2275 var result1 = null; | |
2276 pos = savedPos1; | |
2277 } | |
2278 } else { | |
2279 var result1 = null; | |
2280 pos = savedPos1; | |
2281 } | |
2282 var result2 = result1 !== null | |
2283 ? (function(chars) { return chars.join(""); })(result1[1]) | |
2284 : null; | |
2285 if (result2 !== null) { | |
2286 var result0 = result2; | |
2287 } else { | |
2288 var result0 = null; | |
2289 pos = savedPos0; | |
2290 } | |
2291 | |
2292 | |
2293 | |
2294 cache[cacheKey] = { | |
2295 nextPos: pos, | |
2296 result: result0 | |
2297 }; | |
2298 return result0; | |
2299 } | |
2300 | |
2301 function parse_doubleQuotedCharacter() { | |
2302 var cacheKey = 'doubleQuotedCharacter@' + pos; | |
2303 var cachedResult = cache[cacheKey]; | |
2304 if (cachedResult) { | |
2305 pos = cachedResult.nextPos; | |
2306 return cachedResult.result; | |
2307 } | |
2308 | |
2309 | |
2310 var result6 = parse_simpleDoubleQuotedCharacter(); | |
2311 if (result6 !== null) { | |
2312 var result0 = result6; | |
2313 } else { | |
2314 var result5 = parse_simpleEscapeSequence(); | |
2315 if (result5 !== null) { | |
2316 var result0 = result5; | |
2317 } else { | |
2318 var result4 = parse_zeroEscapeSequence(); | |
2319 if (result4 !== null) { | |
2320 var result0 = result4; | |
2321 } else { | |
2322 var result3 = parse_hexEscapeSequence(); | |
2323 if (result3 !== null) { | |
2324 var result0 = result3; | |
2325 } else { | |
2326 var result2 = parse_unicodeEscapeSequence(); | |
2327 if (result2 !== null) { | |
2328 var result0 = result2; | |
2329 } else { | |
2330 var result1 = parse_eolEscapeSequence(); | |
2331 if (result1 !== null) { | |
2332 var result0 = result1; | |
2333 } else { | |
2334 var result0 = null;; | |
2335 }; | |
2336 }; | |
2337 }; | |
2338 }; | |
2339 }; | |
2340 } | |
2341 | |
2342 | |
2343 | |
2344 cache[cacheKey] = { | |
2345 nextPos: pos, | |
2346 result: result0 | |
2347 }; | |
2348 return result0; | |
2349 } | |
2350 | |
2351 function parse_simpleDoubleQuotedCharacter() { | |
2352 var cacheKey = 'simpleDoubleQuotedCharacter@' + pos; | |
2353 var cachedResult = cache[cacheKey]; | |
2354 if (cachedResult) { | |
2355 pos = cachedResult.nextPos; | |
2356 return cachedResult.result; | |
2357 } | |
2358 | |
2359 | |
2360 var savedPos0 = pos; | |
2361 var savedPos1 = pos; | |
2362 var savedPos2 = pos; | |
2363 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
2364 reportMatchFailures = false; | |
2365 if (input.substr(pos, 1) === "\"") { | |
2366 var result8 = "\""; | |
2367 pos += 1; | |
2368 } else { | |
2369 var result8 = null; | |
2370 if (reportMatchFailures) { | |
2371 matchFailed("\"\\\"\""); | |
2372 } | |
2373 } | |
2374 if (result8 !== null) { | |
2375 var result5 = result8; | |
2376 } else { | |
2377 if (input.substr(pos, 1) === "\\") { | |
2378 var result7 = "\\"; | |
2379 pos += 1; | |
2380 } else { | |
2381 var result7 = null; | |
2382 if (reportMatchFailures) { | |
2383 matchFailed("\"\\\\\""); | |
2384 } | |
2385 } | |
2386 if (result7 !== null) { | |
2387 var result5 = result7; | |
2388 } else { | |
2389 var result6 = parse_eolChar(); | |
2390 if (result6 !== null) { | |
2391 var result5 = result6; | |
2392 } else { | |
2393 var result5 = null;; | |
2394 }; | |
2395 }; | |
2396 } | |
2397 reportMatchFailures = savedReportMatchFailuresVar0; | |
2398 if (result5 === null) { | |
2399 var result3 = ''; | |
2400 } else { | |
2401 var result3 = null; | |
2402 pos = savedPos2; | |
2403 } | |
2404 if (result3 !== null) { | |
2405 if (input.length > pos) { | |
2406 var result4 = input.charAt(pos); | |
2407 pos++; | |
2408 } else { | |
2409 var result4 = null; | |
2410 if (reportMatchFailures) { | |
2411 matchFailed('any character'); | |
2412 } | |
2413 } | |
2414 if (result4 !== null) { | |
2415 var result1 = [result3, result4]; | |
2416 } else { | |
2417 var result1 = null; | |
2418 pos = savedPos1; | |
2419 } | |
2420 } else { | |
2421 var result1 = null; | |
2422 pos = savedPos1; | |
2423 } | |
2424 var result2 = result1 !== null | |
2425 ? (function(char_) { return char_; })(result1[1]) | |
2426 : null; | |
2427 if (result2 !== null) { | |
2428 var result0 = result2; | |
2429 } else { | |
2430 var result0 = null; | |
2431 pos = savedPos0; | |
2432 } | |
2433 | |
2434 | |
2435 | |
2436 cache[cacheKey] = { | |
2437 nextPos: pos, | |
2438 result: result0 | |
2439 }; | |
2440 return result0; | |
2441 } | |
2442 | |
2443 function parse_singleQuotedLiteral() { | |
2444 var cacheKey = 'singleQuotedLiteral@' + pos; | |
2445 var cachedResult = cache[cacheKey]; | |
2446 if (cachedResult) { | |
2447 pos = cachedResult.nextPos; | |
2448 return cachedResult.result; | |
2449 } | |
2450 | |
2451 | |
2452 var savedPos0 = pos; | |
2453 var savedPos1 = pos; | |
2454 if (input.substr(pos, 1) === "'") { | |
2455 var result3 = "'"; | |
2456 pos += 1; | |
2457 } else { | |
2458 var result3 = null; | |
2459 if (reportMatchFailures) { | |
2460 matchFailed("\"'\""); | |
2461 } | |
2462 } | |
2463 if (result3 !== null) { | |
2464 var result4 = []; | |
2465 var result6 = parse_singleQuotedCharacter(); | |
2466 while (result6 !== null) { | |
2467 result4.push(result6); | |
2468 var result6 = parse_singleQuotedCharacter(); | |
2469 } | |
2470 if (result4 !== null) { | |
2471 if (input.substr(pos, 1) === "'") { | |
2472 var result5 = "'"; | |
2473 pos += 1; | |
2474 } else { | |
2475 var result5 = null; | |
2476 if (reportMatchFailures) { | |
2477 matchFailed("\"'\""); | |
2478 } | |
2479 } | |
2480 if (result5 !== null) { | |
2481 var result1 = [result3, result4, result5]; | |
2482 } else { | |
2483 var result1 = null; | |
2484 pos = savedPos1; | |
2485 } | |
2486 } else { | |
2487 var result1 = null; | |
2488 pos = savedPos1; | |
2489 } | |
2490 } else { | |
2491 var result1 = null; | |
2492 pos = savedPos1; | |
2493 } | |
2494 var result2 = result1 !== null | |
2495 ? (function(chars) { return chars.join(""); })(result1[1]) | |
2496 : null; | |
2497 if (result2 !== null) { | |
2498 var result0 = result2; | |
2499 } else { | |
2500 var result0 = null; | |
2501 pos = savedPos0; | |
2502 } | |
2503 | |
2504 | |
2505 | |
2506 cache[cacheKey] = { | |
2507 nextPos: pos, | |
2508 result: result0 | |
2509 }; | |
2510 return result0; | |
2511 } | |
2512 | |
2513 function parse_singleQuotedCharacter() { | |
2514 var cacheKey = 'singleQuotedCharacter@' + pos; | |
2515 var cachedResult = cache[cacheKey]; | |
2516 if (cachedResult) { | |
2517 pos = cachedResult.nextPos; | |
2518 return cachedResult.result; | |
2519 } | |
2520 | |
2521 | |
2522 var result6 = parse_simpleSingleQuotedCharacter(); | |
2523 if (result6 !== null) { | |
2524 var result0 = result6; | |
2525 } else { | |
2526 var result5 = parse_simpleEscapeSequence(); | |
2527 if (result5 !== null) { | |
2528 var result0 = result5; | |
2529 } else { | |
2530 var result4 = parse_zeroEscapeSequence(); | |
2531 if (result4 !== null) { | |
2532 var result0 = result4; | |
2533 } else { | |
2534 var result3 = parse_hexEscapeSequence(); | |
2535 if (result3 !== null) { | |
2536 var result0 = result3; | |
2537 } else { | |
2538 var result2 = parse_unicodeEscapeSequence(); | |
2539 if (result2 !== null) { | |
2540 var result0 = result2; | |
2541 } else { | |
2542 var result1 = parse_eolEscapeSequence(); | |
2543 if (result1 !== null) { | |
2544 var result0 = result1; | |
2545 } else { | |
2546 var result0 = null;; | |
2547 }; | |
2548 }; | |
2549 }; | |
2550 }; | |
2551 }; | |
2552 } | |
2553 | |
2554 | |
2555 | |
2556 cache[cacheKey] = { | |
2557 nextPos: pos, | |
2558 result: result0 | |
2559 }; | |
2560 return result0; | |
2561 } | |
2562 | |
2563 function parse_simpleSingleQuotedCharacter() { | |
2564 var cacheKey = 'simpleSingleQuotedCharacter@' + pos; | |
2565 var cachedResult = cache[cacheKey]; | |
2566 if (cachedResult) { | |
2567 pos = cachedResult.nextPos; | |
2568 return cachedResult.result; | |
2569 } | |
2570 | |
2571 | |
2572 var savedPos0 = pos; | |
2573 var savedPos1 = pos; | |
2574 var savedPos2 = pos; | |
2575 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
2576 reportMatchFailures = false; | |
2577 if (input.substr(pos, 1) === "'") { | |
2578 var result8 = "'"; | |
2579 pos += 1; | |
2580 } else { | |
2581 var result8 = null; | |
2582 if (reportMatchFailures) { | |
2583 matchFailed("\"'\""); | |
2584 } | |
2585 } | |
2586 if (result8 !== null) { | |
2587 var result5 = result8; | |
2588 } else { | |
2589 if (input.substr(pos, 1) === "\\") { | |
2590 var result7 = "\\"; | |
2591 pos += 1; | |
2592 } else { | |
2593 var result7 = null; | |
2594 if (reportMatchFailures) { | |
2595 matchFailed("\"\\\\\""); | |
2596 } | |
2597 } | |
2598 if (result7 !== null) { | |
2599 var result5 = result7; | |
2600 } else { | |
2601 var result6 = parse_eolChar(); | |
2602 if (result6 !== null) { | |
2603 var result5 = result6; | |
2604 } else { | |
2605 var result5 = null;; | |
2606 }; | |
2607 }; | |
2608 } | |
2609 reportMatchFailures = savedReportMatchFailuresVar0; | |
2610 if (result5 === null) { | |
2611 var result3 = ''; | |
2612 } else { | |
2613 var result3 = null; | |
2614 pos = savedPos2; | |
2615 } | |
2616 if (result3 !== null) { | |
2617 if (input.length > pos) { | |
2618 var result4 = input.charAt(pos); | |
2619 pos++; | |
2620 } else { | |
2621 var result4 = null; | |
2622 if (reportMatchFailures) { | |
2623 matchFailed('any character'); | |
2624 } | |
2625 } | |
2626 if (result4 !== null) { | |
2627 var result1 = [result3, result4]; | |
2628 } else { | |
2629 var result1 = null; | |
2630 pos = savedPos1; | |
2631 } | |
2632 } else { | |
2633 var result1 = null; | |
2634 pos = savedPos1; | |
2635 } | |
2636 var result2 = result1 !== null | |
2637 ? (function(char_) { return char_; })(result1[1]) | |
2638 : null; | |
2639 if (result2 !== null) { | |
2640 var result0 = result2; | |
2641 } else { | |
2642 var result0 = null; | |
2643 pos = savedPos0; | |
2644 } | |
2645 | |
2646 | |
2647 | |
2648 cache[cacheKey] = { | |
2649 nextPos: pos, | |
2650 result: result0 | |
2651 }; | |
2652 return result0; | |
2653 } | |
2654 | |
2655 function parse_class() { | |
2656 var cacheKey = 'class@' + pos; | |
2657 var cachedResult = cache[cacheKey]; | |
2658 if (cachedResult) { | |
2659 pos = cachedResult.nextPos; | |
2660 return cachedResult.result; | |
2661 } | |
2662 | |
2663 var savedReportMatchFailures = reportMatchFailures; | |
2664 reportMatchFailures = false; | |
2665 var savedPos0 = pos; | |
2666 var savedPos1 = pos; | |
2667 if (input.substr(pos, 1) === "[") { | |
2668 var result3 = "["; | |
2669 pos += 1; | |
2670 } else { | |
2671 var result3 = null; | |
2672 if (reportMatchFailures) { | |
2673 matchFailed("\"[\""); | |
2674 } | |
2675 } | |
2676 if (result3 !== null) { | |
2677 if (input.substr(pos, 1) === "^") { | |
2678 var result11 = "^"; | |
2679 pos += 1; | |
2680 } else { | |
2681 var result11 = null; | |
2682 if (reportMatchFailures) { | |
2683 matchFailed("\"^\""); | |
2684 } | |
2685 } | |
2686 var result4 = result11 !== null ? result11 : ''; | |
2687 if (result4 !== null) { | |
2688 var result5 = []; | |
2689 var result10 = parse_classCharacterRange(); | |
2690 if (result10 !== null) { | |
2691 var result8 = result10; | |
2692 } else { | |
2693 var result9 = parse_classCharacter(); | |
2694 if (result9 !== null) { | |
2695 var result8 = result9; | |
2696 } else { | |
2697 var result8 = null;; | |
2698 }; | |
2699 } | |
2700 while (result8 !== null) { | |
2701 result5.push(result8); | |
2702 var result10 = parse_classCharacterRange(); | |
2703 if (result10 !== null) { | |
2704 var result8 = result10; | |
2705 } else { | |
2706 var result9 = parse_classCharacter(); | |
2707 if (result9 !== null) { | |
2708 var result8 = result9; | |
2709 } else { | |
2710 var result8 = null;; | |
2711 }; | |
2712 } | |
2713 } | |
2714 if (result5 !== null) { | |
2715 if (input.substr(pos, 1) === "]") { | |
2716 var result6 = "]"; | |
2717 pos += 1; | |
2718 } else { | |
2719 var result6 = null; | |
2720 if (reportMatchFailures) { | |
2721 matchFailed("\"]\""); | |
2722 } | |
2723 } | |
2724 if (result6 !== null) { | |
2725 var result7 = parse___(); | |
2726 if (result7 !== null) { | |
2727 var result1 = [result3, result4, result5, result6, result7]; | |
2728 } else { | |
2729 var result1 = null; | |
2730 pos = savedPos1; | |
2731 } | |
2732 } else { | |
2733 var result1 = null; | |
2734 pos = savedPos1; | |
2735 } | |
2736 } else { | |
2737 var result1 = null; | |
2738 pos = savedPos1; | |
2739 } | |
2740 } else { | |
2741 var result1 = null; | |
2742 pos = savedPos1; | |
2743 } | |
2744 } else { | |
2745 var result1 = null; | |
2746 pos = savedPos1; | |
2747 } | |
2748 var result2 = result1 !== null | |
2749 ? (function(inverted, parts) { | |
2750 var partsConverted = map(parts, function(part) { return part.data; }); | |
2751 var rawText = "[" | |
2752 + inverted | |
2753 + map(parts, function(part) { return part.rawText; }).join("") | |
2754 + "]"; | |
2755 | |
2756 return { | |
2757 type: "class", | |
2758 inverted: inverted === "^", | |
2759 parts: partsConverted, | |
2760 // FIXME: Get the raw text from the input directly. | |
2761 rawText: rawText | |
2762 }; | |
2763 })(result1[1], result1[2]) | |
2764 : null; | |
2765 if (result2 !== null) { | |
2766 var result0 = result2; | |
2767 } else { | |
2768 var result0 = null; | |
2769 pos = savedPos0; | |
2770 } | |
2771 reportMatchFailures = savedReportMatchFailures; | |
2772 if (reportMatchFailures && result0 === null) { | |
2773 matchFailed("character class"); | |
2774 } | |
2775 | |
2776 cache[cacheKey] = { | |
2777 nextPos: pos, | |
2778 result: result0 | |
2779 }; | |
2780 return result0; | |
2781 } | |
2782 | |
2783 function parse_classCharacterRange() { | |
2784 var cacheKey = 'classCharacterRange@' + pos; | |
2785 var cachedResult = cache[cacheKey]; | |
2786 if (cachedResult) { | |
2787 pos = cachedResult.nextPos; | |
2788 return cachedResult.result; | |
2789 } | |
2790 | |
2791 | |
2792 var savedPos0 = pos; | |
2793 var savedPos1 = pos; | |
2794 var result3 = parse_classCharacter(); | |
2795 if (result3 !== null) { | |
2796 if (input.substr(pos, 1) === "-") { | |
2797 var result4 = "-"; | |
2798 pos += 1; | |
2799 } else { | |
2800 var result4 = null; | |
2801 if (reportMatchFailures) { | |
2802 matchFailed("\"-\""); | |
2803 } | |
2804 } | |
2805 if (result4 !== null) { | |
2806 var result5 = parse_classCharacter(); | |
2807 if (result5 !== null) { | |
2808 var result1 = [result3, result4, result5]; | |
2809 } else { | |
2810 var result1 = null; | |
2811 pos = savedPos1; | |
2812 } | |
2813 } else { | |
2814 var result1 = null; | |
2815 pos = savedPos1; | |
2816 } | |
2817 } else { | |
2818 var result1 = null; | |
2819 pos = savedPos1; | |
2820 } | |
2821 var result2 = result1 !== null | |
2822 ? (function(begin, end) { | |
2823 if (begin.data.charCodeAt(0) > end.data.charCodeAt(0)) { | |
2824 throw new this.SyntaxError( | |
2825 "Invalid character range: " + begin.rawText + "-" + end.rawText + "." | |
2826 ); | |
2827 } | |
2828 | |
2829 return { | |
2830 data: [begin.data, end.data], | |
2831 // FIXME: Get the raw text from the input directly. | |
2832 rawText: begin.rawText + "-" + end.rawText | |
2833 } | |
2834 })(result1[0], result1[2]) | |
2835 : null; | |
2836 if (result2 !== null) { | |
2837 var result0 = result2; | |
2838 } else { | |
2839 var result0 = null; | |
2840 pos = savedPos0; | |
2841 } | |
2842 | |
2843 | |
2844 | |
2845 cache[cacheKey] = { | |
2846 nextPos: pos, | |
2847 result: result0 | |
2848 }; | |
2849 return result0; | |
2850 } | |
2851 | |
2852 function parse_classCharacter() { | |
2853 var cacheKey = 'classCharacter@' + pos; | |
2854 var cachedResult = cache[cacheKey]; | |
2855 if (cachedResult) { | |
2856 pos = cachedResult.nextPos; | |
2857 return cachedResult.result; | |
2858 } | |
2859 | |
2860 | |
2861 var savedPos0 = pos; | |
2862 var result1 = parse_bracketDelimitedCharacter(); | |
2863 var result2 = result1 !== null | |
2864 ? (function(char_) { | |
2865 return { | |
2866 data: char_, | |
2867 // FIXME: Get the raw text from the input directly. | |
2868 rawText: quoteForRegexpClass(char_) | |
2869 }; | |
2870 })(result1) | |
2871 : null; | |
2872 if (result2 !== null) { | |
2873 var result0 = result2; | |
2874 } else { | |
2875 var result0 = null; | |
2876 pos = savedPos0; | |
2877 } | |
2878 | |
2879 | |
2880 | |
2881 cache[cacheKey] = { | |
2882 nextPos: pos, | |
2883 result: result0 | |
2884 }; | |
2885 return result0; | |
2886 } | |
2887 | |
2888 function parse_bracketDelimitedCharacter() { | |
2889 var cacheKey = 'bracketDelimitedCharacter@' + pos; | |
2890 var cachedResult = cache[cacheKey]; | |
2891 if (cachedResult) { | |
2892 pos = cachedResult.nextPos; | |
2893 return cachedResult.result; | |
2894 } | |
2895 | |
2896 | |
2897 var result6 = parse_simpleBracketDelimitedCharacter(); | |
2898 if (result6 !== null) { | |
2899 var result0 = result6; | |
2900 } else { | |
2901 var result5 = parse_simpleEscapeSequence(); | |
2902 if (result5 !== null) { | |
2903 var result0 = result5; | |
2904 } else { | |
2905 var result4 = parse_zeroEscapeSequence(); | |
2906 if (result4 !== null) { | |
2907 var result0 = result4; | |
2908 } else { | |
2909 var result3 = parse_hexEscapeSequence(); | |
2910 if (result3 !== null) { | |
2911 var result0 = result3; | |
2912 } else { | |
2913 var result2 = parse_unicodeEscapeSequence(); | |
2914 if (result2 !== null) { | |
2915 var result0 = result2; | |
2916 } else { | |
2917 var result1 = parse_eolEscapeSequence(); | |
2918 if (result1 !== null) { | |
2919 var result0 = result1; | |
2920 } else { | |
2921 var result0 = null;; | |
2922 }; | |
2923 }; | |
2924 }; | |
2925 }; | |
2926 }; | |
2927 } | |
2928 | |
2929 | |
2930 | |
2931 cache[cacheKey] = { | |
2932 nextPos: pos, | |
2933 result: result0 | |
2934 }; | |
2935 return result0; | |
2936 } | |
2937 | |
2938 function parse_simpleBracketDelimitedCharacter() { | |
2939 var cacheKey = 'simpleBracketDelimitedCharacter@' + pos; | |
2940 var cachedResult = cache[cacheKey]; | |
2941 if (cachedResult) { | |
2942 pos = cachedResult.nextPos; | |
2943 return cachedResult.result; | |
2944 } | |
2945 | |
2946 | |
2947 var savedPos0 = pos; | |
2948 var savedPos1 = pos; | |
2949 var savedPos2 = pos; | |
2950 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
2951 reportMatchFailures = false; | |
2952 if (input.substr(pos, 1) === "]") { | |
2953 var result8 = "]"; | |
2954 pos += 1; | |
2955 } else { | |
2956 var result8 = null; | |
2957 if (reportMatchFailures) { | |
2958 matchFailed("\"]\""); | |
2959 } | |
2960 } | |
2961 if (result8 !== null) { | |
2962 var result5 = result8; | |
2963 } else { | |
2964 if (input.substr(pos, 1) === "\\") { | |
2965 var result7 = "\\"; | |
2966 pos += 1; | |
2967 } else { | |
2968 var result7 = null; | |
2969 if (reportMatchFailures) { | |
2970 matchFailed("\"\\\\\""); | |
2971 } | |
2972 } | |
2973 if (result7 !== null) { | |
2974 var result5 = result7; | |
2975 } else { | |
2976 var result6 = parse_eolChar(); | |
2977 if (result6 !== null) { | |
2978 var result5 = result6; | |
2979 } else { | |
2980 var result5 = null;; | |
2981 }; | |
2982 }; | |
2983 } | |
2984 reportMatchFailures = savedReportMatchFailuresVar0; | |
2985 if (result5 === null) { | |
2986 var result3 = ''; | |
2987 } else { | |
2988 var result3 = null; | |
2989 pos = savedPos2; | |
2990 } | |
2991 if (result3 !== null) { | |
2992 if (input.length > pos) { | |
2993 var result4 = input.charAt(pos); | |
2994 pos++; | |
2995 } else { | |
2996 var result4 = null; | |
2997 if (reportMatchFailures) { | |
2998 matchFailed('any character'); | |
2999 } | |
3000 } | |
3001 if (result4 !== null) { | |
3002 var result1 = [result3, result4]; | |
3003 } else { | |
3004 var result1 = null; | |
3005 pos = savedPos1; | |
3006 } | |
3007 } else { | |
3008 var result1 = null; | |
3009 pos = savedPos1; | |
3010 } | |
3011 var result2 = result1 !== null | |
3012 ? (function(char_) { return char_; })(result1[1]) | |
3013 : null; | |
3014 if (result2 !== null) { | |
3015 var result0 = result2; | |
3016 } else { | |
3017 var result0 = null; | |
3018 pos = savedPos0; | |
3019 } | |
3020 | |
3021 | |
3022 | |
3023 cache[cacheKey] = { | |
3024 nextPos: pos, | |
3025 result: result0 | |
3026 }; | |
3027 return result0; | |
3028 } | |
3029 | |
3030 function parse_simpleEscapeSequence() { | |
3031 var cacheKey = 'simpleEscapeSequence@' + pos; | |
3032 var cachedResult = cache[cacheKey]; | |
3033 if (cachedResult) { | |
3034 pos = cachedResult.nextPos; | |
3035 return cachedResult.result; | |
3036 } | |
3037 | |
3038 | |
3039 var savedPos0 = pos; | |
3040 var savedPos1 = pos; | |
3041 if (input.substr(pos, 1) === "\\") { | |
3042 var result3 = "\\"; | |
3043 pos += 1; | |
3044 } else { | |
3045 var result3 = null; | |
3046 if (reportMatchFailures) { | |
3047 matchFailed("\"\\\\\""); | |
3048 } | |
3049 } | |
3050 if (result3 !== null) { | |
3051 var savedPos2 = pos; | |
3052 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
3053 reportMatchFailures = false; | |
3054 var result10 = parse_digit(); | |
3055 if (result10 !== null) { | |
3056 var result6 = result10; | |
3057 } else { | |
3058 if (input.substr(pos, 1) === "x") { | |
3059 var result9 = "x"; | |
3060 pos += 1; | |
3061 } else { | |
3062 var result9 = null; | |
3063 if (reportMatchFailures) { | |
3064 matchFailed("\"x\""); | |
3065 } | |
3066 } | |
3067 if (result9 !== null) { | |
3068 var result6 = result9; | |
3069 } else { | |
3070 if (input.substr(pos, 1) === "u") { | |
3071 var result8 = "u"; | |
3072 pos += 1; | |
3073 } else { | |
3074 var result8 = null; | |
3075 if (reportMatchFailures) { | |
3076 matchFailed("\"u\""); | |
3077 } | |
3078 } | |
3079 if (result8 !== null) { | |
3080 var result6 = result8; | |
3081 } else { | |
3082 var result7 = parse_eolChar(); | |
3083 if (result7 !== null) { | |
3084 var result6 = result7; | |
3085 } else { | |
3086 var result6 = null;; | |
3087 }; | |
3088 }; | |
3089 }; | |
3090 } | |
3091 reportMatchFailures = savedReportMatchFailuresVar0; | |
3092 if (result6 === null) { | |
3093 var result4 = ''; | |
3094 } else { | |
3095 var result4 = null; | |
3096 pos = savedPos2; | |
3097 } | |
3098 if (result4 !== null) { | |
3099 if (input.length > pos) { | |
3100 var result5 = input.charAt(pos); | |
3101 pos++; | |
3102 } else { | |
3103 var result5 = null; | |
3104 if (reportMatchFailures) { | |
3105 matchFailed('any character'); | |
3106 } | |
3107 } | |
3108 if (result5 !== null) { | |
3109 var result1 = [result3, result4, result5]; | |
3110 } else { | |
3111 var result1 = null; | |
3112 pos = savedPos1; | |
3113 } | |
3114 } else { | |
3115 var result1 = null; | |
3116 pos = savedPos1; | |
3117 } | |
3118 } else { | |
3119 var result1 = null; | |
3120 pos = savedPos1; | |
3121 } | |
3122 var result2 = result1 !== null | |
3123 ? (function(char_) { | |
3124 return char_ | |
3125 .replace("b", "\b") | |
3126 .replace("f", "\f") | |
3127 .replace("n", "\n") | |
3128 .replace("r", "\r") | |
3129 .replace("t", "\t") | |
3130 .replace("v", "\x0B") // IE does not recognize "\v". | |
3131 })(result1[2]) | |
3132 : null; | |
3133 if (result2 !== null) { | |
3134 var result0 = result2; | |
3135 } else { | |
3136 var result0 = null; | |
3137 pos = savedPos0; | |
3138 } | |
3139 | |
3140 | |
3141 | |
3142 cache[cacheKey] = { | |
3143 nextPos: pos, | |
3144 result: result0 | |
3145 }; | |
3146 return result0; | |
3147 } | |
3148 | |
3149 function parse_zeroEscapeSequence() { | |
3150 var cacheKey = 'zeroEscapeSequence@' + pos; | |
3151 var cachedResult = cache[cacheKey]; | |
3152 if (cachedResult) { | |
3153 pos = cachedResult.nextPos; | |
3154 return cachedResult.result; | |
3155 } | |
3156 | |
3157 | |
3158 var savedPos0 = pos; | |
3159 var savedPos1 = pos; | |
3160 if (input.substr(pos, 2) === "\\0") { | |
3161 var result3 = "\\0"; | |
3162 pos += 2; | |
3163 } else { | |
3164 var result3 = null; | |
3165 if (reportMatchFailures) { | |
3166 matchFailed("\"\\\\0\""); | |
3167 } | |
3168 } | |
3169 if (result3 !== null) { | |
3170 var savedPos2 = pos; | |
3171 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
3172 reportMatchFailures = false; | |
3173 var result5 = parse_digit(); | |
3174 reportMatchFailures = savedReportMatchFailuresVar0; | |
3175 if (result5 === null) { | |
3176 var result4 = ''; | |
3177 } else { | |
3178 var result4 = null; | |
3179 pos = savedPos2; | |
3180 } | |
3181 if (result4 !== null) { | |
3182 var result1 = [result3, result4]; | |
3183 } else { | |
3184 var result1 = null; | |
3185 pos = savedPos1; | |
3186 } | |
3187 } else { | |
3188 var result1 = null; | |
3189 pos = savedPos1; | |
3190 } | |
3191 var result2 = result1 !== null | |
3192 ? (function() { return "\0"; })() | |
3193 : null; | |
3194 if (result2 !== null) { | |
3195 var result0 = result2; | |
3196 } else { | |
3197 var result0 = null; | |
3198 pos = savedPos0; | |
3199 } | |
3200 | |
3201 | |
3202 | |
3203 cache[cacheKey] = { | |
3204 nextPos: pos, | |
3205 result: result0 | |
3206 }; | |
3207 return result0; | |
3208 } | |
3209 | |
3210 function parse_hexEscapeSequence() { | |
3211 var cacheKey = 'hexEscapeSequence@' + pos; | |
3212 var cachedResult = cache[cacheKey]; | |
3213 if (cachedResult) { | |
3214 pos = cachedResult.nextPos; | |
3215 return cachedResult.result; | |
3216 } | |
3217 | |
3218 | |
3219 var savedPos0 = pos; | |
3220 var savedPos1 = pos; | |
3221 if (input.substr(pos, 2) === "\\x") { | |
3222 var result3 = "\\x"; | |
3223 pos += 2; | |
3224 } else { | |
3225 var result3 = null; | |
3226 if (reportMatchFailures) { | |
3227 matchFailed("\"\\\\x\""); | |
3228 } | |
3229 } | |
3230 if (result3 !== null) { | |
3231 var result4 = parse_hexDigit(); | |
3232 if (result4 !== null) { | |
3233 var result5 = parse_hexDigit(); | |
3234 if (result5 !== null) { | |
3235 var result1 = [result3, result4, result5]; | |
3236 } else { | |
3237 var result1 = null; | |
3238 pos = savedPos1; | |
3239 } | |
3240 } else { | |
3241 var result1 = null; | |
3242 pos = savedPos1; | |
3243 } | |
3244 } else { | |
3245 var result1 = null; | |
3246 pos = savedPos1; | |
3247 } | |
3248 var result2 = result1 !== null | |
3249 ? (function(h1, h2) { | |
3250 return String.fromCharCode(parseInt("0x" + h1 + h2)); | |
3251 })(result1[1], result1[2]) | |
3252 : null; | |
3253 if (result2 !== null) { | |
3254 var result0 = result2; | |
3255 } else { | |
3256 var result0 = null; | |
3257 pos = savedPos0; | |
3258 } | |
3259 | |
3260 | |
3261 | |
3262 cache[cacheKey] = { | |
3263 nextPos: pos, | |
3264 result: result0 | |
3265 }; | |
3266 return result0; | |
3267 } | |
3268 | |
3269 function parse_unicodeEscapeSequence() { | |
3270 var cacheKey = 'unicodeEscapeSequence@' + pos; | |
3271 var cachedResult = cache[cacheKey]; | |
3272 if (cachedResult) { | |
3273 pos = cachedResult.nextPos; | |
3274 return cachedResult.result; | |
3275 } | |
3276 | |
3277 | |
3278 var savedPos0 = pos; | |
3279 var savedPos1 = pos; | |
3280 if (input.substr(pos, 2) === "\\u") { | |
3281 var result3 = "\\u"; | |
3282 pos += 2; | |
3283 } else { | |
3284 var result3 = null; | |
3285 if (reportMatchFailures) { | |
3286 matchFailed("\"\\\\u\""); | |
3287 } | |
3288 } | |
3289 if (result3 !== null) { | |
3290 var result4 = parse_hexDigit(); | |
3291 if (result4 !== null) { | |
3292 var result5 = parse_hexDigit(); | |
3293 if (result5 !== null) { | |
3294 var result6 = parse_hexDigit(); | |
3295 if (result6 !== null) { | |
3296 var result7 = parse_hexDigit(); | |
3297 if (result7 !== null) { | |
3298 var result1 = [result3, result4, result5, result6, result7]; | |
3299 } else { | |
3300 var result1 = null; | |
3301 pos = savedPos1; | |
3302 } | |
3303 } else { | |
3304 var result1 = null; | |
3305 pos = savedPos1; | |
3306 } | |
3307 } else { | |
3308 var result1 = null; | |
3309 pos = savedPos1; | |
3310 } | |
3311 } else { | |
3312 var result1 = null; | |
3313 pos = savedPos1; | |
3314 } | |
3315 } else { | |
3316 var result1 = null; | |
3317 pos = savedPos1; | |
3318 } | |
3319 var result2 = result1 !== null | |
3320 ? (function(h1, h2, h3, h4) { | |
3321 return String.fromCharCode(parseInt("0x" + h1 + h2 + h3 + h4)); | |
3322 })(result1[1], result1[2], result1[3], result1[4]) | |
3323 : null; | |
3324 if (result2 !== null) { | |
3325 var result0 = result2; | |
3326 } else { | |
3327 var result0 = null; | |
3328 pos = savedPos0; | |
3329 } | |
3330 | |
3331 | |
3332 | |
3333 cache[cacheKey] = { | |
3334 nextPos: pos, | |
3335 result: result0 | |
3336 }; | |
3337 return result0; | |
3338 } | |
3339 | |
3340 function parse_eolEscapeSequence() { | |
3341 var cacheKey = 'eolEscapeSequence@' + pos; | |
3342 var cachedResult = cache[cacheKey]; | |
3343 if (cachedResult) { | |
3344 pos = cachedResult.nextPos; | |
3345 return cachedResult.result; | |
3346 } | |
3347 | |
3348 | |
3349 var savedPos0 = pos; | |
3350 var savedPos1 = pos; | |
3351 if (input.substr(pos, 1) === "\\") { | |
3352 var result3 = "\\"; | |
3353 pos += 1; | |
3354 } else { | |
3355 var result3 = null; | |
3356 if (reportMatchFailures) { | |
3357 matchFailed("\"\\\\\""); | |
3358 } | |
3359 } | |
3360 if (result3 !== null) { | |
3361 var result4 = parse_eol(); | |
3362 if (result4 !== null) { | |
3363 var result1 = [result3, result4]; | |
3364 } else { | |
3365 var result1 = null; | |
3366 pos = savedPos1; | |
3367 } | |
3368 } else { | |
3369 var result1 = null; | |
3370 pos = savedPos1; | |
3371 } | |
3372 var result2 = result1 !== null | |
3373 ? (function(eol) { return eol; })(result1[1]) | |
3374 : null; | |
3375 if (result2 !== null) { | |
3376 var result0 = result2; | |
3377 } else { | |
3378 var result0 = null; | |
3379 pos = savedPos0; | |
3380 } | |
3381 | |
3382 | |
3383 | |
3384 cache[cacheKey] = { | |
3385 nextPos: pos, | |
3386 result: result0 | |
3387 }; | |
3388 return result0; | |
3389 } | |
3390 | |
3391 function parse_digit() { | |
3392 var cacheKey = 'digit@' + pos; | |
3393 var cachedResult = cache[cacheKey]; | |
3394 if (cachedResult) { | |
3395 pos = cachedResult.nextPos; | |
3396 return cachedResult.result; | |
3397 } | |
3398 | |
3399 | |
3400 if (input.substr(pos).match(/^[0-9]/) !== null) { | |
3401 var result0 = input.charAt(pos); | |
3402 pos++; | |
3403 } else { | |
3404 var result0 = null; | |
3405 if (reportMatchFailures) { | |
3406 matchFailed("[0-9]"); | |
3407 } | |
3408 } | |
3409 | |
3410 | |
3411 | |
3412 cache[cacheKey] = { | |
3413 nextPos: pos, | |
3414 result: result0 | |
3415 }; | |
3416 return result0; | |
3417 } | |
3418 | |
3419 function parse_hexDigit() { | |
3420 var cacheKey = 'hexDigit@' + pos; | |
3421 var cachedResult = cache[cacheKey]; | |
3422 if (cachedResult) { | |
3423 pos = cachedResult.nextPos; | |
3424 return cachedResult.result; | |
3425 } | |
3426 | |
3427 | |
3428 if (input.substr(pos).match(/^[0-9a-fA-F]/) !== null) { | |
3429 var result0 = input.charAt(pos); | |
3430 pos++; | |
3431 } else { | |
3432 var result0 = null; | |
3433 if (reportMatchFailures) { | |
3434 matchFailed("[0-9a-fA-F]"); | |
3435 } | |
3436 } | |
3437 | |
3438 | |
3439 | |
3440 cache[cacheKey] = { | |
3441 nextPos: pos, | |
3442 result: result0 | |
3443 }; | |
3444 return result0; | |
3445 } | |
3446 | |
3447 function parse_letter() { | |
3448 var cacheKey = 'letter@' + pos; | |
3449 var cachedResult = cache[cacheKey]; | |
3450 if (cachedResult) { | |
3451 pos = cachedResult.nextPos; | |
3452 return cachedResult.result; | |
3453 } | |
3454 | |
3455 | |
3456 var result2 = parse_lowerCaseLetter(); | |
3457 if (result2 !== null) { | |
3458 var result0 = result2; | |
3459 } else { | |
3460 var result1 = parse_upperCaseLetter(); | |
3461 if (result1 !== null) { | |
3462 var result0 = result1; | |
3463 } else { | |
3464 var result0 = null;; | |
3465 }; | |
3466 } | |
3467 | |
3468 | |
3469 | |
3470 cache[cacheKey] = { | |
3471 nextPos: pos, | |
3472 result: result0 | |
3473 }; | |
3474 return result0; | |
3475 } | |
3476 | |
3477 function parse_lowerCaseLetter() { | |
3478 var cacheKey = 'lowerCaseLetter@' + pos; | |
3479 var cachedResult = cache[cacheKey]; | |
3480 if (cachedResult) { | |
3481 pos = cachedResult.nextPos; | |
3482 return cachedResult.result; | |
3483 } | |
3484 | |
3485 | |
3486 if (input.substr(pos).match(/^[a-z]/) !== null) { | |
3487 var result0 = input.charAt(pos); | |
3488 pos++; | |
3489 } else { | |
3490 var result0 = null; | |
3491 if (reportMatchFailures) { | |
3492 matchFailed("[a-z]"); | |
3493 } | |
3494 } | |
3495 | |
3496 | |
3497 | |
3498 cache[cacheKey] = { | |
3499 nextPos: pos, | |
3500 result: result0 | |
3501 }; | |
3502 return result0; | |
3503 } | |
3504 | |
3505 function parse_upperCaseLetter() { | |
3506 var cacheKey = 'upperCaseLetter@' + pos; | |
3507 var cachedResult = cache[cacheKey]; | |
3508 if (cachedResult) { | |
3509 pos = cachedResult.nextPos; | |
3510 return cachedResult.result; | |
3511 } | |
3512 | |
3513 | |
3514 if (input.substr(pos).match(/^[A-Z]/) !== null) { | |
3515 var result0 = input.charAt(pos); | |
3516 pos++; | |
3517 } else { | |
3518 var result0 = null; | |
3519 if (reportMatchFailures) { | |
3520 matchFailed("[A-Z]"); | |
3521 } | |
3522 } | |
3523 | |
3524 | |
3525 | |
3526 cache[cacheKey] = { | |
3527 nextPos: pos, | |
3528 result: result0 | |
3529 }; | |
3530 return result0; | |
3531 } | |
3532 | |
3533 function parse___() { | |
3534 var cacheKey = '__@' + pos; | |
3535 var cachedResult = cache[cacheKey]; | |
3536 if (cachedResult) { | |
3537 pos = cachedResult.nextPos; | |
3538 return cachedResult.result; | |
3539 } | |
3540 | |
3541 | |
3542 var result0 = []; | |
3543 var result4 = parse_whitespace(); | |
3544 if (result4 !== null) { | |
3545 var result1 = result4; | |
3546 } else { | |
3547 var result3 = parse_eol(); | |
3548 if (result3 !== null) { | |
3549 var result1 = result3; | |
3550 } else { | |
3551 var result2 = parse_comment(); | |
3552 if (result2 !== null) { | |
3553 var result1 = result2; | |
3554 } else { | |
3555 var result1 = null;; | |
3556 }; | |
3557 }; | |
3558 } | |
3559 while (result1 !== null) { | |
3560 result0.push(result1); | |
3561 var result4 = parse_whitespace(); | |
3562 if (result4 !== null) { | |
3563 var result1 = result4; | |
3564 } else { | |
3565 var result3 = parse_eol(); | |
3566 if (result3 !== null) { | |
3567 var result1 = result3; | |
3568 } else { | |
3569 var result2 = parse_comment(); | |
3570 if (result2 !== null) { | |
3571 var result1 = result2; | |
3572 } else { | |
3573 var result1 = null;; | |
3574 }; | |
3575 }; | |
3576 } | |
3577 } | |
3578 | |
3579 | |
3580 | |
3581 cache[cacheKey] = { | |
3582 nextPos: pos, | |
3583 result: result0 | |
3584 }; | |
3585 return result0; | |
3586 } | |
3587 | |
3588 function parse_comment() { | |
3589 var cacheKey = 'comment@' + pos; | |
3590 var cachedResult = cache[cacheKey]; | |
3591 if (cachedResult) { | |
3592 pos = cachedResult.nextPos; | |
3593 return cachedResult.result; | |
3594 } | |
3595 | |
3596 var savedReportMatchFailures = reportMatchFailures; | |
3597 reportMatchFailures = false; | |
3598 var result2 = parse_singleLineComment(); | |
3599 if (result2 !== null) { | |
3600 var result0 = result2; | |
3601 } else { | |
3602 var result1 = parse_multiLineComment(); | |
3603 if (result1 !== null) { | |
3604 var result0 = result1; | |
3605 } else { | |
3606 var result0 = null;; | |
3607 }; | |
3608 } | |
3609 reportMatchFailures = savedReportMatchFailures; | |
3610 if (reportMatchFailures && result0 === null) { | |
3611 matchFailed("comment"); | |
3612 } | |
3613 | |
3614 cache[cacheKey] = { | |
3615 nextPos: pos, | |
3616 result: result0 | |
3617 }; | |
3618 return result0; | |
3619 } | |
3620 | |
3621 function parse_singleLineComment() { | |
3622 var cacheKey = 'singleLineComment@' + pos; | |
3623 var cachedResult = cache[cacheKey]; | |
3624 if (cachedResult) { | |
3625 pos = cachedResult.nextPos; | |
3626 return cachedResult.result; | |
3627 } | |
3628 | |
3629 | |
3630 var savedPos0 = pos; | |
3631 if (input.substr(pos, 2) === "//") { | |
3632 var result1 = "//"; | |
3633 pos += 2; | |
3634 } else { | |
3635 var result1 = null; | |
3636 if (reportMatchFailures) { | |
3637 matchFailed("\"//\""); | |
3638 } | |
3639 } | |
3640 if (result1 !== null) { | |
3641 var result2 = []; | |
3642 var savedPos1 = pos; | |
3643 var savedPos2 = pos; | |
3644 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
3645 reportMatchFailures = false; | |
3646 var result6 = parse_eolChar(); | |
3647 reportMatchFailures = savedReportMatchFailuresVar0; | |
3648 if (result6 === null) { | |
3649 var result4 = ''; | |
3650 } else { | |
3651 var result4 = null; | |
3652 pos = savedPos2; | |
3653 } | |
3654 if (result4 !== null) { | |
3655 if (input.length > pos) { | |
3656 var result5 = input.charAt(pos); | |
3657 pos++; | |
3658 } else { | |
3659 var result5 = null; | |
3660 if (reportMatchFailures) { | |
3661 matchFailed('any character'); | |
3662 } | |
3663 } | |
3664 if (result5 !== null) { | |
3665 var result3 = [result4, result5]; | |
3666 } else { | |
3667 var result3 = null; | |
3668 pos = savedPos1; | |
3669 } | |
3670 } else { | |
3671 var result3 = null; | |
3672 pos = savedPos1; | |
3673 } | |
3674 while (result3 !== null) { | |
3675 result2.push(result3); | |
3676 var savedPos1 = pos; | |
3677 var savedPos2 = pos; | |
3678 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
3679 reportMatchFailures = false; | |
3680 var result6 = parse_eolChar(); | |
3681 reportMatchFailures = savedReportMatchFailuresVar0; | |
3682 if (result6 === null) { | |
3683 var result4 = ''; | |
3684 } else { | |
3685 var result4 = null; | |
3686 pos = savedPos2; | |
3687 } | |
3688 if (result4 !== null) { | |
3689 if (input.length > pos) { | |
3690 var result5 = input.charAt(pos); | |
3691 pos++; | |
3692 } else { | |
3693 var result5 = null; | |
3694 if (reportMatchFailures) { | |
3695 matchFailed('any character'); | |
3696 } | |
3697 } | |
3698 if (result5 !== null) { | |
3699 var result3 = [result4, result5]; | |
3700 } else { | |
3701 var result3 = null; | |
3702 pos = savedPos1; | |
3703 } | |
3704 } else { | |
3705 var result3 = null; | |
3706 pos = savedPos1; | |
3707 } | |
3708 } | |
3709 if (result2 !== null) { | |
3710 var result0 = [result1, result2]; | |
3711 } else { | |
3712 var result0 = null; | |
3713 pos = savedPos0; | |
3714 } | |
3715 } else { | |
3716 var result0 = null; | |
3717 pos = savedPos0; | |
3718 } | |
3719 | |
3720 | |
3721 | |
3722 cache[cacheKey] = { | |
3723 nextPos: pos, | |
3724 result: result0 | |
3725 }; | |
3726 return result0; | |
3727 } | |
3728 | |
3729 function parse_multiLineComment() { | |
3730 var cacheKey = 'multiLineComment@' + pos; | |
3731 var cachedResult = cache[cacheKey]; | |
3732 if (cachedResult) { | |
3733 pos = cachedResult.nextPos; | |
3734 return cachedResult.result; | |
3735 } | |
3736 | |
3737 | |
3738 var savedPos0 = pos; | |
3739 if (input.substr(pos, 2) === "/*") { | |
3740 var result1 = "/*"; | |
3741 pos += 2; | |
3742 } else { | |
3743 var result1 = null; | |
3744 if (reportMatchFailures) { | |
3745 matchFailed("\"/*\""); | |
3746 } | |
3747 } | |
3748 if (result1 !== null) { | |
3749 var result2 = []; | |
3750 var savedPos1 = pos; | |
3751 var savedPos2 = pos; | |
3752 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
3753 reportMatchFailures = false; | |
3754 if (input.substr(pos, 2) === "*/") { | |
3755 var result7 = "*/"; | |
3756 pos += 2; | |
3757 } else { | |
3758 var result7 = null; | |
3759 if (reportMatchFailures) { | |
3760 matchFailed("\"*/\""); | |
3761 } | |
3762 } | |
3763 reportMatchFailures = savedReportMatchFailuresVar0; | |
3764 if (result7 === null) { | |
3765 var result5 = ''; | |
3766 } else { | |
3767 var result5 = null; | |
3768 pos = savedPos2; | |
3769 } | |
3770 if (result5 !== null) { | |
3771 if (input.length > pos) { | |
3772 var result6 = input.charAt(pos); | |
3773 pos++; | |
3774 } else { | |
3775 var result6 = null; | |
3776 if (reportMatchFailures) { | |
3777 matchFailed('any character'); | |
3778 } | |
3779 } | |
3780 if (result6 !== null) { | |
3781 var result4 = [result5, result6]; | |
3782 } else { | |
3783 var result4 = null; | |
3784 pos = savedPos1; | |
3785 } | |
3786 } else { | |
3787 var result4 = null; | |
3788 pos = savedPos1; | |
3789 } | |
3790 while (result4 !== null) { | |
3791 result2.push(result4); | |
3792 var savedPos1 = pos; | |
3793 var savedPos2 = pos; | |
3794 var savedReportMatchFailuresVar0 = reportMatchFailures; | |
3795 reportMatchFailures = false; | |
3796 if (input.substr(pos, 2) === "*/") { | |
3797 var result7 = "*/"; | |
3798 pos += 2; | |
3799 } else { | |
3800 var result7 = null; | |
3801 if (reportMatchFailures) { | |
3802 matchFailed("\"*/\""); | |
3803 } | |
3804 } | |
3805 reportMatchFailures = savedReportMatchFailuresVar0; | |
3806 if (result7 === null) { | |
3807 var result5 = ''; | |
3808 } else { | |
3809 var result5 = null; | |
3810 pos = savedPos2; | |
3811 } | |
3812 if (result5 !== null) { | |
3813 if (input.length > pos) { | |
3814 var result6 = input.charAt(pos); | |
3815 pos++; | |
3816 } else { | |
3817 var result6 = null; | |
3818 if (reportMatchFailures) { | |
3819 matchFailed('any character'); | |
3820 } | |
3821 } | |
3822 if (result6 !== null) { | |
3823 var result4 = [result5, result6]; | |
3824 } else { | |
3825 var result4 = null; | |
3826 pos = savedPos1; | |
3827 } | |
3828 } else { | |
3829 var result4 = null; | |
3830 pos = savedPos1; | |
3831 } | |
3832 } | |
3833 if (result2 !== null) { | |
3834 if (input.substr(pos, 2) === "*/") { | |
3835 var result3 = "*/"; | |
3836 pos += 2; | |
3837 } else { | |
3838 var result3 = null; | |
3839 if (reportMatchFailures) { | |
3840 matchFailed("\"*/\""); | |
3841 } | |
3842 } | |
3843 if (result3 !== null) { | |
3844 var result0 = [result1, result2, result3]; | |
3845 } else { | |
3846 var result0 = null; | |
3847 pos = savedPos0; | |
3848 } | |
3849 } else { | |
3850 var result0 = null; | |
3851 pos = savedPos0; | |
3852 } | |
3853 } else { | |
3854 var result0 = null; | |
3855 pos = savedPos0; | |
3856 } | |
3857 | |
3858 | |
3859 | |
3860 cache[cacheKey] = { | |
3861 nextPos: pos, | |
3862 result: result0 | |
3863 }; | |
3864 return result0; | |
3865 } | |
3866 | |
3867 function parse_eol() { | |
3868 var cacheKey = 'eol@' + pos; | |
3869 var cachedResult = cache[cacheKey]; | |
3870 if (cachedResult) { | |
3871 pos = cachedResult.nextPos; | |
3872 return cachedResult.result; | |
3873 } | |
3874 | |
3875 var savedReportMatchFailures = reportMatchFailures; | |
3876 reportMatchFailures = false; | |
3877 if (input.substr(pos, 1) === "\n") { | |
3878 var result5 = "\n"; | |
3879 pos += 1; | |
3880 } else { | |
3881 var result5 = null; | |
3882 if (reportMatchFailures) { | |
3883 matchFailed("\"\\n\""); | |
3884 } | |
3885 } | |
3886 if (result5 !== null) { | |
3887 var result0 = result5; | |
3888 } else { | |
3889 if (input.substr(pos, 2) === "\r\n") { | |
3890 var result4 = "\r\n"; | |
3891 pos += 2; | |
3892 } else { | |
3893 var result4 = null; | |
3894 if (reportMatchFailures) { | |
3895 matchFailed("\"\\r\\n\""); | |
3896 } | |
3897 } | |
3898 if (result4 !== null) { | |
3899 var result0 = result4; | |
3900 } else { | |
3901 if (input.substr(pos, 1) === "\r") { | |
3902 var result3 = "\r"; | |
3903 pos += 1; | |
3904 } else { | |
3905 var result3 = null; | |
3906 if (reportMatchFailures) { | |
3907 matchFailed("\"\\r\""); | |
3908 } | |
3909 } | |
3910 if (result3 !== null) { | |
3911 var result0 = result3; | |
3912 } else { | |
3913 if (input.substr(pos, 1) === "\u2028") { | |
3914 var result2 = "\u2028"; | |
3915 pos += 1; | |
3916 } else { | |
3917 var result2 = null; | |
3918 if (reportMatchFailures) { | |
3919 matchFailed("\"\\u2028\""); | |
3920 } | |
3921 } | |
3922 if (result2 !== null) { | |
3923 var result0 = result2; | |
3924 } else { | |
3925 if (input.substr(pos, 1) === "\u2029") { | |
3926 var result1 = "\u2029"; | |
3927 pos += 1; | |
3928 } else { | |
3929 var result1 = null; | |
3930 if (reportMatchFailures) { | |
3931 matchFailed("\"\\u2029\""); | |
3932 } | |
3933 } | |
3934 if (result1 !== null) { | |
3935 var result0 = result1; | |
3936 } else { | |
3937 var result0 = null;; | |
3938 }; | |
3939 }; | |
3940 }; | |
3941 }; | |
3942 } | |
3943 reportMatchFailures = savedReportMatchFailures; | |
3944 if (reportMatchFailures && result0 === null) { | |
3945 matchFailed("end of line"); | |
3946 } | |
3947 | |
3948 cache[cacheKey] = { | |
3949 nextPos: pos, | |
3950 result: result0 | |
3951 }; | |
3952 return result0; | |
3953 } | |
3954 | |
3955 function parse_eolChar() { | |
3956 var cacheKey = 'eolChar@' + pos; | |
3957 var cachedResult = cache[cacheKey]; | |
3958 if (cachedResult) { | |
3959 pos = cachedResult.nextPos; | |
3960 return cachedResult.result; | |
3961 } | |
3962 | |
3963 | |
3964 if (input.substr(pos).match(/^[\n\r\u2028\u2029]/) !== null) { | |
3965 var result0 = input.charAt(pos); | |
3966 pos++; | |
3967 } else { | |
3968 var result0 = null; | |
3969 if (reportMatchFailures) { | |
3970 matchFailed("[\\n\\r\\u2028\\u2029]"); | |
3971 } | |
3972 } | |
3973 | |
3974 | |
3975 | |
3976 cache[cacheKey] = { | |
3977 nextPos: pos, | |
3978 result: result0 | |
3979 }; | |
3980 return result0; | |
3981 } | |
3982 | |
3983 function parse_whitespace() { | |
3984 var cacheKey = 'whitespace@' + pos; | |
3985 var cachedResult = cache[cacheKey]; | |
3986 if (cachedResult) { | |
3987 pos = cachedResult.nextPos; | |
3988 return cachedResult.result; | |
3989 } | |
3990 | |
3991 var savedReportMatchFailures = reportMatchFailures; | |
3992 reportMatchFailures = false; | |
3993 if (input.substr(pos).match(/^[ \xA0\uFEFF\u1680\u180E\u2000-\u200A\u202F\u205F\u3000]/) !== null) { | |
3994 var result0 = input.charAt(pos); | |
3995 pos++; | |
3996 } else { | |
3997 var result0 = null; | |
3998 if (reportMatchFailures) { | |
3999 matchFailed("[ \\xA0\\uFEFF\\u1680\\u180E\\u2000-\\u200A\\u202F\\u205F\\u3000]"); | |
4000 } | |
4001 } | |
4002 reportMatchFailures = savedReportMatchFailures; | |
4003 if (reportMatchFailures && result0 === null) { | |
4004 matchFailed("whitespace"); | |
4005 } | |
4006 | |
4007 cache[cacheKey] = { | |
4008 nextPos: pos, | |
4009 result: result0 | |
4010 }; | |
4011 return result0; | |
4012 } | |
4013 | |
4014 function buildErrorMessage() { | |
4015 function buildExpected(failuresExpected) { | |
4016 failuresExpected.sort(); | |
4017 | |
4018 var lastFailure = null; | |
4019 var failuresExpectedUnique = []; | |
4020 for (var i = 0; i < failuresExpected.length; i++) { | |
4021 if (failuresExpected[i] !== lastFailure) { | |
4022 failuresExpectedUnique.push(failuresExpected[i]); | |
4023 lastFailure = failuresExpected[i]; | |
4024 } | |
4025 } | |
4026 | |
4027 switch (failuresExpectedUnique.length) { | |
4028 case 0: | |
4029 return 'end of input'; | |
4030 case 1: | |
4031 return failuresExpectedUnique[0]; | |
4032 default: | |
4033 return failuresExpectedUnique.slice(0, failuresExpectedUnique.length - 1).join(', ') | |
4034 + ' or ' | |
4035 + failuresExpectedUnique[failuresExpectedUnique.length - 1]; | |
4036 } | |
4037 } | |
4038 | |
4039 var expected = buildExpected(rightmostMatchFailuresExpected); | |
4040 var actualPos = Math.max(pos, rightmostMatchFailuresPos); | |
4041 var actual = actualPos < input.length | |
4042 ? quote(input.charAt(actualPos)) | |
4043 : 'end of input'; | |
4044 | |
4045 return 'Expected ' + expected + ' but ' + actual + ' found.'; | |
4046 } | |
4047 | |
4048 function computeErrorPosition() { | |
4049 /* | |
4050 * The first idea was to use |String.split| to break the input up to the | |
4051 * error position along newlines and derive the line and column from | |
4052 * there. However IE's |split| implementation is so broken that it was | |
4053 * enough to prevent it. | |
4054 */ | |
4055 | |
4056 var line = 1; | |
4057 var column = 1; | |
4058 var seenCR = false; | |
4059 | |
4060 for (var i = 0; i < rightmostMatchFailuresPos; i++) { | |
4061 var ch = input.charAt(i); | |
4062 if (ch === '\n') { | |
4063 if (!seenCR) { line++; } | |
4064 column = 1; | |
4065 seenCR = false; | |
4066 } else if (ch === '\r' | ch === '\u2028' || ch === '\u2029') { | |
4067 line++; | |
4068 column = 1; | |
4069 seenCR = true; | |
4070 } else { | |
4071 column++; | |
4072 seenCR = false; | |
4073 } | |
4074 } | |
4075 | |
4076 return { line: line, column: column }; | |
4077 } | |
4078 | |
4079 | |
4080 | |
4081 var result = parseFunctions[startRule](); | |
4082 | |
4083 /* | |
4084 * The parser is now in one of the following three states: | |
4085 * | |
4086 * 1. The parser successfully parsed the whole input. | |
4087 * | |
4088 * - |result !== null| | |
4089 * - |pos === input.length| | |
4090 * - |rightmostMatchFailuresExpected| may or may not contain something | |
4091 * | |
4092 * 2. The parser successfully parsed only a part of the input. | |
4093 * | |
4094 * - |result !== null| | |
4095 * - |pos < input.length| | |
4096 * - |rightmostMatchFailuresExpected| may or may not contain something | |
4097 * | |
4098 * 3. The parser did not successfully parse any part of the input. | |
4099 * | |
4100 * - |result === null| | |
4101 * - |pos === 0| | |
4102 * - |rightmostMatchFailuresExpected| contains at least one failure | |
4103 * | |
4104 * All code following this comment (including called functions) must | |
4105 * handle these states. | |
4106 */ | |
4107 if (result === null || pos !== input.length) { | |
4108 var errorPosition = computeErrorPosition(); | |
4109 throw new this.SyntaxError( | |
4110 buildErrorMessage(), | |
4111 errorPosition.line, | |
4112 errorPosition.column | |
4113 ); | |
4114 } | |
4115 | |
4116 return result; | |
4117 }, | |
4118 | |
4119 /* Returns the parser source code. */ | |
4120 toSource: function() { return this._source; } | |
4121 }; | |
4122 | |
4123 /* Thrown when a parser encounters a syntax error. */ | |
4124 | |
4125 result.SyntaxError = function(message, line, column) { | |
4126 this.name = 'SyntaxError'; | |
4127 this.message = message; | |
4128 this.line = line; | |
4129 this.column = column; | |
4130 }; | |
4131 | |
4132 result.SyntaxError.prototype = Error.prototype; | |
4133 | |
4134 return result; | |
4135 })(); | |
4136 PEG.compiler = { | |
4137 /* | |
4138 * Generates a parser from a specified grammar AST. Throws |PEG.GrammarError| | |
4139 * if the AST contains a semantic error. Note that not all errors are detected | |
4140 * during the generation and some may protrude to the generated parser and | |
4141 * cause its malfunction. | |
4142 */ | |
4143 compile: function(ast) { | |
4144 var CHECK_NAMES = [ | |
4145 "missingReferencedRules", | |
4146 "leftRecursion" | |
4147 ]; | |
4148 | |
4149 var PASS_NAMES = [ | |
4150 "proxyRules" | |
4151 ]; | |
4152 | |
4153 for (var i = 0; i < CHECK_NAMES.length; i++) { | |
4154 this.checks[CHECK_NAMES[i]](ast); | |
4155 } | |
4156 | |
4157 for (var i = 0; i < PASS_NAMES.length; i++) { | |
4158 ast = this.passes[PASS_NAMES[i]](ast); | |
4159 } | |
4160 | |
4161 var source = this.emitter(ast); | |
4162 var result = eval(source); | |
4163 result._source = source; | |
4164 | |
4165 return result; | |
4166 } | |
4167 }; | |
4168 | |
4169 /* | |
4170 * Checks made on the grammar AST before compilation. Each check is a function | |
4171 * that is passed the AST and does not return anything. If the check passes, the | |
4172 * function does not do anything special, otherwise it throws | |
4173 * |PEG.GrammarError|. The order in which the checks are run is specified in | |
4174 * |PEG.compiler.compile| and should be the same as the order of definitions | |
4175 * here. | |
4176 */ | |
4177 PEG.compiler.checks = { | |
4178 /* Checks that all referenced rules exist. */ | |
4179 missingReferencedRules: function(ast) { | |
4180 function nop() {} | |
4181 | |
4182 function checkExpression(node) { check(node.expression); } | |
4183 | |
4184 function checkSubnodes(propertyName) { | |
4185 return function(node) { each(node[propertyName], check); }; | |
4186 } | |
4187 | |
4188 var check = buildNodeVisitor({ | |
4189 grammar: | |
4190 function(node) { | |
4191 for (var name in node.rules) { | |
4192 check(node.rules[name]); | |
4193 } | |
4194 }, | |
4195 | |
4196 rule: checkExpression, | |
4197 choice: checkSubnodes("alternatives"), | |
4198 sequence: checkSubnodes("elements"), | |
4199 labeled: checkExpression, | |
4200 simple_and: checkExpression, | |
4201 simple_not: checkExpression, | |
4202 semantic_and: nop, | |
4203 semantic_not: nop, | |
4204 optional: checkExpression, | |
4205 zero_or_more: checkExpression, | |
4206 one_or_more: checkExpression, | |
4207 action: checkExpression, | |
4208 | |
4209 rule_ref: | |
4210 function(node) { | |
4211 if (ast.rules[node.name] === undefined) { | |
4212 throw new PEG.GrammarError( | |
4213 "Referenced rule \"" + node.name + "\" does not exist." | |
4214 ); | |
4215 } | |
4216 }, | |
4217 | |
4218 literal: nop, | |
4219 any: nop, | |
4220 "class": nop | |
4221 }); | |
4222 | |
4223 check(ast); | |
4224 }, | |
4225 | |
4226 /* Checks that no left recursion is present. */ | |
4227 leftRecursion: function(ast) { | |
4228 function nop() {} | |
4229 | |
4230 function checkExpression(node, appliedRules) { | |
4231 check(node.expression, appliedRules); | |
4232 } | |
4233 | |
4234 var check = buildNodeVisitor({ | |
4235 grammar: | |
4236 function(node, appliedRules) { | |
4237 for (var name in node.rules) { | |
4238 check(node.rules[name], appliedRules); | |
4239 } | |
4240 }, | |
4241 | |
4242 rule: | |
4243 function(node, appliedRules) { | |
4244 check(node.expression, appliedRules.concat(node.name)); | |
4245 }, | |
4246 | |
4247 choice: | |
4248 function(node, appliedRules) { | |
4249 each(node.alternatives, function(alternative) { | |
4250 check(alternative, appliedRules); | |
4251 }); | |
4252 }, | |
4253 | |
4254 sequence: | |
4255 function(node, appliedRules) { | |
4256 if (node.elements.length > 0) { | |
4257 check(node.elements[0], appliedRules); | |
4258 } | |
4259 }, | |
4260 | |
4261 labeled: checkExpression, | |
4262 simple_and: checkExpression, | |
4263 simple_not: checkExpression, | |
4264 semantic_and: nop, | |
4265 semantic_not: nop, | |
4266 optional: checkExpression, | |
4267 zero_or_more: checkExpression, | |
4268 one_or_more: checkExpression, | |
4269 action: checkExpression, | |
4270 | |
4271 rule_ref: | |
4272 function(node, appliedRules) { | |
4273 if (contains(appliedRules, node.name)) { | |
4274 throw new PEG.GrammarError( | |
4275 "Left recursion detected for rule \"" + node.name + "\"." | |
4276 ); | |
4277 } | |
4278 check(ast.rules[node.name], appliedRules); | |
4279 }, | |
4280 | |
4281 literal: nop, | |
4282 any: nop, | |
4283 "class": nop | |
4284 }); | |
4285 | |
4286 check(ast, []); | |
4287 } | |
4288 }; | |
4289 /* | |
4290 * Optimalization passes made on the grammar AST before compilation. Each pass | |
4291 * is a function that is passed the AST and returns a new AST. The AST can be | |
4292 * modified in-place by the pass. The order in which the passes are run is | |
4293 * specified in |PEG.compiler.compile| and should be the same as the order of | |
4294 * definitions here. | |
4295 */ | |
4296 PEG.compiler.passes = { | |
4297 /* | |
4298 * Removes proxy rules -- that is, rules that only delegate to other rule. | |
4299 */ | |
4300 proxyRules: function(ast) { | |
4301 function isProxyRule(node) { | |
4302 return node.type === "rule" && node.expression.type === "rule_ref"; | |
4303 } | |
4304 | |
4305 function replaceRuleRefs(ast, from, to) { | |
4306 function nop() {} | |
4307 | |
4308 function replaceInExpression(node, from, to) { | |
4309 replace(node.expression, from, to); | |
4310 } | |
4311 | |
4312 function replaceInSubnodes(propertyName) { | |
4313 return function(node, from, to) { | |
4314 each(node[propertyName], function(subnode) { | |
4315 replace(subnode, from, to); | |
4316 }); | |
4317 }; | |
4318 } | |
4319 | |
4320 var replace = buildNodeVisitor({ | |
4321 grammar: | |
4322 function(node, from, to) { | |
4323 for (var name in node.rules) { | |
4324 replace(node.rules[name], from, to); | |
4325 } | |
4326 }, | |
4327 | |
4328 rule: replaceInExpression, | |
4329 choice: replaceInSubnodes("alternatives"), | |
4330 sequence: replaceInSubnodes("elements"), | |
4331 labeled: replaceInExpression, | |
4332 simple_and: replaceInExpression, | |
4333 simple_not: replaceInExpression, | |
4334 semantic_and: nop, | |
4335 semantic_not: nop, | |
4336 optional: replaceInExpression, | |
4337 zero_or_more: replaceInExpression, | |
4338 one_or_more: replaceInExpression, | |
4339 action: replaceInExpression, | |
4340 | |
4341 rule_ref: | |
4342 function(node, from, to) { | |
4343 if (node.name === from) { | |
4344 node.name = to; | |
4345 } | |
4346 }, | |
4347 | |
4348 literal: nop, | |
4349 any: nop, | |
4350 "class": nop | |
4351 }); | |
4352 | |
4353 replace(ast, from, to); | |
4354 } | |
4355 | |
4356 for (var name in ast.rules) { | |
4357 if (isProxyRule(ast.rules[name])) { | |
4358 replaceRuleRefs(ast, ast.rules[name].name, ast.rules[name].expression.name); | |
4359 if (name === ast.startRule) { | |
4360 ast.startRule = ast.rules[name].expression.name; | |
4361 } | |
4362 delete ast.rules[name]; | |
4363 } | |
4364 } | |
4365 | |
4366 return ast; | |
4367 } | |
4368 }; | |
4369 /* Emits the generated code for the AST. */ | |
4370 PEG.compiler.emitter = function(ast) { | |
4371 /* | |
4372 * Takes parts of code, interpolates variables inside them and joins them with | |
4373 * a newline. | |
4374 * | |
4375 * Variables are delimited with "${" and "}" and their names must be valid | |
4376 * identifiers (i.e. they must match [a-zA-Z_][a-zA-Z0-9_]*). Variable values | |
4377 * are specified as properties of the last parameter (if this is an object, | |
4378 * otherwise empty variable set is assumed). Undefined variables result in | |
4379 * throwing |Error|. | |
4380 * | |
4381 * There can be a filter specified after the variable name, prefixed with "|". | |
4382 * The filter name must be a valid identifier. The only recognized filter | |
4383 * right now is "string", which quotes the variable value as a JavaScript | |
4384 * string. Unrecognized filters result in throwing |Error|. | |
4385 * | |
4386 * If any part has multiple lines and the first line is indented by some | |
4387 * amount of whitespace (as defined by the /\s+/ JavaScript regular | |
4388 * expression), second to last lines are indented by the same amount of | |
4389 * whitespace. This results in nicely indented multiline code in variables | |
4390 * without making the templates look ugly. | |
4391 * | |
4392 * Examples: | |
4393 * | |
4394 * formatCode("foo", "bar"); // "foo\nbar" | |
4395 * formatCode("foo", "${bar}", { bar: "baz" }); // "foo\nbaz" | |
4396 * formatCode("foo", "${bar}"); // throws Error | |
4397 * formatCode("foo", "${bar|string}", { bar: "baz" }); // "foo\n\"baz\"" | |
4398 * formatCode("foo", "${bar|eeek}", { bar: "baz" }); // throws Error | |
4399 * formatCode("foo", "${bar}", { bar: " baz\nqux" }); // "foo\n baz\n qux" | |
4400 */ | |
4401 function formatCode() { | |
4402 function interpolateVariablesInParts(parts) { | |
4403 return map(parts, function(part) { | |
4404 return part.replace( | |
4405 /\$\{([a-zA-Z_][a-zA-Z0-9_]*)(\|([a-zA-Z_][a-zA-Z0-9_]*))?\}/g, | |
4406 function(match, name, dummy, filter) { | |
4407 var value = vars[name]; | |
4408 if (value === undefined) { | |
4409 throw new Error("Undefined variable: \"" + name + "\"."); | |
4410 } | |
4411 | |
4412 if (filter !== undefined && filter != "") { // JavaScript engines differ here. | |
4413 if (filter === "string") { | |
4414 return quote(value); | |
4415 } else { | |
4416 throw new Error("Unrecognized filter: \"" + filter + "\"."); | |
4417 } | |
4418 } else { | |
4419 return value; | |
4420 } | |
4421 } | |
4422 ); | |
4423 }); | |
4424 } | |
4425 | |
4426 function indentMultilineParts(parts) { | |
4427 return map(parts, function(part) { | |
4428 if (!/\n/.test(part)) { return part; } | |
4429 | |
4430 var firstLineWhitespacePrefix = part.match(/^\s*/)[0]; | |
4431 var lines = part.split("\n"); | |
4432 var linesIndented = [lines[0]].concat( | |
4433 map(lines.slice(1), function(line) { | |
4434 return firstLineWhitespacePrefix + line; | |
4435 }) | |
4436 ); | |
4437 return linesIndented.join("\n"); | |
4438 }); | |
4439 } | |
4440 | |
4441 var args = Array.prototype.slice.call(arguments); | |
4442 var vars = args[args.length - 1] instanceof Object ? args.pop() : {}; | |
4443 | |
4444 return indentMultilineParts(interpolateVariablesInParts(args)).join("\n"); | |
4445 }; | |
4446 | |
4447 /* Unique ID generator. */ | |
4448 var UID = { | |
4449 _counters: {}, | |
4450 | |
4451 next: function(prefix) { | |
4452 this._counters[prefix] = this._counters[prefix] || 0; | |
4453 return prefix + this._counters[prefix]++; | |
4454 }, | |
4455 | |
4456 reset: function() { | |
4457 this._counters = {}; | |
4458 } | |
4459 }; | |
4460 | |
4461 var emit = buildNodeVisitor({ | |
4462 grammar: function(node) { | |
4463 var initializerCode = node.initializer !== null | |
4464 ? emit(node.initializer) | |
4465 : ""; | |
4466 | |
4467 var parseFunctionTableItems = []; | |
4468 for (var name in node.rules) { | |
4469 parseFunctionTableItems.push(quote(name) + ": parse_" + name); | |
4470 } | |
4471 parseFunctionTableItems.sort(); | |
4472 | |
4473 var parseFunctionDefinitions = []; | |
4474 for (var name in node.rules) { | |
4475 parseFunctionDefinitions.push(emit(node.rules[name])); | |
4476 } | |
4477 | |
4478 return formatCode( | |
4479 "(function(){", | |
4480 " /* Generated by PEG.js 0.6.2 (http://pegjs.majda.cz/). */", | |
4481 " ", | |
4482 " var result = {", | |
4483 " /*", | |
4484 " * Parses the input with a generated parser. If the parsing is successfull,", | |
4485 " * returns a value explicitly or implicitly specified by the grammar from", | |
4486 " * which the parser was generated (see |PEG.buildParser|). If the parsing is", | |
4487 " * unsuccessful, throws |PEG.parser.SyntaxError| describing the error.", | |
4488 " */", | |
4489 " parse: function(input, startRule) {", | |
4490 " var parseFunctions = {", | |
4491 " ${parseFunctionTableItems}", | |
4492 " };", | |
4493 " ", | |
4494 " if (startRule !== undefined) {", | |
4495 " if (parseFunctions[startRule] === undefined) {", | |
4496 " throw new Error(\"Invalid rule name: \" + quote(startRule) + \".\");", | |
4497 " }", | |
4498 " } else {", | |
4499 " startRule = ${startRule|string};", | |
4500 " }", | |
4501 " ", | |
4502 " var pos = 0;", | |
4503 " var reportMatchFailures = true;", | |
4504 " var rightmostMatchFailuresPos = 0;", | |
4505 " var rightmostMatchFailuresExpected = [];", | |
4506 " var cache = {};", | |
4507 " ", | |
4508 /* This needs to be in sync with |padLeft| in utils.js. */ | |
4509 " function padLeft(input, padding, length) {", | |
4510 " var result = input;", | |
4511 " ", | |
4512 " var padLength = length - input.length;", | |
4513 " for (var i = 0; i < padLength; i++) {", | |
4514 " result = padding + result;", | |
4515 " }", | |
4516 " ", | |
4517 " return result;", | |
4518 " }", | |
4519 " ", | |
4520 /* This needs to be in sync with |escape| in utils.js. */ | |
4521 " function escape(ch) {", | |
4522 " var charCode = ch.charCodeAt(0);", | |
4523 " ", | |
4524 " if (charCode <= 0xFF) {", | |
4525 " var escapeChar = 'x';", | |
4526 " var length = 2;", | |
4527 " } else {", | |
4528 " var escapeChar = 'u';", | |
4529 " var length = 4;", | |
4530 " }", | |
4531 " ", | |
4532 " return '\\\\' + escapeChar + padLeft(charCode.toString(16).toUpperCase(), '0', length);", | |
4533 " }", | |
4534 " ", | |
4535 /* This needs to be in sync with |quote| in utils.js. */ | |
4536 " function quote(s) {", | |
4537 " /*", | |
4538 " * ECMA-262, 5th ed., 7.8.4: All characters may appear literally in a", | |
4539 " * string literal except for the closing quote character, backslash,", | |
4540 " * carriage return, line separator, paragraph separator, and line feed.", | |
4541 " * Any character may appear in the form of an escape sequence.", | |
4542 " */", | |
4543 " return '\"' + s", | |
4544 " .replace(/\\\\/g, '\\\\\\\\') // backslash", | |
4545 " .replace(/\"/g, '\\\\\"') // closing quote character", | |
4546 " .replace(/\\r/g, '\\\\r') // carriage return", | |
4547 " .replace(/\\n/g, '\\\\n') // line feed", | |
4548 " .replace(/[\\x80-\\uFFFF]/g, escape) // non-ASCII characters", | |
4549 " + '\"';", | |
4550 " }", | |
4551 " ", | |
4552 " function matchFailed(failure) {", | |
4553 " if (pos < rightmostMatchFailuresPos) {", | |
4554 " return;", | |
4555 " }", | |
4556 " ", | |
4557 " if (pos > rightmostMatchFailuresPos) {", | |
4558 " rightmostMatchFailuresPos = pos;", | |
4559 " rightmostMatchFailuresExpected = [];", | |
4560 " }", | |
4561 " ", | |
4562 " rightmostMatchFailuresExpected.push(failure);", | |
4563 " }", | |
4564 " ", | |
4565 " ${parseFunctionDefinitions}", | |
4566 " ", | |
4567 " function buildErrorMessage() {", | |
4568 " function buildExpected(failuresExpected) {", | |
4569 " failuresExpected.sort();", | |
4570 " ", | |
4571 " var lastFailure = null;", | |
4572 " var failuresExpectedUnique = [];", | |
4573 " for (var i = 0; i < failuresExpected.length; i++) {", | |
4574 " if (failuresExpected[i] !== lastFailure) {", | |
4575 " failuresExpectedUnique.push(failuresExpected[i]);", | |
4576 " lastFailure = failuresExpected[i];", | |
4577 " }", | |
4578 " }", | |
4579 " ", | |
4580 " switch (failuresExpectedUnique.length) {", | |
4581 " case 0:", | |
4582 " return 'end of input';", | |
4583 " case 1:", | |
4584 " return failuresExpectedUnique[0];", | |
4585 " default:", | |
4586 " return failuresExpectedUnique.slice(0, failuresExpectedUnique.length - 1).join(', ')", | |
4587 " + ' or '", | |
4588 " + failuresExpectedUnique[failuresExpectedUnique.length - 1];", | |
4589 " }", | |
4590 " }", | |
4591 " ", | |
4592 " var expected = buildExpected(rightmostMatchFailuresExpected);", | |
4593 " var actualPos = Math.max(pos, rightmostMatchFailuresPos);", | |
4594 " var actual = actualPos < input.length", | |
4595 " ? quote(input.charAt(actualPos))", | |
4596 " : 'end of input';", | |
4597 " ", | |
4598 " return 'Expected ' + expected + ' but ' + actual + ' found.';", | |
4599 " }", | |
4600 " ", | |
4601 " function computeErrorPosition() {", | |
4602 " /*", | |
4603 " * The first idea was to use |String.split| to break the input up to the", | |
4604 " * error position along newlines and derive the line and column from", | |
4605 " * there. However IE's |split| implementation is so broken that it was", | |
4606 " * enough to prevent it.", | |
4607 " */", | |
4608 " ", | |
4609 " var line = 1;", | |
4610 " var column = 1;", | |
4611 " var seenCR = false;", | |
4612 " ", | |
4613 " for (var i = 0; i < rightmostMatchFailuresPos; i++) {", | |
4614 " var ch = input.charAt(i);", | |
4615 " if (ch === '\\n') {", | |
4616 " if (!seenCR) { line++; }", | |
4617 " column = 1;", | |
4618 " seenCR = false;", | |
4619 " } else if (ch === '\\r' | ch === '\\u2028' || ch === '\\u2029') {", | |
4620 " line++;", | |
4621 " column = 1;", | |
4622 " seenCR = true;", | |
4623 " } else {", | |
4624 " column++;", | |
4625 " seenCR = false;", | |
4626 " }", | |
4627 " }", | |
4628 " ", | |
4629 " return { line: line, column: column };", | |
4630 " }", | |
4631 " ", | |
4632 " ${initializerCode}", | |
4633 " ", | |
4634 " var result = parseFunctions[startRule]();", | |
4635 " ", | |
4636 " /*", | |
4637 " * The parser is now in one of the following three states:", | |
4638 " *", | |
4639 " * 1. The parser successfully parsed the whole input.", | |
4640 " *", | |
4641 " * - |result !== null|", | |
4642 " * - |pos === input.length|", | |
4643 " * - |rightmostMatchFailuresExpected| may or may not contain something", | |
4644 " *", | |
4645 " * 2. The parser successfully parsed only a part of the input.", | |
4646 " *", | |
4647 " * - |result !== null|", | |
4648 " * - |pos < input.length|", | |
4649 " * - |rightmostMatchFailuresExpected| may or may not contain something", | |
4650 " *", | |
4651 " * 3. The parser did not successfully parse any part of the input.", | |
4652 " *", | |
4653 " * - |result === null|", | |
4654 " * - |pos === 0|", | |
4655 " * - |rightmostMatchFailuresExpected| contains at least one failure", | |
4656 " *", | |
4657 " * All code following this comment (including called functions) must", | |
4658 " * handle these states.", | |
4659 " */", | |
4660 " if (result === null || pos !== input.length) {", | |
4661 " var errorPosition = computeErrorPosition();", | |
4662 " throw new this.SyntaxError(", | |
4663 " buildErrorMessage(),", | |
4664 " errorPosition.line,", | |
4665 " errorPosition.column", | |
4666 " );", | |
4667 " }", | |
4668 " ", | |
4669 " return result;", | |
4670 " },", | |
4671 " ", | |
4672 " /* Returns the parser source code. */", | |
4673 " toSource: function() { return this._source; }", | |
4674 " };", | |
4675 " ", | |
4676 " /* Thrown when a parser encounters a syntax error. */", | |
4677 " ", | |
4678 " result.SyntaxError = function(message, line, column) {", | |
4679 " this.name = 'SyntaxError';", | |
4680 " this.message = message;", | |
4681 " this.line = line;", | |
4682 " this.column = column;", | |
4683 " };", | |
4684 " ", | |
4685 " result.SyntaxError.prototype = Error.prototype;", | |
4686 " ", | |
4687 " return result;", | |
4688 "})()", | |
4689 { | |
4690 initializerCode: initializerCode, | |
4691 parseFunctionTableItems: parseFunctionTableItems.join(",\n"), | |
4692 parseFunctionDefinitions: parseFunctionDefinitions.join("\n\n"), | |
4693 startRule: node.startRule | |
4694 } | |
4695 ); | |
4696 }, | |
4697 | |
4698 initializer: function(node) { | |
4699 return node.code; | |
4700 }, | |
4701 | |
4702 rule: function(node) { | |
4703 /* | |
4704 * We want to reset variable names at the beginning of every function so | |
4705 * that a little change in the source grammar does not change variables in | |
4706 * all the generated code. This is desired especially when one has the | |
4707 * generated grammar stored in a VCS (this is true e.g. for our | |
4708 * metagrammar). | |
4709 */ | |
4710 UID.reset(); | |
4711 | |
4712 var resultVar = UID.next("result"); | |
4713 | |
4714 if (node.displayName !== null) { | |
4715 var setReportMatchFailuresCode = formatCode( | |
4716 "var savedReportMatchFailures = reportMatchFailures;", | |
4717 "reportMatchFailures = false;" | |
4718 ); | |
4719 var restoreReportMatchFailuresCode = formatCode( | |
4720 "reportMatchFailures = savedReportMatchFailures;" | |
4721 ); | |
4722 var reportMatchFailureCode = formatCode( | |
4723 "if (reportMatchFailures && ${resultVar} === null) {", | |
4724 " matchFailed(${displayName|string});", | |
4725 "}", | |
4726 { | |
4727 displayName: node.displayName, | |
4728 resultVar: resultVar | |
4729 } | |
4730 ); | |
4731 } else { | |
4732 var setReportMatchFailuresCode = ""; | |
4733 var restoreReportMatchFailuresCode = ""; | |
4734 var reportMatchFailureCode = ""; | |
4735 } | |
4736 | |
4737 return formatCode( | |
4738 "function parse_${name}() {", | |
4739 " var cacheKey = '${name}@' + pos;", | |
4740 " var cachedResult = cache[cacheKey];", | |
4741 " if (cachedResult) {", | |
4742 " pos = cachedResult.nextPos;", | |
4743 " return cachedResult.result;", | |
4744 " }", | |
4745 " ", | |
4746 " ${setReportMatchFailuresCode}", | |
4747 " ${code}", | |
4748 " ${restoreReportMatchFailuresCode}", | |
4749 " ${reportMatchFailureCode}", | |
4750 " ", | |
4751 " cache[cacheKey] = {", | |
4752 " nextPos: pos,", | |
4753 " result: ${resultVar}", | |
4754 " };", | |
4755 " return ${resultVar};", | |
4756 "}", | |
4757 { | |
4758 name: node.name, | |
4759 setReportMatchFailuresCode: setReportMatchFailuresCode, | |
4760 restoreReportMatchFailuresCode: restoreReportMatchFailuresCode, | |
4761 reportMatchFailureCode: reportMatchFailureCode, | |
4762 code: emit(node.expression, resultVar), | |
4763 resultVar: resultVar | |
4764 } | |
4765 ); | |
4766 }, | |
4767 | |
4768 /* | |
4769 * The contract for all code fragments generated by the following functions | |
4770 * is as follows: | |
4771 * | |
4772 * * The code fragment should try to match a part of the input starting with | |
4773 * the position indicated in |pos|. That position may point past the end of | |
4774 * the input. | |
4775 * | |
4776 * * If the code fragment matches the input, it advances |pos| after the | |
4777 * matched part of the input and sets variable with a name stored in | |
4778 * |resultVar| to appropriate value, which is always non-null. | |
4779 * | |
4780 * * If the code fragment does not match the input, it does not change |pos| | |
4781 * and it sets a variable with a name stored in |resultVar| to |null|. | |
4782 */ | |
4783 | |
4784 choice: function(node, resultVar) { | |
4785 var code = formatCode( | |
4786 "var ${resultVar} = null;", | |
4787 { resultVar: resultVar } | |
4788 ); | |
4789 | |
4790 for (var i = node.alternatives.length - 1; i >= 0; i--) { | |
4791 var alternativeResultVar = UID.next("result"); | |
4792 code = formatCode( | |
4793 "${alternativeCode}", | |
4794 "if (${alternativeResultVar} !== null) {", | |
4795 " var ${resultVar} = ${alternativeResultVar};", | |
4796 "} else {", | |
4797 " ${code};", | |
4798 "}", | |
4799 { | |
4800 alternativeCode: emit(node.alternatives[i], alternativeResultVar), | |
4801 alternativeResultVar: alternativeResultVar, | |
4802 code: code, | |
4803 resultVar: resultVar | |
4804 } | |
4805 ); | |
4806 } | |
4807 | |
4808 return code; | |
4809 }, | |
4810 | |
4811 sequence: function(node, resultVar) { | |
4812 var savedPosVar = UID.next("savedPos"); | |
4813 | |
4814 var elementResultVars = map(node.elements, function() { | |
4815 return UID.next("result") | |
4816 }); | |
4817 | |
4818 var code = formatCode( | |
4819 "var ${resultVar} = ${elementResultVarArray};", | |
4820 { | |
4821 resultVar: resultVar, | |
4822 elementResultVarArray: "[" + elementResultVars.join(", ") + "]" | |
4823 } | |
4824 ); | |
4825 | |
4826 for (var i = node.elements.length - 1; i >= 0; i--) { | |
4827 code = formatCode( | |
4828 "${elementCode}", | |
4829 "if (${elementResultVar} !== null) {", | |
4830 " ${code}", | |
4831 "} else {", | |
4832 " var ${resultVar} = null;", | |
4833 " pos = ${savedPosVar};", | |
4834 "}", | |
4835 { | |
4836 elementCode: emit(node.elements[i], elementResultVars[i]), | |
4837 elementResultVar: elementResultVars[i], | |
4838 code: code, | |
4839 savedPosVar: savedPosVar, | |
4840 resultVar: resultVar | |
4841 } | |
4842 ); | |
4843 } | |
4844 | |
4845 return formatCode( | |
4846 "var ${savedPosVar} = pos;", | |
4847 "${code}", | |
4848 { | |
4849 code: code, | |
4850 savedPosVar: savedPosVar | |
4851 } | |
4852 ); | |
4853 }, | |
4854 | |
4855 labeled: function(node, resultVar) { | |
4856 return emit(node.expression, resultVar); | |
4857 }, | |
4858 | |
4859 simple_and: function(node, resultVar) { | |
4860 var savedPosVar = UID.next("savedPos"); | |
4861 var savedReportMatchFailuresVar = UID.next("savedReportMatchFailuresVar"); | |
4862 var expressionResultVar = UID.next("result"); | |
4863 | |
4864 return formatCode( | |
4865 "var ${savedPosVar} = pos;", | |
4866 "var ${savedReportMatchFailuresVar} = reportMatchFailures;", | |
4867 "reportMatchFailures = false;", | |
4868 "${expressionCode}", | |
4869 "reportMatchFailures = ${savedReportMatchFailuresVar};", | |
4870 "if (${expressionResultVar} !== null) {", | |
4871 " var ${resultVar} = '';", | |
4872 " pos = ${savedPosVar};", | |
4873 "} else {", | |
4874 " var ${resultVar} = null;", | |
4875 "}", | |
4876 { | |
4877 expressionCode: emit(node.expression, expressionResultVar), | |
4878 expressionResultVar: expressionResultVar, | |
4879 savedPosVar: savedPosVar, | |
4880 savedReportMatchFailuresVar: savedReportMatchFailuresVar, | |
4881 resultVar: resultVar | |
4882 } | |
4883 ); | |
4884 }, | |
4885 | |
4886 simple_not: function(node, resultVar) { | |
4887 var savedPosVar = UID.next("savedPos"); | |
4888 var savedReportMatchFailuresVar = UID.next("savedReportMatchFailuresVar"); | |
4889 var expressionResultVar = UID.next("result"); | |
4890 | |
4891 return formatCode( | |
4892 "var ${savedPosVar} = pos;", | |
4893 "var ${savedReportMatchFailuresVar} = reportMatchFailures;", | |
4894 "reportMatchFailures = false;", | |
4895 "${expressionCode}", | |
4896 "reportMatchFailures = ${savedReportMatchFailuresVar};", | |
4897 "if (${expressionResultVar} === null) {", | |
4898 " var ${resultVar} = '';", | |
4899 "} else {", | |
4900 " var ${resultVar} = null;", | |
4901 " pos = ${savedPosVar};", | |
4902 "}", | |
4903 { | |
4904 expressionCode: emit(node.expression, expressionResultVar), | |
4905 expressionResultVar: expressionResultVar, | |
4906 savedPosVar: savedPosVar, | |
4907 savedReportMatchFailuresVar: savedReportMatchFailuresVar, | |
4908 resultVar: resultVar | |
4909 } | |
4910 ); | |
4911 }, | |
4912 | |
4913 semantic_and: function(node, resultVar) { | |
4914 return formatCode( | |
4915 "var ${resultVar} = (function() {${actionCode}})() ? '' : null;", | |
4916 { | |
4917 actionCode: node.code, | |
4918 resultVar: resultVar | |
4919 } | |
4920 ); | |
4921 }, | |
4922 | |
4923 semantic_not: function(node, resultVar) { | |
4924 return formatCode( | |
4925 "var ${resultVar} = (function() {${actionCode}})() ? null : '';", | |
4926 { | |
4927 actionCode: node.code, | |
4928 resultVar: resultVar | |
4929 } | |
4930 ); | |
4931 }, | |
4932 | |
4933 optional: function(node, resultVar) { | |
4934 var expressionResultVar = UID.next("result"); | |
4935 | |
4936 return formatCode( | |
4937 "${expressionCode}", | |
4938 "var ${resultVar} = ${expressionResultVar} !== null ? ${expressionResultVar} : '';", | |
4939 { | |
4940 expressionCode: emit(node.expression, expressionResultVar), | |
4941 expressionResultVar: expressionResultVar, | |
4942 resultVar: resultVar | |
4943 } | |
4944 ); | |
4945 }, | |
4946 | |
4947 zero_or_more: function(node, resultVar) { | |
4948 var expressionResultVar = UID.next("result"); | |
4949 | |
4950 return formatCode( | |
4951 "var ${resultVar} = [];", | |
4952 "${expressionCode}", | |
4953 "while (${expressionResultVar} !== null) {", | |
4954 " ${resultVar}.push(${expressionResultVar});", | |
4955 " ${expressionCode}", | |
4956 "}", | |
4957 { | |
4958 expressionCode: emit(node.expression, expressionResultVar), | |
4959 expressionResultVar: expressionResultVar, | |
4960 resultVar: resultVar | |
4961 } | |
4962 ); | |
4963 }, | |
4964 | |
4965 one_or_more: function(node, resultVar) { | |
4966 var expressionResultVar = UID.next("result"); | |
4967 | |
4968 return formatCode( | |
4969 "${expressionCode}", | |
4970 "if (${expressionResultVar} !== null) {", | |
4971 " var ${resultVar} = [];", | |
4972 " while (${expressionResultVar} !== null) {", | |
4973 " ${resultVar}.push(${expressionResultVar});", | |
4974 " ${expressionCode}", | |
4975 " }", | |
4976 "} else {", | |
4977 " var ${resultVar} = null;", | |
4978 "}", | |
4979 { | |
4980 expressionCode: emit(node.expression, expressionResultVar), | |
4981 expressionResultVar: expressionResultVar, | |
4982 resultVar: resultVar | |
4983 } | |
4984 ); | |
4985 }, | |
4986 | |
4987 action: function(node, resultVar) { | |
4988 /* | |
4989 * In case of sequences, we splat their elements into function arguments | |
4990 * one by one. Example: | |
4991 * | |
4992 * start: a:"a" b:"b" c:"c" { alert(arguments.length) } // => 3 | |
4993 * | |
4994 * This behavior is reflected in this function. | |
4995 */ | |
4996 | |
4997 var expressionResultVar = UID.next("result"); | |
4998 var actionResultVar = UID.next("result"); | |
4999 var savedPosVar = UID.next("savedPos"); | |
5000 | |
5001 if (node.expression.type === "sequence") { | |
5002 var formalParams = []; | |
5003 var actualParams = []; | |
5004 | |
5005 var elements = node.expression.elements; | |
5006 var elementsLength = elements.length; | |
5007 for (var i = 0; i < elementsLength; i++) { | |
5008 if (elements[i].type === "labeled") { | |
5009 formalParams.push(elements[i].label); | |
5010 actualParams.push(expressionResultVar + "[" + i + "]"); | |
5011 } | |
5012 } | |
5013 } else if (node.expression.type === "labeled") { | |
5014 var formalParams = [node.expression.label]; | |
5015 var actualParams = [expressionResultVar]; | |
5016 } else { | |
5017 var formalParams = []; | |
5018 var actualParams = []; | |
5019 } | |
5020 | |
5021 return formatCode( | |
5022 "var ${savedPosVar} = pos;", | |
5023 "${expressionCode}", | |
5024 "var ${actionResultVar} = ${expressionResultVar} !== null", | |
5025 " ? (function(${formalParams}) {${actionCode}})(${actualParams})", | |
5026 " : null;", | |
5027 "if (${actionResultVar} !== null) {", | |
5028 " var ${resultVar} = ${actionResultVar};", | |
5029 "} else {", | |
5030 " var ${resultVar} = null;", | |
5031 " pos = ${savedPosVar};", | |
5032 "}", | |
5033 { | |
5034 expressionCode: emit(node.expression, expressionResultVar), | |
5035 expressionResultVar: expressionResultVar, | |
5036 actionCode: node.code, | |
5037 actionResultVar: actionResultVar, | |
5038 formalParams: formalParams.join(", "), | |
5039 actualParams: actualParams.join(", "), | |
5040 savedPosVar: savedPosVar, | |
5041 resultVar: resultVar | |
5042 } | |
5043 ); | |
5044 }, | |
5045 | |
5046 rule_ref: function(node, resultVar) { | |
5047 return formatCode( | |
5048 "var ${resultVar} = ${ruleMethod}();", | |
5049 { | |
5050 ruleMethod: "parse_" + node.name, | |
5051 resultVar: resultVar | |
5052 } | |
5053 ); | |
5054 }, | |
5055 | |
5056 literal: function(node, resultVar) { | |
5057 return formatCode( | |
5058 "if (input.substr(pos, ${length}) === ${value|string}) {", | |
5059 " var ${resultVar} = ${value|string};", | |
5060 " pos += ${length};", | |
5061 "} else {", | |
5062 " var ${resultVar} = null;", | |
5063 " if (reportMatchFailures) {", | |
5064 " matchFailed(${valueQuoted|string});", | |
5065 " }", | |
5066 "}", | |
5067 { | |
5068 value: node.value, | |
5069 valueQuoted: quote(node.value), | |
5070 length: node.value.length, | |
5071 resultVar: resultVar | |
5072 } | |
5073 ); | |
5074 }, | |
5075 | |
5076 any: function(node, resultVar) { | |
5077 return formatCode( | |
5078 "if (input.length > pos) {", | |
5079 " var ${resultVar} = input.charAt(pos);", | |
5080 " pos++;", | |
5081 "} else {", | |
5082 " var ${resultVar} = null;", | |
5083 " if (reportMatchFailures) {", | |
5084 " matchFailed('any character');", | |
5085 " }", | |
5086 "}", | |
5087 { resultVar: resultVar } | |
5088 ); | |
5089 }, | |
5090 | |
5091 "class": function(node, resultVar) { | |
5092 if (node.parts.length > 0) { | |
5093 var regexp = "/^[" | |
5094 + (node.inverted ? "^" : "") | |
5095 + map(node.parts, function(part) { | |
5096 return part instanceof Array | |
5097 ? quoteForRegexpClass(part[0]) | |
5098 + "-" | |
5099 + quoteForRegexpClass(part[1]) | |
5100 : quoteForRegexpClass(part); | |
5101 }).join("") | |
5102 + "]/"; | |
5103 } else { | |
5104 /* | |
5105 * Stupid IE considers regexps /[]/ and /[^]/ syntactically invalid, so | |
5106 * we translate them into euqivalents it can handle. | |
5107 */ | |
5108 var regexp = node.inverted ? "/^[\\S\\s]/" : "/^(?!)/"; | |
5109 } | |
5110 | |
5111 return formatCode( | |
5112 "if (input.substr(pos).match(${regexp}) !== null) {", | |
5113 " var ${resultVar} = input.charAt(pos);", | |
5114 " pos++;", | |
5115 "} else {", | |
5116 " var ${resultVar} = null;", | |
5117 " if (reportMatchFailures) {", | |
5118 " matchFailed(${rawText|string});", | |
5119 " }", | |
5120 "}", | |
5121 { | |
5122 regexp: regexp, | |
5123 rawText: node.rawText, | |
5124 resultVar: resultVar | |
5125 } | |
5126 ); | |
5127 } | |
5128 }); | |
5129 | |
5130 return emit(ast); | |
5131 }; | |
5132 | |
5133 if (typeof module === "object") { | |
5134 module.exports = PEG; | |
5135 } else if (typeof window === "object") { | |
5136 window.PEG = PEG; | |
5137 } else { | |
5138 throw new Error("Can't export PEG library (no \"module\" nor \"window\" object detected)."); | |
5139 } | |
5140 | |
5141 })(); |