diff --git a/jdk.js b/jdk.js index 5e54d23..ee9cb33 100755 --- a/jdk.js +++ b/jdk.js @@ -221,8 +221,24 @@ let packageName = (file.match(/package\s+([^;]+)/gm) || [])[1] || 'default'; - let trans = await java_to_javascript(file); + let trans; + let workerPath = this.root.split('/').slice(0, -1).join('/') + '/transpile_worker.js'; + try { + let worker = new Worker(workerPath); + worker.postMessage(file); + await new Promise((resolve, reject) => { + worker.onmessage = (e) => { + trans = e.data; + resolve(); + }; + }); + } catch (ror) { + console.warn( + 'Due to a likely CORS error, java2js was unable to transpile with multithreaded worker: ' + workerPath + ); + trans = java_to_javascript(file); + } // log(trans); // TODO fix this by adding real support for lambda @@ -19572,59 +19588,55 @@ * @return {string} - Converted JavaScript */ const javaToJavascript = (javaString, options = {}, progress) => { - return new Promise((resolve, reject) => { - if (typeof javaString !== 'string') { - reject('java-to-javascript: First argument must be a string'); - } + if (typeof javaString !== 'string') { + throw 'java-to-javascript: First argument must be a string'; + } - // Reset opts parameters - Object.assign(opts, DEFAULT_OPTIONS); + // Reset opts parameters + Object.assign(opts, DEFAULT_OPTIONS); - if (options.globalVars) opts.globalVars = options.globalVars; - if (options.globalScope) opts.globalScope = options.globalScope; - if (options.ugly) opts.separator = ''; - if (options.p5) { - Object.assign(opts.globalVars, p5_options.globalVars, opts.globalVars); - if (!opts.globalScope) opts.globalScope = 'p5'; - } + if (options.globalVars) opts.globalVars = options.globalVars; + if (options.globalScope) opts.globalScope = options.globalScope; + if (options.ugly) opts.separator = ''; + if (options.p5) { + Object.assign(opts.globalVars, p5_options.globalVars, opts.globalVars); + if (!opts.globalScope) opts.globalScope = 'p5'; + } - if (progress) progress(0, 'Parsing Java'); + if (progress) progress(0, 'Parsing Java'); - if (options.p5) javaString = `class JavaJsTemp__ {${fixP5(javaString)}}`; + if (options.p5) javaString = `class JavaJsTemp__ {${fixP5(javaString)}}`; - let javaAST$$1; - try { - javaAST$$1 = javaAST.parse(javaString); - } catch (e) { - let line = e.location.start.line; - if (e.location) reject(`on line ${line}: \n\n${javaString.split('\n')[line - 1].trim()}\n\n${e.stack}`); - else reject(e); - } + let javaAST$$1; + try { + javaAST$$1 = javaAST.parse(javaString); + } catch (e) { + let line = e.location.start.line; + if (e.location) throw `on line ${line}: \n\n${javaString.split('\n')[line - 1].trim()}\n\n${e.stack}`; + else throw e; + } - if (progress) progress(0.5, 'Converting to JavaScript'); + if (progress) progress(0.5, 'Converting to JavaScript'); - let jsString; - if (options.p5) { - jsString = globalsToJs(parseClass(javaAST$$1.types[0], true)); - } else { - jsString = javaAST$$1.types - .map((globalClass) => classToJs(parseClass(globalClass))) - .join(opts.separator); - } + let jsString; + if (options.p5) { + jsString = globalsToJs(parseClass(javaAST$$1.types[0], true)); + } else { + jsString = javaAST$$1.types.map((globalClass) => classToJs(parseClass(globalClass))).join(opts.separator); + } - if (progress) progress(0.75, 'Beautifying'); + if (progress) progress(0.75, 'Beautifying'); - if (!options.ugly) { - jsString = - beautify$2(jsString, { - indent_size: 2 - }) + '\n'; - } + if (!options.ugly) { + jsString = + beautify$2(jsString, { + indent_size: 2 + }) + '\n'; + } - if (progress) progress(1.0, 'Success'); + if (progress) progress(1.0, 'Success'); - resolve(jsString); - }); + return jsString; }; var lib = javaToJavascript; diff --git a/package.json b/package.json index fd32721..7f128a6 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "java2js", - "version": "1.2.8", + "version": "1.2.9", "description": "Converts Java to JavaScript and runs it with a JS JDK", "main": "jdk.js", "scripts": { diff --git a/transpile_worker.js b/transpile_worker.js new file mode 100644 index 0000000..ea33596 --- /dev/null +++ b/transpile_worker.js @@ -0,0 +1,19404 @@ +(function () { + function r(e, n, t) { + function o(i, f) { + if (!n[i]) { + if (!e[i]) { + var c = 'function' == typeof require && require; + if (!f && c) return c(i, !0); + if (u) return u(i, !0); + var a = new Error("Cannot find module '" + i + "'"); + throw ((a.code = 'MODULE_NOT_FOUND'), a); + } + var p = (n[i] = { + exports: {} + }); + e[i][0].call( + p.exports, + function (r) { + var n = e[i][1][r]; + return o(n || r); + }, + p, + p.exports, + r, + e, + n, + t + ); + } + return n[i].exports; + } + for (var u = 'function' == typeof require && require, i = 0; i < t.length; i++) o(t[i]); + return o; + } + return r; +})()( + { + 1: [ + function (require, module, exports) { + const java_to_javascript = require('java-to-javascript'); + self.addEventListener('message', (e) => { + self.postMessage(java_to_javascript(e.data)); + }); + }, + { + 'java-to-javascript': 2 + } + ], + 2: [ + function (require, module, exports) { + /* beautify ignore:start */ + (function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' + ? (module.exports = factory()) + : typeof define === 'function' && define.amd + ? define(factory) + : ((global = global || self), (global.javaToJavascript = factory())); + })(this, function () { + function unwrapExports(x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x.default : x; + } + + function createCommonjsModule(fn, module) { + return (module = { exports: {} }), fn(module, module.exports), module.exports; + } + + var beautify = createCommonjsModule(function (module, exports) { + /* AUTO-GENERATED. DO NOT MODIFY. */ + /* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + + JS Beautifier + --------------- + + + Written by Einar Lielmanis, + https://beautifier.io/ + + Originally converted to javascript by Vital, + "End braces on own line" added by Chris J. Shull, + Parsing improvements for brace-less statements by Liam Newman + + + Usage: + js_beautify(js_source_text); + js_beautify(js_source_text, options); + + The options are: + indent_size (default 4) - indentation size, + indent_char (default space) - character to indent with, + preserve_newlines (default true) - whether existing line breaks should be preserved, + max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk, + + jslint_happy (default false) - if true, then jslint-stricter mode is enforced. + + jslint_happy !jslint_happy + --------------------------------- + function () function() + + switch () { switch() { + case 1: case 1: + break; break; + } } + + space_after_anon_function (default false) - should the space before an anonymous function's parens be added, "function()" vs "function ()", + NOTE: This option is overriden by jslint_happy (i.e. if jslint_happy is true, space_after_anon_function is true by design) + + brace_style (default "collapse") - "collapse" | "expand" | "end-expand" | "none" | any of the former + ",preserve-inline" + put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line, or attempt to keep them where they are. + preserve-inline will try to preserve inline blocks of curly braces + + space_before_conditional (default true) - should the space before conditional statement be added, "if(true)" vs "if (true)", + + unescape_strings (default false) - should printable characters in strings encoded in \xNN notation be unescaped, "example" vs "\x65\x78\x61\x6d\x70\x6c\x65" + + wrap_line_length (default unlimited) - lines should wrap at next opportunity after this number of characters. + NOTE: This is not a hard limit. Lines will continue until a point where a newline would + be preserved if it were present. + + end_with_newline (default false) - end output with a newline + + + e.g + + js_beautify(js_source_text, { + 'indent_size': 1, + 'indent_char': '\t' + }); + + */ + + (function () { + /* GENERATED_BUILD_OUTPUT */ + var legacy_beautify_js = /******/ (function (modules) { + // webpackBootstrap + /******/ // The module cache + /******/ var installedModules = {}; + /******/ + /******/ // The require function + /******/ function __webpack_require__(moduleId) { + /******/ + /******/ // Check if module is in cache + /******/ if (installedModules[moduleId]) { + /******/ return installedModules[moduleId].exports; + /******/ + } + /******/ // Create a new module (and put it into the cache) + /******/ var module = (installedModules[moduleId] = { + /******/ i: moduleId, + /******/ l: false, + /******/ exports: {} + /******/ + }); + /******/ + /******/ // Execute the module function + /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + /******/ + /******/ // Flag the module as loaded + /******/ module.l = true; + /******/ + /******/ // Return the exports of the module + /******/ return module.exports; + /******/ + } + /******/ + /******/ + /******/ // expose the modules object (__webpack_modules__) + /******/ __webpack_require__.m = modules; + /******/ + /******/ // expose the module cache + /******/ __webpack_require__.c = installedModules; + /******/ + /******/ // define getter function for harmony exports + /******/ __webpack_require__.d = function (exports, name, getter) { + /******/ if (!__webpack_require__.o(exports, name)) { + /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); + /******/ + } + /******/ + }; + /******/ + /******/ // define __esModule on exports + /******/ __webpack_require__.r = function (exports) { + /******/ if (typeof Symbol !== 'undefined' && Symbol.toStringTag) { + /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + /******/ + } + /******/ Object.defineProperty(exports, '__esModule', { value: true }); + /******/ + }; + /******/ + /******/ // create a fake namespace object + /******/ // mode & 1: value is a module id, require it + /******/ // mode & 2: merge all properties of value into the ns + /******/ // mode & 4: return value when already ns object + /******/ // mode & 8|1: behave like require + /******/ __webpack_require__.t = function (value, mode) { + /******/ if (mode & 1) value = __webpack_require__(value); + /******/ if (mode & 8) return value; + /******/ if (mode & 4 && typeof value === 'object' && value && value.__esModule) return value; + /******/ var ns = Object.create(null); + /******/ __webpack_require__.r(ns); + /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); + /******/ if (mode & 2 && typeof value != 'string') + for (var key in value) + __webpack_require__.d( + ns, + key, + function (key) { + return value[key]; + }.bind(null, key) + ); + /******/ return ns; + /******/ + }; + /******/ + /******/ // getDefaultExport function for compatibility with non-harmony modules + /******/ __webpack_require__.n = function (module) { + /******/ var getter = + module && module.__esModule + ? /******/ function getDefault() { + return module['default']; + } + : /******/ function getModuleExports() { + return module; + }; + /******/ __webpack_require__.d(getter, 'a', getter); + /******/ return getter; + /******/ + }; + /******/ + /******/ // Object.prototype.hasOwnProperty.call + /******/ __webpack_require__.o = function (object, property) { + return Object.prototype.hasOwnProperty.call(object, property); + }; + /******/ + /******/ // __webpack_public_path__ + /******/ __webpack_require__.p = ''; + /******/ + /******/ + /******/ // Load entry module and return exports + /******/ return __webpack_require__((__webpack_require__.s = 0)); + /******/ + })( + /************************************************************************/ + /******/ [ + /* 0 */ + /***/ function (module, exports, __webpack_require__) { + var Beautifier = __webpack_require__(1).Beautifier, + Options = __webpack_require__(5).Options; + + function js_beautify(js_source_text, options) { + var beautifier = new Beautifier(js_source_text, options); + return beautifier.beautify(); + } + + module.exports = js_beautify; + module.exports.defaultOptions = function () { + return new Options(); + }; + + /***/ + }, + /* 1 */ + /***/ function (module, exports, __webpack_require__) { + var Output = __webpack_require__(2).Output; + var Token = __webpack_require__(3).Token; + var acorn = __webpack_require__(4); + var Options = __webpack_require__(5).Options; + var Tokenizer = __webpack_require__(7).Tokenizer; + var line_starters = __webpack_require__(7).line_starters; + var positionable_operators = __webpack_require__(7).positionable_operators; + var TOKEN = __webpack_require__(7).TOKEN; + + function remove_redundant_indentation(output, frame) { + // This implementation is effective but has some issues: + // - can cause line wrap to happen too soon due to indent removal + // after wrap points are calculated + // These issues are minor compared to ugly indentation. + + if ( + frame.multiline_frame || + frame.mode === MODE.ForInitializer || + frame.mode === MODE.Conditional + ) { + return; + } + + // remove one indent from each line inside this section + output.remove_indent(frame.start_line_index); + } + + function in_array(what, arr) { + return arr.indexOf(what) !== -1; + } + + function ltrim(s) { + return s.replace(/^\s+/g, ''); + } + + function generateMapFromStrings(list) { + var result = {}; + for (var x = 0; x < list.length; x++) { + // make the mapped names underscored instead of dash + result[list[x].replace(/-/g, '_')] = list[x]; + } + return result; + } + + function reserved_word(token, word) { + return token && token.type === TOKEN.RESERVED && token.text === word; + } + + function reserved_array(token, words) { + return token && token.type === TOKEN.RESERVED && in_array(token.text, words); + } + // Unsure of what they mean, but they work. Worth cleaning up in future. + var special_words = [ + 'case', + 'return', + 'do', + 'if', + 'throw', + 'else', + 'await', + 'break', + 'continue', + 'async' + ]; + + var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline']; + + // Generate map from array + var OPERATOR_POSITION = generateMapFromStrings(validPositionValues); + + var OPERATOR_POSITION_BEFORE_OR_PRESERVE = [ + OPERATOR_POSITION.before_newline, + OPERATOR_POSITION.preserve_newline + ]; + + var MODE = { + BlockStatement: 'BlockStatement', // 'BLOCK' + Statement: 'Statement', // 'STATEMENT' + ObjectLiteral: 'ObjectLiteral', // 'OBJECT', + ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]', + ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)', + Conditional: 'Conditional', //'(COND-EXPRESSION)', + Expression: 'Expression' //'(EXPRESSION)' + }; + + // we could use just string.split, but + // IE doesn't like returning empty strings + function split_linebreaks(s) { + //return s.split(/\x0d\x0a|\x0a/); + + s = s.replace(acorn.allLineBreaks, '\n'); + var out = [], + idx = s.indexOf('\n'); + while (idx !== -1) { + out.push(s.substring(0, idx)); + s = s.substring(idx + 1); + idx = s.indexOf('\n'); + } + if (s.length) { + out.push(s); + } + return out; + } + + function is_array(mode) { + return mode === MODE.ArrayLiteral; + } + + function is_expression(mode) { + return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]); + } + + function all_lines_start_with(lines, c) { + for (var i = 0; i < lines.length; i++) { + var line = lines[i].trim(); + if (line.charAt(0) !== c) { + return false; + } + } + return true; + } + + function each_line_matches_indent(lines, indent) { + var i = 0, + len = lines.length, + line; + for (; i < len; i++) { + line = lines[i]; + // allow empty lines to pass through + if (line && line.indexOf(indent) !== 0) { + return false; + } + } + return true; + } + + function Beautifier(source_text, options) { + options = options || {}; + this._source_text = source_text || ''; + + this._output = null; + this._tokens = null; + this._last_last_text = null; + this._flags = null; + this._previous_flags = null; + + this._flag_store = null; + this._options = new Options(options); + } + + Beautifier.prototype.create_flags = function (flags_base, mode) { + var next_indent_level = 0; + if (flags_base) { + next_indent_level = flags_base.indentation_level; + if (!this._output.just_added_newline() && flags_base.line_indent_level > next_indent_level) { + next_indent_level = flags_base.line_indent_level; + } + } + + var next_flags = { + mode: mode, + parent: flags_base, + last_token: flags_base ? flags_base.last_token : new Token(TOKEN.START_BLOCK, ''), // last token text + last_word: flags_base ? flags_base.last_word : '', // last TOKEN.WORD passed + declaration_statement: false, + declaration_assignment: false, + multiline_frame: false, + inline_frame: false, + if_block: false, + else_block: false, + do_block: false, + do_while: false, + import_block: false, + in_case_statement: false, // switch(..){ INSIDE HERE } + in_case: false, // we're on the exact line with "case 0:" + case_body: false, // the indented case-action block + indentation_level: next_indent_level, + line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level, + start_line_index: this._output.get_line_number(), + ternary_depth: 0 + }; + return next_flags; + }; + + Beautifier.prototype._reset = function (source_text) { + var baseIndentString = source_text.match(/^[\t ]*/)[0]; + + this._last_last_text = ''; // pre-last token text + this._output = new Output(this._options, baseIndentString); + + // If testing the ignore directive, start with output disable set to true + this._output.raw = this._options.test_output_raw; + + // Stack of parsing/formatting states, including MODE. + // We tokenize, parse, and output in an almost purely a forward-only stream of token input + // and formatted output. This makes the beautifier less accurate than full parsers + // but also far more tolerant of syntax errors. + // + // For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type + // MODE.BlockStatement on the the stack, even though it could be object literal. If we later + // encounter a ":", we'll switch to to MODE.ObjectLiteral. If we then see a ";", + // most full parsers would die, but the beautifier gracefully falls back to + // MODE.BlockStatement and continues on. + this._flag_store = []; + this.set_mode(MODE.BlockStatement); + var tokenizer = new Tokenizer(source_text, this._options); + this._tokens = tokenizer.tokenize(); + return source_text; + }; + + Beautifier.prototype.beautify = function () { + // if disabled, return the input unchanged. + if (this._options.disabled) { + return this._source_text; + } + + var sweet_code; + var source_text = this._reset(this._source_text); + + var eol = this._options.eol; + if (this._options.eol === 'auto') { + eol = '\n'; + if (source_text && acorn.lineBreak.test(source_text || '')) { + eol = source_text.match(acorn.lineBreak)[0]; + } + } + + var current_token = this._tokens.next(); + while (current_token) { + this.handle_token(current_token); + + this._last_last_text = this._flags.last_token.text; + this._flags.last_token = current_token; + + current_token = this._tokens.next(); + } + + sweet_code = this._output.get_code(eol); + + return sweet_code; + }; + + Beautifier.prototype.handle_token = function (current_token, preserve_statement_flags) { + if (current_token.type === TOKEN.START_EXPR) { + this.handle_start_expr(current_token); + } else if (current_token.type === TOKEN.END_EXPR) { + this.handle_end_expr(current_token); + } else if (current_token.type === TOKEN.START_BLOCK) { + this.handle_start_block(current_token); + } else if (current_token.type === TOKEN.END_BLOCK) { + this.handle_end_block(current_token); + } else if (current_token.type === TOKEN.WORD) { + this.handle_word(current_token); + } else if (current_token.type === TOKEN.RESERVED) { + this.handle_word(current_token); + } else if (current_token.type === TOKEN.SEMICOLON) { + this.handle_semicolon(current_token); + } else if (current_token.type === TOKEN.STRING) { + this.handle_string(current_token); + } else if (current_token.type === TOKEN.EQUALS) { + this.handle_equals(current_token); + } else if (current_token.type === TOKEN.OPERATOR) { + this.handle_operator(current_token); + } else if (current_token.type === TOKEN.COMMA) { + this.handle_comma(current_token); + } else if (current_token.type === TOKEN.BLOCK_COMMENT) { + this.handle_block_comment(current_token, preserve_statement_flags); + } else if (current_token.type === TOKEN.COMMENT) { + this.handle_comment(current_token, preserve_statement_flags); + } else if (current_token.type === TOKEN.DOT) { + this.handle_dot(current_token); + } else if (current_token.type === TOKEN.EOF) { + this.handle_eof(current_token); + } else if (current_token.type === TOKEN.UNKNOWN) { + this.handle_unknown(current_token, preserve_statement_flags); + } else { + this.handle_unknown(current_token, preserve_statement_flags); + } + }; + + Beautifier.prototype.handle_whitespace_and_comments = function ( + current_token, + preserve_statement_flags + ) { + var newlines = current_token.newlines; + var keep_whitespace = this._options.keep_array_indentation && is_array(this._flags.mode); + + if (current_token.comments_before) { + var comment_token = current_token.comments_before.next(); + while (comment_token) { + // The cleanest handling of inline comments is to treat them as though they aren't there. + // Just continue formatting and the behavior should be logical. + // Also ignore unknown tokens. Again, this should result in better behavior. + this.handle_whitespace_and_comments(comment_token, preserve_statement_flags); + this.handle_token(comment_token, preserve_statement_flags); + comment_token = current_token.comments_before.next(); + } + } + + if (keep_whitespace) { + for (var i = 0; i < newlines; i += 1) { + this.print_newline(i > 0, preserve_statement_flags); + } + } else { + if (this._options.max_preserve_newlines && newlines > this._options.max_preserve_newlines) { + newlines = this._options.max_preserve_newlines; + } + + if (this._options.preserve_newlines) { + if (newlines > 1) { + this.print_newline(false, preserve_statement_flags); + for (var j = 1; j < newlines; j += 1) { + this.print_newline(true, preserve_statement_flags); + } + } + } + } + }; + + var newline_restricted_tokens = ['async', 'break', 'continue', 'return', 'throw', 'yield']; + + Beautifier.prototype.allow_wrap_or_preserved_newline = function (current_token, force_linewrap) { + force_linewrap = force_linewrap === undefined ? false : force_linewrap; + + // Never wrap the first token on a line + if (this._output.just_added_newline()) { + return; + } + + var shouldPreserveOrForce = + (this._options.preserve_newlines && current_token.newlines) || force_linewrap; + var operatorLogicApplies = + in_array(this._flags.last_token.text, positionable_operators) || + in_array(current_token.text, positionable_operators); + + if (operatorLogicApplies) { + var shouldPrintOperatorNewline = + (in_array(this._flags.last_token.text, positionable_operators) && + in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) || + in_array(current_token.text, positionable_operators); + shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline; + } + + if (shouldPreserveOrForce) { + this.print_newline(false, true); + } else if (this._options.wrap_line_length) { + if (reserved_array(this._flags.last_token, newline_restricted_tokens)) { + // These tokens should never have a newline inserted + // between them and the following expression. + return; + } + var proposed_line_length = + this._output.current_line.get_character_count() + + current_token.text.length + + (this._output.space_before_token ? 1 : 0); + if (proposed_line_length >= this._options.wrap_line_length) { + this.print_newline(false, true); + } + } + }; + + Beautifier.prototype.print_newline = function (force_newline, preserve_statement_flags) { + if (!preserve_statement_flags) { + if ( + this._flags.last_token.text !== ';' && + this._flags.last_token.text !== ',' && + this._flags.last_token.text !== '=' && + (this._flags.last_token.type !== TOKEN.OPERATOR || + this._flags.last_token.text === '--' || + this._flags.last_token.text === '++') + ) { + var next_token = this._tokens.peek(); + while ( + this._flags.mode === MODE.Statement && + !(this._flags.if_block && reserved_word(next_token, 'else')) && + !this._flags.do_block + ) { + this.restore_mode(); + } + } + } + + if (this._output.add_new_line(force_newline)) { + this._flags.multiline_frame = true; + } + }; + + Beautifier.prototype.print_token_line_indentation = function (current_token) { + if (this._output.just_added_newline()) { + if ( + this._options.keep_array_indentation && + is_array(this._flags.mode) && + current_token.newlines + ) { + this._output.current_line.push(current_token.whitespace_before); + this._output.space_before_token = false; + } else if (this._output.set_indent(this._flags.indentation_level)) { + this._flags.line_indent_level = this._flags.indentation_level; + } + } + }; + + Beautifier.prototype.print_token = function (current_token, printable_token) { + if (this._output.raw) { + this._output.add_raw_token(current_token); + return; + } + + if ( + this._options.comma_first && + current_token.previous && + current_token.previous.type === TOKEN.COMMA && + this._output.just_added_newline() + ) { + if (this._output.previous_line.last() === ',') { + var popped = this._output.previous_line.pop(); + // if the comma was already at the start of the line, + // pull back onto that line and reprint the indentation + if (this._output.previous_line.is_empty()) { + this._output.previous_line.push(popped); + this._output.trim(true); + this._output.current_line.pop(); + this._output.trim(); + } + + // add the comma in front of the next token + this.print_token_line_indentation(current_token); + this._output.add_token(','); + this._output.space_before_token = true; + } + } + + printable_token = printable_token || current_token.text; + this.print_token_line_indentation(current_token); + this._output.add_token(printable_token); + }; + + Beautifier.prototype.indent = function () { + this._flags.indentation_level += 1; + }; + + Beautifier.prototype.deindent = function () { + if ( + this._flags.indentation_level > 0 && + (!this._flags.parent || this._flags.indentation_level > this._flags.parent.indentation_level) + ) { + this._flags.indentation_level -= 1; + } + }; + + Beautifier.prototype.set_mode = function (mode) { + if (this._flags) { + this._flag_store.push(this._flags); + this._previous_flags = this._flags; + } else { + this._previous_flags = this.create_flags(null, mode); + } + + this._flags = this.create_flags(this._previous_flags, mode); + }; + + Beautifier.prototype.restore_mode = function () { + if (this._flag_store.length > 0) { + this._previous_flags = this._flags; + this._flags = this._flag_store.pop(); + if (this._previous_flags.mode === MODE.Statement) { + remove_redundant_indentation(this._output, this._previous_flags); + } + } + }; + + Beautifier.prototype.start_of_object_property = function () { + return ( + this._flags.parent.mode === MODE.ObjectLiteral && + this._flags.mode === MODE.Statement && + ((this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || + reserved_array(this._flags.last_token, ['get', 'set'])) + ); + }; + + Beautifier.prototype.start_of_statement = function (current_token) { + var start = false; + start = + start || + (reserved_array(this._flags.last_token, ['var', 'let', 'const']) && + current_token.type === TOKEN.WORD); + start = start || reserved_word(this._flags.last_token, 'do'); + start = + start || + (!(this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement) && + reserved_array(this._flags.last_token, newline_restricted_tokens) && + !current_token.newlines); + start = + start || + (reserved_word(this._flags.last_token, 'else') && + !(reserved_word(current_token, 'if') && !current_token.comments_before)); + start = + start || + (this._flags.last_token.type === TOKEN.END_EXPR && + (this._previous_flags.mode === MODE.ForInitializer || + this._previous_flags.mode === MODE.Conditional)); + start = + start || + (this._flags.last_token.type === TOKEN.WORD && + this._flags.mode === MODE.BlockStatement && + !this._flags.in_case && + !(current_token.text === '--' || current_token.text === '++') && + this._last_last_text !== 'function' && + current_token.type !== TOKEN.WORD && + current_token.type !== TOKEN.RESERVED); + start = + start || + (this._flags.mode === MODE.ObjectLiteral && + ((this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || + reserved_array(this._flags.last_token, ['get', 'set']))); + + if (start) { + this.set_mode(MODE.Statement); + this.indent(); + + this.handle_whitespace_and_comments(current_token, true); + + // Issue #276: + // If starting a new statement with [if, for, while, do], push to a new line. + // if (a) if (b) if(c) d(); else e(); else f(); + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline( + current_token, + reserved_array(current_token, ['do', 'for', 'if', 'while']) + ); + } + return true; + } + return false; + }; + + Beautifier.prototype.handle_start_expr = function (current_token) { + // The conditional starts the statement if appropriate. + if (!this.start_of_statement(current_token)) { + this.handle_whitespace_and_comments(current_token); + } + + var next_mode = MODE.Expression; + if (current_token.text === '[') { + if (this._flags.last_token.type === TOKEN.WORD || this._flags.last_token.text === ')') { + // this is array index specifier, break immediately + // a[x], fn()[x] + if (reserved_array(this._flags.last_token, line_starters)) { + this._output.space_before_token = true; + } + this.set_mode(next_mode); + this.print_token(current_token); + this.indent(); + if (this._options.space_in_paren) { + this._output.space_before_token = true; + } + return; + } + + next_mode = MODE.ArrayLiteral; + if (is_array(this._flags.mode)) { + if ( + this._flags.last_token.text === '[' || + (this._flags.last_token.text === ',' && + (this._last_last_text === ']' || this._last_last_text === '}')) + ) { + // ], [ goes to new line + // }, [ goes to new line + if (!this._options.keep_array_indentation) { + this.print_newline(); + } + } + } + + if ( + !in_array(this._flags.last_token.type, [ + TOKEN.START_EXPR, + TOKEN.END_EXPR, + TOKEN.WORD, + TOKEN.OPERATOR + ]) + ) { + this._output.space_before_token = true; + } + } else { + if (this._flags.last_token.type === TOKEN.RESERVED) { + if (this._flags.last_token.text === 'for') { + this._output.space_before_token = this._options.space_before_conditional; + next_mode = MODE.ForInitializer; + } else if (in_array(this._flags.last_token.text, ['if', 'while'])) { + this._output.space_before_token = this._options.space_before_conditional; + next_mode = MODE.Conditional; + } else if (in_array(this._flags.last_word, ['await', 'async'])) { + // Should be a space between await and an IIFE, or async and an arrow function + this._output.space_before_token = true; + } else if ( + this._flags.last_token.text === 'import' && + current_token.whitespace_before === '' + ) { + this._output.space_before_token = false; + } else if ( + in_array(this._flags.last_token.text, line_starters) || + this._flags.last_token.text === 'catch' + ) { + this._output.space_before_token = true; + } + } else if ( + this._flags.last_token.type === TOKEN.EQUALS || + this._flags.last_token.type === TOKEN.OPERATOR + ) { + // Support of this kind of newline preservation. + // a = (b && + // (c || d)); + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token); + } + } else if (this._flags.last_token.type === TOKEN.WORD) { + this._output.space_before_token = false; + + // function name() vs function name () + // function* name() vs function* name () + // async name() vs async name () + // In ES6, you can also define the method properties of an object + // var obj = {a: function() {}} + // It can be abbreviated + // var obj = {a() {}} + // var obj = { a() {}} vs var obj = { a () {}} + // var obj = { * a() {}} vs var obj = { * a () {}} + var peek_back_two = this._tokens.peek(-3); + if (this._options.space_after_named_function && peek_back_two) { + // peek starts at next character so -1 is current token + var peek_back_three = this._tokens.peek(-4); + if ( + reserved_array(peek_back_two, ['async', 'function']) || + (peek_back_two.text === '*' && reserved_array(peek_back_three, ['async', 'function'])) + ) { + this._output.space_before_token = true; + } else if (this._flags.mode === MODE.ObjectLiteral) { + if ( + peek_back_two.text === '{' || + peek_back_two.text === ',' || + (peek_back_two.text === '*' && + (peek_back_three.text === '{' || peek_back_three.text === ',')) + ) { + this._output.space_before_token = true; + } + } + } + } else { + // Support preserving wrapped arrow function expressions + // a.b('c', + // () => d.e + // ) + this.allow_wrap_or_preserved_newline(current_token); + } + + // function() vs function () + // yield*() vs yield* () + // function*() vs function* () + if ( + (this._flags.last_token.type === TOKEN.RESERVED && + (this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) || + (this._flags.last_token.text === '*' && + (in_array(this._last_last_text, ['function', 'yield']) || + (this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ','])))) + ) { + this._output.space_before_token = this._options.space_after_anon_function; + } + } + + if (this._flags.last_token.text === ';' || this._flags.last_token.type === TOKEN.START_BLOCK) { + this.print_newline(); + } else if ( + this._flags.last_token.type === TOKEN.END_EXPR || + this._flags.last_token.type === TOKEN.START_EXPR || + this._flags.last_token.type === TOKEN.END_BLOCK || + this._flags.last_token.text === '.' || + this._flags.last_token.type === TOKEN.COMMA + ) { + // do nothing on (( and )( and ][ and ]( and .( + // TODO: Consider whether forcing this is required. Review failing tests when removed. + this.allow_wrap_or_preserved_newline(current_token, current_token.newlines); + } + + this.set_mode(next_mode); + this.print_token(current_token); + if (this._options.space_in_paren) { + this._output.space_before_token = true; + } + + // In all cases, if we newline while inside an expression it should be indented. + this.indent(); + }; + + Beautifier.prototype.handle_end_expr = function (current_token) { + // statements inside expressions are not valid syntax, but... + // statements must all be closed when their container closes + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + + this.handle_whitespace_and_comments(current_token); + + if (this._flags.multiline_frame) { + this.allow_wrap_or_preserved_newline( + current_token, + current_token.text === ']' && + is_array(this._flags.mode) && + !this._options.keep_array_indentation + ); + } + + if (this._options.space_in_paren) { + if (this._flags.last_token.type === TOKEN.START_EXPR && !this._options.space_in_empty_paren) { + // () [] no inner space in empty parens like these, ever, ref #320 + this._output.trim(); + this._output.space_before_token = false; + } else { + this._output.space_before_token = true; + } + } + if (current_token.text === ']' && this._options.keep_array_indentation) { + this.print_token(current_token); + this.restore_mode(); + } else { + this.restore_mode(); + this.print_token(current_token); + } + remove_redundant_indentation(this._output, this._previous_flags); + + // do {} while () // no statement required after + if (this._flags.do_while && this._previous_flags.mode === MODE.Conditional) { + this._previous_flags.mode = MODE.Expression; + this._flags.do_block = false; + this._flags.do_while = false; + } + }; + + Beautifier.prototype.handle_start_block = function (current_token) { + this.handle_whitespace_and_comments(current_token); + + // Check if this is should be treated as a ObjectLiteral + var next_token = this._tokens.peek(); + var second_token = this._tokens.peek(1); + if (this._flags.last_word === 'switch' && this._flags.last_token.type === TOKEN.END_EXPR) { + this.set_mode(MODE.BlockStatement); + this._flags.in_case_statement = true; + } else if ( + second_token && + ((in_array(second_token.text, [':', ',']) && + in_array(next_token.type, [TOKEN.STRING, TOKEN.WORD, TOKEN.RESERVED])) || + (in_array(next_token.text, ['get', 'set', '...']) && + in_array(second_token.type, [TOKEN.WORD, TOKEN.RESERVED]))) + ) { + // We don't support TypeScript,but we didn't break it for a very long time. + // We'll try to keep not breaking it. + if (!in_array(this._last_last_text, ['class', 'interface'])) { + this.set_mode(MODE.ObjectLiteral); + } else { + this.set_mode(MODE.BlockStatement); + } + } else if ( + this._flags.last_token.type === TOKEN.OPERATOR && + this._flags.last_token.text === '=>' + ) { + // arrow function: (param1, paramN) => { statements } + this.set_mode(MODE.BlockStatement); + } else if ( + in_array(this._flags.last_token.type, [ + TOKEN.EQUALS, + TOKEN.START_EXPR, + TOKEN.COMMA, + TOKEN.OPERATOR + ]) || + reserved_array(this._flags.last_token, ['return', 'throw', 'import', 'default']) + ) { + // Detecting shorthand function syntax is difficult by scanning forward, + // so check the surrounding context. + // If the block is being returned, imported, export default, passed as arg, + // assigned with = or assigned in a nested object, treat as an ObjectLiteral. + this.set_mode(MODE.ObjectLiteral); + } else { + this.set_mode(MODE.BlockStatement); + } + + var empty_braces = !next_token.comments_before && next_token.text === '}'; + var empty_anonymous_function = + empty_braces && + this._flags.last_word === 'function' && + this._flags.last_token.type === TOKEN.END_EXPR; + + if (this._options.brace_preserve_inline) { + // check for inline, set inline_frame if so + // search forward for a newline wanted inside this block + var index = 0; + var check_token = null; + this._flags.inline_frame = true; + do { + index += 1; + check_token = this._tokens.peek(index - 1); + if (check_token.newlines) { + this._flags.inline_frame = false; + break; + } + } while ( + check_token.type !== TOKEN.EOF && + !(check_token.type === TOKEN.END_BLOCK && check_token.opened === current_token) + ); + } + + if ( + (this._options.brace_style === 'expand' || + (this._options.brace_style === 'none' && current_token.newlines)) && + !this._flags.inline_frame + ) { + if ( + this._flags.last_token.type !== TOKEN.OPERATOR && + (empty_anonymous_function || + this._flags.last_token.type === TOKEN.EQUALS || + (reserved_array(this._flags.last_token, special_words) && + this._flags.last_token.text !== 'else')) + ) { + this._output.space_before_token = true; + } else { + this.print_newline(false, true); + } + } else { + // collapse || inline_frame + if ( + is_array(this._previous_flags.mode) && + (this._flags.last_token.type === TOKEN.START_EXPR || + this._flags.last_token.type === TOKEN.COMMA) + ) { + if (this._flags.last_token.type === TOKEN.COMMA || this._options.space_in_paren) { + this._output.space_before_token = true; + } + + if ( + this._flags.last_token.type === TOKEN.COMMA || + (this._flags.last_token.type === TOKEN.START_EXPR && this._flags.inline_frame) + ) { + this.allow_wrap_or_preserved_newline(current_token); + this._previous_flags.multiline_frame = + this._previous_flags.multiline_frame || this._flags.multiline_frame; + this._flags.multiline_frame = false; + } + } + if ( + this._flags.last_token.type !== TOKEN.OPERATOR && + this._flags.last_token.type !== TOKEN.START_EXPR + ) { + if (this._flags.last_token.type === TOKEN.START_BLOCK && !this._flags.inline_frame) { + this.print_newline(); + } else { + this._output.space_before_token = true; + } + } + } + this.print_token(current_token); + this.indent(); + + // Except for specific cases, open braces are followed by a new line. + if (!empty_braces && !(this._options.brace_preserve_inline && this._flags.inline_frame)) { + this.print_newline(); + } + }; + + Beautifier.prototype.handle_end_block = function (current_token) { + // statements must all be closed when their container closes + this.handle_whitespace_and_comments(current_token); + + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + + var empty_braces = this._flags.last_token.type === TOKEN.START_BLOCK; + + if (this._flags.inline_frame && !empty_braces) { + // try inline_frame (only set if this._options.braces-preserve-inline) first + this._output.space_before_token = true; + } else if (this._options.brace_style === 'expand') { + if (!empty_braces) { + this.print_newline(); + } + } else { + // skip {} + if (!empty_braces) { + if (is_array(this._flags.mode) && this._options.keep_array_indentation) { + // we REALLY need a newline here, but newliner would skip that + this._options.keep_array_indentation = false; + this.print_newline(); + this._options.keep_array_indentation = true; + } else { + this.print_newline(); + } + } + } + this.restore_mode(); + this.print_token(current_token); + }; + + Beautifier.prototype.handle_word = function (current_token) { + if (current_token.type === TOKEN.RESERVED) { + if (in_array(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) { + current_token.type = TOKEN.WORD; + } else if (current_token.text === 'import' && this._tokens.peek().text === '(') { + current_token.type = TOKEN.WORD; + } else if (in_array(current_token.text, ['as', 'from']) && !this._flags.import_block) { + current_token.type = TOKEN.WORD; + } else if (this._flags.mode === MODE.ObjectLiteral) { + var next_token = this._tokens.peek(); + if (next_token.text === ':') { + current_token.type = TOKEN.WORD; + } + } + } + + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + if ( + reserved_array(this._flags.last_token, ['var', 'let', 'const']) && + current_token.type === TOKEN.WORD + ) { + this._flags.declaration_statement = true; + } + } else if ( + current_token.newlines && + !is_expression(this._flags.mode) && + (this._flags.last_token.type !== TOKEN.OPERATOR || + this._flags.last_token.text === '--' || + this._flags.last_token.text === '++') && + this._flags.last_token.type !== TOKEN.EQUALS && + (this._options.preserve_newlines || + !reserved_array(this._flags.last_token, ['var', 'let', 'const', 'set', 'get'])) + ) { + this.handle_whitespace_and_comments(current_token); + this.print_newline(); + } else { + this.handle_whitespace_and_comments(current_token); + } + + if (this._flags.do_block && !this._flags.do_while) { + if (reserved_word(current_token, 'while')) { + // do {} ## while () + this._output.space_before_token = true; + this.print_token(current_token); + this._output.space_before_token = true; + this._flags.do_while = true; + return; + } else { + // do {} should always have while as the next word. + // if we don't see the expected while, recover + this.print_newline(); + this._flags.do_block = false; + } + } + + // if may be followed by else, or not + // Bare/inline ifs are tricky + // Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e(); + if (this._flags.if_block) { + if (!this._flags.else_block && reserved_word(current_token, 'else')) { + this._flags.else_block = true; + } else { + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + this._flags.if_block = false; + this._flags.else_block = false; + } + } + + if (this._flags.in_case_statement && reserved_array(current_token, ['case', 'default'])) { + this.print_newline(); + if (this._flags.case_body || this._options.jslint_happy) { + // switch cases following one another + this.deindent(); + this._flags.case_body = false; + } + this.print_token(current_token); + this._flags.in_case = true; + return; + } + + if ( + this._flags.last_token.type === TOKEN.COMMA || + this._flags.last_token.type === TOKEN.START_EXPR || + this._flags.last_token.type === TOKEN.EQUALS || + this._flags.last_token.type === TOKEN.OPERATOR + ) { + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token); + } + } + + if (reserved_word(current_token, 'function')) { + if ( + in_array(this._flags.last_token.text, ['}', ';']) || + (this._output.just_added_newline() && + !( + in_array(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) || + this._flags.last_token.type === TOKEN.OPERATOR + )) + ) { + // make sure there is a nice clean space of at least one blank line + // before a new function definition + if (!this._output.just_added_blankline() && !current_token.comments_before) { + this.print_newline(); + this.print_newline(true); + } + } + if ( + this._flags.last_token.type === TOKEN.RESERVED || + this._flags.last_token.type === TOKEN.WORD + ) { + if ( + reserved_array(this._flags.last_token, ['get', 'set', 'new', 'export']) || + reserved_array(this._flags.last_token, newline_restricted_tokens) + ) { + this._output.space_before_token = true; + } else if ( + reserved_word(this._flags.last_token, 'default') && + this._last_last_text === 'export' + ) { + this._output.space_before_token = true; + } else if (this._flags.last_token.text === 'declare') { + // accomodates Typescript declare function formatting + this._output.space_before_token = true; + } else { + this.print_newline(); + } + } else if ( + this._flags.last_token.type === TOKEN.OPERATOR || + this._flags.last_token.text === '=' + ) { + // foo = function + this._output.space_before_token = true; + } else if ( + !this._flags.multiline_frame && + (is_expression(this._flags.mode) || is_array(this._flags.mode)) + ); + else { + this.print_newline(); + } + + this.print_token(current_token); + this._flags.last_word = current_token.text; + return; + } + + var prefix = 'NONE'; + + if (this._flags.last_token.type === TOKEN.END_BLOCK) { + if (this._previous_flags.inline_frame) { + prefix = 'SPACE'; + } else if (!reserved_array(current_token, ['else', 'catch', 'finally', 'from'])) { + prefix = 'NEWLINE'; + } else { + if ( + this._options.brace_style === 'expand' || + this._options.brace_style === 'end-expand' || + (this._options.brace_style === 'none' && current_token.newlines) + ) { + prefix = 'NEWLINE'; + } else { + prefix = 'SPACE'; + this._output.space_before_token = true; + } + } + } else if ( + this._flags.last_token.type === TOKEN.SEMICOLON && + this._flags.mode === MODE.BlockStatement + ) { + // TODO: Should this be for STATEMENT as well? + prefix = 'NEWLINE'; + } else if (this._flags.last_token.type === TOKEN.SEMICOLON && is_expression(this._flags.mode)) { + prefix = 'SPACE'; + } else if (this._flags.last_token.type === TOKEN.STRING) { + prefix = 'NEWLINE'; + } else if ( + this._flags.last_token.type === TOKEN.RESERVED || + this._flags.last_token.type === TOKEN.WORD || + (this._flags.last_token.text === '*' && + (in_array(this._last_last_text, ['function', 'yield']) || + (this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ','])))) + ) { + prefix = 'SPACE'; + } else if (this._flags.last_token.type === TOKEN.START_BLOCK) { + if (this._flags.inline_frame) { + prefix = 'SPACE'; + } else { + prefix = 'NEWLINE'; + } + } else if (this._flags.last_token.type === TOKEN.END_EXPR) { + this._output.space_before_token = true; + prefix = 'NEWLINE'; + } + + if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') { + if ( + this._flags.inline_frame || + this._flags.last_token.text === 'else' || + this._flags.last_token.text === 'export' + ) { + prefix = 'SPACE'; + } else { + prefix = 'NEWLINE'; + } + } + + if (reserved_array(current_token, ['else', 'catch', 'finally'])) { + if ( + (!( + this._flags.last_token.type === TOKEN.END_BLOCK && + this._previous_flags.mode === MODE.BlockStatement + ) || + this._options.brace_style === 'expand' || + this._options.brace_style === 'end-expand' || + (this._options.brace_style === 'none' && current_token.newlines)) && + !this._flags.inline_frame + ) { + this.print_newline(); + } else { + this._output.trim(true); + var line = this._output.current_line; + // If we trimmed and there's something other than a close block before us + // put a newline back in. Handles '} // comment' scenario. + if (line.last() !== '}') { + this.print_newline(); + } + this._output.space_before_token = true; + } + } else if (prefix === 'NEWLINE') { + if (reserved_array(this._flags.last_token, special_words)) { + // no newline between 'return nnn' + this._output.space_before_token = true; + } else if ( + this._flags.last_token.text === 'declare' && + reserved_array(current_token, ['var', 'let', 'const']) + ) { + // accomodates Typescript declare formatting + this._output.space_before_token = true; + } else if (this._flags.last_token.type !== TOKEN.END_EXPR) { + if ( + (this._flags.last_token.type !== TOKEN.START_EXPR || + !reserved_array(current_token, ['var', 'let', 'const'])) && + this._flags.last_token.text !== ':' + ) { + // no need to force newline on 'var': for (var x = 0...) + if (reserved_word(current_token, 'if') && reserved_word(current_token.previous, 'else')) { + // no newline for } else if { + this._output.space_before_token = true; + } else { + this.print_newline(); + } + } + } else if ( + reserved_array(current_token, line_starters) && + this._flags.last_token.text !== ')' + ) { + this.print_newline(); + } + } else if ( + this._flags.multiline_frame && + is_array(this._flags.mode) && + this._flags.last_token.text === ',' && + this._last_last_text === '}' + ) { + this.print_newline(); // }, in lists get a newline treatment + } else if (prefix === 'SPACE') { + this._output.space_before_token = true; + } + if ( + current_token.previous && + (current_token.previous.type === TOKEN.WORD || current_token.previous.type === TOKEN.RESERVED) + ) { + this._output.space_before_token = true; + } + this.print_token(current_token); + this._flags.last_word = current_token.text; + + if (current_token.type === TOKEN.RESERVED) { + if (current_token.text === 'do') { + this._flags.do_block = true; + } else if (current_token.text === 'if') { + this._flags.if_block = true; + } else if (current_token.text === 'import') { + this._flags.import_block = true; + } else if (this._flags.import_block && reserved_word(current_token, 'from')) { + this._flags.import_block = false; + } + } + }; + + Beautifier.prototype.handle_semicolon = function (current_token) { + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + // Semicolon can be the start (and end) of a statement + this._output.space_before_token = false; + } else { + this.handle_whitespace_and_comments(current_token); + } + + var next_token = this._tokens.peek(); + while ( + this._flags.mode === MODE.Statement && + !(this._flags.if_block && reserved_word(next_token, 'else')) && + !this._flags.do_block + ) { + this.restore_mode(); + } + + // hacky but effective for the moment + if (this._flags.import_block) { + this._flags.import_block = false; + } + this.print_token(current_token); + }; + + Beautifier.prototype.handle_string = function (current_token) { + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + // One difference - strings want at least a space before + this._output.space_before_token = true; + } else { + this.handle_whitespace_and_comments(current_token); + if ( + this._flags.last_token.type === TOKEN.RESERVED || + this._flags.last_token.type === TOKEN.WORD || + this._flags.inline_frame + ) { + this._output.space_before_token = true; + } else if ( + this._flags.last_token.type === TOKEN.COMMA || + this._flags.last_token.type === TOKEN.START_EXPR || + this._flags.last_token.type === TOKEN.EQUALS || + this._flags.last_token.type === TOKEN.OPERATOR + ) { + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token); + } + } else { + this.print_newline(); + } + } + this.print_token(current_token); + }; + + Beautifier.prototype.handle_equals = function (current_token) { + if (this.start_of_statement(current_token)); + else { + this.handle_whitespace_and_comments(current_token); + } + + if (this._flags.declaration_statement) { + // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done + this._flags.declaration_assignment = true; + } + this._output.space_before_token = true; + this.print_token(current_token); + this._output.space_before_token = true; + }; + + Beautifier.prototype.handle_comma = function (current_token) { + this.handle_whitespace_and_comments(current_token, true); + + this.print_token(current_token); + this._output.space_before_token = true; + if (this._flags.declaration_statement) { + if (is_expression(this._flags.parent.mode)) { + // do not break on comma, for(var a = 1, b = 2) + this._flags.declaration_assignment = false; + } + + if (this._flags.declaration_assignment) { + this._flags.declaration_assignment = false; + this.print_newline(false, true); + } else if (this._options.comma_first) { + // for comma-first, we want to allow a newline before the comma + // to turn into a newline after the comma, which we will fixup later + this.allow_wrap_or_preserved_newline(current_token); + } + } else if ( + this._flags.mode === MODE.ObjectLiteral || + (this._flags.mode === MODE.Statement && this._flags.parent.mode === MODE.ObjectLiteral) + ) { + if (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + + if (!this._flags.inline_frame) { + this.print_newline(); + } + } else if (this._options.comma_first) { + // EXPR or DO_BLOCK + // for comma-first, we want to allow a newline before the comma + // to turn into a newline after the comma, which we will fixup later + this.allow_wrap_or_preserved_newline(current_token); + } + }; + + Beautifier.prototype.handle_operator = function (current_token) { + var isGeneratorAsterisk = + current_token.text === '*' && + (reserved_array(this._flags.last_token, ['function', 'yield']) || + in_array(this._flags.last_token.type, [ + TOKEN.START_BLOCK, + TOKEN.COMMA, + TOKEN.END_BLOCK, + TOKEN.SEMICOLON + ])); + var isUnary = + in_array(current_token.text, ['-', '+']) && + (in_array(this._flags.last_token.type, [ + TOKEN.START_BLOCK, + TOKEN.START_EXPR, + TOKEN.EQUALS, + TOKEN.OPERATOR + ]) || + in_array(this._flags.last_token.text, line_starters) || + this._flags.last_token.text === ','); + + if (this.start_of_statement(current_token)); + else { + var preserve_statement_flags = !isGeneratorAsterisk; + this.handle_whitespace_and_comments(current_token, preserve_statement_flags); + } + + if (reserved_array(this._flags.last_token, special_words)) { + // "return" had a special handling in TK_WORD. Now we need to return the favor + this._output.space_before_token = true; + this.print_token(current_token); + return; + } + + // hack for actionscript's import .*; + if (current_token.text === '*' && this._flags.last_token.type === TOKEN.DOT) { + this.print_token(current_token); + return; + } + + if (current_token.text === '::') { + // no spaces around exotic namespacing syntax operator + this.print_token(current_token); + return; + } + + // Allow line wrapping between operators when operator_position is + // set to before or preserve + if ( + this._flags.last_token.type === TOKEN.OPERATOR && + in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE) + ) { + this.allow_wrap_or_preserved_newline(current_token); + } + + if (current_token.text === ':' && this._flags.in_case) { + this._flags.case_body = true; + this.indent(); + this.print_token(current_token); + this.print_newline(); + this._flags.in_case = false; + return; + } + + var space_before = true; + var space_after = true; + var in_ternary = false; + if (current_token.text === ':') { + if (this._flags.ternary_depth === 0) { + // Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant. + space_before = false; + } else { + this._flags.ternary_depth -= 1; + in_ternary = true; + } + } else if (current_token.text === '?') { + this._flags.ternary_depth += 1; + } + + // let's handle the operator_position option prior to any conflicting logic + if ( + !isUnary && + !isGeneratorAsterisk && + this._options.preserve_newlines && + in_array(current_token.text, positionable_operators) + ) { + var isColon = current_token.text === ':'; + var isTernaryColon = isColon && in_ternary; + var isOtherColon = isColon && !in_ternary; + + switch (this._options.operator_position) { + case OPERATOR_POSITION.before_newline: + // if the current token is : and it's not a ternary statement then we set space_before to false + this._output.space_before_token = !isOtherColon; + + this.print_token(current_token); + + if (!isColon || isTernaryColon) { + this.allow_wrap_or_preserved_newline(current_token); + } + + this._output.space_before_token = true; + return; + + case OPERATOR_POSITION.after_newline: + // if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement, + // then print a newline. + + this._output.space_before_token = true; + + if (!isColon || isTernaryColon) { + if (this._tokens.peek().newlines) { + this.print_newline(false, true); + } else { + this.allow_wrap_or_preserved_newline(current_token); + } + } else { + this._output.space_before_token = false; + } + + this.print_token(current_token); + + this._output.space_before_token = true; + return; + + case OPERATOR_POSITION.preserve_newline: + if (!isOtherColon) { + this.allow_wrap_or_preserved_newline(current_token); + } + + // if we just added a newline, or the current token is : and it's not a ternary statement, + // then we set space_before to false + space_before = !(this._output.just_added_newline() || isOtherColon); + + this._output.space_before_token = space_before; + this.print_token(current_token); + this._output.space_before_token = true; + return; + } + } + + if (isGeneratorAsterisk) { + this.allow_wrap_or_preserved_newline(current_token); + space_before = false; + var next_token = this._tokens.peek(); + space_after = next_token && in_array(next_token.type, [TOKEN.WORD, TOKEN.RESERVED]); + } else if (current_token.text === '...') { + this.allow_wrap_or_preserved_newline(current_token); + space_before = this._flags.last_token.type === TOKEN.START_BLOCK; + space_after = false; + } else if (in_array(current_token.text, ['--', '++', '!', '~']) || isUnary) { + // unary operators (and binary +/- pretending to be unary) special cases + if ( + this._flags.last_token.type === TOKEN.COMMA || + this._flags.last_token.type === TOKEN.START_EXPR + ) { + this.allow_wrap_or_preserved_newline(current_token); + } + + space_before = false; + space_after = false; + + // http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1 + // if there is a newline between -- or ++ and anything else we should preserve it. + if (current_token.newlines && (current_token.text === '--' || current_token.text === '++')) { + this.print_newline(false, true); + } + + if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) { + // for (;; ++i) + // ^^^ + space_before = true; + } + + if (this._flags.last_token.type === TOKEN.RESERVED) { + space_before = true; + } else if (this._flags.last_token.type === TOKEN.END_EXPR) { + space_before = !( + this._flags.last_token.text === ']' && + (current_token.text === '--' || current_token.text === '++') + ); + } else if (this._flags.last_token.type === TOKEN.OPERATOR) { + // a++ + ++b; + // a - -b + space_before = + in_array(current_token.text, ['--', '-', '++', '+']) && + in_array(this._flags.last_token.text, ['--', '-', '++', '+']); + // + and - are not unary when preceeded by -- or ++ operator + // a-- + b + // a * +b + // a - -b + if ( + in_array(current_token.text, ['+', '-']) && + in_array(this._flags.last_token.text, ['--', '++']) + ) { + space_after = true; + } + } + + if ( + ((this._flags.mode === MODE.BlockStatement && !this._flags.inline_frame) || + this._flags.mode === MODE.Statement) && + (this._flags.last_token.text === '{' || this._flags.last_token.text === ';') + ) { + // { foo; --i } + // foo(); --bar; + this.print_newline(); + } + } + + this._output.space_before_token = this._output.space_before_token || space_before; + this.print_token(current_token); + this._output.space_before_token = space_after; + }; + + Beautifier.prototype.handle_block_comment = function (current_token, preserve_statement_flags) { + if (this._output.raw) { + this._output.add_raw_token(current_token); + if (current_token.directives && current_token.directives.preserve === 'end') { + // If we're testing the raw output behavior, do not allow a directive to turn it off. + this._output.raw = this._options.test_output_raw; + } + return; + } + + if (current_token.directives) { + this.print_newline(false, preserve_statement_flags); + this.print_token(current_token); + if (current_token.directives.preserve === 'start') { + this._output.raw = true; + } + this.print_newline(false, true); + return; + } + + // inline block + if (!acorn.newline.test(current_token.text) && !current_token.newlines) { + this._output.space_before_token = true; + this.print_token(current_token); + this._output.space_before_token = true; + return; + } + + var lines = split_linebreaks(current_token.text); + var j; // iterator for this case + var javadoc = false; + var starless = false; + var lastIndent = current_token.whitespace_before; + var lastIndentLength = lastIndent.length; + + // block comment starts with a new line + this.print_newline(false, preserve_statement_flags); + if (lines.length > 1) { + javadoc = all_lines_start_with(lines.slice(1), '*'); + starless = each_line_matches_indent(lines.slice(1), lastIndent); + } + + // first line always indented + this.print_token(current_token, lines[0]); + for (j = 1; j < lines.length; j++) { + this.print_newline(false, true); + if (javadoc) { + // javadoc: reformat and re-indent + this.print_token(current_token, ' ' + ltrim(lines[j])); + } else if (starless && lines[j].length > lastIndentLength) { + // starless: re-indent non-empty content, avoiding trim + this.print_token(current_token, lines[j].substring(lastIndentLength)); + } else { + // normal comments output raw + this._output.add_token(lines[j]); + } + } + + // for comments of more than one line, make sure there's a new line after + this.print_newline(false, preserve_statement_flags); + }; + + Beautifier.prototype.handle_comment = function (current_token, preserve_statement_flags) { + if (current_token.newlines) { + this.print_newline(false, preserve_statement_flags); + } else { + this._output.trim(true); + } + + this._output.space_before_token = true; + this.print_token(current_token); + this.print_newline(false, preserve_statement_flags); + }; + + Beautifier.prototype.handle_dot = function (current_token) { + if (this.start_of_statement(current_token)); + else { + this.handle_whitespace_and_comments(current_token, true); + } + + if (reserved_array(this._flags.last_token, special_words)) { + this._output.space_before_token = false; + } else { + // allow preserved newlines before dots in general + // force newlines on dots after close paren when break_chained - for bar().baz() + this.allow_wrap_or_preserved_newline( + current_token, + this._flags.last_token.text === ')' && this._options.break_chained_methods + ); + } + + // Only unindent chained method dot if this dot starts a new line. + // Otherwise the automatic extra indentation removal will handle the over indent + if (this._options.unindent_chained_methods && this._output.just_added_newline()) { + this.deindent(); + } + + this.print_token(current_token); + }; + + Beautifier.prototype.handle_unknown = function (current_token, preserve_statement_flags) { + this.print_token(current_token); + + if (current_token.text[current_token.text.length - 1] === '\n') { + this.print_newline(false, preserve_statement_flags); + } + }; + + Beautifier.prototype.handle_eof = function (current_token) { + // Unwind any open statements + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + this.handle_whitespace_and_comments(current_token); + }; + + module.exports.Beautifier = Beautifier; + + /***/ + }, + /* 2 */ + /***/ function (module, exports, __webpack_require__) { + function OutputLine(parent) { + this.__parent = parent; + this.__character_count = 0; + // use indent_count as a marker for this.__lines that have preserved indentation + this.__indent_count = -1; + this.__alignment_count = 0; + + this.__items = []; + } + + OutputLine.prototype.item = function (index) { + if (index < 0) { + return this.__items[this.__items.length + index]; + } else { + return this.__items[index]; + } + }; + + OutputLine.prototype.has_match = function (pattern) { + for ( + var lastCheckedOutput = this.__items.length - 1; + lastCheckedOutput >= 0; + lastCheckedOutput-- + ) { + if (this.__items[lastCheckedOutput].match(pattern)) { + return true; + } + } + return false; + }; + + OutputLine.prototype.set_indent = function (indent, alignment) { + this.__indent_count = indent || 0; + this.__alignment_count = alignment || 0; + this.__character_count = + this.__parent.baseIndentLength + + this.__alignment_count + + this.__indent_count * this.__parent.indent_length; + }; + + OutputLine.prototype.get_character_count = function () { + return this.__character_count; + }; + + OutputLine.prototype.is_empty = function () { + return this.__items.length === 0; + }; + + OutputLine.prototype.last = function () { + if (!this.is_empty()) { + return this.__items[this.__items.length - 1]; + } else { + return null; + } + }; + + OutputLine.prototype.push = function (item) { + this.__items.push(item); + this.__character_count += item.length; + }; + + OutputLine.prototype.push_raw = function (item) { + this.push(item); + var last_newline_index = item.lastIndexOf('\n'); + if (last_newline_index !== -1) { + this.__character_count = item.length - last_newline_index; + } + }; + + OutputLine.prototype.pop = function () { + var item = null; + if (!this.is_empty()) { + item = this.__items.pop(); + this.__character_count -= item.length; + } + return item; + }; + + OutputLine.prototype.remove_indent = function () { + if (this.__indent_count > 0) { + this.__indent_count -= 1; + this.__character_count -= this.__parent.indent_length; + } + }; + + OutputLine.prototype.trim = function () { + while (this.last() === ' ') { + this.__items.pop(); + this.__character_count -= 1; + } + }; + + OutputLine.prototype.toString = function () { + var result = ''; + if (!this.is_empty()) { + if (this.__indent_count >= 0) { + result = this.__parent.get_indent_string(this.__indent_count); + } + if (this.__alignment_count >= 0) { + result += this.__parent.get_alignment_string(this.__alignment_count); + } + result += this.__items.join(''); + } + return result; + }; + + function IndentCache(base_string, level_string) { + this.__cache = [base_string]; + this.__level_string = level_string; + } + + IndentCache.prototype.__ensure_cache = function (level) { + while (level >= this.__cache.length) { + this.__cache.push(this.__cache[this.__cache.length - 1] + this.__level_string); + } + }; + + IndentCache.prototype.get_level_string = function (level) { + this.__ensure_cache(level); + return this.__cache[level]; + }; + + function Output(options, baseIndentString) { + var indent_string = options.indent_char; + if (options.indent_size > 1) { + indent_string = new Array(options.indent_size + 1).join(options.indent_char); + } + + // Set to null to continue support for auto detection of base indent level. + baseIndentString = baseIndentString || ''; + if (options.indent_level > 0) { + baseIndentString = new Array(options.indent_level + 1).join(indent_string); + } + + this.__indent_cache = new IndentCache(baseIndentString, indent_string); + this.__alignment_cache = new IndentCache('', ' '); + this.baseIndentLength = baseIndentString.length; + this.indent_length = indent_string.length; + this.raw = false; + this._end_with_newline = options.end_with_newline; + + this.__lines = []; + this.previous_line = null; + this.current_line = null; + this.space_before_token = false; + // initialize + this.__add_outputline(); + } + + Output.prototype.__add_outputline = function () { + this.previous_line = this.current_line; + this.current_line = new OutputLine(this); + this.__lines.push(this.current_line); + }; + + Output.prototype.get_line_number = function () { + return this.__lines.length; + }; + + Output.prototype.get_indent_string = function (level) { + return this.__indent_cache.get_level_string(level); + }; + + Output.prototype.get_alignment_string = function (level) { + return this.__alignment_cache.get_level_string(level); + }; + + Output.prototype.is_empty = function () { + return !this.previous_line && this.current_line.is_empty(); + }; + + Output.prototype.add_new_line = function (force_newline) { + // never newline at the start of file + // otherwise, newline only if we didn't just add one or we're forced + if (this.is_empty() || (!force_newline && this.just_added_newline())) { + return false; + } + + // if raw output is enabled, don't print additional newlines, + // but still return True as though you had + if (!this.raw) { + this.__add_outputline(); + } + return true; + }; + + Output.prototype.get_code = function (eol) { + var sweet_code = this.__lines.join('\n').replace(/[\r\n\t ]+$/, ''); + + if (this._end_with_newline) { + sweet_code += '\n'; + } + + if (eol !== '\n') { + sweet_code = sweet_code.replace(/[\n]/g, eol); + } + + return sweet_code; + }; + + Output.prototype.set_indent = function (indent, alignment) { + indent = indent || 0; + alignment = alignment || 0; + + // Never indent your first output indent at the start of the file + if (this.__lines.length > 1) { + this.current_line.set_indent(indent, alignment); + return true; + } + this.current_line.set_indent(); + return false; + }; + + Output.prototype.add_raw_token = function (token) { + for (var x = 0; x < token.newlines; x++) { + this.__add_outputline(); + } + this.current_line.push(token.whitespace_before); + this.current_line.push_raw(token.text); + this.space_before_token = false; + }; + + Output.prototype.add_token = function (printable_token) { + this.add_space_before_token(); + this.current_line.push(printable_token); + }; + + Output.prototype.add_space_before_token = function () { + if (this.space_before_token && !this.just_added_newline()) { + this.current_line.push(' '); + } + this.space_before_token = false; + }; + + Output.prototype.remove_indent = function (index) { + var output_length = this.__lines.length; + while (index < output_length) { + this.__lines[index].remove_indent(); + index++; + } + }; + + Output.prototype.trim = function (eat_newlines) { + eat_newlines = eat_newlines === undefined ? false : eat_newlines; + + this.current_line.trim(this.indent_string, this.baseIndentString); + + while (eat_newlines && this.__lines.length > 1 && this.current_line.is_empty()) { + this.__lines.pop(); + this.current_line = this.__lines[this.__lines.length - 1]; + this.current_line.trim(); + } + + this.previous_line = this.__lines.length > 1 ? this.__lines[this.__lines.length - 2] : null; + }; + + Output.prototype.just_added_newline = function () { + return this.current_line.is_empty(); + }; + + Output.prototype.just_added_blankline = function () { + return this.is_empty() || (this.current_line.is_empty() && this.previous_line.is_empty()); + }; + + Output.prototype.ensure_empty_line_above = function (starts_with, ends_with) { + var index = this.__lines.length - 2; + while (index >= 0) { + var potentialEmptyLine = this.__lines[index]; + if (potentialEmptyLine.is_empty()) { + break; + } else if ( + potentialEmptyLine.item(0).indexOf(starts_with) !== 0 && + potentialEmptyLine.item(-1) !== ends_with + ) { + this.__lines.splice(index + 1, 0, new OutputLine(this)); + this.previous_line = this.__lines[this.__lines.length - 2]; + break; + } + index--; + } + }; + + module.exports.Output = Output; + + /***/ + }, + /* 3 */ + /***/ function (module, exports, __webpack_require__) { + function Token(type, text, newlines, whitespace_before) { + this.type = type; + this.text = text; + + // comments_before are + // comments that have a new line before them + // and may or may not have a newline after + // this is a set of comments before + this.comments_before = null; /* inline comment*/ + + // this.comments_after = new TokenStream(); // no new line before and newline after + this.newlines = newlines || 0; + this.whitespace_before = whitespace_before || ''; + this.parent = null; + this.next = null; + this.previous = null; + this.opened = null; + this.closed = null; + this.directives = null; + } + + module.exports.Token = Token; + + /***/ + }, + /* 4 */ + /***/ function (module, exports, __webpack_require__) { + // Parts of this section of code is taken from acorn. + // + // Acorn was written by Marijn Haverbeke and released under an MIT + // license. The Unicode regexps (for identifiers and whitespace) were + // taken from [Esprima](http://esprima.org) by Ariya Hidayat. + // + // Git repositories for Acorn are available at + // + // http://marijnhaverbeke.nl/git/acorn + // https://github.com/marijnh/acorn.git + + // ## Character categories + + // acorn used char codes to squeeze the last bit of performance out + // Beautifier is okay without that, so we're using regex + // permit $ (36) and @ (64). @ is used in ES7 decorators. + // 65 through 91 are uppercase letters. + // permit _ (95). + // 97 through 123 are lowercase letters. + var baseASCIIidentifierStartChars = '\x24\x40\x41-\x5a\x5f\x61-\x7a'; + + // inside an identifier @ is not allowed but 0-9 are. + var baseASCIIidentifierChars = '\x24\x30-\x39\x41-\x5a\x5f\x61-\x7a'; + + // Big ugly regular expressions that match characters in the + // whitespace, identifier, and identifier-start categories. These + // are only applied when a character is found to actually have a + // code point above 128. + var nonASCIIidentifierStartChars = + '\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc'; + var nonASCIIidentifierChars = + '\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f'; + //var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]"); + //var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]"); + + var identifierStart = '[' + baseASCIIidentifierStartChars + nonASCIIidentifierStartChars + ']'; + var identifierChars = + '[' + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + ']*'; + + exports.identifier = new RegExp(identifierStart + identifierChars, 'g'); + + // Whether a single character denotes a newline. + + exports.newline = /[\n\r\u2028\u2029]/; + + // Matches a whole line break (where CRLF is considered a single + // line break). Used to count lines. + + // in javascript, these two differ + // in python they are the same, different methods are called on them + exports.lineBreak = new RegExp('\r\n|' + exports.newline.source); + exports.allLineBreaks = new RegExp(exports.lineBreak.source, 'g'); + + /***/ + }, + /* 5 */ + /***/ function (module, exports, __webpack_require__) { + var BaseOptions = __webpack_require__(6).Options; + + var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline']; + + function Options(options) { + BaseOptions.call(this, options, 'js'); + + // compatibility, re + var raw_brace_style = this.raw_options.brace_style || null; + if (raw_brace_style === 'expand-strict') { + //graceful handling of deprecated option + this.raw_options.brace_style = 'expand'; + } else if (raw_brace_style === 'collapse-preserve-inline') { + //graceful handling of deprecated option + this.raw_options.brace_style = 'collapse,preserve-inline'; + } else if (this.raw_options.braces_on_own_line !== undefined) { + //graceful handling of deprecated option + this.raw_options.brace_style = this.raw_options.braces_on_own_line ? 'expand' : 'collapse'; + // } else if (!raw_brace_style) { //Nothing exists to set it + // raw_brace_style = "collapse"; + } + + //preserve-inline in delimited string will trigger brace_preserve_inline, everything + //else is considered a brace_style and the last one only will have an effect + + var brace_style_split = this._get_selection_list('brace_style', [ + 'collapse', + 'expand', + 'end-expand', + 'none', + 'preserve-inline' + ]); + + this.brace_preserve_inline = false; //Defaults in case one or other was not specified in meta-option + this.brace_style = 'collapse'; + + for (var bs = 0; bs < brace_style_split.length; bs++) { + if (brace_style_split[bs] === 'preserve-inline') { + this.brace_preserve_inline = true; + } else { + this.brace_style = brace_style_split[bs]; + } + } + + this.unindent_chained_methods = this._get_boolean('unindent_chained_methods'); + this.break_chained_methods = this._get_boolean('break_chained_methods'); + this.space_in_paren = this._get_boolean('space_in_paren'); + this.space_in_empty_paren = this._get_boolean('space_in_empty_paren'); + this.jslint_happy = this._get_boolean('jslint_happy'); + this.space_after_anon_function = this._get_boolean('space_after_anon_function'); + this.space_after_named_function = this._get_boolean('space_after_named_function'); + this.keep_array_indentation = this._get_boolean('keep_array_indentation'); + this.space_before_conditional = this._get_boolean('space_before_conditional', true); + this.unescape_strings = this._get_boolean('unescape_strings'); + this.e4x = this._get_boolean('e4x'); + this.comma_first = this._get_boolean('comma_first'); + this.operator_position = this._get_selection('operator_position', validPositionValues); + + // For testing of beautify preserve:start directive + this.test_output_raw = this._get_boolean('test_output_raw'); + + // force this._options.space_after_anon_function to true if this._options.jslint_happy + if (this.jslint_happy) { + this.space_after_anon_function = true; + } + } + Options.prototype = new BaseOptions(); + + module.exports.Options = Options; + + /***/ + }, + /* 6 */ + /***/ function (module, exports, __webpack_require__) { + function Options(options, merge_child_field) { + this.raw_options = _mergeOpts(options, merge_child_field); + + // Support passing the source text back with no change + this.disabled = this._get_boolean('disabled'); + + this.eol = this._get_characters('eol', 'auto'); + this.end_with_newline = this._get_boolean('end_with_newline'); + this.indent_size = this._get_number('indent_size', 4); + this.indent_char = this._get_characters('indent_char', ' '); + this.indent_level = this._get_number('indent_level'); + + this.preserve_newlines = this._get_boolean('preserve_newlines', true); + this.max_preserve_newlines = this._get_number('max_preserve_newlines', 32786); + if (!this.preserve_newlines) { + this.max_preserve_newlines = 0; + } + + this.indent_with_tabs = this._get_boolean('indent_with_tabs'); + if (this.indent_with_tabs) { + this.indent_char = '\t'; + this.indent_size = 1; + } + + // Backwards compat with 1.3.x + this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char')); + } + + Options.prototype._get_array = function (name, default_value) { + var option_value = this.raw_options[name]; + var result = default_value || []; + if (typeof option_value === 'object') { + if (option_value !== null && typeof option_value.concat === 'function') { + result = option_value.concat(); + } + } else if (typeof option_value === 'string') { + result = option_value.split(/[^a-zA-Z0-9_\/\-]+/); + } + return result; + }; + + Options.prototype._get_boolean = function (name, default_value) { + var option_value = this.raw_options[name]; + var result = option_value === undefined ? !!default_value : !!option_value; + return result; + }; + + Options.prototype._get_characters = function (name, default_value) { + var option_value = this.raw_options[name]; + var result = default_value || ''; + if (typeof option_value === 'string') { + result = option_value.replace(/\\r/, '\r').replace(/\\n/, '\n').replace(/\\t/, '\t'); + } + return result; + }; + + Options.prototype._get_number = function (name, default_value) { + var option_value = this.raw_options[name]; + default_value = parseInt(default_value, 10); + if (isNaN(default_value)) { + default_value = 0; + } + var result = parseInt(option_value, 10); + if (isNaN(result)) { + result = default_value; + } + return result; + }; + + Options.prototype._get_selection = function (name, selection_list, default_value) { + var result = this._get_selection_list(name, selection_list, default_value); + if (result.length !== 1) { + throw new Error( + "Invalid Option Value: The option '" + + name + + "' can only be one of the following values:\n" + + selection_list + + "\nYou passed in: '" + + this.raw_options[name] + + "'" + ); + } + + return result[0]; + }; + + Options.prototype._get_selection_list = function (name, selection_list, default_value) { + if (!selection_list || selection_list.length === 0) { + throw new Error('Selection list cannot be empty.'); + } + + default_value = default_value || [selection_list[0]]; + if (!this._is_valid_selection(default_value, selection_list)) { + throw new Error('Invalid Default Value!'); + } + + var result = this._get_array(name, default_value); + if (!this._is_valid_selection(result, selection_list)) { + throw new Error( + "Invalid Option Value: The option '" + + name + + "' can contain only the following values:\n" + + selection_list + + "\nYou passed in: '" + + this.raw_options[name] + + "'" + ); + } + + return result; + }; + + Options.prototype._is_valid_selection = function (result, selection_list) { + return ( + result.length && + selection_list.length && + !result.some(function (item) { + return selection_list.indexOf(item) === -1; + }) + ); + }; + + // merges child options up with the parent options object + // Example: obj = {a: 1, b: {a: 2}} + // mergeOpts(obj, 'b') + // + // Returns: {a: 2} + function _mergeOpts(allOptions, childFieldName) { + var finalOpts = {}; + allOptions = _normalizeOpts(allOptions); + var name; + + for (name in allOptions) { + if (name !== childFieldName) { + finalOpts[name] = allOptions[name]; + } + } + + //merge in the per type settings for the childFieldName + if (childFieldName && allOptions[childFieldName]) { + for (name in allOptions[childFieldName]) { + finalOpts[name] = allOptions[childFieldName][name]; + } + } + return finalOpts; + } + + function _normalizeOpts(options) { + var convertedOpts = {}; + var key; + + for (key in options) { + var newKey = key.replace(/-/g, '_'); + convertedOpts[newKey] = options[key]; + } + return convertedOpts; + } + + module.exports.Options = Options; + module.exports.normalizeOpts = _normalizeOpts; + module.exports.mergeOpts = _mergeOpts; + + /***/ + }, + /* 7 */ + /***/ function (module, exports, __webpack_require__) { + var InputScanner = __webpack_require__(8).InputScanner; + var BaseTokenizer = __webpack_require__(9).Tokenizer; + var BASETOKEN = __webpack_require__(9).TOKEN; + var Directives = __webpack_require__(11).Directives; + var acorn = __webpack_require__(4); + + function in_array(what, arr) { + return arr.indexOf(what) !== -1; + } + + var TOKEN = { + START_EXPR: 'TK_START_EXPR', + END_EXPR: 'TK_END_EXPR', + START_BLOCK: 'TK_START_BLOCK', + END_BLOCK: 'TK_END_BLOCK', + WORD: 'TK_WORD', + RESERVED: 'TK_RESERVED', + SEMICOLON: 'TK_SEMICOLON', + STRING: 'TK_STRING', + EQUALS: 'TK_EQUALS', + OPERATOR: 'TK_OPERATOR', + COMMA: 'TK_COMMA', + BLOCK_COMMENT: 'TK_BLOCK_COMMENT', + COMMENT: 'TK_COMMENT', + DOT: 'TK_DOT', + UNKNOWN: 'TK_UNKNOWN', + START: BASETOKEN.START, + RAW: BASETOKEN.RAW, + EOF: BASETOKEN.EOF + }; + + var directives_core = new Directives(/\/\*/, /\*\//); + + var number_pattern = + /0[xX][0123456789abcdefABCDEF]*|0[oO][01234567]*|0[bB][01]*|\d+n|(?:\.\d+|\d+\.?\d*)(?:[eE][+-]?\d+)?/g; + + var digit = /[0-9]/; + + // Dot "." must be distinguished from "..." and decimal + var dot_pattern = /[^\d\.]/; + + var positionable_operators = ( + '>>> === !== ' + + '<< && >= ** != == <= >> || ' + + '< / - + > : & % ? ^ | *' + ).split(' '); + + // IMPORTANT: this must be sorted longest to shortest or tokenizing many not work. + // Also, you must update possitionable operators separately from punct + var punct = + '>>>= ' + + '... >>= <<= === >>> !== **= ' + + '=> ^= :: /= << <= == && -= >= >> != -- += ** || ++ %= &= *= |= ' + + '= ! ? > < : / ^ - + * & % ~ |'; + + punct = punct.replace(/[-[\]{}()*+?.,\\^$|#]/g, '\\$&'); + punct = punct.replace(/ /g, '|'); + + var punct_pattern = new RegExp(punct, 'g'); + var shebang_pattern = /#![^\n\r\u2028\u2029]*(?:\r\n|[\n\r\u2028\u2029])?/g; + var include_pattern = /#include[^\n\r\u2028\u2029]*(?:\r\n|[\n\r\u2028\u2029])?/g; + + // words which should always start on new line. + var line_starters = + 'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,import,export'.split( + ',' + ); + var reserved_words = line_starters.concat([ + 'do', + 'in', + 'of', + 'else', + 'get', + 'set', + 'new', + 'catch', + 'finally', + 'typeof', + 'yield', + 'async', + 'await', + 'from', + 'as' + ]); + var reserved_word_pattern = new RegExp('^(?:' + reserved_words.join('|') + ')$'); + + // /* ... */ comment ends with nearest */ or end of file + var block_comment_pattern = /\/\*(?:[\s\S]*?)((?:\*\/)|$)/g; + + // comment ends just before nearest linefeed or end of file + var comment_pattern = /\/\/(?:[^\n\r\u2028\u2029]*)/g; + + var template_pattern = /(?:(?:<\?php|<\?=)[\s\S]*?\?>)|(?:<%[\s\S]*?%>)/g; + + var in_html_comment; + + var Tokenizer = function (input_string, options) { + BaseTokenizer.call(this, input_string, options); + + this._whitespace_pattern = + /[\n\r\u2028\u2029\t\u000B\u00A0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff ]+/g; + this._newline_pattern = /([^\n\r\u2028\u2029]*)(\r\n|[\n\r\u2028\u2029])?/g; + }; + Tokenizer.prototype = new BaseTokenizer(); + + Tokenizer.prototype._is_comment = function (current_token) { + return ( + current_token.type === TOKEN.COMMENT || + current_token.type === TOKEN.BLOCK_COMMENT || + current_token.type === TOKEN.UNKNOWN + ); + }; + + Tokenizer.prototype._is_opening = function (current_token) { + return current_token.type === TOKEN.START_BLOCK || current_token.type === TOKEN.START_EXPR; + }; + + Tokenizer.prototype._is_closing = function (current_token, open_token) { + return ( + (current_token.type === TOKEN.END_BLOCK || current_token.type === TOKEN.END_EXPR) && + open_token && + ((current_token.text === ']' && open_token.text === '[') || + (current_token.text === ')' && open_token.text === '(') || + (current_token.text === '}' && open_token.text === '{')) + ); + }; + + Tokenizer.prototype._reset = function () { + in_html_comment = false; + }; + + Tokenizer.prototype._get_next_token = function (previous_token, open_token) { + this._readWhitespace(); + var token = null; + var c = this._input.peek(); + + token = token || this._read_singles(c); + token = token || this._read_word(previous_token); + token = token || this._read_comment(c); + token = token || this._read_string(c); + token = token || this._read_regexp(c, previous_token); + token = token || this._read_xml(c, previous_token); + token = token || this._read_non_javascript(c); + token = token || this._read_punctuation(); + token = token || this._create_token(TOKEN.UNKNOWN, this._input.next()); + + return token; + }; + + Tokenizer.prototype._read_word = function (previous_token) { + var resulting_string; + resulting_string = this._input.read(acorn.identifier); + if (resulting_string !== '') { + if ( + !( + previous_token.type === TOKEN.DOT || + (previous_token.type === TOKEN.RESERVED && + (previous_token.text === 'set' || previous_token.text === 'get')) + ) && + reserved_word_pattern.test(resulting_string) + ) { + if (resulting_string === 'in' || resulting_string === 'of') { + // hack for 'in' and 'of' operators + return this._create_token(TOKEN.OPERATOR, resulting_string); + } + return this._create_token(TOKEN.RESERVED, resulting_string); + } + + return this._create_token(TOKEN.WORD, resulting_string); + } + + resulting_string = this._input.read(number_pattern); + if (resulting_string !== '') { + return this._create_token(TOKEN.WORD, resulting_string); + } + }; + + Tokenizer.prototype._read_singles = function (c) { + var token = null; + if (c === null) { + token = this._create_token(TOKEN.EOF, ''); + } else if (c === '(' || c === '[') { + token = this._create_token(TOKEN.START_EXPR, c); + } else if (c === ')' || c === ']') { + token = this._create_token(TOKEN.END_EXPR, c); + } else if (c === '{') { + token = this._create_token(TOKEN.START_BLOCK, c); + } else if (c === '}') { + token = this._create_token(TOKEN.END_BLOCK, c); + } else if (c === ';') { + token = this._create_token(TOKEN.SEMICOLON, c); + } else if (c === '.' && dot_pattern.test(this._input.peek(1))) { + token = this._create_token(TOKEN.DOT, c); + } else if (c === ',') { + token = this._create_token(TOKEN.COMMA, c); + } + + if (token) { + this._input.next(); + } + return token; + }; + + Tokenizer.prototype._read_punctuation = function () { + var resulting_string = this._input.read(punct_pattern); + + if (resulting_string !== '') { + if (resulting_string === '=') { + return this._create_token(TOKEN.EQUALS, resulting_string); + } else { + return this._create_token(TOKEN.OPERATOR, resulting_string); + } + } + }; + + Tokenizer.prototype._read_non_javascript = function (c) { + var resulting_string = ''; + + if (c === '#') { + if (this._is_first_token()) { + resulting_string = this._input.read(shebang_pattern); + + if (resulting_string) { + return this._create_token(TOKEN.UNKNOWN, resulting_string.trim() + '\n'); + } + } + + // handles extendscript #includes + resulting_string = this._input.read(include_pattern); + + if (resulting_string) { + return this._create_token(TOKEN.UNKNOWN, resulting_string.trim() + '\n'); + } + + c = this._input.next(); + + // Spidermonkey-specific sharp variables for circular references. Considered obsolete. + var sharp = '#'; + if (this._input.hasNext() && this._input.testChar(digit)) { + do { + c = this._input.next(); + sharp += c; + } while (this._input.hasNext() && c !== '#' && c !== '='); + if (c === '#'); + else if (this._input.peek() === '[' && this._input.peek(1) === ']') { + sharp += '[]'; + this._input.next(); + this._input.next(); + } else if (this._input.peek() === '{' && this._input.peek(1) === '}') { + sharp += '{}'; + this._input.next(); + this._input.next(); + } + return this._create_token(TOKEN.WORD, sharp); + } + + this._input.back(); + } else if (c === '<') { + if (this._input.peek(1) === '?' || this._input.peek(1) === '%') { + resulting_string = this._input.read(template_pattern); + if (resulting_string) { + resulting_string = resulting_string.replace(acorn.allLineBreaks, '\n'); + return this._create_token(TOKEN.STRING, resulting_string); + } + } else if (this._input.match(/<\!--/g)) { + c = '/g)) { + in_html_comment = false; + return this._create_token(TOKEN.COMMENT, '-->'); + } + + return null; + }; + + Tokenizer.prototype._read_comment = function (c) { + var token = null; + if (c === '/') { + var comment = ''; + if (this._input.peek(1) === '*') { + // peek for comment /* ... */ + comment = this._input.read(block_comment_pattern); + var directives = directives_core.get_directives(comment); + if (directives && directives.ignore === 'start') { + comment += directives_core.readIgnored(this._input); + } + comment = comment.replace(acorn.allLineBreaks, '\n'); + token = this._create_token(TOKEN.BLOCK_COMMENT, comment); + token.directives = directives; + } else if (this._input.peek(1) === '/') { + // peek for comment // ... + comment = this._input.read(comment_pattern); + token = this._create_token(TOKEN.COMMENT, comment); + } + } + return token; + }; + + Tokenizer.prototype._read_string = function (c) { + if (c === '`' || c === "'" || c === '"') { + var resulting_string = this._input.next(); + this.has_char_escapes = false; + + if (c === '`') { + resulting_string += this._read_string_recursive('`', true, '${'); + } else { + resulting_string += this._read_string_recursive(c); + } + + if (this.has_char_escapes && this._options.unescape_strings) { + resulting_string = unescape_string(resulting_string); + } + if (this._input.peek() === c) { + resulting_string += this._input.next(); + } + + return this._create_token(TOKEN.STRING, resulting_string); + } + + return null; + }; + + Tokenizer.prototype._allow_regexp_or_xml = function (previous_token) { + // regex and xml can only appear in specific locations during parsing + return ( + (previous_token.type === TOKEN.RESERVED && + in_array(previous_token.text, [ + 'return', + 'case', + 'throw', + 'else', + 'do', + 'typeof', + 'yield' + ])) || + (previous_token.type === TOKEN.END_EXPR && + previous_token.text === ')' && + previous_token.opened.previous.type === TOKEN.RESERVED && + in_array(previous_token.opened.previous.text, ['if', 'while', 'for'])) || + in_array(previous_token.type, [ + TOKEN.COMMENT, + TOKEN.START_EXPR, + TOKEN.START_BLOCK, + TOKEN.START, + TOKEN.END_BLOCK, + TOKEN.OPERATOR, + TOKEN.EQUALS, + TOKEN.EOF, + TOKEN.SEMICOLON, + TOKEN.COMMA + ]) + ); + }; + + Tokenizer.prototype._read_regexp = function (c, previous_token) { + if (c === '/' && this._allow_regexp_or_xml(previous_token)) { + // handle regexp + // + var resulting_string = this._input.next(); + var esc = false; + + var in_char_class = false; + while ( + this._input.hasNext() && + (esc || in_char_class || this._input.peek() !== c) && + !this._input.testChar(acorn.newline) + ) { + resulting_string += this._input.peek(); + if (!esc) { + esc = this._input.peek() === '\\'; + if (this._input.peek() === '[') { + in_char_class = true; + } else if (this._input.peek() === ']') { + in_char_class = false; + } + } else { + esc = false; + } + this._input.next(); + } + + if (this._input.peek() === c) { + resulting_string += this._input.next(); + + // regexps may have modifiers /regexp/MOD , so fetch those, too + // Only [gim] are valid, but if the user puts in garbage, do what we can to take it. + resulting_string += this._input.read(acorn.identifier); + } + return this._create_token(TOKEN.STRING, resulting_string); + } + return null; + }; + + var startXmlRegExp = + /<()([-a-zA-Z:0-9_.]+|{[\s\S]+?}|!\[CDATA\[[\s\S]*?\]\])(\s+{[\s\S]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{[\s\S]+?}))*\s*(\/?)\s*>/g; + var xmlRegExp = + /[\s\S]*?<(\/?)([-a-zA-Z:0-9_.]+|{[\s\S]+?}|!\[CDATA\[[\s\S]*?\]\])(\s+{[\s\S]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{[\s\S]+?}))*\s*(\/?)\s*>/g; + + Tokenizer.prototype._read_xml = function (c, previous_token) { + if ( + this._options.e4x && + c === '<' && + this._input.test(startXmlRegExp) && + this._allow_regexp_or_xml(previous_token) + ) { + // handle e4x xml literals + // + var xmlStr = ''; + var match = this._input.match(startXmlRegExp); + if (match) { + // Trim root tag to attempt to + var rootTag = match[2].replace(/^{\s+/, '{').replace(/\s+}$/, '}'); + var isCurlyRoot = rootTag.indexOf('{') === 0; + var depth = 0; + while (match) { + var isEndTag = !!match[1]; + var tagName = match[2]; + var isSingletonTag = !!match[match.length - 1] || tagName.slice(0, 8) === '![CDATA['; + if ( + !isSingletonTag && + (tagName === rootTag || + (isCurlyRoot && tagName.replace(/^{\s+/, '{').replace(/\s+}$/, '}'))) + ) { + if (isEndTag) { + --depth; + } else { + ++depth; + } + } + xmlStr += match[0]; + if (depth <= 0) { + break; + } + match = this._input.match(xmlRegExp); + } + // if we didn't close correctly, keep unformatted. + if (!match) { + xmlStr += this._input.match(/[\s\S]*/g)[0]; + } + xmlStr = xmlStr.replace(acorn.allLineBreaks, '\n'); + return this._create_token(TOKEN.STRING, xmlStr); + } + } + + return null; + }; + + function unescape_string(s) { + // You think that a regex would work for this + // return s.replace(/\\x([0-9a-f]{2})/gi, function(match, val) { + // return String.fromCharCode(parseInt(val, 16)); + // }) + // However, dealing with '\xff', '\\xff', '\\\xff' makes this more fun. + var out = '', + escaped = 0; + + var input_scan = new InputScanner(s); + var matched = null; + + while (input_scan.hasNext()) { + // Keep any whitespace, non-slash characters + // also keep slash pairs. + matched = input_scan.match(/([\s]|[^\\]|\\\\)+/g); + + if (matched) { + out += matched[0]; + } + + if (input_scan.peek() === '\\') { + input_scan.next(); + if (input_scan.peek() === 'x') { + matched = input_scan.match(/x([0-9A-Fa-f]{2})/g); + } else if (input_scan.peek() === 'u') { + matched = input_scan.match(/u([0-9A-Fa-f]{4})/g); + } else { + out += '\\'; + if (input_scan.hasNext()) { + out += input_scan.next(); + } + continue; + } + + // If there's some error decoding, return the original string + if (!matched) { + return s; + } + + escaped = parseInt(matched[1], 16); + + if (escaped > 0x7e && escaped <= 0xff && matched[0].indexOf('x') === 0) { + // we bail out on \x7f..\xff, + // leaving whole string escaped, + // as it's probably completely binary + return s; + } else if (escaped >= 0x00 && escaped < 0x20) { + // leave 0x00...0x1f escaped + out += '\\' + matched[0]; + continue; + } else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) { + // single-quote, apostrophe, backslash - escape these + out += '\\' + String.fromCharCode(escaped); + } else { + out += String.fromCharCode(escaped); + } + } + } + + return out; + } + + // handle string + // + Tokenizer.prototype._read_string_recursive = function ( + delimiter, + allow_unescaped_newlines, + start_sub + ) { + // Template strings can travers lines without escape characters. + // Other strings cannot + var current_char; + var resulting_string = ''; + var esc = false; + while (this._input.hasNext()) { + current_char = this._input.peek(); + if ( + !( + esc || + (current_char !== delimiter && + (allow_unescaped_newlines || !acorn.newline.test(current_char))) + ) + ) { + break; + } + + // Handle \r\n linebreaks after escapes or in template strings + if ((esc || allow_unescaped_newlines) && acorn.newline.test(current_char)) { + if (current_char === '\r' && this._input.peek(1) === '\n') { + this._input.next(); + current_char = this._input.peek(); + } + resulting_string += '\n'; + } else { + resulting_string += current_char; + } + + if (esc) { + if (current_char === 'x' || current_char === 'u') { + this.has_char_escapes = true; + } + esc = false; + } else { + esc = current_char === '\\'; + } + + this._input.next(); + + if ( + start_sub && + resulting_string.indexOf(start_sub, resulting_string.length - start_sub.length) !== -1 + ) { + if (delimiter === '`') { + resulting_string += this._read_string_recursive('}', allow_unescaped_newlines, '`'); + } else { + resulting_string += this._read_string_recursive('`', allow_unescaped_newlines, '${'); + } + + if (this._input.hasNext()) { + resulting_string += this._input.next(); + } + } + } + + return resulting_string; + }; + + module.exports.Tokenizer = Tokenizer; + module.exports.TOKEN = TOKEN; + module.exports.positionable_operators = positionable_operators.slice(); + module.exports.line_starters = line_starters.slice(); + + /***/ + }, + /* 8 */ + /***/ function (module, exports, __webpack_require__) { + function InputScanner(input_string) { + this.__input = input_string || ''; + this.__input_length = this.__input.length; + this.__position = 0; + } + + InputScanner.prototype.restart = function () { + this.__position = 0; + }; + + InputScanner.prototype.back = function () { + if (this.__position > 0) { + this.__position -= 1; + } + }; + + InputScanner.prototype.hasNext = function () { + return this.__position < this.__input_length; + }; + + InputScanner.prototype.next = function () { + var val = null; + if (this.hasNext()) { + val = this.__input.charAt(this.__position); + this.__position += 1; + } + return val; + }; + + InputScanner.prototype.peek = function (index) { + var val = null; + index = index || 0; + index += this.__position; + if (index >= 0 && index < this.__input_length) { + val = this.__input.charAt(index); + } + return val; + }; + + InputScanner.prototype.test = function (pattern, index) { + index = index || 0; + index += this.__position; + pattern.lastIndex = index; + + if (index >= 0 && index < this.__input_length) { + var pattern_match = pattern.exec(this.__input); + return pattern_match && pattern_match.index === index; + } else { + return false; + } + }; + + InputScanner.prototype.testChar = function (pattern, index) { + // test one character regex match + var val = this.peek(index); + return val !== null && pattern.test(val); + }; + + InputScanner.prototype.match = function (pattern) { + pattern.lastIndex = this.__position; + var pattern_match = pattern.exec(this.__input); + if (pattern_match && pattern_match.index === this.__position) { + this.__position += pattern_match[0].length; + } else { + pattern_match = null; + } + return pattern_match; + }; + + InputScanner.prototype.read = function (pattern) { + var val = ''; + var match = this.match(pattern); + if (match) { + val = match[0]; + } + return val; + }; + + InputScanner.prototype.readUntil = function (pattern, include_match) { + var val = ''; + var match_index = this.__position; + pattern.lastIndex = this.__position; + var pattern_match = pattern.exec(this.__input); + if (pattern_match) { + if (include_match) { + match_index = pattern_match.index + pattern_match[0].length; + } else { + match_index = pattern_match.index; + } + } else { + match_index = this.__input_length; + } + + val = this.__input.substring(this.__position, match_index); + this.__position = match_index; + return val; + }; + + InputScanner.prototype.readUntilAfter = function (pattern) { + return this.readUntil(pattern, true); + }; + + /* css beautifier legacy helpers */ + InputScanner.prototype.peekUntilAfter = function (pattern) { + var start = this.__position; + var val = this.readUntilAfter(pattern); + this.__position = start; + return val; + }; + + InputScanner.prototype.lookBack = function (testVal) { + var start = this.__position - 1; + return ( + start >= testVal.length && + this.__input.substring(start - testVal.length, start).toLowerCase() === testVal + ); + }; + + module.exports.InputScanner = InputScanner; + + /***/ + }, + /* 9 */ + /***/ function (module, exports, __webpack_require__) { + var InputScanner = __webpack_require__(8).InputScanner; + var Token = __webpack_require__(3).Token; + var TokenStream = __webpack_require__(10).TokenStream; + + var TOKEN = { + START: 'TK_START', + RAW: 'TK_RAW', + EOF: 'TK_EOF' + }; + + var Tokenizer = function (input_string, options) { + this._input = new InputScanner(input_string); + this._options = options || {}; + this.__tokens = null; + this.__newline_count = 0; + this.__whitespace_before_token = ''; + + this._whitespace_pattern = /[\n\r\t ]+/g; + this._newline_pattern = /([^\n\r]*)(\r\n|[\n\r])?/g; + }; + + Tokenizer.prototype.tokenize = function () { + this._input.restart(); + this.__tokens = new TokenStream(); + + this._reset(); + + var current; + var previous = new Token(TOKEN.START, ''); + var open_token = null; + var open_stack = []; + var comments = new TokenStream(); + + while (previous.type !== TOKEN.EOF) { + current = this._get_next_token(previous, open_token); + while (this._is_comment(current)) { + comments.add(current); + current = this._get_next_token(previous, open_token); + } + + if (!comments.isEmpty()) { + current.comments_before = comments; + comments = new TokenStream(); + } + + current.parent = open_token; + + if (this._is_opening(current)) { + open_stack.push(open_token); + open_token = current; + } else if (open_token && this._is_closing(current, open_token)) { + current.opened = open_token; + open_token.closed = current; + open_token = open_stack.pop(); + current.parent = open_token; + } + + current.previous = previous; + previous.next = current; + + this.__tokens.add(current); + previous = current; + } + + return this.__tokens; + }; + + Tokenizer.prototype._is_first_token = function () { + return this.__tokens.isEmpty(); + }; + + Tokenizer.prototype._reset = function () {}; + + Tokenizer.prototype._get_next_token = function (previous_token, open_token) { + this._readWhitespace(); + var resulting_string = this._input.read(/.+/g); + if (resulting_string) { + return this._create_token(TOKEN.RAW, resulting_string); + } else { + return this._create_token(TOKEN.EOF, ''); + } + }; + + Tokenizer.prototype._is_comment = function (current_token) { + return false; + }; + + Tokenizer.prototype._is_opening = function (current_token) { + return false; + }; + + Tokenizer.prototype._is_closing = function (current_token, open_token) { + return false; + }; + + Tokenizer.prototype._create_token = function (type, text) { + var token = new Token(type, text, this.__newline_count, this.__whitespace_before_token); + this.__newline_count = 0; + this.__whitespace_before_token = ''; + return token; + }; + + Tokenizer.prototype._readWhitespace = function () { + var resulting_string = this._input.read(this._whitespace_pattern); + if (resulting_string === ' ') { + this.__whitespace_before_token = resulting_string; + } else if (resulting_string !== '') { + this._newline_pattern.lastIndex = 0; + var nextMatch = this._newline_pattern.exec(resulting_string); + while (nextMatch[2]) { + this.__newline_count += 1; + nextMatch = this._newline_pattern.exec(resulting_string); + } + this.__whitespace_before_token = nextMatch[1]; + } + }; + + module.exports.Tokenizer = Tokenizer; + module.exports.TOKEN = TOKEN; + + /***/ + }, + /* 10 */ + /***/ function (module, exports, __webpack_require__) { + function TokenStream(parent_token) { + // private + this.__tokens = []; + this.__tokens_length = this.__tokens.length; + this.__position = 0; + this.__parent_token = parent_token; + } + + TokenStream.prototype.restart = function () { + this.__position = 0; + }; + + TokenStream.prototype.isEmpty = function () { + return this.__tokens_length === 0; + }; + + TokenStream.prototype.hasNext = function () { + return this.__position < this.__tokens_length; + }; + + TokenStream.prototype.next = function () { + var val = null; + if (this.hasNext()) { + val = this.__tokens[this.__position]; + this.__position += 1; + } + return val; + }; + + TokenStream.prototype.peek = function (index) { + var val = null; + index = index || 0; + index += this.__position; + if (index >= 0 && index < this.__tokens_length) { + val = this.__tokens[index]; + } + return val; + }; + + TokenStream.prototype.add = function (token) { + if (this.__parent_token) { + token.parent = this.__parent_token; + } + this.__tokens.push(token); + this.__tokens_length += 1; + }; + + module.exports.TokenStream = TokenStream; + + /***/ + }, + /* 11 */ + /***/ function (module, exports, __webpack_require__) { + function Directives(start_block_pattern, end_block_pattern) { + start_block_pattern = + typeof start_block_pattern === 'string' ? start_block_pattern : start_block_pattern.source; + end_block_pattern = + typeof end_block_pattern === 'string' ? end_block_pattern : end_block_pattern.source; + this.__directives_block_pattern = new RegExp( + start_block_pattern + / beautify( \w+[:]\w+)+ /.source + end_block_pattern, + 'g' + ); + this.__directive_pattern = / (\w+)[:](\w+)/g; + + this.__directives_end_ignore_pattern = new RegExp( + '(?:[\\s\\S]*?)((?:' + + start_block_pattern + + /\sbeautify\signore:end\s/.source + + end_block_pattern + + ')|$)', + 'g' + ); + } + + Directives.prototype.get_directives = function (text) { + if (!text.match(this.__directives_block_pattern)) { + return null; + } + + var directives = {}; + this.__directive_pattern.lastIndex = 0; + var directive_match = this.__directive_pattern.exec(text); + + while (directive_match) { + directives[directive_match[1]] = directive_match[2]; + directive_match = this.__directive_pattern.exec(text); + } + + return directives; + }; + + Directives.prototype.readIgnored = function (input) { + return input.read(this.__directives_end_ignore_pattern); + }; + + module.exports.Directives = Directives; + + /***/ + } + /******/ + ] + ); + var js_beautify = legacy_beautify_js; + /* Footer */ + { + // Add support for CommonJS. Just put this file somewhere on your require.paths + // and you will be able to `var js_beautify = require("beautify").js_beautify`. + exports.js_beautify = js_beautify; + } + })(); + }); + + unwrapExports(beautify); + var beautify_1 = beautify.js_beautify; + + /* + * Generated by PEG.js 0.10.0. + * + * http://pegjs.org/ + */ + + var javaAST = (function () { + function peg$subclass(child, parent) { + function ctor() { + this.constructor = child; + } + ctor.prototype = parent.prototype; + child.prototype = new ctor(); + } + + function peg$SyntaxError(message, expected, found, location) { + this.message = message; + this.expected = expected; + this.found = found; + this.location = location; + this.name = 'SyntaxError'; + + if (typeof Error.captureStackTrace === 'function') { + Error.captureStackTrace(this, peg$SyntaxError); + } + } + + peg$subclass(peg$SyntaxError, Error); + + peg$SyntaxError.buildMessage = function (expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function (expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + + class: function (expectation) { + var escapedParts = '', + i; + + for (i = 0; i < expectation.parts.length; i++) { + escapedParts += + expectation.parts[i] instanceof Array + ? classEscape(expectation.parts[i][0]) + '-' + classEscape(expectation.parts[i][1]) + : classEscape(expectation.parts[i]); + } + + return '[' + (expectation.inverted ? '^' : '') + escapedParts + ']'; + }, + + any: function (expectation) { + return 'any character'; + }, + + end: function (expectation) { + return 'end of input'; + }, + + other: function (expectation) { + return expectation.description; + } + }; + + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + + function literalEscape(s) { + return s + .replace(/\\/g, '\\\\') + .replace(/"/g, '\\"') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function (ch) { + return '\\x0' + hex(ch); + }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) { + return '\\x' + hex(ch); + }); + } + + function classEscape(s) { + return s + .replace(/\\/g, '\\\\') + .replace(/\]/g, '\\]') + .replace(/\^/g, '\\^') + .replace(/-/g, '\\-') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function (ch) { + return '\\x0' + hex(ch); + }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) { + return '\\x' + hex(ch); + }); + } + + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + + function describeExpected(expected) { + var descriptions = new Array(expected.length), + i, + j; + + for (i = 0; i < expected.length; i++) { + descriptions[i] = describeExpectation(expected[i]); + } + + descriptions.sort(); + + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + + switch (descriptions.length) { + case 1: + return descriptions[0]; + + case 2: + return descriptions[0] + ' or ' + descriptions[1]; + + default: + return descriptions.slice(0, -1).join(', ') + ', or ' + descriptions[descriptions.length - 1]; + } + } + + function describeFound(found) { + return found ? '"' + literalEscape(found) + '"' : 'end of input'; + } + + return 'Expected ' + describeExpected(expected) + ' but ' + describeFound(found) + ' found.'; + }; + + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + + var peg$FAILED = {}, + peg$startRuleFunctions = { CompilationUnit: peg$parseCompilationUnit }, + peg$startRuleFunction = peg$parseCompilationUnit, + peg$c0 = function (pack, imports, types) { + return { + node: 'CompilationUnit', + types: skipNulls(types), + package: pack, + imports: skipNulls(imports) + }; + }, + peg$c1 = function (annot, name) { + return { + node: 'PackageDeclaration', + name: name, + annotations: annot + }; + }, + peg$c2 = function (stat, name, asterisk) { + return { + node: 'ImportDeclaration', + name: name, + static: !!stat, + onDemand: !!extractOptional(asterisk, 1) + }; + }, + peg$c3 = function () { + return null; + }, + peg$c4 = function (modifiers, type) { + return mergeProps(type, { modifiers: modifiers }); + }, + peg$c5 = function (id, gen, ext, impl, body) { + return { + node: 'TypeDeclaration', + name: id, + superInterfaceTypes: extractOptionalList(impl, 1), + superclassType: extractOptional(ext, 1), + bodyDeclarations: body, + typeParameters: optionalList(gen), + interface: false + }; + }, + peg$c6 = function (decls) { + return skipNulls(decls); + }, + peg$c7 = function (modifier, body) { + return { + node: 'Initializer', + body: body, + modifiers: modifier === null ? [] : [makeModifier('static')] + }; + }, + peg$c8 = function (modifiers, member) { + return mergeProps(member, { modifiers: modifiers }); + }, + peg$c9 = function (params, rest) { + return mergeProps(rest, { + node: 'MethodDeclaration', + typeParameters: params + }); + }, + peg$c10 = function (type, id, rest) { + return mergeProps(rest, { + node: 'MethodDeclaration', + returnType2: type, + name: id, + typeParameters: [] + }); + }, + peg$c11 = function (type, decls) { + return { + node: 'FieldDeclaration', + fragments: decls, + type: type + }; + }, + peg$c12 = function (id, rest) { + return mergeProps(rest, { + node: 'MethodDeclaration', + returnType2: makePrimitive('void'), + name: id, + constructor: false + }); + }, + peg$c13 = function (id, rest) { + return mergeProps(rest, { + node: 'MethodDeclaration', + name: id, + typeParameters: [] + }); + }, + peg$c14 = function () { + return makePrimitive('void'); + }, + peg$c15 = function (type, id, rest) { + return mergeProps(rest, { + returnType2: type, + name: id + }); + }, + peg$c16 = function (id, rest) { + return mergeProps(rest, { name: id }); + }, + peg$c17 = function (params, dims, throws) { + return null; + }, + peg$c18 = function (params, dims, throws, body) { + return { + parameters: params, + thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)), + extraDimensions: dims.length, + body: body, + constructor: false + }; + }, + peg$c19 = function (params, throws) { + return null; + }, + peg$c20 = function (params, throws, body) { + return { + parameters: params, + thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)), + body: body, + extraDimensions: 0, + typeParameters: [] + }; + }, + peg$c21 = function (params, throws, body) { + return { + parameters: params, + thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)), + body: body, + returnType2: null, + constructor: true, + extraDimensions: 0 + }; + }, + peg$c22 = function (id, gen, ext, body) { + return { + node: 'TypeDeclaration', + name: id, + superInterfaceTypes: extractOptionalList(ext, 1), + superclassType: null, + bodyDeclarations: body, + typeParameters: optionalList(gen), + interface: true + }; + }, + peg$c23 = function (type, id, rest) { + if (rest.node === 'FieldDeclaration') { + rest.fragments[0].name = id; + return mergeProps(rest, { type: type }); + } else { + return mergeProps(rest, { + returnType2: type, + name: id, + typeParameters: [] + }); + } + }, + peg$c24 = function (rest) { + return { node: 'FieldDeclaration', fragments: rest }; + }, + peg$c25 = function (params, dims, throws) { + return { + node: 'MethodDeclaration', + parameters: params, + thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)), + extraDimensions: dims.length, + body: null, + constructor: false + }; + }, + peg$c26 = function (params) { + return makePrimitive('void'); + }, + peg$c27 = function (params, type, id, rest) { + return mergeProps(rest, { + returnType2: type, + name: id, + typeParameters: params + }); + }, + peg$c28 = function (params, throws) { + return { + node: 'MethodDeclaration', + parameters: params, + thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)), + returnType2: makePrimitive('void'), + extraDimensions: 0, + typeParameters: [], + body: null, + constructor: false + }; + }, + peg$c29 = function (first, rest) { + return buildList(first, rest, 1); + }, + peg$c30 = function (dims, init) { + return { + node: 'VariableDeclarationFragment', + extraDimensions: dims.length, + initializer: init + }; + }, + peg$c31 = function (name, impl, eb) { + return mergeProps(eb, { + node: 'EnumDeclaration', + name: name, + superInterfaceTypes: extractOptionalList(impl, 1) + }); + }, + peg$c32 = function (consts, body) { + return { + enumConstants: optionalList(consts), + bodyDeclarations: optionalList(body) + }; + }, + peg$c33 = function (annot, name, args, cls) { + return { + node: 'EnumConstantDeclaration', + anonymousClassDeclaration: + cls === null + ? null + : { + node: 'AnonymousClassDeclaration', + bodyDeclarations: cls + }, + arguments: optionalList(args), + modifiers: annot, + name: name + }; + }, + peg$c34 = function (decl) { + return decl; + }, + peg$c35 = function () { + return makeModifier('final'); + }, + peg$c36 = function (modifiers, type, decls) { + return { + node: 'VariableDeclarationStatement', + fragments: decls, + modifiers: modifiers, + type: type + }; + }, + peg$c37 = function (name, dims, init) { + return { + node: 'VariableDeclarationFragment', + name: name, + extraDimensions: dims.length, + initializer: extractOptional(init, 1) + }; + }, + peg$c38 = function (params) { + return optionalList(params); + }, + peg$c39 = function (modifiers, type, decl) { + return mergeProps(decl, { + type: type, + modifiers: modifiers, + varargs: false, + initializer: null + }); + }, + peg$c40 = function (modifiers, type, decl) { + return mergeProps(decl, { + type: type, + modifiers: modifiers, + varargs: true, + initializer: null + }); + }, + peg$c41 = function (first, rest, last) { + return buildList(first, rest, 1).concat(extractOptionalList(last, 1)); + }, + peg$c42 = function (last) { + return [last]; + }, + peg$c43 = function (id, dims) { + return { + node: 'SingleVariableDeclaration', + name: id, + extraDimensions: dims.length + }; + }, + peg$c44 = function (statements) { + return { + node: 'Block', + statements: statements + }; + }, + peg$c45 = function (modifiers, decl) { + return { + node: 'TypeDeclarationStatement', + declaration: mergeProps(decl, { modifiers: modifiers }) + }; + }, + peg$c46 = function (expr, message) { + return { + node: 'AssertStatement', + expression: expr, + message: extractOptional(message, 1) + }; + }, + peg$c47 = function (expr, then, alt) { + return { + node: 'IfStatement', + elseStatement: extractOptional(alt, 1), + thenStatement: then, + expression: expr.expression + }; + }, + peg$c48 = function (init, expr, up, body) { + return { + node: 'ForStatement', + initializers: optionalList(init), + expression: expr, + updaters: optionalList(up), + body: body + }; + }, + peg$c49 = function (param, expr, statement) { + return { + node: 'EnhancedForStatement', + parameter: param, + expression: expr, + body: statement + }; + }, + peg$c50 = function (expr, body) { + return { + node: 'WhileStatement', + expression: expr.expression, + body: body + }; + }, + peg$c51 = function (statement, expr) { + return { + node: 'DoStatement', + expression: expr.expression, + body: statement + }; + }, + peg$c52 = function (first, rest, body, cat, fin) { + return mergeProps(makeCatchFinally(cat, fin), { + node: 'TryStatement', + body: body, + resources: buildList(first, rest, 1) + }); + }, + peg$c53 = function (body, cat, fin) { + return makeCatchFinally(cat, fin); + }, + peg$c54 = function (body, fin) { + return makeCatchFinally([], fin); + }, + peg$c55 = function (body, rest) { + return mergeProps(rest, { + node: 'TryStatement', + body: body, + resources: [] + }); + }, + peg$c56 = function (expr, cases) { + return { node: 'SwitchStatement', statements: cases, expression: expr.expression }; + }, + peg$c57 = function (expr, body) { + return { node: 'SynchronizedStatement', expression: expr.expression, body: body }; + }, + peg$c58 = function (expr) { + return { node: 'ReturnStatement', expression: expr }; + }, + peg$c59 = function (expr) { + return { node: 'ThrowStatement', expression: expr }; + }, + peg$c60 = function (id) { + return { node: 'BreakStatement', label: id }; + }, + peg$c61 = function (id) { + return { node: 'ContinueStatement', label: id }; + }, + peg$c62 = function () { + return { node: 'EmptyStatement' }; + }, + peg$c63 = function (statement) { + return statement; + }, + peg$c64 = function (id, statement) { + return { node: 'LabeledStatement', label: id, body: statement }; + }, + peg$c65 = function (modifiers, type, decl, expr) { + var fragment = mergeProps(decl, { initializer: expr }); + fragment.node = 'VariableDeclarationFragment'; + return { + node: 'VariableDeclarationExpression', + modifiers: modifiers, + type: type, + fragments: [fragment] + }; + }, + peg$c66 = function (modifiers, first, rest, decl, body) { + return { + node: 'CatchClause', + body: body, + exception: mergeProps(decl, { + modifiers: modifiers, + initializer: null, + varargs: false, + type: rest.length + ? { + node: 'UnionType', + types: buildList(first, rest, 1) + } + : first + }) + }; + }, + peg$c67 = function (block) { + return block; + }, + peg$c68 = function (blocks) { + return [].concat.apply([], blocks); + }, + peg$c69 = function (expr, blocks) { + return [{ node: 'SwitchCase', expression: expr }].concat(blocks); + }, + peg$c70 = function (expr) { + return expr; + }, + peg$c71 = function (modifiers, type, decls) { + return [ + { + node: 'VariableDeclarationExpression', + modifiers: modifiers, + fragments: decls, + type: type + } + ]; + }, + peg$c72 = function (first, rest) { + return extractExpressions(buildList(first, rest, 1)); + }, + peg$c73 = function (expr) { + switch (expr.node) { + case 'SuperConstructorInvocation': + case 'ConstructorInvocation': + return expr; + default: + return { + node: 'ExpressionStatement', + expression: expr + }; + } + }, + peg$c74 = function (left, op, right) { + return { + node: 'Assignment', + operator: op[0] /* remove ending spaces */, + leftHandSide: left, + rightHandSide: right + }; + }, + peg$c75 = function (expr, then, alt) { + return { + node: 'ConditionalExpression', + expression: expr, + thenExpression: then, + elseExpression: alt + }; + }, + peg$c76 = function (first, rest) { + return buildInfixExpr(first, rest); + }, + peg$c77 = function (first, rest) { + return buildTree(first, rest, function (result, element) { + return element[0][0] === 'instanceof' + ? { + node: 'InstanceofExpression', + leftOperand: result, + rightOperand: element[1] + } + : { + node: 'InfixExpression', + operator: element[0][0], // remove ending Spacing + leftOperand: result, + rightOperand: element[1] + }; + }); + }, + peg$c78 = function (operator, operand) { + return operand.node === 'NumberLiteral' && + operator === '-' && + (operand.token === '9223372036854775808L' || + operand.token === '9223372036854775808l' || + operand.token === '2147483648') + ? { node: 'NumberLiteral', token: text() } + : { + node: 'PrefixExpression', + operator: operator, + operand: operand + }; + }, + peg$c79 = function (expr) { + return { + node: 'CastExpression', + type: expr[1], + expression: expr[3] + }; + }, + peg$c80 = function (arg, sel, sels, operator) { + return operator.length > 1 + ? TODO(/* JLS7? */) + : { + node: 'PostfixExpression', + operator: operator[0], + operand: buildSelectorTree(arg, sel, sels) + }; + }, + peg$c81 = function (arg, sel, sels) { + return buildSelectorTree(arg, sel, sels); + }, + peg$c82 = function (arg, operator) { + return operator.length > 1 + ? TODO(/* JLS7? */) + : { + node: 'PostfixExpression', + operator: operator[0], + operand: arg + }; + }, + peg$c83 = function (args, args_r) { + return { node: 'ConstructorInvocation', arguments: args_r, typeArguments: [] }; + }, + peg$c84 = function (args, ret) { + if (ret.typeArguments.length) return TODO(/* Ugly ! */); + ret.typeArguments = args; + return ret; + }, + peg$c85 = function (args) { + return args === null + ? { + node: 'ThisExpression', + qualifier: null + } + : { + node: 'ConstructorInvocation', + arguments: args, + typeArguments: [] + }; + }, + peg$c86 = function (suffix) { + return suffix.node === 'SuperConstructorInvocation' + ? suffix + : mergeProps(suffix, { qualifier: null }); + }, + peg$c87 = function (creator) { + return creator; + }, + peg$c88 = function (type, dims) { + return { + node: 'TypeLiteral', + type: buildArrayTree(type, dims) + }; + }, + peg$c89 = function () { + return { + node: 'TypeLiteral', + type: makePrimitive('void') + }; + }, + peg$c90 = function (qual, dims) { + return { + node: 'TypeLiteral', + type: buildArrayTree(buildTypeName(qual, null, []), dims) + }; + }, + peg$c91 = function (qual, expr) { + return { node: 'ArrayAccess', array: qual, index: expr }; + }, + peg$c92 = function (qual, args) { + return mergeProps(popQualified(qual), { + node: 'MethodInvocation', + arguments: args, + typeArguments: [] + }); + }, + peg$c93 = function (qual) { + return { node: 'TypeLiteral', type: buildTypeName(qual, null, []) }; + }, + peg$c94 = function (qual, ret) { + if (ret.expression) return TODO(/* Ugly ! */); + ret.expression = qual; + return ret; + }, + peg$c95 = function (qual) { + return { node: 'ThisExpression', qualifier: qual }; + }, + peg$c96 = function (qual, args) { + return { + node: 'SuperConstructorInvocation', + arguments: args, + expression: qual, + typeArguments: [] + }; + }, + peg$c97 = function (qual, args, rest) { + return mergeProps(rest, { expression: qual, typeArguments: optionalList(args) }); + }, + peg$c98 = function () { + return []; + }, + peg$c99 = function (suffix) { + return suffix; + }, + peg$c100 = function (id, args) { + return { node: 'MethodInvocation', arguments: args, name: id, typeArguments: [] }; + }, + peg$c101 = function (op) { + return op[0]; /* remove ending spaces */ + }, + peg$c102 = function (id) { + return { node: 'FieldAccess', name: id }; + }, + peg$c103 = function (ret) { + return ret; + }, + peg$c104 = function () { + return TODO(/* Any sample ? */); + }, + peg$c105 = function (args, ret) { + return mergeProps(ret, { typeArguments: optionalList(args) }); + }, + peg$c106 = function (expr) { + return { node: 'ArrayAccess', index: expr }; + }, + peg$c107 = function (args) { + return { + node: 'SuperConstructorInvocation', + arguments: args, + expression: null, + typeArguments: [] + }; + }, + peg$c108 = function (gen, id, args) { + return args === null + ? { + node: 'SuperFieldAccess', + name: id + } + : { + node: 'SuperMethodInvocation', + typeArguments: optionalList(gen), + name: id, + arguments: args + }; + }, + peg$c109 = 'byte', + peg$c110 = peg$literalExpectation('byte', false), + peg$c111 = 'short', + peg$c112 = peg$literalExpectation('short', false), + peg$c113 = 'char', + peg$c114 = peg$literalExpectation('char', false), + peg$c115 = 'int', + peg$c116 = peg$literalExpectation('int', false), + peg$c117 = 'long', + peg$c118 = peg$literalExpectation('long', false), + peg$c119 = 'float', + peg$c120 = peg$literalExpectation('float', false), + peg$c121 = 'double', + peg$c122 = peg$literalExpectation('double', false), + peg$c123 = 'boolean', + peg$c124 = peg$literalExpectation('boolean', false), + peg$c125 = function (type) { + return makePrimitive(type); + }, + peg$c126 = function (args) { + return optionalList(args); + }, + peg$c127 = function (type, rest) { + return { + node: 'ArrayCreation', + type: buildArrayTree(type, rest.extraDims), + initializer: rest.init, + dimensions: rest.dimms + }; + }, + peg$c128 = function (args, type, rest) { + return mergeProps(rest, { + node: 'ClassInstanceCreation', + type: type, + typeArguments: optionalList(args), + expression: null + }); + }, + peg$c129 = function (qual, args, rest) { + return buildTypeName(qual, args, rest); + }, + peg$c130 = function (id, args, rest) { + return mergeProps(rest, { + node: 'ClassInstanceCreation', + type: buildTypeName(id, args, []) + }); + }, + peg$c131 = function (args, body) { + return { + arguments: args, + anonymousClassDeclaration: + body === null + ? null + : { + node: 'AnonymousClassDeclaration', + bodyDeclarations: body + } + }; + }, + peg$c132 = function (dims, init) { + return { extraDims: dims, init: init, dimms: [] }; + }, + peg$c133 = function (dimexpr, dims) { + return { extraDims: dimexpr.concat(dims), init: null, dimms: dimexpr }; + }, + peg$c134 = function (dim) { + return { extraDims: [dim], init: null, dimms: [] }; + }, + peg$c135 = function (init) { + return { node: 'ArrayInitializer', expressions: optionalList(init) }; + }, + peg$c136 = function (expr) { + return { node: 'ParenthesizedExpression', expression: expr }; + }, + peg$c137 = function (first, rest) { + return buildQualified(first, rest, 1); + }, + peg$c138 = function (exp) { + return exp; + }, + peg$c139 = function (type, dims) { + return buildArrayTree(type, dims); + }, + peg$c140 = function (bas, dims) { + return buildArrayTree(bas, dims); + }, + peg$c141 = function (cls, dims) { + return buildArrayTree(cls, dims); + }, + peg$c142 = function () { + return true; + }, + peg$c143 = function () { + return false; + }, + peg$c144 = function (rest) { + return { + node: 'WildcardType', + upperBound: extractOptional(rest, 0, true), + bound: extractOptional(rest, 1) + }; + }, + peg$c145 = function (id, bounds) { + return { + node: 'TypeParameter', + name: id, + typeBounds: extractOptionalList(bounds, 1) + }; + }, + peg$c146 = 'public', + peg$c147 = peg$literalExpectation('public', false), + peg$c148 = 'protected', + peg$c149 = peg$literalExpectation('protected', false), + peg$c150 = 'private', + peg$c151 = peg$literalExpectation('private', false), + peg$c152 = 'static', + peg$c153 = peg$literalExpectation('static', false), + peg$c154 = 'abstract', + peg$c155 = peg$literalExpectation('abstract', false), + peg$c156 = 'final', + peg$c157 = peg$literalExpectation('final', false), + peg$c158 = 'native', + peg$c159 = peg$literalExpectation('native', false), + peg$c160 = 'synchronized', + peg$c161 = peg$literalExpectation('synchronized', false), + peg$c162 = 'transient', + peg$c163 = peg$literalExpectation('transient', false), + peg$c164 = 'volatile', + peg$c165 = peg$literalExpectation('volatile', false), + peg$c166 = 'strictfp', + peg$c167 = peg$literalExpectation('strictfp', false), + peg$c168 = function (keyword) { + return makeModifier(keyword); + }, + peg$c169 = function (id, body) { + return { + node: 'AnnotationTypeDeclaration', + name: id, + bodyDeclarations: body + }; + }, + peg$c170 = function (decl) { + return skipNulls(decl); + }, + peg$c171 = function (modifiers, rest) { + return mergeProps(rest, { modifiers: modifiers }); + }, + peg$c172 = function (type, rest) { + return mergeProps(rest, { type: type }); + }, + peg$c173 = function (id, def) { + return { + node: 'AnnotationTypeMemberDeclaration', + name: id, + default: def + }; + }, + peg$c174 = function (fragments) { + return { node: 'FieldDeclaration', fragments: fragments }; + }, + peg$c175 = function (val) { + return val; + }, + peg$c176 = function (id, pairs) { + return { + node: 'NormalAnnotation', + typeName: id, + values: optionalList(pairs) + }; + }, + peg$c177 = function (id, value) { + return { + node: 'SingleMemberAnnotation', + typeName: id, + value: value + }; + }, + peg$c178 = function (id) { + return { node: 'MarkerAnnotation', typeName: id }; + }, + peg$c179 = function (name, value) { + return { + node: 'MemberValuePair', + name: name, + value: value + }; + }, + peg$c180 = function (values) { + return { node: 'ArrayInitializer', expressions: optionalList(values) }; + }, + peg$c181 = /^[ \t\r\n\f]/, + peg$c182 = peg$classExpectation([' ', '\t', '\r', '\n', '\f'], false, false), + peg$c183 = '/*', + peg$c184 = peg$literalExpectation('/*', false), + peg$c185 = '*/', + peg$c186 = peg$literalExpectation('*/', false), + peg$c187 = '//', + peg$c188 = peg$literalExpectation('//', false), + peg$c189 = /^[\r\n]/, + peg$c190 = peg$classExpectation(['\r', '\n'], false, false), + peg$c191 = function (first, rest) { + return { identifier: first + rest, node: 'SimpleName' }; + }, + peg$c192 = /^[a-z]/, + peg$c193 = peg$classExpectation([['a', 'z']], false, false), + peg$c194 = /^[A-Z]/, + peg$c195 = peg$classExpectation([['A', 'Z']], false, false), + peg$c196 = /^[_$]/, + peg$c197 = peg$classExpectation(['_', '$'], false, false), + peg$c198 = /^[0-9]/, + peg$c199 = peg$classExpectation([['0', '9']], false, false), + peg$c200 = 'assert', + peg$c201 = peg$literalExpectation('assert', false), + peg$c202 = 'break', + peg$c203 = peg$literalExpectation('break', false), + peg$c204 = 'case', + peg$c205 = peg$literalExpectation('case', false), + peg$c206 = 'catch', + peg$c207 = peg$literalExpectation('catch', false), + peg$c208 = 'class', + peg$c209 = peg$literalExpectation('class', false), + peg$c210 = 'const', + peg$c211 = peg$literalExpectation('const', false), + peg$c212 = 'continue', + peg$c213 = peg$literalExpectation('continue', false), + peg$c214 = 'default', + peg$c215 = peg$literalExpectation('default', false), + peg$c216 = 'do', + peg$c217 = peg$literalExpectation('do', false), + peg$c218 = 'else', + peg$c219 = peg$literalExpectation('else', false), + peg$c220 = 'enum', + peg$c221 = peg$literalExpectation('enum', false), + peg$c222 = 'extends', + peg$c223 = peg$literalExpectation('extends', false), + peg$c224 = 'false', + peg$c225 = peg$literalExpectation('false', false), + peg$c226 = 'finally', + peg$c227 = peg$literalExpectation('finally', false), + peg$c228 = 'for', + peg$c229 = peg$literalExpectation('for', false), + peg$c230 = 'goto', + peg$c231 = peg$literalExpectation('goto', false), + peg$c232 = 'if', + peg$c233 = peg$literalExpectation('if', false), + peg$c234 = 'implements', + peg$c235 = peg$literalExpectation('implements', false), + peg$c236 = 'import', + peg$c237 = peg$literalExpectation('import', false), + peg$c238 = 'interface', + peg$c239 = peg$literalExpectation('interface', false), + peg$c240 = 'instanceof', + peg$c241 = peg$literalExpectation('instanceof', false), + peg$c242 = 'new', + peg$c243 = peg$literalExpectation('new', false), + peg$c244 = 'null', + peg$c245 = peg$literalExpectation('null', false), + peg$c246 = 'package', + peg$c247 = peg$literalExpectation('package', false), + peg$c248 = 'return', + peg$c249 = peg$literalExpectation('return', false), + peg$c250 = 'super', + peg$c251 = peg$literalExpectation('super', false), + peg$c252 = 'switch', + peg$c253 = peg$literalExpectation('switch', false), + peg$c254 = 'this', + peg$c255 = peg$literalExpectation('this', false), + peg$c256 = 'throws', + peg$c257 = peg$literalExpectation('throws', false), + peg$c258 = 'throw', + peg$c259 = peg$literalExpectation('throw', false), + peg$c260 = 'true', + peg$c261 = peg$literalExpectation('true', false), + peg$c262 = 'try', + peg$c263 = peg$literalExpectation('try', false), + peg$c264 = 'void', + peg$c265 = peg$literalExpectation('void', false), + peg$c266 = 'while', + peg$c267 = peg$literalExpectation('while', false), + peg$c268 = function () { + return { node: 'BooleanLiteral', booleanValue: true }; + }, + peg$c269 = function () { + return { node: 'BooleanLiteral', booleanValue: false }; + }, + peg$c270 = function () { + return { node: 'NullLiteral' }; + }, + peg$c271 = function (literal) { + return literal; + }, + peg$c272 = /^[lL]/, + peg$c273 = peg$classExpectation(['l', 'L'], false, false), + peg$c274 = function () { + return { node: 'NumberLiteral', token: text() }; + }, + peg$c275 = '0', + peg$c276 = peg$literalExpectation('0', false), + peg$c277 = /^[1-9]/, + peg$c278 = peg$classExpectation([['1', '9']], false, false), + peg$c279 = /^[_]/, + peg$c280 = peg$classExpectation(['_'], false, false), + peg$c281 = '0x', + peg$c282 = peg$literalExpectation('0x', false), + peg$c283 = '0X', + peg$c284 = peg$literalExpectation('0X', false), + peg$c285 = '0b', + peg$c286 = peg$literalExpectation('0b', false), + peg$c287 = '0B', + peg$c288 = peg$literalExpectation('0B', false), + peg$c289 = /^[01]/, + peg$c290 = peg$classExpectation(['0', '1'], false, false), + peg$c291 = /^[0-7]/, + peg$c292 = peg$classExpectation([['0', '7']], false, false), + peg$c293 = '.', + peg$c294 = peg$literalExpectation('.', false), + peg$c295 = /^[fFdD]/, + peg$c296 = peg$classExpectation(['f', 'F', 'd', 'D'], false, false), + peg$c297 = /^[eE]/, + peg$c298 = peg$classExpectation(['e', 'E'], false, false), + peg$c299 = /^[+\-]/, + peg$c300 = peg$classExpectation(['+', '-'], false, false), + peg$c301 = /^[pP]/, + peg$c302 = peg$classExpectation(['p', 'P'], false, false), + peg$c303 = /^[a-f]/, + peg$c304 = peg$classExpectation([['a', 'f']], false, false), + peg$c305 = /^[A-F]/, + peg$c306 = peg$classExpectation([['A', 'F']], false, false), + peg$c307 = "'", + peg$c308 = peg$literalExpectation("'", false), + peg$c309 = /^['\\\n\r]/, + peg$c310 = peg$classExpectation(["'", '\\', '\n', '\r'], false, false), + peg$c311 = function () { + return { node: 'CharacterLiteral', escapedValue: text() }; + }, + peg$c312 = '"', + peg$c313 = peg$literalExpectation('"', false), + peg$c314 = /^["\\\n\r]/, + peg$c315 = peg$classExpectation(['"', '\\', '\n', '\r'], false, false), + peg$c316 = function () { + return { node: 'StringLiteral', escapedValue: text() }; + }, + peg$c317 = '\\', + peg$c318 = peg$literalExpectation('\\', false), + peg$c319 = /^[btnfr"'\\]/, + peg$c320 = peg$classExpectation(['b', 't', 'n', 'f', 'r', '"', "'", '\\'], false, false), + peg$c321 = /^[0-3]/, + peg$c322 = peg$classExpectation([['0', '3']], false, false), + peg$c323 = 'u', + peg$c324 = peg$literalExpectation('u', false), + peg$c325 = '@', + peg$c326 = peg$literalExpectation('@', false), + peg$c327 = '&', + peg$c328 = peg$literalExpectation('&', false), + peg$c329 = /^[=&]/, + peg$c330 = peg$classExpectation(['=', '&'], false, false), + peg$c331 = '&&', + peg$c332 = peg$literalExpectation('&&', false), + peg$c333 = '&=', + peg$c334 = peg$literalExpectation('&=', false), + peg$c335 = '!', + peg$c336 = peg$literalExpectation('!', false), + peg$c337 = '=', + peg$c338 = peg$literalExpectation('=', false), + peg$c339 = '>>>', + peg$c340 = peg$literalExpectation('>>>', false), + peg$c341 = '>>>=', + peg$c342 = peg$literalExpectation('>>>=', false), + peg$c343 = ':', + peg$c344 = peg$literalExpectation(':', false), + peg$c345 = ',', + peg$c346 = peg$literalExpectation(',', false), + peg$c347 = '--', + peg$c348 = peg$literalExpectation('--', false), + peg$c349 = '/', + peg$c350 = peg$literalExpectation('/', false), + peg$c351 = '/=', + peg$c352 = peg$literalExpectation('/=', false), + peg$c353 = '...', + peg$c354 = peg$literalExpectation('...', false), + peg$c355 = '==', + peg$c356 = peg$literalExpectation('==', false), + peg$c357 = '>=', + peg$c358 = peg$literalExpectation('>=', false), + peg$c359 = '>', + peg$c360 = peg$literalExpectation('>', false), + peg$c361 = /^[=>]/, + peg$c362 = peg$classExpectation(['=', '>'], false, false), + peg$c363 = '^', + peg$c364 = peg$literalExpectation('^', false), + peg$c365 = '^=', + peg$c366 = peg$literalExpectation('^=', false), + peg$c367 = '++', + peg$c368 = peg$literalExpectation('++', false), + peg$c369 = '[', + peg$c370 = peg$literalExpectation('[', false), + peg$c371 = '<=', + peg$c372 = peg$literalExpectation('<=', false), + peg$c373 = '(', + peg$c374 = peg$literalExpectation('(', false), + peg$c375 = '<', + peg$c376 = peg$literalExpectation('<', false), + peg$c377 = /^[=<]/, + peg$c378 = peg$classExpectation(['=', '<'], false, false), + peg$c379 = '{', + peg$c380 = peg$literalExpectation('{', false), + peg$c381 = '-', + peg$c382 = peg$literalExpectation('-', false), + peg$c383 = /^[=\-]/, + peg$c384 = peg$classExpectation(['=', '-'], false, false), + peg$c385 = '-=', + peg$c386 = peg$literalExpectation('-=', false), + peg$c387 = '%', + peg$c388 = peg$literalExpectation('%', false), + peg$c389 = '%=', + peg$c390 = peg$literalExpectation('%=', false), + peg$c391 = '!=', + peg$c392 = peg$literalExpectation('!=', false), + peg$c393 = '|', + peg$c394 = peg$literalExpectation('|', false), + peg$c395 = /^[=|]/, + peg$c396 = peg$classExpectation(['=', '|'], false, false), + peg$c397 = '|=', + peg$c398 = peg$literalExpectation('|=', false), + peg$c399 = '||', + peg$c400 = peg$literalExpectation('||', false), + peg$c401 = '+', + peg$c402 = peg$literalExpectation('+', false), + peg$c403 = /^[=+]/, + peg$c404 = peg$classExpectation(['=', '+'], false, false), + peg$c405 = '+=', + peg$c406 = peg$literalExpectation('+=', false), + peg$c407 = '?', + peg$c408 = peg$literalExpectation('?', false), + peg$c409 = ']', + peg$c410 = peg$literalExpectation(']', false), + peg$c411 = ')', + peg$c412 = peg$literalExpectation(')', false), + peg$c413 = '}', + peg$c414 = peg$literalExpectation('}', false), + peg$c415 = ';', + peg$c416 = peg$literalExpectation(';', false), + peg$c417 = '<<', + peg$c418 = peg$literalExpectation('<<', false), + peg$c419 = '<<=', + peg$c420 = peg$literalExpectation('<<=', false), + peg$c421 = '>>', + peg$c422 = peg$literalExpectation('>>', false), + peg$c423 = '>>=', + peg$c424 = peg$literalExpectation('>>=', false), + peg$c425 = '*', + peg$c426 = peg$literalExpectation('*', false), + peg$c427 = '*=', + peg$c428 = peg$literalExpectation('*=', false), + peg$c429 = '~', + peg$c430 = peg$literalExpectation('~', false), + peg$c431 = peg$anyExpectation(), + peg$currPos = 0, + peg$savedPos = 0, + peg$posDetailsCache = [{ line: 1, column: 1 }], + peg$maxFailPos = 0, + peg$maxFailExpected = [], + peg$silentFails = 0, + peg$result; + + if ('startRule' in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error('Can\'t start parsing from rule "' + options.startRule + '".'); + } + + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + + function peg$literalExpectation(text, ignoreCase) { + return { type: 'literal', text: text, ignoreCase: ignoreCase }; + } + + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: 'class', parts: parts, inverted: inverted, ignoreCase: ignoreCase }; + } + + function peg$anyExpectation() { + return { type: 'any' }; + } + + function peg$endExpectation() { + return { type: 'end' }; + } + + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos], + p; + + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + + p++; + } + + peg$posDetailsCache[pos] = details; + return details; + } + } + + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos), + endPosDetails = peg$computePosDetails(endPos); + + return { + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + + function peg$fail(expected) { + if (peg$currPos < peg$maxFailPos) { + return; + } + + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + + peg$maxFailExpected.push(expected); + } + + function peg$buildStructuredError(expected, found, location) { + return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location); + } + + function peg$parseCompilationUnit() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseSpacing(); + if (s1 !== peg$FAILED) { + s2 = peg$parsePackageDeclaration(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parseImportDeclaration(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseImportDeclaration(); + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parseTypeDeclaration(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parseTypeDeclaration(); + } + if (s4 !== peg$FAILED) { + s5 = peg$parseEOT(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c0(s2, s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parsePackageDeclaration() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseAnnotation(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseAnnotation(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parsePACKAGE(); + if (s2 !== peg$FAILED) { + s3 = peg$parseQualifiedIdentifier(); + if (s3 !== peg$FAILED) { + s4 = peg$parseSEMI(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c1(s1, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseImportDeclaration() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$parseIMPORT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseSTATIC(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseQualifiedIdentifier(); + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parseDOT(); + if (s5 !== peg$FAILED) { + s6 = peg$parseSTAR(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + s5 = peg$parseSEMI(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c2(s2, s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSEMI(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c3(); + } + s0 = s1; + } + + return s0; + } + + function peg$parseTypeDeclaration() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseModifier(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseModifier(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseClassDeclaration(); + if (s2 === peg$FAILED) { + s2 = peg$parseEnumDeclaration(); + if (s2 === peg$FAILED) { + s2 = peg$parseInterfaceDeclaration(); + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotationTypeDeclaration(); + } + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c4(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSEMI(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c3(); + } + s0 = s1; + } + + return s0; + } + + function peg$parseClassDeclaration() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseCLASS(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseTypeParameters(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parseEXTENDS(); + if (s5 !== peg$FAILED) { + s6 = peg$parseClassType(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + s5 = peg$currPos; + s6 = peg$parseIMPLEMENTS(); + if (s6 !== peg$FAILED) { + s7 = peg$parseClassTypeList(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 === peg$FAILED) { + s5 = null; + } + if (s5 !== peg$FAILED) { + s6 = peg$parseClassBody(); + if (s6 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c5(s2, s3, s4, s5, s6); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseClassBody() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseLWING(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseClassBodyDeclaration(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseClassBodyDeclaration(); + } + if (s2 !== peg$FAILED) { + s3 = peg$parseRWING(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c6(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseClassBodyDeclaration() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseSEMI(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c3(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSTATIC(); + if (s1 === peg$FAILED) { + s1 = null; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseBlock(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c7(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseModifier(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseModifier(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseMemberDecl(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c8(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + + return s0; + } + + function peg$parseMemberDecl() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseTypeParameters(); + if (s1 !== peg$FAILED) { + s2 = peg$parseGenericMethodOrConstructorRest(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c9(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseType(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseMethodDeclaratorRest(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c10(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseType(); + if (s1 !== peg$FAILED) { + s2 = peg$parseVariableDeclarators(); + if (s2 !== peg$FAILED) { + s3 = peg$parseSEMI(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c11(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseVOID(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseVoidMethodDeclaratorRest(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c12(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseConstructorDeclaratorRest(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c13(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseInterfaceDeclaration(); + if (s0 === peg$FAILED) { + s0 = peg$parseClassDeclaration(); + if (s0 === peg$FAILED) { + s0 = peg$parseEnumDeclaration(); + if (s0 === peg$FAILED) { + s0 = peg$parseAnnotationTypeDeclaration(); + } + } + } + } + } + } + } + } + + return s0; + } + + function peg$parseGenericMethodOrConstructorRest() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseType(); + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseVOID(); + if (s2 !== peg$FAILED) { + peg$savedPos = s1; + s2 = peg$c14(); + } + s1 = s2; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseMethodDeclaratorRest(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c15(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseConstructorDeclaratorRest(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c16(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseMethodDeclaratorRest() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseFormalParameters(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseTHROWS(); + if (s4 !== peg$FAILED) { + s5 = peg$parseClassTypeList(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseBlock(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parseSEMI(); + if (s5 !== peg$FAILED) { + peg$savedPos = s4; + s5 = peg$c17(s1, s2, s3); + } + s4 = s5; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c18(s1, s2, s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseVoidMethodDeclaratorRest() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseFormalParameters(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseTHROWS(); + if (s3 !== peg$FAILED) { + s4 = peg$parseClassTypeList(); + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseBlock(); + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseSEMI(); + if (s4 !== peg$FAILED) { + peg$savedPos = s3; + s4 = peg$c19(s1, s2); + } + s3 = s4; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c20(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseConstructorDeclaratorRest() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseFormalParameters(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseTHROWS(); + if (s3 !== peg$FAILED) { + s4 = peg$parseClassTypeList(); + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseBlock(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c21(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseInterfaceDeclaration() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$parseINTERFACE(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseTypeParameters(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parseEXTENDS(); + if (s5 !== peg$FAILED) { + s6 = peg$parseClassTypeList(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + s5 = peg$parseInterfaceBody(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c22(s2, s3, s4, s5); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseInterfaceBody() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseLWING(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseInterfaceBodyDeclaration(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseInterfaceBodyDeclaration(); + } + if (s2 !== peg$FAILED) { + s3 = peg$parseRWING(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c6(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseInterfaceBodyDeclaration() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseModifier(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseModifier(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseInterfaceMemberDecl(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c8(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSEMI(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c3(); + } + s0 = s1; + } + + return s0; + } + + function peg$parseInterfaceMemberDecl() { + var s0, s1, s2, s3; + + s0 = peg$parseInterfaceMethodOrFieldDecl(); + if (s0 === peg$FAILED) { + s0 = peg$parseInterfaceGenericMethodDecl(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseVOID(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseVoidInterfaceMethodDeclaratorRest(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c16(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseInterfaceDeclaration(); + if (s0 === peg$FAILED) { + s0 = peg$parseAnnotationTypeDeclaration(); + if (s0 === peg$FAILED) { + s0 = peg$parseClassDeclaration(); + if (s0 === peg$FAILED) { + s0 = peg$parseEnumDeclaration(); + } + } + } + } + } + } + + return s0; + } + + function peg$parseInterfaceMethodOrFieldDecl() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseType(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseInterfaceMethodOrFieldRest(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c23(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseInterfaceMethodOrFieldRest() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseConstantDeclaratorsRest(); + if (s1 !== peg$FAILED) { + s2 = peg$parseSEMI(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c24(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseInterfaceMethodDeclaratorRest(); + } + + return s0; + } + + function peg$parseInterfaceMethodDeclaratorRest() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseFormalParameters(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseTHROWS(); + if (s4 !== peg$FAILED) { + s5 = peg$parseClassTypeList(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseSEMI(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c25(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseInterfaceGenericMethodDecl() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseTypeParameters(); + if (s1 !== peg$FAILED) { + s2 = peg$parseType(); + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseVOID(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c26(s1); + } + s2 = s3; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseIdentifier(); + if (s3 !== peg$FAILED) { + s4 = peg$parseInterfaceMethodDeclaratorRest(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c27(s1, s2, s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseVoidInterfaceMethodDeclaratorRest() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseFormalParameters(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseTHROWS(); + if (s3 !== peg$FAILED) { + s4 = peg$parseClassTypeList(); + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSEMI(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c28(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseConstantDeclaratorsRest() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseConstantDeclaratorRest(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseConstantDeclarator(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseConstantDeclarator(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseConstantDeclarator() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseConstantDeclaratorRest(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c16(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseConstantDeclaratorRest() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseDim(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseDim(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseEQU(); + if (s2 !== peg$FAILED) { + s3 = peg$parseVariableInitializer(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c30(s1, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEnumDeclaration() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseENUM(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseIMPLEMENTS(); + if (s4 !== peg$FAILED) { + s5 = peg$parseClassTypeList(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseEnumBody(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c31(s2, s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEnumBody() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseLWING(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEnumConstants(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseCOMMA(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseEnumBodyDeclarations(); + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + s5 = peg$parseRWING(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c32(s2, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEnumConstants() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseEnumConstant(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseEnumConstant(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseEnumConstant(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEnumConstant() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseAnnotation(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseAnnotation(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseArguments(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseClassBody(); + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c33(s1, s2, s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEnumBodyDeclarations() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseSEMI(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseClassBodyDeclaration(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseClassBodyDeclaration(); + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c34(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLocalVariableDeclarationStatement() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseType(); + if (s2 !== peg$FAILED) { + s3 = peg$parseVariableDeclarators(); + if (s3 !== peg$FAILED) { + s4 = peg$parseSEMI(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c36(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseVariableDeclarators() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseVariableDeclarator(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseVariableDeclarator(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseVariableDeclarator(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseVariableDeclarator() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseEQU(); + if (s4 !== peg$FAILED) { + s5 = peg$parseVariableInitializer(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c37(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseFormalParameters() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseLPAR(); + if (s1 !== peg$FAILED) { + s2 = peg$parseFormalParameterList(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseRPAR(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c38(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseFormalParameter() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseType(); + if (s2 !== peg$FAILED) { + s3 = peg$parseVariableDeclaratorId(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c39(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLastFormalParameter() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseType(); + if (s2 !== peg$FAILED) { + s3 = peg$parseELLIPSIS(); + if (s3 !== peg$FAILED) { + s4 = peg$parseVariableDeclaratorId(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c40(s1, s2, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseFormalParameterList() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseFormalParameter(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseFormalParameter(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseFormalParameter(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseLastFormalParameter(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c41(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseLastFormalParameter(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c42(s1); + } + s0 = s1; + } + + return s0; + } + + function peg$parseVariableDeclaratorId() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c43(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseBlock() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseLWING(); + if (s1 !== peg$FAILED) { + s2 = peg$parseBlockStatements(); + if (s2 !== peg$FAILED) { + s3 = peg$parseRWING(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c44(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseBlockStatements() { + var s0, s1; + + s0 = []; + s1 = peg$parseBlockStatement(); + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parseBlockStatement(); + } + + return s0; + } + + function peg$parseBlockStatement() { + var s0, s1, s2; + + s0 = peg$parseLocalVariableDeclarationStatement(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseModifier(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseModifier(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseClassDeclaration(); + if (s2 === peg$FAILED) { + s2 = peg$parseEnumDeclaration(); + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c45(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseStatement(); + } + } + + return s0; + } + + function peg$parseStatement() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + + s0 = peg$parseBlock(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseASSERT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseCOLON(); + if (s4 !== peg$FAILED) { + s5 = peg$parseExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseSEMI(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c46(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseIF(); + if (s1 !== peg$FAILED) { + s2 = peg$parseParExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$parseStatement(); + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parseELSE(); + if (s5 !== peg$FAILED) { + s6 = peg$parseStatement(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c47(s2, s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseFOR(); + if (s1 !== peg$FAILED) { + s2 = peg$parseLPAR(); + if (s2 !== peg$FAILED) { + s3 = peg$parseForInit(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseSEMI(); + if (s4 !== peg$FAILED) { + s5 = peg$parseExpression(); + if (s5 === peg$FAILED) { + s5 = null; + } + if (s5 !== peg$FAILED) { + s6 = peg$parseSEMI(); + if (s6 !== peg$FAILED) { + s7 = peg$parseForUpdate(); + if (s7 === peg$FAILED) { + s7 = null; + } + if (s7 !== peg$FAILED) { + s8 = peg$parseRPAR(); + if (s8 !== peg$FAILED) { + s9 = peg$parseStatement(); + if (s9 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c48(s3, s5, s7, s9); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseFOR(); + if (s1 !== peg$FAILED) { + s2 = peg$parseLPAR(); + if (s2 !== peg$FAILED) { + s3 = peg$parseFormalParameter(); + if (s3 !== peg$FAILED) { + s4 = peg$parseCOLON(); + if (s4 !== peg$FAILED) { + s5 = peg$parseExpression(); + if (s5 !== peg$FAILED) { + s6 = peg$parseRPAR(); + if (s6 !== peg$FAILED) { + s7 = peg$parseStatement(); + if (s7 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c49(s3, s5, s7); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseWHILE(); + if (s1 !== peg$FAILED) { + s2 = peg$parseParExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$parseStatement(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c50(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDO(); + if (s1 !== peg$FAILED) { + s2 = peg$parseStatement(); + if (s2 !== peg$FAILED) { + s3 = peg$parseWHILE(); + if (s3 !== peg$FAILED) { + s4 = peg$parseParExpression(); + if (s4 !== peg$FAILED) { + s5 = peg$parseSEMI(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c51(s2, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseTRY(); + if (s1 !== peg$FAILED) { + s2 = peg$parseLPAR(); + if (s2 !== peg$FAILED) { + s3 = peg$parseResource(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = peg$parseSEMI(); + if (s6 !== peg$FAILED) { + s7 = peg$parseResource(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$parseSEMI(); + if (s6 !== peg$FAILED) { + s7 = peg$parseResource(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseSEMI(); + if (s5 === peg$FAILED) { + s5 = null; + } + if (s5 !== peg$FAILED) { + s6 = peg$parseRPAR(); + if (s6 !== peg$FAILED) { + s7 = peg$parseBlock(); + if (s7 !== peg$FAILED) { + s8 = []; + s9 = peg$parseCatch(); + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parseCatch(); + } + if (s8 !== peg$FAILED) { + s9 = peg$parseFinally(); + if (s9 === peg$FAILED) { + s9 = null; + } + if (s9 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c52(s3, s4, s7, s8, s9); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseTRY(); + if (s1 !== peg$FAILED) { + s2 = peg$parseBlock(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = []; + s5 = peg$parseCatch(); + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parseCatch(); + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parseFinally(); + if (s5 === peg$FAILED) { + s5 = null; + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s4 = peg$c53(s2, s4, s5); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseFinally(); + if (s4 !== peg$FAILED) { + peg$savedPos = s3; + s4 = peg$c54(s2, s4); + } + s3 = s4; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c55(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSWITCH(); + if (s1 !== peg$FAILED) { + s2 = peg$parseParExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$parseLWING(); + if (s3 !== peg$FAILED) { + s4 = peg$parseSwitchBlockStatementGroups(); + if (s4 !== peg$FAILED) { + s5 = peg$parseRWING(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c56(s2, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSYNCHRONIZED(); + if (s1 !== peg$FAILED) { + s2 = peg$parseParExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$parseBlock(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c57(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseRETURN(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExpression(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSEMI(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c58(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseTHROW(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$parseSEMI(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c59(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseBREAK(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSEMI(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c60(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseCONTINUE(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSEMI(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c61(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSEMI(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c62(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseStatementExpression(); + if (s1 !== peg$FAILED) { + s2 = peg$parseSEMI(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c63(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseCOLON(); + if (s2 !== peg$FAILED) { + s3 = peg$parseStatement(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c64(s1, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + + return s0; + } + + function peg$parseResource() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseType(); + if (s2 !== peg$FAILED) { + s3 = peg$parseVariableDeclaratorId(); + if (s3 !== peg$FAILED) { + s4 = peg$parseEQU(); + if (s4 !== peg$FAILED) { + s5 = peg$parseExpression(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c65(s1, s2, s3, s5); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseCatch() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + + s0 = peg$currPos; + s1 = peg$parseCATCH(); + if (s1 !== peg$FAILED) { + s2 = peg$parseLPAR(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$parseFINAL(); + if (s5 !== peg$FAILED) { + peg$savedPos = s4; + s5 = peg$c35(); + } + s4 = s5; + if (s4 === peg$FAILED) { + s4 = peg$parseAnnotation(); + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseFINAL(); + if (s5 !== peg$FAILED) { + peg$savedPos = s4; + s5 = peg$c35(); + } + s4 = s5; + if (s4 === peg$FAILED) { + s4 = peg$parseAnnotation(); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseType(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$currPos; + s7 = peg$parseOR(); + if (s7 !== peg$FAILED) { + s8 = peg$parseType(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$currPos; + s7 = peg$parseOR(); + if (s7 !== peg$FAILED) { + s8 = peg$parseType(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseVariableDeclaratorId(); + if (s6 !== peg$FAILED) { + s7 = peg$parseRPAR(); + if (s7 !== peg$FAILED) { + s8 = peg$parseBlock(); + if (s8 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c66(s3, s4, s5, s6, s8); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseFinally() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseFINALLY(); + if (s1 !== peg$FAILED) { + s2 = peg$parseBlock(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c67(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSwitchBlockStatementGroups() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseSwitchBlockStatementGroup(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseSwitchBlockStatementGroup(); + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c68(s1); + } + s0 = s1; + + return s0; + } + + function peg$parseSwitchBlockStatementGroup() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseSwitchLabel(); + if (s1 !== peg$FAILED) { + s2 = peg$parseBlockStatements(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c69(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSwitchLabel() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseCASE(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$parseCOLON(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c70(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseCASE(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseCOLON(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c70(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDEFAULT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseCOLON(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c3(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + + return s0; + } + + function peg$parseForInit() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parseFINAL(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c35(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$parseAnnotation(); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseType(); + if (s2 !== peg$FAILED) { + s3 = peg$parseVariableDeclarators(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c71(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseStatementExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseStatementExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseStatementExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c72(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseForUpdate() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseStatementExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseStatementExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseStatementExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c72(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseStatementExpression() { + var s0, s1; + + s0 = peg$currPos; + s1 = peg$parseExpression(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c73(s1); + } + s0 = s1; + + return s0; + } + + function peg$parseExpression() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseConditionalExpression(); + if (s1 !== peg$FAILED) { + s2 = peg$parseAssignmentOperator(); + if (s2 !== peg$FAILED) { + s3 = peg$parseExpression(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c74(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseConditionalExpression(); + } + + return s0; + } + + function peg$parseAssignmentOperator() { + var s0; + + s0 = peg$parseEQU(); + if (s0 === peg$FAILED) { + s0 = peg$parsePLUSEQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseMINUSEQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseSTAREQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseDIVEQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseANDEQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseOREQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseHATEQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseMODEQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseSLEQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseSREQU(); + if (s0 === peg$FAILED) { + s0 = peg$parseBSREQU(); + } + } + } + } + } + } + } + } + } + } + } + + return s0; + } + + function peg$parseConditionalExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseConditionalOrExpression(); + if (s1 !== peg$FAILED) { + s2 = peg$parseQUERY(); + if (s2 !== peg$FAILED) { + s3 = peg$parseExpression(); + if (s3 !== peg$FAILED) { + s4 = peg$parseCOLON(); + if (s4 !== peg$FAILED) { + s5 = peg$parseConditionalExpression(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c75(s1, s3, s5); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseConditionalOrExpression(); + } + + return s0; + } + + function peg$parseConditionalOrExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseConditionalAndExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseOROR(); + if (s4 !== peg$FAILED) { + s5 = peg$parseConditionalAndExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseOROR(); + if (s4 !== peg$FAILED) { + s5 = peg$parseConditionalAndExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c76(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseConditionalAndExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseInclusiveOrExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseANDAND(); + if (s4 !== peg$FAILED) { + s5 = peg$parseInclusiveOrExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseANDAND(); + if (s4 !== peg$FAILED) { + s5 = peg$parseInclusiveOrExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c76(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseInclusiveOrExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseExclusiveOrExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseOR(); + if (s4 !== peg$FAILED) { + s5 = peg$parseExclusiveOrExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseOR(); + if (s4 !== peg$FAILED) { + s5 = peg$parseExclusiveOrExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c76(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseExclusiveOrExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseAndExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseHAT(); + if (s4 !== peg$FAILED) { + s5 = peg$parseAndExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseHAT(); + if (s4 !== peg$FAILED) { + s5 = peg$parseAndExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c76(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseAndExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseEqualityExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseAND(); + if (s4 !== peg$FAILED) { + s5 = peg$parseEqualityExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseAND(); + if (s4 !== peg$FAILED) { + s5 = peg$parseEqualityExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c76(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEqualityExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseRelationalExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseEQUAL(); + if (s4 === peg$FAILED) { + s4 = peg$parseNOTEQUAL(); + } + if (s4 !== peg$FAILED) { + s5 = peg$parseRelationalExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseEQUAL(); + if (s4 === peg$FAILED) { + s4 = peg$parseNOTEQUAL(); + } + if (s4 !== peg$FAILED) { + s5 = peg$parseRelationalExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c76(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseRelationalExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseShiftExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseLE(); + if (s4 === peg$FAILED) { + s4 = peg$parseGE(); + if (s4 === peg$FAILED) { + s4 = peg$parseLT(); + if (s4 === peg$FAILED) { + s4 = peg$parseGT(); + } + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseShiftExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseINSTANCEOF(); + if (s4 !== peg$FAILED) { + s5 = peg$parseReferenceType(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseLE(); + if (s4 === peg$FAILED) { + s4 = peg$parseGE(); + if (s4 === peg$FAILED) { + s4 = peg$parseLT(); + if (s4 === peg$FAILED) { + s4 = peg$parseGT(); + } + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseShiftExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseINSTANCEOF(); + if (s4 !== peg$FAILED) { + s5 = peg$parseReferenceType(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c77(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseShiftExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseAdditiveExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseSL(); + if (s4 === peg$FAILED) { + s4 = peg$parseSR(); + if (s4 === peg$FAILED) { + s4 = peg$parseBSR(); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseAdditiveExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseSL(); + if (s4 === peg$FAILED) { + s4 = peg$parseSR(); + if (s4 === peg$FAILED) { + s4 = peg$parseBSR(); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseAdditiveExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c76(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseAdditiveExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseMultiplicativeExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parsePLUS(); + if (s4 === peg$FAILED) { + s4 = peg$parseMINUS(); + } + if (s4 !== peg$FAILED) { + s5 = peg$parseMultiplicativeExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parsePLUS(); + if (s4 === peg$FAILED) { + s4 = peg$parseMINUS(); + } + if (s4 !== peg$FAILED) { + s5 = peg$parseMultiplicativeExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c76(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseMultiplicativeExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseUnaryExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseSTAR(); + if (s4 === peg$FAILED) { + s4 = peg$parseDIV(); + if (s4 === peg$FAILED) { + s4 = peg$parseMOD(); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseUnaryExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseSTAR(); + if (s4 === peg$FAILED) { + s4 = peg$parseDIV(); + if (s4 === peg$FAILED) { + s4 = peg$parseMOD(); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseUnaryExpression(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c76(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseUnaryExpression() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parsePrefixOp(); + if (s1 !== peg$FAILED) { + s2 = peg$parseUnaryExpression(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c78(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseUnaryExpressionNotPlusMinus(); + } + + return s0; + } + + function peg$parseUnaryExpressionNotPlusMinus() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseCastExpression(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c79(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsePrimary(); + if (s1 !== peg$FAILED) { + s2 = peg$parseSelector(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parseSelector(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseSelector(); + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parsePostfixOp(); + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parsePostfixOp(); + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c80(s1, s2, s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsePrimary(); + if (s1 !== peg$FAILED) { + s2 = peg$parseSelector(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parseSelector(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseSelector(); + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c81(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsePrimary(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsePostfixOp(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsePostfixOp(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c82(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsePrimary(); + } + } + } + } + + return s0; + } + + function peg$parseCastExpression() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseLPAR(); + if (s1 !== peg$FAILED) { + s2 = peg$parseBasicType(); + if (s2 !== peg$FAILED) { + s3 = peg$parseRPAR(); + if (s3 !== peg$FAILED) { + s4 = peg$parseUnaryExpression(); + if (s4 !== peg$FAILED) { + s1 = [s1, s2, s3, s4]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseLPAR(); + if (s1 !== peg$FAILED) { + s2 = peg$parseReferenceType(); + if (s2 !== peg$FAILED) { + s3 = peg$parseRPAR(); + if (s3 !== peg$FAILED) { + s4 = peg$parseUnaryExpressionNotPlusMinus(); + if (s4 !== peg$FAILED) { + s1 = [s1, s2, s3, s4]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parsePrimary() { + var s0, s1, s2, s3, s4; + + s0 = peg$parseParExpression(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseNonWildcardTypeArguments(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExplicitGenericInvocationSuffix(); + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseTHIS(); + if (s3 !== peg$FAILED) { + s4 = peg$parseArguments(); + if (s4 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c83(s1, s4); + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c84(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseTHIS(); + if (s1 !== peg$FAILED) { + s2 = peg$parseArguments(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c85(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSUPER(); + if (s1 !== peg$FAILED) { + s2 = peg$parseSuperSuffix(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c86(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseLiteral(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseNEW(); + if (s1 !== peg$FAILED) { + s2 = peg$parseCreator(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c87(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseQualifiedIdentifierSuffix(); + if (s0 === peg$FAILED) { + s0 = peg$parseQualifiedIdentifier(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseBasicType(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + if (s2 !== peg$FAILED) { + s3 = peg$parseDOT(); + if (s3 !== peg$FAILED) { + s4 = peg$parseCLASS(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c88(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseVOID(); + if (s1 !== peg$FAILED) { + s2 = peg$parseDOT(); + if (s2 !== peg$FAILED) { + s3 = peg$parseCLASS(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c89(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + } + } + } + } + } + } + } + + return s0; + } + + function peg$parseQualifiedIdentifierSuffix() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseDOT(); + if (s3 !== peg$FAILED) { + s4 = peg$parseCLASS(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c90(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseLBRK(); + if (s2 !== peg$FAILED) { + s3 = peg$parseExpression(); + if (s3 !== peg$FAILED) { + s4 = peg$parseRBRK(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c91(s1, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseArguments(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c92(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseDOT(); + if (s2 !== peg$FAILED) { + s3 = peg$parseCLASS(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c93(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseDOT(); + if (s2 !== peg$FAILED) { + s3 = peg$parseExplicitGenericInvocation(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c94(s1, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseDOT(); + if (s2 !== peg$FAILED) { + s3 = peg$parseTHIS(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c95(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseDOT(); + if (s2 !== peg$FAILED) { + s3 = peg$parseSUPER(); + if (s3 !== peg$FAILED) { + s4 = peg$parseArguments(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c96(s1, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseDOT(); + if (s2 !== peg$FAILED) { + s3 = peg$parseNEW(); + if (s3 !== peg$FAILED) { + s4 = peg$parseNonWildcardTypeArguments(); + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + s5 = peg$parseInnerCreator(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c97(s1, s4, s5); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + } + } + } + } + } + + return s0; + } + + function peg$parseExplicitGenericInvocation() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseNonWildcardTypeArguments(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExplicitGenericInvocationSuffix(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c84(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseNonWildcardTypeArguments() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$parseLPOINT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseReferenceType(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$parseCOMMA(); + if (s5 !== peg$FAILED) { + s6 = peg$parseReferenceType(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseCOMMA(); + if (s5 !== peg$FAILED) { + s6 = peg$parseReferenceType(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseRPOINT(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseTypeArgumentsOrDiamond() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseLPOINT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseRPOINT(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c98(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseTypeArguments(); + } + + return s0; + } + + function peg$parseNonWildcardTypeArgumentsOrDiamond() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseLPOINT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseRPOINT(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseNonWildcardTypeArguments(); + } + + return s0; + } + + function peg$parseExplicitGenericInvocationSuffix() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseSUPER(); + if (s1 !== peg$FAILED) { + s2 = peg$parseSuperSuffix(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c99(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseArguments(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c100(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parsePrefixOp() { + var s0, s1; + + s0 = peg$currPos; + s1 = peg$parseINC(); + if (s1 === peg$FAILED) { + s1 = peg$parseDEC(); + if (s1 === peg$FAILED) { + s1 = peg$parseBANG(); + if (s1 === peg$FAILED) { + s1 = peg$parseTILDA(); + if (s1 === peg$FAILED) { + s1 = peg$parsePLUS(); + if (s1 === peg$FAILED) { + s1 = peg$parseMINUS(); + } + } + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c101(s1); + } + s0 = s1; + + return s0; + } + + function peg$parsePostfixOp() { + var s0, s1; + + s0 = peg$currPos; + s1 = peg$parseINC(); + if (s1 === peg$FAILED) { + s1 = peg$parseDEC(); + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c101(s1); + } + s0 = s1; + + return s0; + } + + function peg$parseSelector() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseDOT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseArguments(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c100(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDOT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c102(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDOT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExplicitGenericInvocation(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c103(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDOT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseTHIS(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c104(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDOT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseSUPER(); + if (s2 !== peg$FAILED) { + s3 = peg$parseSuperSuffix(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c99(s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDOT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseNEW(); + if (s2 !== peg$FAILED) { + s3 = peg$parseNonWildcardTypeArguments(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseInnerCreator(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c105(s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDimExpr(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c106(s1); + } + s0 = s1; + } + } + } + } + } + } + + return s0; + } + + function peg$parseSuperSuffix() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseArguments(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c107(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDOT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseNonWildcardTypeArguments(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseIdentifier(); + if (s3 !== peg$FAILED) { + s4 = peg$parseArguments(); + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c108(s2, s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseBasicType() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c109) { + s1 = peg$c109; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c110); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c111) { + s1 = peg$c111; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c112); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c113) { + s1 = peg$c113; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c114); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c115) { + s1 = peg$c115; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c116); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c117) { + s1 = peg$c117; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c118); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c119) { + s1 = peg$c119; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c120); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c121) { + s1 = peg$c121; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c122); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c123) { + s1 = peg$c123; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c124); + } + } + } + } + } + } + } + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c125(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseArguments() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseLPAR(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseExpression(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = peg$parseCOMMA(); + if (s6 !== peg$FAILED) { + s7 = peg$parseExpression(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$parseCOMMA(); + if (s6 !== peg$FAILED) { + s7 = peg$parseExpression(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c29(s3, s4); + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseRPAR(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c126(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseCreator() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseBasicType(); + if (s1 === peg$FAILED) { + s1 = peg$parseCreatedName(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseArrayCreatorRest(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c127(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseNonWildcardTypeArguments(); + if (s1 === peg$FAILED) { + s1 = null; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseCreatedName(); + if (s2 !== peg$FAILED) { + s3 = peg$parseClassCreatorRest(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c128(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseCreatedName() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseTypeArgumentsOrDiamond(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$parseDOT(); + if (s5 !== peg$FAILED) { + s6 = peg$parseIdentifier(); + if (s6 !== peg$FAILED) { + s7 = peg$parseTypeArgumentsOrDiamond(); + if (s7 === peg$FAILED) { + s7 = null; + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseDOT(); + if (s5 !== peg$FAILED) { + s6 = peg$parseIdentifier(); + if (s6 !== peg$FAILED) { + s7 = peg$parseTypeArgumentsOrDiamond(); + if (s7 === peg$FAILED) { + s7 = null; + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c129(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseInnerCreator() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseNonWildcardTypeArgumentsOrDiamond(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseClassCreatorRest(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c130(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseClassCreatorRest() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseArguments(); + if (s1 !== peg$FAILED) { + s2 = peg$parseClassBody(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c131(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseArrayCreatorRest() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseDim(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseDim(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseArrayInitializer(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c132(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseDimExpr(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseDimExpr(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c133(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDim(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c134(s1); + } + s0 = s1; + } + } + + return s0; + } + + function peg$parseArrayInitializer() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseLWING(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseVariableInitializer(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = peg$parseCOMMA(); + if (s6 !== peg$FAILED) { + s7 = peg$parseVariableInitializer(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$parseCOMMA(); + if (s6 !== peg$FAILED) { + s7 = peg$parseVariableInitializer(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$c29(s3, s4); + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseCOMMA(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseRWING(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c135(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseVariableInitializer() { + var s0; + + s0 = peg$parseArrayInitializer(); + if (s0 === peg$FAILED) { + s0 = peg$parseExpression(); + } + + return s0; + } + + function peg$parseParExpression() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseLPAR(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$parseRPAR(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c136(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseQualifiedIdentifier() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseDOT(); + if (s4 !== peg$FAILED) { + s5 = peg$parseIdentifier(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseDOT(); + if (s4 !== peg$FAILED) { + s5 = peg$parseIdentifier(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c137(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDim() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseLBRK(); + if (s1 !== peg$FAILED) { + s2 = peg$parseRBRK(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDimExpr() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseLBRK(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$parseRBRK(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c138(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseType() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseBasicType(); + if (s1 === peg$FAILED) { + s1 = peg$parseClassType(); + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c139(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseReferenceType() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseBasicType(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c140(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseClassType(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseDim(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseDim(); + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c141(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseClassType() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseQualifiedIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseTypeArguments(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$parseDOT(); + if (s5 !== peg$FAILED) { + s6 = peg$parseIdentifier(); + if (s6 !== peg$FAILED) { + s7 = peg$parseTypeArguments(); + if (s7 === peg$FAILED) { + s7 = null; + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseDOT(); + if (s5 !== peg$FAILED) { + s6 = peg$parseIdentifier(); + if (s6 !== peg$FAILED) { + s7 = peg$parseTypeArguments(); + if (s7 === peg$FAILED) { + s7 = null; + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c129(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseClassTypeList() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseClassType(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseClassType(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseClassType(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseTypeArguments() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$parseLPOINT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseTypeArgument(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$parseCOMMA(); + if (s5 !== peg$FAILED) { + s6 = peg$parseTypeArgument(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseCOMMA(); + if (s5 !== peg$FAILED) { + s6 = peg$parseTypeArgument(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseRPOINT(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseTypeArgument() { + var s0, s1, s2, s3, s4; + + s0 = peg$parseReferenceType(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseQUERY(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$parseEXTENDS(); + if (s4 !== peg$FAILED) { + peg$savedPos = s3; + s4 = peg$c142(); + } + s3 = s4; + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parseSUPER(); + if (s4 !== peg$FAILED) { + peg$savedPos = s3; + s4 = peg$c143(); + } + s3 = s4; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseReferenceType(); + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c144(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseTypeParameters() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$parseLPOINT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseTypeParameter(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$parseCOMMA(); + if (s5 !== peg$FAILED) { + s6 = peg$parseTypeParameter(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseCOMMA(); + if (s5 !== peg$FAILED) { + s6 = peg$parseTypeParameter(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseRPOINT(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseTypeParameter() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseEXTENDS(); + if (s3 !== peg$FAILED) { + s4 = peg$parseBound(); + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c145(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseBound() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseClassType(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseAND(); + if (s4 !== peg$FAILED) { + s5 = peg$parseClassType(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseAND(); + if (s4 !== peg$FAILED) { + s5 = peg$parseClassType(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseModifier() { + var s0, s1, s2, s3; + + s0 = peg$parseAnnotation(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.substr(peg$currPos, 6) === peg$c146) { + s1 = peg$c146; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c147); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c148) { + s1 = peg$c148; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c149); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c150) { + s1 = peg$c150; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c151); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c152) { + s1 = peg$c152; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c153); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c154) { + s1 = peg$c154; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c155); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c156) { + s1 = peg$c156; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c157); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c158) { + s1 = peg$c158; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c159); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 12) === peg$c160) { + s1 = peg$c160; + peg$currPos += 12; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c161); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c162) { + s1 = peg$c162; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c163); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c164) { + s1 = peg$c164; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c165); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c166) { + s1 = peg$c166; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c167); + } + } + } + } + } + } + } + } + } + } + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c168(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseAnnotationTypeDeclaration() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseAT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseINTERFACE(); + if (s2 !== peg$FAILED) { + s3 = peg$parseIdentifier(); + if (s3 !== peg$FAILED) { + s4 = peg$parseAnnotationTypeBody(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c169(s3, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseAnnotationTypeBody() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseLWING(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseAnnotationTypeElementDeclaration(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseAnnotationTypeElementDeclaration(); + } + if (s2 !== peg$FAILED) { + s3 = peg$parseRWING(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c170(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseAnnotationTypeElementDeclaration() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseModifier(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseModifier(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseAnnotationTypeElementRest(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c171(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSEMI(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c3(); + } + s0 = s1; + } + + return s0; + } + + function peg$parseAnnotationTypeElementRest() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseType(); + if (s1 !== peg$FAILED) { + s2 = peg$parseAnnotationMethodOrConstantRest(); + if (s2 !== peg$FAILED) { + s3 = peg$parseSEMI(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c172(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseClassDeclaration(); + if (s0 === peg$FAILED) { + s0 = peg$parseEnumDeclaration(); + if (s0 === peg$FAILED) { + s0 = peg$parseInterfaceDeclaration(); + if (s0 === peg$FAILED) { + s0 = peg$parseAnnotationTypeDeclaration(); + } + } + } + } + + return s0; + } + + function peg$parseAnnotationMethodOrConstantRest() { + var s0; + + s0 = peg$parseAnnotationMethodRest(); + if (s0 === peg$FAILED) { + s0 = peg$parseAnnotationConstantRest(); + } + + return s0; + } + + function peg$parseAnnotationMethodRest() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseLPAR(); + if (s2 !== peg$FAILED) { + s3 = peg$parseRPAR(); + if (s3 !== peg$FAILED) { + s4 = peg$parseDefaultValue(); + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c173(s1, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseAnnotationConstantRest() { + var s0, s1; + + s0 = peg$currPos; + s1 = peg$parseVariableDeclarators(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c174(s1); + } + s0 = s1; + + return s0; + } + + function peg$parseDefaultValue() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseDEFAULT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseElementValue(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c175(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseAnnotation() { + var s0; + + s0 = peg$parseNormalAnnotation(); + if (s0 === peg$FAILED) { + s0 = peg$parseSingleElementAnnotation(); + if (s0 === peg$FAILED) { + s0 = peg$parseMarkerAnnotation(); + } + } + + return s0; + } + + function peg$parseNormalAnnotation() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseAT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseQualifiedIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseLPAR(); + if (s3 !== peg$FAILED) { + s4 = peg$parseElementValuePairs(); + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + s5 = peg$parseRPAR(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c176(s2, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSingleElementAnnotation() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseAT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseQualifiedIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parseLPAR(); + if (s3 !== peg$FAILED) { + s4 = peg$parseElementValue(); + if (s4 !== peg$FAILED) { + s5 = peg$parseRPAR(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c177(s2, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseMarkerAnnotation() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseAT(); + if (s1 !== peg$FAILED) { + s2 = peg$parseQualifiedIdentifier(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c178(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseElementValuePairs() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseElementValuePair(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseElementValuePair(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseElementValuePair(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseElementValuePair() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEQU(); + if (s2 !== peg$FAILED) { + s3 = peg$parseElementValue(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c179(s1, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseElementValue() { + var s0; + + s0 = peg$parseConditionalExpression(); + if (s0 === peg$FAILED) { + s0 = peg$parseAnnotation(); + if (s0 === peg$FAILED) { + s0 = peg$parseElementValueArrayInitializer(); + } + } + + return s0; + } + + function peg$parseElementValueArrayInitializer() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseLWING(); + if (s1 !== peg$FAILED) { + s2 = peg$parseElementValues(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseCOMMA(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseRWING(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c180(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseElementValues() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseElementValue(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseElementValue(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parseCOMMA(); + if (s4 !== peg$FAILED) { + s5 = peg$parseElementValue(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c29(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSpacing() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = []; + s1 = []; + if (peg$c181.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c182); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$c181.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c182); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c183) { + s2 = peg$c183; + peg$currPos += 2; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c184); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.substr(peg$currPos, 2) === peg$c185) { + s6 = peg$c185; + peg$currPos += 2; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c186); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.substr(peg$currPos, 2) === peg$c185) { + s6 = peg$c185; + peg$currPos += 2; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c186); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c185) { + s4 = peg$c185; + peg$currPos += 2; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c186); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c187) { + s2 = peg$c187; + peg$currPos += 2; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c188); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (peg$c189.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c190); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (peg$c189.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c190); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + if (peg$c189.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c190); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + } + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = []; + if (peg$c181.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c182); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$c181.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c182); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c183) { + s2 = peg$c183; + peg$currPos += 2; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c184); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.substr(peg$currPos, 2) === peg$c185) { + s6 = peg$c185; + peg$currPos += 2; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c186); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.substr(peg$currPos, 2) === peg$c185) { + s6 = peg$c185; + peg$currPos += 2; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c186); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c185) { + s4 = peg$c185; + peg$currPos += 2; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c186); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c187) { + s2 = peg$c187; + peg$currPos += 2; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c188); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (peg$c189.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c190); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (peg$c189.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c190); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + if (peg$c189.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c190); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + } + } + + return s0; + } + + function peg$parseIdentifier() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parseKeyword(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseLetter(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = []; + s5 = peg$parseLetterOrDigit(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parseLetterOrDigit(); + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseSpacing(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c191(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLetter() { + var s0; + + if (peg$c192.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c193); + } + } + if (s0 === peg$FAILED) { + if (peg$c194.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c195); + } + } + if (s0 === peg$FAILED) { + if (peg$c196.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c197); + } + } + } + } + + return s0; + } + + function peg$parseLetterOrDigit() { + var s0; + + if (peg$c192.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c193); + } + } + if (s0 === peg$FAILED) { + if (peg$c194.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c195); + } + } + if (s0 === peg$FAILED) { + if (peg$c198.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c199); + } + } + if (s0 === peg$FAILED) { + if (peg$c196.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c197); + } + } + } + } + } + + return s0; + } + + function peg$parseKeyword() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 8) === peg$c154) { + s1 = peg$c154; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c155); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c200) { + s1 = peg$c200; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c201); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c123) { + s1 = peg$c123; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c124); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c202) { + s1 = peg$c202; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c203); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c109) { + s1 = peg$c109; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c110); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c204) { + s1 = peg$c204; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c205); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c206) { + s1 = peg$c206; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c207); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c113) { + s1 = peg$c113; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c114); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c208) { + s1 = peg$c208; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c209); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c210) { + s1 = peg$c210; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c211); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c212) { + s1 = peg$c212; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c213); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c214) { + s1 = peg$c214; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c215); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c121) { + s1 = peg$c121; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c122); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c216) { + s1 = peg$c216; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c217); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c218) { + s1 = peg$c218; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c219); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c220) { + s1 = peg$c220; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c221); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c222) { + s1 = peg$c222; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c223); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c224) { + s1 = peg$c224; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c225); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c226) { + s1 = peg$c226; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c227); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c156) { + s1 = peg$c156; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c157); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c119) { + s1 = peg$c119; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c120); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c228) { + s1 = peg$c228; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c229); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c230) { + s1 = peg$c230; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c231); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c232) { + s1 = peg$c232; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c233); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c234) { + s1 = peg$c234; + peg$currPos += 10; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c235); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c236) { + s1 = peg$c236; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c237); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c238) { + s1 = peg$c238; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c239); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c115) { + s1 = peg$c115; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c116); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr(peg$currPos, 10) === peg$c240 + ) { + s1 = peg$c240; + peg$currPos += 10; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c241); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr(peg$currPos, 4) === peg$c117 + ) { + s1 = peg$c117; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c118); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr(peg$currPos, 6) === peg$c158 + ) { + s1 = peg$c158; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c159); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr(peg$currPos, 3) === + peg$c242 + ) { + s1 = peg$c242; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c243); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr(peg$currPos, 4) === + peg$c244 + ) { + s1 = peg$c244; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c245); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr(peg$currPos, 7) === + peg$c246 + ) { + s1 = peg$c246; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c247); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr(peg$currPos, 7) === + peg$c150 + ) { + s1 = peg$c150; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c151); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr(peg$currPos, 9) === + peg$c148 + ) { + s1 = peg$c148; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c149); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr( + peg$currPos, + 6 + ) === peg$c146 + ) { + s1 = peg$c146; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c147); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr( + peg$currPos, + 6 + ) === peg$c248 + ) { + s1 = peg$c248; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c249); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr( + peg$currPos, + 5 + ) === peg$c111 + ) { + s1 = peg$c111; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if ( + peg$silentFails === 0 + ) { + peg$fail(peg$c112); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr( + peg$currPos, + 6 + ) === peg$c152 + ) { + s1 = peg$c152; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if ( + peg$silentFails === 0 + ) { + peg$fail(peg$c153); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr( + peg$currPos, + 8 + ) === peg$c166 + ) { + s1 = peg$c166; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail(peg$c167); + } + } + if (s1 === peg$FAILED) { + if ( + input.substr( + peg$currPos, + 5 + ) === peg$c250 + ) { + s1 = peg$c250; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c251 + ); + } + } + if ( + s1 === peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 6 + ) === peg$c252 + ) { + s1 = peg$c252; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c253 + ); + } + } + if ( + s1 === peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 12 + ) === peg$c160 + ) { + s1 = peg$c160; + peg$currPos += 12; + } else { + s1 = peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c161 + ); + } + } + if ( + s1 === + peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 4 + ) === peg$c254 + ) { + s1 = peg$c254; + peg$currPos += 4; + } else { + s1 = + peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c255 + ); + } + } + if ( + s1 === + peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 6 + ) === + peg$c256 + ) { + s1 = + peg$c256; + peg$currPos += 6; + } else { + s1 = + peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c257 + ); + } + } + if ( + s1 === + peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 5 + ) === + peg$c258 + ) { + s1 = + peg$c258; + peg$currPos += 5; + } else { + s1 = + peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c259 + ); + } + } + if ( + s1 === + peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 9 + ) === + peg$c162 + ) { + s1 = + peg$c162; + peg$currPos += 9; + } else { + s1 = + peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c163 + ); + } + } + if ( + s1 === + peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 4 + ) === + peg$c260 + ) { + s1 = + peg$c260; + peg$currPos += 4; + } else { + s1 = + peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c261 + ); + } + } + if ( + s1 === + peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 3 + ) === + peg$c262 + ) { + s1 = + peg$c262; + peg$currPos += 3; + } else { + s1 = + peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c263 + ); + } + } + if ( + s1 === + peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 4 + ) === + peg$c264 + ) { + s1 = + peg$c264; + peg$currPos += 4; + } else { + s1 = + peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c265 + ); + } + } + if ( + s1 === + peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 8 + ) === + peg$c164 + ) { + s1 = + peg$c164; + peg$currPos += 8; + } else { + s1 = + peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c165 + ); + } + } + if ( + s1 === + peg$FAILED + ) { + if ( + input.substr( + peg$currPos, + 5 + ) === + peg$c266 + ) { + s1 = + peg$c266; + peg$currPos += 5; + } else { + s1 = + peg$FAILED; + if ( + peg$silentFails === + 0 + ) { + peg$fail( + peg$c267 + ); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseASSERT() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 6) === peg$c200) { + s1 = peg$c200; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c201); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseBREAK() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c202) { + s1 = peg$c202; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c203); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseCASE() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c204) { + s1 = peg$c204; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c205); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseCATCH() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c206) { + s1 = peg$c206; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c207); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseCLASS() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c208) { + s1 = peg$c208; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c209); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseCONTINUE() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 8) === peg$c212) { + s1 = peg$c212; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c213); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDEFAULT() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 7) === peg$c214) { + s1 = peg$c214; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c215); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDO() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c216) { + s1 = peg$c216; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c217); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseELSE() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c218) { + s1 = peg$c218; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c219); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseENUM() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c220) { + s1 = peg$c220; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c221); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEXTENDS() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 7) === peg$c222) { + s1 = peg$c222; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c223); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseFINALLY() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 7) === peg$c226) { + s1 = peg$c226; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c227); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseFINAL() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c156) { + s1 = peg$c156; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c157); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseFOR() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c228) { + s1 = peg$c228; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c229); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseIF() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c232) { + s1 = peg$c232; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c233); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseIMPLEMENTS() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 10) === peg$c234) { + s1 = peg$c234; + peg$currPos += 10; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c235); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseIMPORT() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 6) === peg$c236) { + s1 = peg$c236; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c237); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseINTERFACE() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 9) === peg$c238) { + s1 = peg$c238; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c239); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseINSTANCEOF() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 10) === peg$c240) { + s1 = peg$c240; + peg$currPos += 10; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c241); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseNEW() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c242) { + s1 = peg$c242; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c243); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parsePACKAGE() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 7) === peg$c246) { + s1 = peg$c246; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c247); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseRETURN() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 6) === peg$c248) { + s1 = peg$c248; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c249); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSTATIC() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 6) === peg$c152) { + s1 = peg$c152; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c153); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSUPER() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c250) { + s1 = peg$c250; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c251); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSWITCH() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 6) === peg$c252) { + s1 = peg$c252; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c253); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSYNCHRONIZED() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 12) === peg$c160) { + s1 = peg$c160; + peg$currPos += 12; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c161); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseTHIS() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c254) { + s1 = peg$c254; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c255); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseTHROWS() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 6) === peg$c256) { + s1 = peg$c256; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c257); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseTHROW() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c258) { + s1 = peg$c258; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c259); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseTRY() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c262) { + s1 = peg$c262; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c263); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseVOID() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c264) { + s1 = peg$c264; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c265); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseWHILE() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c266) { + s1 = peg$c266; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c267); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLiteral() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parseFloatLiteral(); + if (s1 === peg$FAILED) { + s1 = peg$parseIntegerLiteral(); + if (s1 === peg$FAILED) { + s1 = peg$parseCharLiteral(); + if (s1 === peg$FAILED) { + s1 = peg$parseStringLiteral(); + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c260) { + s2 = peg$c260; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c261); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s2 = peg$c268(); + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c224) { + s2 = peg$c224; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c225); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s2 = peg$c269(); + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c244) { + s2 = peg$c244; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c245); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parseLetterOrDigit(); + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s2 = peg$c270(); + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + } + } + } + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c271(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseIntegerLiteral() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseHexNumeral(); + if (s1 === peg$FAILED) { + s1 = peg$parseBinaryNumeral(); + if (s1 === peg$FAILED) { + s1 = peg$parseOctalNumeral(); + if (s1 === peg$FAILED) { + s1 = peg$parseDecimalNumeral(); + } + } + } + if (s1 !== peg$FAILED) { + if (peg$c272.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c273); + } + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c274(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDecimalNumeral() { + var s0, s1, s2, s3, s4, s5; + + if (input.charCodeAt(peg$currPos) === 48) { + s0 = peg$c275; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c276); + } + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (peg$c277.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c278); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s4 !== peg$FAILED) { + if (peg$c198.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c199); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s4 !== peg$FAILED) { + if (peg$c198.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c199); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseHexNumeral() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c281) { + s1 = peg$c281; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c282); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c283) { + s1 = peg$c283; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c284); + } + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseHexDigits(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseBinaryNumeral() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c285) { + s1 = peg$c285; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c286); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c287) { + s1 = peg$c287; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c288); + } + } + } + if (s1 !== peg$FAILED) { + if (peg$c289.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c290); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$c279.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s5 !== peg$FAILED) { + if (peg$c289.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c290); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$c279.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s5 !== peg$FAILED) { + if (peg$c289.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c290); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseOctalNumeral() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 48) { + s1 = peg$c275; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c276); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s4 !== peg$FAILED) { + if (peg$c291.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c292); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s4 !== peg$FAILED) { + if (peg$c291.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c292); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseFloatLiteral() { + var s0, s1; + + s0 = peg$currPos; + s1 = peg$parseHexFloat(); + if (s1 === peg$FAILED) { + s1 = peg$parseDecimalFloat(); + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c274(); + } + s0 = s1; + + return s0; + } + + function peg$parseDecimalFloat() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseDigits(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s2 = peg$c293; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c294); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parseDigits(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseExponent(); + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + if (peg$c295.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c296); + } + } + if (s5 === peg$FAILED) { + s5 = null; + } + if (s5 !== peg$FAILED) { + s1 = [s1, s2, s3, s4, s5]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s1 = peg$c293; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c294); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseDigits(); + if (s2 !== peg$FAILED) { + s3 = peg$parseExponent(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + if (peg$c295.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c296); + } + } + if (s4 === peg$FAILED) { + s4 = null; + } + if (s4 !== peg$FAILED) { + s1 = [s1, s2, s3, s4]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDigits(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExponent(); + if (s2 !== peg$FAILED) { + if (peg$c295.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c296); + } + } + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseDigits(); + if (s1 !== peg$FAILED) { + s2 = peg$parseExponent(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + if (peg$c295.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c296); + } + } + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + } + + return s0; + } + + function peg$parseExponent() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (peg$c297.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c298); + } + } + if (s1 !== peg$FAILED) { + if (peg$c299.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c300); + } + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseDigits(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseHexFloat() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parseHexSignificand(); + if (s1 !== peg$FAILED) { + s2 = peg$parseBinaryExponent(); + if (s2 !== peg$FAILED) { + if (peg$c295.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c296); + } + } + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseHexSignificand() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c281) { + s1 = peg$c281; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c282); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c283) { + s1 = peg$c283; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c284); + } + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseHexDigits(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c293; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c294); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseHexDigits(); + if (s4 !== peg$FAILED) { + s1 = [s1, s2, s3, s4]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseHexNumeral(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s2 = peg$c293; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c294); + } + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseBinaryExponent() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (peg$c301.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c302); + } + } + if (s1 !== peg$FAILED) { + if (peg$c299.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c300); + } + } + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseDigits(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDigits() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + if (peg$c198.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c199); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s4 !== peg$FAILED) { + if (peg$c198.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c199); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s4 !== peg$FAILED) { + if (peg$c198.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c199); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseHexDigits() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$parseHexDigit(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseHexDigit(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = []; + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$c279.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c280); + } + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseHexDigit(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseHexDigit() { + var s0; + + if (peg$c303.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c304); + } + } + if (s0 === peg$FAILED) { + if (peg$c305.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c306); + } + } + if (s0 === peg$FAILED) { + if (peg$c198.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c199); + } + } + } + } + + return s0; + } + + function peg$parseCharLiteral() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 39) { + s1 = peg$c307; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c308); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseEscape(); + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$currPos; + peg$silentFails++; + if (peg$c309.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c310); + } + } + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 39) { + s3 = peg$c307; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c308); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c311(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseStringLiteral() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 34) { + s1 = peg$c312; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c313); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseEscape(); + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + if (peg$c314.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c315); + } + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parse_(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseEscape(); + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + if (peg$c314.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c315); + } + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parse_(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 34) { + s3 = peg$c312; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c313); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c316(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEscape() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c317; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c318); + } + } + if (s1 !== peg$FAILED) { + if (peg$c319.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c320); + } + } + if (s2 === peg$FAILED) { + s2 = peg$parseOctalEscape(); + if (s2 === peg$FAILED) { + s2 = peg$parseUnicodeEscape(); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseOctalEscape() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (peg$c321.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c322); + } + } + if (s1 !== peg$FAILED) { + if (peg$c291.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c292); + } + } + if (s2 !== peg$FAILED) { + if (peg$c291.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c292); + } + } + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (peg$c291.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c292); + } + } + if (s1 !== peg$FAILED) { + if (peg$c291.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c292); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + if (peg$c291.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c292); + } + } + } + } + + return s0; + } + + function peg$parseUnicodeEscape() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 117) { + s2 = peg$c323; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c324); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 117) { + s2 = peg$c323; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c324); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseHexDigit(); + if (s2 !== peg$FAILED) { + s3 = peg$parseHexDigit(); + if (s3 !== peg$FAILED) { + s4 = peg$parseHexDigit(); + if (s4 !== peg$FAILED) { + s5 = peg$parseHexDigit(); + if (s5 !== peg$FAILED) { + s1 = [s1, s2, s3, s4, s5]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseAT() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 64) { + s1 = peg$c325; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c326); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseAND() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 38) { + s1 = peg$c327; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c328); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (peg$c329.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c330); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseANDAND() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c331) { + s1 = peg$c331; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c332); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseANDEQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c333) { + s1 = peg$c333; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c334); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseBANG() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c335; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c336); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 61) { + s3 = peg$c337; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c338); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseBSR() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c339) { + s1 = peg$c339; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c340); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 61) { + s3 = peg$c337; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c338); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseBSREQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c341) { + s1 = peg$c341; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c342); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseCOLON() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 58) { + s1 = peg$c343; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c344); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseCOMMA() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s1 = peg$c345; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c346); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDEC() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c347) { + s1 = peg$c347; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c348); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDIV() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s1 = peg$c349; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c350); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 61) { + s3 = peg$c337; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c338); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDIVEQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c351) { + s1 = peg$c351; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c352); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseDOT() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s1 = peg$c293; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c294); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseELLIPSIS() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c353) { + s1 = peg$c353; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c354); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEQU() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 61) { + s1 = peg$c337; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c338); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 61) { + s3 = peg$c337; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c338); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEQUAL() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c355) { + s1 = peg$c355; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c356); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseGE() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c357) { + s1 = peg$c357; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c358); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseGT() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 62) { + s1 = peg$c359; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c360); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (peg$c361.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c362); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseHAT() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 94) { + s1 = peg$c363; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c364); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 61) { + s3 = peg$c337; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c338); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseHATEQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c365) { + s1 = peg$c365; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c366); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseINC() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c367) { + s1 = peg$c367; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c368); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLBRK() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 91) { + s1 = peg$c369; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c370); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLE() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c371) { + s1 = peg$c371; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c372); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLPAR() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 40) { + s1 = peg$c373; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c374); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLPOINT() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 60) { + s1 = peg$c375; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c376); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLT() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 60) { + s1 = peg$c375; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c376); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (peg$c377.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c378); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseLWING() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c379; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c380); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseMINUS() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 45) { + s1 = peg$c381; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c382); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (peg$c383.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c384); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseMINUSEQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c385) { + s1 = peg$c385; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c386); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseMOD() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 37) { + s1 = peg$c387; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c388); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 61) { + s3 = peg$c337; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c338); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseMODEQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c389) { + s1 = peg$c389; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c390); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseNOTEQUAL() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c391) { + s1 = peg$c391; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c392); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseOR() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 124) { + s1 = peg$c393; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c394); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (peg$c395.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c396); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseOREQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c397) { + s1 = peg$c397; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c398); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseOROR() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c399) { + s1 = peg$c399; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c400); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parsePLUS() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + s1 = peg$c401; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c402); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (peg$c403.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c404); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parsePLUSEQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c405) { + s1 = peg$c405; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c406); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseQUERY() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 63) { + s1 = peg$c407; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c408); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseRBRK() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 93) { + s1 = peg$c409; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c410); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseRPAR() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 41) { + s1 = peg$c411; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c412); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseRPOINT() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 62) { + s1 = peg$c359; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c360); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseRWING() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 125) { + s1 = peg$c413; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c414); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSEMI() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s1 = peg$c415; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c416); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSL() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c417) { + s1 = peg$c417; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c418); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 61) { + s3 = peg$c337; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c338); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSLEQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c419) { + s1 = peg$c419; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c420); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSR() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c421) { + s1 = peg$c421; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c422); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (peg$c361.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c362); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSREQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c423) { + s1 = peg$c423; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c424); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSTAR() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 42) { + s1 = peg$c425; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c426); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 61) { + s3 = peg$c337; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c338); + } + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSpacing(); + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSTAREQU() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c427) { + s1 = peg$c427; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c428); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseTILDA() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 126) { + s1 = peg$c429; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c430); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseSpacing(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseEOT() { + var s0, s1; + + s0 = peg$currPos; + peg$silentFails++; + s1 = peg$parse_(); + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parse_() { + var s0; + + if (input.length > peg$currPos) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$c431); + } + } + + return s0; + } + + function extractOptional(optional, index, def) { + def = typeof def !== 'undefined' ? def : null; + return optional ? optional[index] : def; + } + + function extractList(list, index) { + var result = new Array(list.length), + i; + + for (i = 0; i < list.length; i++) { + result[i] = list[i][index]; + } + + return result; + } + + function buildList(first, rest, index) { + return [first].concat(extractList(rest, index)); + } + + function buildTree(first, rest, builder) { + var result = first, + i; + + for (i = 0; i < rest.length; i++) { + result = builder(result, rest[i]); + } + + return result; + } + + function buildInfixExpr(first, rest) { + return buildTree(first, rest, function (result, element) { + return { + node: 'InfixExpression', + operator: element[0][0], // remove ending Spacing + leftOperand: result, + rightOperand: element[1] + }; + }); + } + + function buildQualified(first, rest, index) { + return buildTree(first, rest, function (result, element) { + return { + node: 'QualifiedName', + qualifier: result, + name: element[index] + }; + }); + } + + function popQualified(tree) { + return tree.node === 'QualifiedName' + ? { name: tree.name, expression: tree.qualifier } + : { name: tree, expression: null }; + } + + function extractThrowsClassType(list) { + return list.map(function (node) { + return node.name; + }); + } + + function extractExpressions(list) { + return list.map(function (node) { + return node.expression; + }); + } + + function buildArrayTree(first, rest) { + return buildTree(first, rest, function (result, element) { + return { + node: 'ArrayType', + componentType: result + }; + }); + } + + function optionalList(value) { + return value !== null ? value : []; + } + + function extractOptionalList(list, index) { + return optionalList(extractOptional(list, index)); + } + + function skipNulls(list) { + return list.filter(function (v) { + return v !== null; + }); + } + + function makePrimitive(code) { + return { + node: 'PrimitiveType', + primitiveTypeCode: code + }; + } + + function makeModifier(keyword) { + return { + node: 'Modifier', + keyword: keyword + }; + } + + function makeCatchFinally(catchClauses, finallyBlock) { + return { + catchClauses: catchClauses, + finally: finallyBlock + }; + } + + function buildTypeName(qual, args, rest) { + var first = + args === null + ? { + node: 'SimpleType', + name: qual + } + : { + node: 'ParameterizedType', + type: { + node: 'SimpleType', + name: qual + }, + typeArguments: args + }; + + return buildTree(first, rest, function (result, element) { + var args = element[2]; + return args === null + ? { + node: 'QualifiedType', + name: element[1], + qualifier: result + } + : { + node: 'ParameterizedType', + type: { + node: 'QualifiedType', + name: element[1], + qualifier: result + }, + typeArguments: args + }; + }); + } + + function mergeProps(obj, props) { + var key; + for (key in props) { + if (props.hasOwnProperty(key)) { + if (obj.hasOwnProperty(key)) { + throw new Error( + 'Property ' + + key + + ' exists ' + + line() + + '\n' + + text() + + '\nCurrent value: ' + + JSON.stringify(obj[key], null, 2) + + '\nNew value: ' + + JSON.stringify(props[key], null, 2) + ); + } else { + obj[key] = props[key]; + } + } + } + return obj; + } + + function buildSelectorTree(arg, sel, sels) { + function getMergeVal(o, v) { + switch (o.node) { + case 'SuperFieldAccess': + case 'SuperMethodInvocation': + return { qualifier: v }; + case 'ArrayAccess': + return { array: v }; + default: + return { expression: v }; + } + } + return buildTree(mergeProps(sel, getMergeVal(sel, arg)), sels, function (result, element) { + return mergeProps(element, getMergeVal(element, result)); + }); + } + + function TODO() { + throw new Error('TODO: not impl line ' + line() + '\n' + text()); + } + + peg$result = peg$startRuleFunction(); + + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length + ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) + : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + })(); + + var p5_options = { + globalScope: 'p5', + globalVars: { + // Map methods + pushMatrix: 'push', + popMatrix: 'pop', + size: 'createCanvas', + println: 'print', + PVector: 'Vector', + + // Fix literal methods + int$: 'int', + float$: 'float', + byte$: 'byte', + char$: 'char', + boolean$: 'boolean', + + // Methods + alpha: true, + blue: true, + brightness: true, + color: true, + green: true, + hue: true, + lerpColor: true, + lightness: true, + red: true, + saturation: true, + background: true, + clear: true, + colorMode: true, + fill: true, + noFill: true, + noStroke: true, + stroke: true, + arc: true, + ellipse: true, + line: true, + point: true, + quad: true, + rect: true, + triangle: true, + ellipseMode: true, + noSmooth: true, + rectMode: true, + smooth: true, + strokeCap: true, + strokeJoin: true, + strokeWeight: true, + bezier: true, + bezierDetail: true, + bezierPoint: true, + bezierTangent: true, + curve: true, + curveDetail: true, + curveTightness: true, + curvePoint: true, + curveTangent: true, + beginContour: true, + beginShape: true, + bezierVertex: true, + curveVertex: true, + endContour: true, + endShape: true, + quadraticVertex: true, + vertex: true, + loadModel: true, + model: true, + plane: true, + box: true, + sphere: true, + cylinder: true, + cone: true, + ellipsoid: true, + torus: true, + preload: true, + setup: true, + draw: true, + remove: true, + noLoop: true, + loop: true, + redraw: true, + print: true, + cursor: true, + frameRate: true, + noCursor: true, + windowResized: true, + fullscreen: true, + pixelDensity: true, + displayDensity: true, + getURL: true, + getURLPath: true, + getURLParams: true, + resizeCanvas: true, + noCanvas: true, + createGraphics: true, + blendMode: true, + setAttributes: true, + applyMatrix: true, + resetMatrix: true, + rotate: true, + rotateX: true, + rotateY: true, + rotateZ: true, + scale: true, + shearX: true, + shearY: true, + translate: true, + createStringDict: true, + createNumberDict: true, + append: true, + arrayCopy: true, + concat: true, + reverse: true, + shorten: true, + shuffle: true, + sort: true, + splice: true, + subset: true, + float: true, + int: true, + str: true, + boolean: true, + byte: true, + char: true, + unchar: true, + hex: true, + unhex: true, + join: true, + match: true, + matchAll: true, + nf: true, + nfc: true, + nfp: true, + nfs: true, + split: true, + splitTokens: true, + trim: true, + setMoveThreshold: true, + setShakeThreshold: true, + deviceMoved: true, + deviceTurned: true, + deviceShaken: true, + keyPressed: true, + keyReleased: true, + keyTyped: true, + keyIsDown: true, + mouseMoved: true, + mouseDragged: true, + mousePressed: true, + mouseReleased: true, + mouseClicked: true, + doubleClicked: true, + mouseWheel: true, + touchStarted: true, + touchMoved: true, + touchEnded: true, + createImage: true, + saveCanvas: true, + saveFrames: true, + loadImage: true, + image: true, + tint: true, + noTint: true, + imageMode: true, + blend: true, + copy: true, + filter: true, + get: true, + loadPixels: true, + set: true, + updatePixels: true, + loadJSON: true, + loadStrings: true, + loadTable: true, + loadXML: true, + loadBytes: true, + httpGet: true, + httpPost: true, + httpDo: true, + createWriter: true, + save: true, + saveJSON: true, + saveStrings: true, + saveTable: true, + day: true, + hour: true, + minute: true, + millis: true, + month: true, + second: true, + year: true, + createVector: true, + abs: true, + ceil: true, + constrain: true, + dist: true, + exp: true, + floor: true, + lerp: true, + log: true, + mag: true, + map: true, + max: true, + min: true, + norm: true, + pow: true, + round: true, + sq: true, + sqrt: true, + noise: true, + noiseDetail: true, + noiseSeed: true, + randomSeed: true, + random: true, + randomGaussian: true, + acos: true, + asin: true, + atan: true, + atan2: true, + cos: true, + sin: true, + tan: true, + degrees: true, + radians: true, + angleMode: true, + textAlign: true, + textLeading: true, + textSize: true, + textStyle: true, + textWidth: true, + textAscent: true, + textDescent: true, + loadFont: true, + text: true, + textFont: true, + camera: true, + perspective: true, + ortho: true, + orbitControl: true, + ambientLight: true, + directionalLight: true, + pointLight: true, + loadShader: true, + createShader: true, + shader: true, + normalMaterial: true, + texture: true, + ambientMaterial: true, + specularMaterial: true, + + // Classes + Graphics: true, + Vector3: true, + + // Constants + P2D: true, + WEBGL: true, + ARROW: true, + CROSS: true, + HAND: true, + MOVE: true, + TEXT: true, + WAIT: true, + HALF_PI: true, + PI: true, + QUARTER_PI: true, + TAU: true, + TWO_PI: true, + DEGREES: true, + RADIANS: true, + DEG_TO_RAD: true, + RAD_TO_DEG: true, + CORNER: true, + CORNERS: true, + RADIUS: true, + RIGHT: true, + LEFT: true, + CENTER: true, + TOP: true, + BOTTOM: true, + BASELINE: true, + POINTS: true, + LINES: true, + LINE_STRIP: true, + LINE_LOOP: true, + TRIANGLES: true, + TRIANGLE_FAN: true, + TRIANGLE_STRIP: true, + QUADS: true, + QUAD_STRIP: true, + CLOSE: true, + OPEN: true, + CHORD: true, + PIE: true, + PROJECT: true, + SQUARE: true, + ROUND: true, + BEVEL: true, + MITER: true, + RGB: true, + HSB: true, + HSL: true, + AUTO: true, + ALT: true, + BACKSPACE: true, + CONTROL: true, + DELETE: true, + DOWN_ARROW: true, + ENTER: true, + ESCAPE: true, + LEFT_ARROW: true, + OPTION: true, + RETURN: true, + RIGHT_ARROW: true, + SHIFT: true, + TAB: true, + UP_ARROW: true, + BLEND: true, + ADD: true, + DARKEST: true, + LIGHTEST: true, + DIFFERENCE: true, + EXCLUSION: true, + MULTIPLY: true, + SCREEN: true, + REPLACE: true, + OVERLAY: true, + HARD_LIGHT: true, + SOFT_LIGHT: true, + DODGE: true, + BURN: true, + THRESHOLD: true, + GRAY: true, + OPAQUE: true, + INVERT: true, + POSTERIZE: true, + DILATE: true, + ERODE: true, + BLUR: true, + NORMAL: true, + ITALIC: true, + BOLD: true, + LINEAR: true, + QUADRATIC: true, + BEZIER: true, + CURVE: true, + STROKE: true, + FILL: true, + TEXTURE: true, + IMMEDIATE: true, + NEAREST: true, + REPEAT: true, + CLAMP: true, + MIRROR: true, + LANDSCAPE: true, + PORTRAIT: true, + GRID: true, + AXES: true, + + // Variables + frameCount: true, + focused: true, + Color: true, + displayWidth: true, + displayHeight: true, + windowWidth: true, + windowHeight: true, + width: true, + height: true, + deviceOrientation: true, + accelerationX: true, + accelerationY: true, + accelerationZ: true, + pAccelerationX: true, + pAccelerationY: true, + pAccelerationZ: true, + rotationX: true, + rotationY: true, + rotationZ: true, + pRotationX: true, + pRotationY: true, + pRotationZ: true, + turnAxis: true, + keyIsPressed: true, + key: true, + keyCode: true, + mouseX: true, + mouseY: true, + pmouseX: true, + pmouseY: true, + winMouseX: true, + winMouseY: true, + pwinMouseX: true, + pwinMouseY: true, + mouseButton: true, + mouseIsPressed: true, + touches: true, + pixels: true + } + }; + + /** + * @module java-to-javascript + */ + + // const beautify = require('js-beautify').js; + const beautify$2 = beautify.js_beautify; + + const DEFAULT_OPTIONS = { + globalVars: {}, + globalScope: null, + separator: '\n\n' + }; + const opts = {}; + + const literalInitializers = { + int: '0', + float: '0', + double: '0', + short: '0', + long: '0', + char: "''", + boolean: 'false' + }; + + const SEP = '$'; + + const unhandledNode = (node, more = '') => { + console.error(`Unhandled node: ${node.node}. ${more}`); + return ''; + }; + + const joinStatements = (stats) => `${stats.join(';')}${stats.length ? ';' : ''}`; + + let variableTypes = {}; + + const varToString = ({ name, value, type, final }, noLet) => { + if (value === undefined) value = literalInitializers[type] || 'null'; + variableTypes[name] = type; + return `${noLet !== true ? (final ? 'const ' : 'let ') : ''}${name} = ${value}`; + }; + + const parseType = (type) => { + if (type.node === 'ArrayType') return 'Array'; + // Doesn't matter what we return, we don't use it + else if (type.node === 'SimpleType') return type.name.identifier; + else if (type.node === 'PrimitiveType') return type.primitiveTypeCode; + else if (type.node === 'ParameterizedType') return parseType(type.type); + else return unhandledNode(type); + }; + + const parseModifiers = (modifiers) => { + const mods = {}; + for (const mod of modifiers) { + mods[mod.keyword] = true; + } + return mods; + }; + + const parseClass = (class_, isGlobal) => { + const modifiers = parseModifiers(class_.modifiers); + if (modifiers.abstract || class_.interface) return { abstract: true }; + + const classData = { + name: class_.name.identifier, + superclass: class_.superclassType && parseType(class_.superclassType), + classes: [], + vars: [], + methods: [] + }; + const classVarsMap = {}; + + let asyncMethods = { + Scanner: [ + 'hasNext', + 'hasNextLine', + 'next', + 'nextLine', + 'nextInt', + 'nextShort', + 'nextLong', + 'nextFloat', + 'nextDouble' + ], + Thread: ['sleep'] + }; + if (typeof QuintOS != 'undefined') { + Object.assign(asyncMethods, { + Sprite: ['move'], + window: ['alert', 'delay', 'eraseRect', 'frame', 'play', 'prompt', 'text', 'textRect'] + }); + } + if (!asyncMethods.window) asyncMethods.window = []; + + const assignParent = (name, isInConstructor) => { + if (name in classVarsMap) { + let v = classData.vars.find((x) => x.name == name); + if (!isInConstructor && (!v || !v.static)) { + return `this.${name}`; + } else if (v.static) { + return `${classData.name}.${name}`; + } else { + return name; + } + } + const mapped = opts.globalVars[name]; + if (mapped) { + const newName = typeof mapped === 'string' ? mapped : name; + return opts.globalScope ? `${opts.globalScope}.${newName}` : newName; + } + return name; + }; + + const parseExpr = (expr) => { + if (!expr) return undefined; + + switch (expr.node) { + case 'ThisExpression': + return 'this'; + case 'NullLiteral': + return 'null'; + case 'BooleanLiteral': + return expr.booleanValue; + case 'NumberLiteral': + let num = expr.token; + num = num.replace(/_/g, ''); + if (/^0\d+$/.test(num)) num = '0o' + num.substring(1); + else if (/[lfd]$/i.test(num)) num = num.slice(0, -1); + return num; + case 'StringLiteral': + return expr.escapedValue.replace(/'/g, "\\'").replace(/"/g, "'"); + case 'CharacterLiteral': + const char = expr.escapedValue.slice(1, -1); + if (char.length === 1) return "'" + char + "'"; + else if (char.startsWith('\\u')) return parseInt(char.substring(2), 16).toString(); + else return unhandledNode(expr, 'Weird char: ' + char); + case 'CastExpression': + let exp = parseExpr(expr.expression); + let type; + if (expr.expression.node == 'SimpleName') { + type = variableTypes[expr.expression.identifier]; + } else if (expr.expression.node == 'CharacterLiteral') { + type = 'char'; + } else if (expr.expression.node == 'NumberLiteral') { + type = 'double'; + } else if (expr.expression.node == 'StringLiteral') { + type = 'String'; + } + let castError = false; + let cast = expr.type.primitiveTypeCode; + if (cast == 'int') { + // if cast to int + if (type == 'String') { + castError = true; + } else if (type == 'char') { + exp += '.charCodeAt(0)'; + } else { + exp = 'Math.floor(' + exp + ')'; + } + } else if (cast == 'char') { + if (type == 'String') { + castError = true; + } else { + exp = 'String.fromCharCode(' + exp + ')'; + } + } + if (castError) { + let msg = `error: incompatible types: ${type} cannot be converted to ${cast}: ${exp}`; + console.log(msg); + System.err.println(msg); + return ''; + } + return exp; + case 'ConditionalExpression': + return `${parseExpr(expr.expression)} ? ${parseExpr(expr.thenExpression)} : ${parseExpr( + expr.elseExpression + )}`; + case 'SimpleName': + return assignParent(expr.identifier, expr.isInConstructor); + case 'QualifiedName': + return `${parseExpr(expr.qualifier)}.${expr.name.identifier}`; + case 'FieldAccess': + return `${parseExpr(expr.expression)}.${expr.name.identifier}`; + case 'Assignment': + return `${parseExpr(expr.leftHandSide)} ${expr.operator} ${parseExpr(expr.rightHandSide)}`; + case 'InfixExpression': + let op = expr.operator; + if (op === '!=' || op === '==') op += '='; // triple equals in JS + return `${parseExpr(expr.leftOperand)} ${op} ${parseExpr(expr.rightOperand)}`; + case 'MethodInvocation': + let str = ''; + if (expr.expression) { + let exp = expr.expression; + if (exp.expression) exp = exp.expression; + let arr = asyncMethods[variableTypes[exp.identifier]]; + if (arr && arr.length && arr.includes(expr.name.identifier) && !expr.isInConstructor) { + str += 'await '; + } + str += `${parseExpr(expr.expression)}.${expr.name.identifier}`; + if (expr.name.identifier == 'length') return str; + } else { + if (asyncMethods.window.includes(expr.name.identifier) && !expr.isInConstructor) { + str += 'await '; + } + str += `${assignParent(expr.name.identifier)}`; + } + return str + `(${expr.arguments.map(parseExpr)})`; + case 'InstanceofExpression': + return `${parseExpr(expr.leftOperand)} instanceof ${parseType(expr.rightOperand)}`; + case 'SuperMethodInvocation': + return `super.${expr.name.identifier}(${expr.arguments.map(parseExpr)})`; + case 'ClassInstanceCreation': + return `new ${parseType(expr.type)}(${expr.arguments.map(parseExpr)})`; + case 'PostfixExpression': + return `${parseExpr(expr.operand)}${expr.operator}`; + case 'PrefixExpression': + return `${expr.operator}${parseExpr(expr.operand)}`; + case 'VariableDeclarationExpression': + return `${parseFieldVars(expr).map(varToString)}`; + case 'ArrayInitializer': + return `[${expr.expressions.map(parseExpr)}]`; + case 'ArrayCreation': + return `new Array()`; + case 'ArrayAccess': + let arr = expr.array; + // TODO support for three dimensional arrays + if (arr.array) { + return `${assignParent(arr.array.identifier)}[${parseExpr(arr.index)}][${parseExpr(expr.index)}]`; + } + if (arr.identifier) { + return `${assignParent(arr.identifier)}[${parseExpr(expr.index)}]`; + } + // TODO support for third level subclasses + if (arr.qualifier.qualifier) { + return `${assignParent(arr.qualifier.qualifier.identifier)}.${arr.qualifier.name.identifier}.${ + arr.name.identifier + }[${parseExpr(expr.index)}]`; + } + return `${assignParent(arr.qualifier.identifier)}.${arr.name.identifier}[${parseExpr(expr.index)}]`; + case 'ParenthesizedExpression': + return `(${parseExpr(expr.expression)})`; + default: + return unhandledNode(expr); + } + }; + + const parseFieldVars = (field) => { + const vars = []; + const data = parseModifiers(field.modifiers); + data.type = parseType(field.type); + + for (const frag of field.fragments) { + if (frag.node === 'VariableDeclarationFragment') { + vars.push( + Object.assign( + { + name: frag.name.identifier, + value: parseExpr(frag.initializer) + }, + data + ) + ); + variableTypes[frag.name.identifier] = data.type; + } else unhandledNode(frag); + } + return vars; + }; + + const parseStatement = (stat) => { + switch (stat.node) { + case 'EmptyStatement': + return ''; + case 'ExpressionStatement': + return parseExpr(stat.expression); + case 'VariableDeclarationStatement': + return parseFieldVars(stat).map(varToString); + case 'ReturnStatement': + return `return ${parseExpr(stat.expression)}`; + case 'SuperConstructorInvocation': + // TODO stat.expression stat.typeArguments + return `super(${stat.arguments.map(parseExpr)})`; + case 'IfStatement': + let ifBlock = `if(${parseExpr(stat.expression)}){${parseBlock(stat.thenStatement)}}`; + if (stat.elseStatement) ifBlock += `else{${parseBlock(stat.elseStatement)}}`; + return ifBlock; + case 'WhileStatement': + return `while(${parseExpr(stat.expression)}){${parseBlock(stat.body)}}`; + case 'DoStatement': + return `do{${parseBlock(stat.body)}}while(${parseExpr(stat.expression)})`; + case 'ForStatement': + let initializers = stat.initializers.map(parseExpr).join(','); + if (stat.initializers.length && stat.initializers[0].node === 'VariableDeclarationExpression') + initializers = 'let ' + initializers.replace(/(let|const) /g, ''); + return `for(${initializers};${parseExpr(stat.expression) || ''};${stat.updaters.map( + parseExpr + )}){${parseBlock(stat.body)}}`; + case 'EnhancedForStatement': + return `for(const ${stat.parameter.name.identifier} of ${parseExpr(stat.expression)}){${parseBlock( + stat.body + )}}`; + case 'BreakStatement': + return `break ${stat.label ? stat.label.identifier : ''}`; + case 'ContinueStatement': + return `continue ${stat.label ? stat.label.identifier : ''}`; + case 'LabeledStatement': + return `${stat.label.identifier}:${parseStatement(stat.body)}`; + case 'SwitchCase': + return `case ${parseExpr(stat.expression)}:`; + case 'SwitchStatement': + let switchStats = ''; + for (const _stat of stat.statements) { + const statStr = parseStatement(_stat); + switchStats += statStr + (statStr.endsWith(':') ? '' : ';'); + } + return `switch(${parseExpr(stat.expression)}){${switchStats}}`; + case 'AssertStatement': + return `if(!(${parseExpr(stat.expression)}))throw ${ + stat.message ? parseExpr(stat.message) : "'Assertion Failed'" + }`; + case 'ThrowStatement': + return `throw ${parseExpr(stat.expression)}`; + case 'TryStatement': + let tryBlock = `try{${parseBlock(stat.body)}}`; + for (const clause of stat.catchClauses) + tryBlock += ` catch(${clause.exception.name.identifier}){${parseBlock(clause.body)}}`; // TODO handle exception types? + if (stat.finally) tryBlock += `finally{${parseBlock(stat.finally)}}`; + return tryBlock; + default: + return unhandledNode(stat); + } + }; + + const parseBlock = (block, method) => { + const semicolon = (str) => `${str}${str.endsWith('}') ? '' : ';'}`; + + if (block.node !== 'Block') return semicolon(parseStatement(block)); + + const statements = []; + + for (const stat of block.statements) { + if (method && stat.node == 'ExpressionStatement') { + stat.expression.isInConstructor = method.constructor; + } + const str = parseStatement(stat); + const arr = Array.isArray(str) ? str : [str]; + statements.push(...arr.map(semicolon)); + if (method && !method.isAsync && !method.constructor && statements.join('').includes('await')) { + asyncMethods.window.push(method.name.identifier); + method.isAsync = true; + } + } + + return statements.join(''); + }; + + const parseMethod = (method) => { + const data = Object.assign( + { + name: method.name.identifier, + parameters: [] + }, + parseModifiers(method.modifiers) + ); + + if (method.constructor) { + data.isConstructor = true; + data.name = 'constructor'; + data.static = false; + for (let stat of method.body.statements) { + if (stat.expression.rightHandSide) { + stat.expression.rightHandSide.isInConstructor = true; + } + } + } + + for (const param of method.parameters) { + if (param.node === 'SingleVariableDeclaration') data.parameters.push(param.name.identifier); + else unhandledNode(block); + } + + data.block = parseBlock(method.body, method); + + if (data.block.includes('await')) data.isAsync = true; + + return data; + }; + + for (const dec of class_.bodyDeclarations) { + if (dec.node === 'FieldDeclaration') { + classData.vars.push(...parseFieldVars(dec)); + } else if (dec.node === 'MethodDeclaration' && !dec.constructor && isGlobal !== true) { + classVarsMap[dec.name.identifier] = true; + } + } + + if (isGlobal !== true) { + for (const var_ of classData.vars) classVarsMap[var_.name] = true; + } + + for (const dec of class_.bodyDeclarations) { + if (dec.node === 'TypeDeclaration') classData.classes.push(parseClass(dec)); + else if (dec.node === 'MethodDeclaration') classData.methods.push(parseMethod(dec)); + else if (dec.node !== 'FieldDeclaration') unhandledNode(dec); + } + + return classData; + }; + + const classToJs = ({ name: className, vars, superclass, methods, abstract, classes }) => { + if (abstract) return ''; + + const initVars = []; + const classProps = []; + const staticVars = []; + + for (const cl of classes) { + staticVars.push(`${classToJs(cl)}\n${className}.${cl.name}=${cl.name};`); + } + + for (const var_ of vars) { + if (var_.value === undefined) var_.value = literalInitializers[var_.type] || 'null'; + if (var_.static) { + staticVars.push(`${className}.${var_.name}=${var_.value};`); + } else { + if (typeof var_.value == 'string') { + for (const vv of vars) { + var_.value = var_.value.replaceAll(vv.name, 'this.' + vv.name); + } + } + initVars.push(`this.${var_.name}=${var_.value};`); + } + } + + let addedConstructor = false; + + const addMethod = ({ name, parameters, block, isConstructor, isAsync, static: static_ }, addInitVars) => { + if (isConstructor) addedConstructor = true; + if (static_) staticVars.push(`${className}.${name}=(${parameters})=>{${block}};`); + else { + const preblock = + isConstructor && addInitVars && initVars.length + ? initVars.join('') + (block ? opts.separator : '') + : ''; + let method = `${name}(${parameters}){${preblock}${block}}`; + if (isAsync) method = 'async ' + method; + classProps.push(method); + } + }; + + const methodMap = {}; + for (const meth of methods) { + const safeName = meth.name + '$$'; + if (!(safeName in methodMap)) methodMap[safeName] = {}; + methodMap[safeName][meth.parameters.length] = meth; + } + for (const safeName in methodMap) { + const name = safeName.slice(0, -2); + const paramMap = methodMap[safeName]; + const paramCounts = Object.keys(paramMap); + + const first = paramMap[paramCounts[0]]; + if (paramCounts.length === 1) { + addMethod(first, true); + } else { + let cases = ''; + for (const paramCount of paramCounts) { + const meth = paramMap[paramCount]; + meth.name = `${name}${SEP}${paramCount}`; + cases += `case ${paramCount}:return ${meth.static ? className : 'this'}.${meth.name}(...args$);`; + addMethod(meth); + } + if (first.static) + staticVars.push(`${className}.${name}=(...args${SEP})=>{switch(args${SEP}.length){${cases}}};`); + else classProps.push(`${name}(...args${SEP}){switch(args${SEP}.length){${cases}}}`); + } + if (name == 'main') staticVars.push(`jdk.main = ${className}.main;`); + } + + if (!addedConstructor && initVars.length) classProps.unshift(`constructor(){${initVars.join('')}}`); + + return `class ${className}${superclass ? ' extends ' + superclass : ''}{${classProps.join( + '' + )}}${staticVars.join('')}`; + }; + + const globalsToJs = ({ vars, methods, classes }) => { + const join = []; + + join.push(joinStatements(vars.map(varToString))); + + join.push( + methods + .map( + ({ name, parameters, block }) => + `${ + opts.globalScope && name in opts.globalVars ? `${opts.globalScope}.` : 'const ' + }${name} = (${parameters}) => {${block}};` + ) + .join(opts.separator) + ); + + join.push(classes.map(classToJs).join(opts.separator)); + + return join.join(opts.separator); + }; + + const fixP5 = (str) => { + return str + .replace(/(int|float|byte|char|boolean)\s*\(/g, '$1$$(') // Temporarily change name of literal method calls e.g. int(x) -> int$(x) + .replace(/[^"](#[a-f0-9]{6,8})[^"]/gi, "'$1'") // Replace silly hex notation with string + .replace(/new\s+PVector\s*\(/g, 'createVector('); // use p5 vector initializer + }; + + /** + * Convert Java string to JavaScript string + * @param {string} javaString - Java file contents + * @param {object} [options] + * @param {object} [options.globalVars] - Object keys are added to the `globalScope` object. If the object value is a string, the variable is renamed to that string + * @param {string} [options.globalScope] - If specified, variables in `globalVars` are appended to `globalScope` object + * @param {boolean} [options.p5] - Sets `globalScope` to `'p5'`, adds [p5 variable mappings](./p5_globals.js) to `globalVars`, and allows for global methods and variables + * @param {boolean} [options.ugly] - Don't beautify JavaScript code + * @param {function} [progress] - Callback on progress of conversion. Args are progress number (0 to 1), and a message string + * @return {string} - Converted JavaScript + */ + const javaToJavascript = (javaString, options = {}, progress) => { + if (typeof javaString !== 'string') { + throw 'java-to-javascript: First argument must be a string'; + } + + // Reset opts parameters + Object.assign(opts, DEFAULT_OPTIONS); + + if (options.globalVars) opts.globalVars = options.globalVars; + if (options.globalScope) opts.globalScope = options.globalScope; + if (options.ugly) opts.separator = ''; + if (options.p5) { + Object.assign(opts.globalVars, p5_options.globalVars, opts.globalVars); + if (!opts.globalScope) opts.globalScope = 'p5'; + } + + if (progress) progress(0, 'Parsing Java'); + + if (options.p5) javaString = `class JavaJsTemp__ {${fixP5(javaString)}}`; + + let javaAST$$1; + try { + javaAST$$1 = javaAST.parse(javaString); + } catch (e) { + let line = e.location.start.line; + if (e.location) throw `on line ${line}: \n\n${javaString.split('\n')[line - 1].trim()}\n\n${e.stack}`; + else throw e; + } + + if (progress) progress(0.5, 'Converting to JavaScript'); + + let jsString; + if (options.p5) { + jsString = globalsToJs(parseClass(javaAST$$1.types[0], true)); + } else { + jsString = javaAST$$1.types.map((globalClass) => classToJs(parseClass(globalClass))).join(opts.separator); + } + + if (progress) progress(0.75, 'Beautifying'); + + if (!options.ugly) { + jsString = + beautify$2(jsString, { + indent_size: 2 + }) + '\n'; + } + + if (progress) progress(1.0, 'Success'); + + return jsString; + }; + + var lib = javaToJavascript; + + return lib; + }); + + /* beautify ignore:end */ + }, + {} + ] + }, + {}, + [1] +);