// This is a bundle the JDK class code is the main part that // I (quinton-ashley) made. That section starts on line 40. (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 log = console.log; /* Java to JavaScript transpiler */ const java_to_javascript = require('java-to-javascript'); /* JDK implementation in modern JavaScript */ class JDK { constructor() {} async init(root) { this.root = root || './jdk'; this.java = {}; let pkgs = ['com', 'io', 'lang', 'org', 'security', 'time', 'util']; for (let pkg of pkgs) { this.java[pkg] = {}; } this.imports = {}; /** * The 'java.lang' package is imported automatically because this package * provides classes that are fundamental to the Java programming language. * Since classes like String already exist in JS, so I just extended them, * no need to import. */ try { let names = [ 'Character', 'Double', 'Exception', 'Float', 'Integer', 'Long', 'Short', 'String', 'StringBuilder', 'System', 'Thread' ]; let lang = []; for (let name of names) { lang.push('java.lang.' + name); } await this.import(lang); } catch (ror) { console.error(ror); return; } // make java.lang classes global for (let name in this.java.lang) { if (name == 'String') continue; window[name] = this.java.lang[name]; } System.in.reset(); System.out.reset(); // stub main this.main = () => { console.error('No main method found in loaded classes!'); }; } run(jvmArgs) { this.main(jvmArgs); } getClass(classPath) { let _class = this; for (let part of classPath) { _class = _class[part]; if (!_class) return; } return _class; } async import(classNames) { if (!classNames) return; if (typeof classNames == 'string') { classNames = [classNames]; } let classes = []; for (let className of classNames) { // log('importing ' + className); let imp = this.imports[className]; if (!imp) { imp = this.imports[className] = {}; imp.load = null; imp.classPath = className.split('.'); let src = this.root; for (let part of imp.classPath) { src += '/' + part; } src += '.js'; const loadJS = () => { return new Promise((resolve, reject) => { const script = document.createElement('script'); document.body.appendChild(script); script.async = true; script.onload = resolve; script.onerror = reject; script.src = src; }); }; await loadJS(); } if (!imp.ready) await imp.load(); classes.push(this.getClass(imp.classPath)); } if (classNames.length == 1) classes = classes[0]; return classes; } async transpile(file) { if (!this.java) { console.error( 'java2js error: JDK not initialized! You must call `await jdk.init()` before using `jdk.load()`' ); } // bodge fix to avoid getting the index of a commented out class // (only works with normal comments) let classLine = file.indexOf('\npublic class'); if (classLine < 0) { classLine = file.indexOf('public class'); } else { classLine += 1; } let imports = file.slice(0, classLine); imports = imports.match(/(?<=^import )[^;]*/gm) || []; let className = file.slice(classLine + 13, file.indexOf('{', classLine + 13)); // workaround hack for converting triple quotes to a normal string file = file.replace(/"""([^"]*)"""/gm, (match, p1) => { return '(' + p1.replace(/( |\t){0,3}(.*)(\r*\n|$)/gm, '"$2\\n"+').slice(0, -1) + ')'; }); let arrToString = ''; // hacky support for Array literals file = file.replace(/new\s*\w*\s*\[\s*\]\s*\{([^}]*)}/gm, 'Array.of($1)'); // 2D arrays file = file.replace(/new\s*\w*(\s*\[\s*\])*\s*\{([^}]*)\}/gm, (match, p1, p2) => { return 'Array.of(' + p2.replace(/\{([^\}]*)\}/gm, 'Array.of($1)') + ')'; }); // Array with defined length file = file.replace(/new\s*\w*\s*\[\s*(\d)+\s*\]\s*/gm, 'new Array($1)'); // workaround hack for converting lambda expressions to Runnables let lambdaRegex = /\(\)\s*\->\s*\{(([^\{\}]*\{[^\}]*\})*[^\}]*)\}/g; // can't even do this... bruh // file = file.replace(lambdaRegex, (match, in0) => { // // log(in0); // if (lambdaRegex.test(in0)) { // in0 = in0.replace(lambdaRegex, (match, in1) => { // return 'new Runnable() {\\n@Override\\npublic void run() {' + in1 + '}\\n}'; // }); // } // return 'new Runnable() {\\n@Override\\npublic void run() {' + in0 + '}\\n}'; // }); // TODO fix this by adding real support for lambda file = file.replace(lambdaRegex, (match, in0) => { // log(in0); if (lambdaRegex.test(in0)) { in0 = in0.replace(lambdaRegex, (match, in1) => { in1.replaceAll('\n', '\\n'); return 'new Runnable("' + in1 + '")'; }); } in0 = in0.replaceAll('\n', '\\n'); return 'new Runnable("' + in0 + '")'; }); let packageName = (file.match(/package\s+([^;]+)/gm) || [])[1] || 'default'; 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 trans = trans.replace(/new\s*Runnable\('([^]*)'\)/gm, (match, p1) => { return '() => {' + p1.replaceAll('\\n', '\n') + '}'; }); trans.replace(/catch \(\w*/gm, 'catch ('); trans = trans.replace(/(\([^\(\)]*\) =>)/gm, 'async $1'); let prefix = `(jdk.imports['${packageName}.${className}'] = {}).load = async () => {\n\n`; // handle Java class imports for (let i = 0; i < imports.length; i++) { let imp = imports[i]; // skip static imports for now if (imp.includes('static')) continue; let impPath = imp.split('.'); let impName = impPath[impPath.length - 1]; if (impName == '*') { prefix += `await jdk.import('${imp}');\n`; } else { prefix += `let ${impName} = await jdk.import('${imp}');\n`; } } prefix += '\n'; let suffix = '\n'; suffix += `window.${className} = ${className};\n`; suffix += `console.log("loaded ${className}.java");\n`; suffix += '};'; trans = prefix + trans + suffix; const script = document.createElement('script'); script.innerHTML = trans; document.body.appendChild(script); try { await jdk.imports[`${packageName}.${className}`].load(); } catch (ror) { console.error('Failed to load class!\n' + trans); System.err.println('ERROR: Failed to load class'); return; } return trans; } } window.jdk = new JDK(); }, { '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] );