xonecas.io
818
Du

dustymarkdown / files

dustymarkdown / node_modules / uglify-js / lib / parse-js.js

51.3 KB
1/***********************************************************************
2
3  A JavaScript tokenizer / parser / beautifier / compressor.
4
5  This version is suitable for Node.js.  With minimal changes (the
6  exports stuff) it should work on any JS platform.
7
8  This file contains the tokenizer/parser.  It is a port to JavaScript
9  of parse-js [1], a JavaScript parser library written in Common Lisp
10  by Marijn Haverbeke.  Thank you Marijn!
11
12  [1] http://marijn.haverbeke.nl/parse-js/
13
14  Exported functions:
15
16    - tokenizer(code) -- returns a function.  Call the returned
17      function to fetch the next token.
18
19    - parse(code) -- returns an AST of the given JavaScript code.
20
21  -------------------------------- (C) ---------------------------------
22
23                           Author: Mihai Bazon
24                         <mihai.bazon@gmail.com>
25                       http://mihai.bazon.net/blog
26
27  Distributed under the BSD license:
28
29    Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
30    Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
31
32    Redistribution and use in source and binary forms, with or without
33    modification, are permitted provided that the following conditions
34    are met:
35
36        * Redistributions of source code must retain the above
37          copyright notice, this list of conditions and the following
38          disclaimer.
39
40        * Redistributions in binary form must reproduce the above
41          copyright notice, this list of conditions and the following
42          disclaimer in the documentation and/or other materials
43          provided with the distribution.
44
45    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
46    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
48    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
49    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
50    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
51    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
52    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
53    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
54    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
55    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56    SUCH DAMAGE.
57
58 ***********************************************************************/
59
60/* -----[ Tokenizer (constants) ]----- */
61
62var KEYWORDS = array_to_hash([
63        "break",
64        "case",
65        "catch",
66        "const",
67        "continue",
68        "default",
69        "delete",
70        "do",
71        "else",
72        "finally",
73        "for",
74        "function",
75        "if",
76        "in",
77        "instanceof",
78        "new",
79        "return",
80        "switch",
81        "throw",
82        "try",
83        "typeof",
84        "var",
85        "void",
86        "while",
87        "with"
88]);
89
90var RESERVED_WORDS = array_to_hash([
91        "abstract",
92        "boolean",
93        "byte",
94        "char",
95        "class",
96        "debugger",
97        "double",
98        "enum",
99        "export",
100        "extends",
101        "final",
102        "float",
103        "goto",
104        "implements",
105        "import",
106        "int",
107        "interface",
108        "long",
109        "native",
110        "package",
111        "private",
112        "protected",
113        "public",
114        "short",
115        "static",
116        "super",
117        "synchronized",
118        "throws",
119        "transient",
120        "volatile"
121]);
122
123var KEYWORDS_BEFORE_EXPRESSION = array_to_hash([
124        "return",
125        "new",
126        "delete",
127        "throw",
128        "else",
129        "case"
130]);
131
132var KEYWORDS_ATOM = array_to_hash([
133        "false",
134        "null",
135        "true",
136        "undefined"
137]);
138
139var OPERATOR_CHARS = array_to_hash(characters("+-*&%=<>!?|~^"));
140
141var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
142var RE_OCT_NUMBER = /^0[0-7]+$/;
143var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
144
145var OPERATORS = array_to_hash([
146        "in",
147        "instanceof",
148        "typeof",
149        "new",
150        "void",
151        "delete",
152        "++",
153        "--",
154        "+",
155        "-",
156        "!",
157        "~",
158        "&",
159        "|",
160        "^",
161        "*",
162        "/",
163        "%",
164        ">>",
165        "<<",
166        ">>>",
167        "<",
168        ">",
169        "<=",
170        ">=",
171        "==",
172        "===",
173        "!=",
174        "!==",
175        "?",
176        "=",
177        "+=",
178        "-=",
179        "/=",
180        "*=",
181        "%=",
182        ">>=",
183        "<<=",
184        ">>>=",
185        "|=",
186        "^=",
187        "&=",
188        "&&",
189        "||"
190]);
191
192var WHITESPACE_CHARS = array_to_hash(characters(" \u00a0\n\r\t\f\v\u200b"));
193
194var PUNC_BEFORE_EXPRESSION = array_to_hash(characters("[{}(,.;:"));
195
196var PUNC_CHARS = array_to_hash(characters("[]{}(),;:"));
197
198var REGEXP_MODIFIERS = array_to_hash(characters("gmsiy"));
199
200/* -----[ Tokenizer ]----- */
201
202// regexps adapted from http://xregexp.com/plugins/#unicode
203var UNICODE = {
204        letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971\\u0972\\u097B-\\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\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D3D\\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\\u0EDD\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8B\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10D0-\\u10FA\\u10FC\\u1100-\\u1159\\u115F-\\u11A2\\u11A8-\\u11F9\\u1200-\\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-\\u1676\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19A9\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\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-\\u2094\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C6F\\u2C71-\\u2C7D\\u2C80-\\u2CE4\\u2D00-\\u2D25\\u2D30-\\u2D65\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31B7\\u31F0-\\u31FF\\u3400\\u4DB5\\u4E00\\u9FC3\\uA000-\\uA48C\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA65F\\uA662-\\uA66E\\uA67F-\\uA697\\uA717-\\uA71F\\uA722-\\uA788\\uA78B\\uA78C\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA90A-\\uA925\\uA930-\\uA946\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAC00\\uD7A3\\uF900-\\uFA2D\\uFA30-\\uFA6A\\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]"),
205        non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
206        space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),
207        connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")
208};
209
210function is_letter(ch) {
211        return UNICODE.letter.test(ch);
212};
213
214function is_digit(ch) {
215        ch = ch.charCodeAt(0);
216        return ch >= 48 && ch <= 57; //XXX: find out if "UnicodeDigit" means something else than 0..9
217};
218
219function is_alphanumeric_char(ch) {
220        return is_digit(ch) || is_letter(ch);
221};
222
223function is_unicode_combining_mark(ch) {
224        return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch);
225};
226
227function is_unicode_connector_punctuation(ch) {
228        return UNICODE.connector_punctuation.test(ch);
229};
230
231function is_identifier_start(ch) {
232        return ch == "$" || ch == "_" || is_letter(ch);
233};
234
235function is_identifier_char(ch) {
236        return is_identifier_start(ch)
237                || is_unicode_combining_mark(ch)
238                || is_digit(ch)
239                || is_unicode_connector_punctuation(ch)
240                || ch == "\u200c" // zero-width non-joiner <ZWNJ>
241                || ch == "\u200d" // zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)
242        ;
243};
244
245function parse_js_number(num) {
246        if (RE_HEX_NUMBER.test(num)) {
247                return parseInt(num.substr(2), 16);
248        } else if (RE_OCT_NUMBER.test(num)) {
249                return parseInt(num.substr(1), 8);
250        } else if (RE_DEC_NUMBER.test(num)) {
251                return parseFloat(num);
252        }
253};
254
255function JS_Parse_Error(message, line, col, pos) {
256        this.message = message;
257        this.line = line;
258        this.col = col;
259        this.pos = pos;
260        try {
261                ({})();
262        } catch(ex) {
263                this.stack = ex.stack;
264        };
265};
266
267JS_Parse_Error.prototype.toString = function() {
268        return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack;
269};
270
271function js_error(message, line, col, pos) {
272        throw new JS_Parse_Error(message, line, col, pos);
273};
274
275function is_token(token, type, val) {
276        return token.type == type && (val == null || token.value == val);
277};
278
279var EX_EOF = {};
280
281function tokenizer($TEXT) {
282
283        var S = {
284                text            : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, ''),
285                pos             : 0,
286                tokpos          : 0,
287                line            : 0,
288                tokline         : 0,
289                col             : 0,
290                tokcol          : 0,
291                newline_before  : false,
292                regex_allowed   : false,
293                comments_before : []
294        };
295
296        function peek() { return S.text.charAt(S.pos); };
297
298        function next(signal_eof) {
299                var ch = S.text.charAt(S.pos++);
300                if (signal_eof && !ch)
301                        throw EX_EOF;
302                if (ch == "\n") {
303                        S.newline_before = true;
304                        ++S.line;
305                        S.col = 0;
306                } else {
307                        ++S.col;
308                }
309                return ch;
310        };
311
312        function eof() {
313                return !S.peek();
314        };
315
316        function find(what, signal_eof) {
317                var pos = S.text.indexOf(what, S.pos);
318                if (signal_eof && pos == -1) throw EX_EOF;
319                return pos;
320        };
321
322        function start_token() {
323                S.tokline = S.line;
324                S.tokcol = S.col;
325                S.tokpos = S.pos;
326        };
327
328        function token(type, value, is_comment) {
329                S.regex_allowed = ((type == "operator" && !HOP(UNARY_POSTFIX, value)) ||
330                                   (type == "keyword" && HOP(KEYWORDS_BEFORE_EXPRESSION, value)) ||
331                                   (type == "punc" && HOP(PUNC_BEFORE_EXPRESSION, value)));
332                var ret = {
333                        type  : type,
334                        value : value,
335                        line  : S.tokline,
336                        col   : S.tokcol,
337                        pos   : S.tokpos,
338                        nlb   : S.newline_before
339                };
340                if (!is_comment) {
341                        ret.comments_before = S.comments_before;
342                        S.comments_before = [];
343                }
344                S.newline_before = false;
345                return ret;
346        };
347
348        function skip_whitespace() {
349                while (HOP(WHITESPACE_CHARS, peek()))
350                        next();
351        };
352
353        function read_while(pred) {
354                var ret = "", ch = peek(), i = 0;
355                while (ch && pred(ch, i++)) {
356                        ret += next();
357                        ch = peek();
358                }
359                return ret;
360        };
361
362        function parse_error(err) {
363                js_error(err, S.tokline, S.tokcol, S.tokpos);
364        };
365
366        function read_num(prefix) {
367                var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
368                var num = read_while(function(ch, i){
369                        if (ch == "x" || ch == "X") {
370                                if (has_x) return false;
371                                return has_x = true;
372                        }
373                        if (!has_x && (ch == "E" || ch == "e")) {
374                                if (has_e) return false;
375                                return has_e = after_e = true;
376                        }
377                        if (ch == "-") {
378                                if (after_e || (i == 0 && !prefix)) return true;
379                                return false;
380                        }
381                        if (ch == "+") return after_e;
382                        after_e = false;
383                        if (ch == ".") {
384                                if (!has_dot && !has_x)
385                                        return has_dot = true;
386                                return false;
387                        }
388                        return is_alphanumeric_char(ch);
389                });
390                if (prefix)
391                        num = prefix + num;
392                var valid = parse_js_number(num);
393                if (!isNaN(valid)) {
394                        return token("num", valid);
395                } else {
396                        parse_error("Invalid syntax: " + num);
397                }
398        };
399
400        function read_escaped_char() {
401                var ch = next(true);
402                switch (ch) {
403                    case "n" : return "\n";
404                    case "r" : return "\r";
405                    case "t" : return "\t";
406                    case "b" : return "\b";
407                    case "v" : return "\v";
408                    case "f" : return "\f";
409                    case "0" : return "\0";
410                    case "x" : return String.fromCharCode(hex_bytes(2));
411                    case "u" : return String.fromCharCode(hex_bytes(4));
412                    default  : return ch;
413                }
414        };
415
416        function hex_bytes(n) {
417                var num = 0;
418                for (; n > 0; --n) {
419                        var digit = parseInt(next(true), 16);
420                        if (isNaN(digit))
421                                parse_error("Invalid hex-character pattern in string");
422                        num = (num << 4) | digit;
423                }
424                return num;
425        };
426
427        function read_string() {
428                return with_eof_error("Unterminated string constant", function(){
429                        var quote = next(), ret = "";
430                        for (;;) {
431                                var ch = next(true);
432                                if (ch == "\\") ch = read_escaped_char();
433                                else if (ch == quote) break;
434                                ret += ch;
435                        }
436                        return token("string", ret);
437                });
438        };
439
440        function read_line_comment() {
441                next();
442                var i = find("\n"), ret;
443                if (i == -1) {
444                        ret = S.text.substr(S.pos);
445                        S.pos = S.text.length;
446                } else {
447                        ret = S.text.substring(S.pos, i);
448                        S.pos = i;
449                }
450                return token("comment1", ret, true);
451        };
452
453        function read_multiline_comment() {
454                next();
455                return with_eof_error("Unterminated multiline comment", function(){
456                        var i = find("*/", true),
457                            text = S.text.substring(S.pos, i),
458                            tok = token("comment2", text, true);
459                        S.pos = i + 2;
460                        S.line += text.split("\n").length - 1;
461                        S.newline_before = text.indexOf("\n") >= 0;
462
463                        // https://github.com/mishoo/UglifyJS/issues/#issue/100
464                        if (/^@cc_on/i.test(text)) {
465                                warn("WARNING: at line " + S.line);
466                                warn("*** Found \"conditional comment\": " + text);
467                                warn("*** UglifyJS DISCARDS ALL COMMENTS.  This means your code might no longer work properly in Internet Explorer.");
468                        }
469
470                        return tok;
471                });
472        };
473
474        function read_name() {
475                var backslash = false, name = "", ch;
476                while ((ch = peek()) != null) {
477                        if (!backslash) {
478                                if (ch == "\\") backslash = true, next();
479                                else if (is_identifier_char(ch)) name += next();
480                                else break;
481                        }
482                        else {
483                                if (ch != "u") parse_error("Expecting UnicodeEscapeSequence -- uXXXX");
484                                ch = read_escaped_char();
485                                if (!is_identifier_char(ch)) parse_error("Unicode char: " + ch.charCodeAt(0) + " is not valid in identifier");
486                                name += ch;
487                                backslash = false;
488                        }
489                }
490                return name;
491        };
492
493        function read_regexp() {
494                return with_eof_error("Unterminated regular expression", function(){
495                        var prev_backslash = false, regexp = "", ch, in_class = false;
496                        while ((ch = next(true))) if (prev_backslash) {
497                                regexp += "\\" + ch;
498                                prev_backslash = false;
499                        } else if (ch == "[") {
500                                in_class = true;
501                                regexp += ch;
502                        } else if (ch == "]" && in_class) {
503                                in_class = false;
504                                regexp += ch;
505                        } else if (ch == "/" && !in_class) {
506                                break;
507                        } else if (ch == "\\") {
508                                prev_backslash = true;
509                        } else {
510                                regexp += ch;
511                        }
512                        var mods = read_name();
513                        return token("regexp", [ regexp, mods ]);
514                });
515        };
516
517        function read_operator(prefix) {
518                function grow(op) {
519                        if (!peek()) return op;
520                        var bigger = op + peek();
521                        if (HOP(OPERATORS, bigger)) {
522                                next();
523                                return grow(bigger);
524                        } else {
525                                return op;
526                        }
527                };
528                return token("operator", grow(prefix || next()));
529        };
530
531        function handle_slash() {
532                next();
533                var regex_allowed = S.regex_allowed;
534                switch (peek()) {
535                    case "/":
536                        S.comments_before.push(read_line_comment());
537                        S.regex_allowed = regex_allowed;
538                        return next_token();
539                    case "*":
540                        S.comments_before.push(read_multiline_comment());
541                        S.regex_allowed = regex_allowed;
542                        return next_token();
543                }
544                return S.regex_allowed ? read_regexp() : read_operator("/");
545        };
546
547        function handle_dot() {
548                next();
549                return is_digit(peek())
550                        ? read_num(".")
551                        : token("punc", ".");
552        };
553
554        function read_word() {
555                var word = read_name();
556                return !HOP(KEYWORDS, word)
557                        ? token("name", word)
558                        : HOP(OPERATORS, word)
559                        ? token("operator", word)
560                        : HOP(KEYWORDS_ATOM, word)
561                        ? token("atom", word)
562                        : token("keyword", word);
563        };
564
565        function with_eof_error(eof_error, cont) {
566                try {
567                        return cont();
568                } catch(ex) {
569                        if (ex === EX_EOF) parse_error(eof_error);
570                        else throw ex;
571                }
572        };
573
574        function next_token(force_regexp) {
575                if (force_regexp)
576                        return read_regexp();
577                skip_whitespace();
578                start_token();
579                var ch = peek();
580                if (!ch) return token("eof");
581                if (is_digit(ch)) return read_num();
582                if (ch == '"' || ch == "'") return read_string();
583                if (HOP(PUNC_CHARS, ch)) return token("punc", next());
584                if (ch == ".") return handle_dot();
585                if (ch == "/") return handle_slash();
586                if (HOP(OPERATOR_CHARS, ch)) return read_operator();
587                if (ch == "\\" || is_identifier_start(ch)) return read_word();
588                parse_error("Unexpected character '" + ch + "'");
589        };
590
591        next_token.context = function(nc) {
592                if (nc) S = nc;
593                return S;
594        };
595
596        return next_token;
597
598};
599
600/* -----[ Parser (constants) ]----- */
601
602var UNARY_PREFIX = array_to_hash([
603        "typeof",
604        "void",
605        "delete",
606        "--",
607        "++",
608        "!",
609        "~",
610        "-",
611        "+"
612]);
613
614var UNARY_POSTFIX = array_to_hash([ "--", "++" ]);
615
616var ASSIGNMENT = (function(a, ret, i){
617        while (i < a.length) {
618                ret[a[i]] = a[i].substr(0, a[i].length - 1);
619                i++;
620        }
621        return ret;
622})(
623        ["+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&="],
624        { "=": true },
625        0
626);
627
628var PRECEDENCE = (function(a, ret){
629        for (var i = 0, n = 1; i < a.length; ++i, ++n) {
630                var b = a[i];
631                for (var j = 0; j < b.length; ++j) {
632                        ret[b[j]] = n;
633                }
634        }
635        return ret;
636})(
637        [
638                ["||"],
639                ["&&"],
640                ["|"],
641                ["^"],
642                ["&"],
643                ["==", "===", "!=", "!=="],
644                ["<", ">", "<=", ">=", "in", "instanceof"],
645                [">>", "<<", ">>>"],
646                ["+", "-"],
647                ["*", "/", "%"]
648        ],
649        {}
650);
651
652var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
653
654var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
655
656/* -----[ Parser ]----- */
657
658function NodeWithToken(str, start, end) {
659        this.name = str;
660        this.start = start;
661        this.end = end;
662};
663
664NodeWithToken.prototype.toString = function() { return this.name; };
665
666function parse($TEXT, exigent_mode, embed_tokens) {
667
668        var S = {
669                input       : typeof $TEXT == "string" ? tokenizer($TEXT, true) : $TEXT,
670                token       : null,
671                prev        : null,
672                peeked      : null,
673                in_function : 0,
674                in_loop     : 0,
675                labels      : []
676        };
677
678        S.token = next();
679
680        function is(type, value) {
681                return is_token(S.token, type, value);
682        };
683
684        function peek() { return S.peeked || (S.peeked = S.input()); };
685
686        function next() {
687                S.prev = S.token;
688                if (S.peeked) {
689                        S.token = S.peeked;
690                        S.peeked = null;
691                } else {
692                        S.token = S.input();
693                }
694                return S.token;
695        };
696
697        function prev() {
698                return S.prev;
699        };
700
701        function croak(msg, line, col, pos) {
702                var ctx = S.input.context();
703                js_error(msg,
704                         line != null ? line : ctx.tokline,
705                         col != null ? col : ctx.tokcol,
706                         pos != null ? pos : ctx.tokpos);
707        };
708
709        function token_error(token, msg) {
710                croak(msg, token.line, token.col);
711        };
712
713        function unexpected(token) {
714                if (token == null)
715                        token = S.token;
716                token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
717        };
718
719        function expect_token(type, val) {
720                if (is(type, val)) {
721                        return next();
722                }
723                token_error(S.token, "Unexpected token " + S.token.type + ", expected " + type);
724        };
725
726        function expect(punc) { return expect_token("punc", punc); };
727
728        function can_insert_semicolon() {
729                return !exigent_mode && (
730                        S.token.nlb || is("eof") || is("punc", "}")
731                );
732        };
733
734        function semicolon() {
735                if (is("punc", ";")) next();
736                else if (!can_insert_semicolon()) unexpected();
737        };
738
739        function as() {
740                return slice(arguments);
741        };
742
743        function parenthesised() {
744                expect("(");
745                var ex = expression();
746                expect(")");
747                return ex;
748        };
749
750        function add_tokens(str, start, end) {
751                return str instanceof NodeWithToken ? str : new NodeWithToken(str, start, end);
752        };
753
754        function maybe_embed_tokens(parser) {
755                if (embed_tokens) return function() {
756                        var start = S.token;
757                        var ast = parser.apply(this, arguments);
758                        ast[0] = add_tokens(ast[0], start, prev());
759                        return ast;
760                };
761                else return parser;
762        };
763
764        var statement = maybe_embed_tokens(function() {
765                if (is("operator", "/")) {
766                        S.peeked = null;
767                        S.token = S.input(true); // force regexp
768                }
769                switch (S.token.type) {
770                    case "num":
771                    case "string":
772                    case "regexp":
773                    case "operator":
774                    case "atom":
775                        return simple_statement();
776
777                    case "name":
778                        return is_token(peek(), "punc", ":")
779                                ? labeled_statement(prog1(S.token.value, next, next))
780                                : simple_statement();
781
782                    case "punc":
783                        switch (S.token.value) {
784                            case "{":
785                                return as("block", block_());
786                            case "[":
787                            case "(":
788                                return simple_statement();
789                            case ";":
790                                next();
791                                return as("block");
792                            default:
793                                unexpected();
794                        }
795
796                    case "keyword":
797                        switch (prog1(S.token.value, next)) {
798                            case "break":
799                                return break_cont("break");
800
801                            case "continue":
802                                return break_cont("continue");
803
804                            case "debugger":
805                                semicolon();
806                                return as("debugger");
807
808                            case "do":
809                                return (function(body){
810                                        expect_token("keyword", "while");
811                                        return as("do", prog1(parenthesised, semicolon), body);
812                                })(in_loop(statement));
813
814                            case "for":
815                                return for_();
816
817                            case "function":
818                                return function_(true);
819
820                            case "if":
821                                return if_();
822
823                            case "return":
824                                if (S.in_function == 0)
825                                        croak("'return' outside of function");
826                                return as("return",
827                                          is("punc", ";")
828                                          ? (next(), null)
829                                          : can_insert_semicolon()
830                                          ? null
831                                          : prog1(expression, semicolon));
832
833                            case "switch":
834                                return as("switch", parenthesised(), switch_block_());
835
836                            case "throw":
837                                return as("throw", prog1(expression, semicolon));
838
839                            case "try":
840                                return try_();
841
842                            case "var":
843                                return prog1(var_, semicolon);
844
845                            case "const":
846                                return prog1(const_, semicolon);
847
848                            case "while":
849                                return as("while", parenthesised(), in_loop(statement));
850
851                            case "with":
852                                return as("with", parenthesised(), statement());
853
854                            default:
855                                unexpected();
856                        }
857                }
858        });
859
860        function labeled_statement(label) {
861                S.labels.push(label);
862                var start = S.token, stat = statement();
863                if (exigent_mode && !HOP(STATEMENTS_WITH_LABELS, stat[0]))
864                        unexpected(start);
865                S.labels.pop();
866                return as("label", label, stat);
867        };
868
869        function simple_statement() {
870                return as("stat", prog1(expression, semicolon));
871        };
872
873        function break_cont(type) {
874                var name = is("name") ? S.token.value : null;
875                if (name != null) {
876                        next();
877                        if (!member(name, S.labels))
878                                croak("Label " + name + " without matching loop or statement");
879                }
880                else if (S.in_loop == 0)
881                        croak(type + " not inside a loop or switch");
882                semicolon();
883                return as(type, name);
884        };
885
886        function for_() {
887                expect("(");
888                var init = null;
889                if (!is("punc", ";")) {
890                        init = is("keyword", "var")
891                                ? (next(), var_(true))
892                                : expression(true, true);
893                        if (is("operator", "in"))
894                                return for_in(init);
895                }
896                return regular_for(init);
897        };
898
899        function regular_for(init) {
900                expect(";");
901                var test = is("punc", ";") ? null : expression();
902                expect(";");
903                var step = is("punc", ")") ? null : expression();
904                expect(")");
905                return as("for", init, test, step, in_loop(statement));
906        };
907
908        function for_in(init) {
909                var lhs = init[0] == "var" ? as("name", init[1][0]) : init;
910                next();
911                var obj = expression();
912                expect(")");
913                return as("for-in", init, lhs, obj, in_loop(statement));
914        };
915
916        var function_ = maybe_embed_tokens(function(in_statement) {
917                var name = is("name") ? prog1(S.token.value, next) : null;
918                if (in_statement && !name)
919                        unexpected();
920                expect("(");
921                return as(in_statement ? "defun" : "function",
922                          name,
923                          // arguments
924                          (function(first, a){
925                                  while (!is("punc", ")")) {
926                                          if (first) first = false; else expect(",");
927                                          if (!is("name")) unexpected();
928                                          a.push(S.token.value);
929                                          next();
930                                  }
931                                  next();
932                                  return a;
933                          })(true, []),
934                          // body
935                          (function(){
936                                  ++S.in_function;
937                                  var loop = S.in_loop;
938                                  S.in_loop = 0;
939                                  var a = block_();
940                                  --S.in_function;
941                                  S.in_loop = loop;
942                                  return a;
943                          })());
944        });
945
946        function if_() {
947                var cond = parenthesised(), body = statement(), belse;
948                if (is("keyword", "else")) {
949                        next();
950                        belse = statement();
951                }
952                return as("if", cond, body, belse);
953        };
954
955        function block_() {
956                expect("{");
957                var a = [];
958                while (!is("punc", "}")) {
959                        if (is("eof")) unexpected();
960                        a.push(statement());
961                }
962                next();
963                return a;
964        };
965
966        var switch_block_ = curry(in_loop, function(){
967                expect("{");
968                var a = [], cur = null;
969                while (!is("punc", "}")) {
970                        if (is("eof")) unexpected();
971                        if (is("keyword", "case")) {
972                                next();
973                                cur = [];
974                                a.push([ expression(), cur ]);
975                                expect(":");
976                        }
977                        else if (is("keyword", "default")) {
978                                next();
979                                expect(":");
980                                cur = [];
981                                a.push([ null, cur ]);
982                        }
983                        else {
984                                if (!cur) unexpected();
985                                cur.push(statement());
986                        }
987                }
988                next();
989                return a;
990        });
991
992        function try_() {
993                var body = block_(), bcatch, bfinally;
994                if (is("keyword", "catch")) {
995                        next();
996                        expect("(");
997                        if (!is("name"))
998                                croak("Name expected");
999                        var name = S.token.value;
1000                        next();
1001                        expect(")");
1002                        bcatch = [ name, block_() ];
1003                }
1004                if (is("keyword", "finally")) {
1005                        next();
1006                        bfinally = block_();
1007                }
1008                if (!bcatch && !bfinally)
1009                        croak("Missing catch/finally blocks");
1010                return as("try", body, bcatch, bfinally);
1011        };
1012
1013        function vardefs(no_in) {
1014                var a = [];
1015                for (;;) {
1016                        if (!is("name"))
1017                                unexpected();
1018                        var name = S.token.value;
1019                        next();
1020                        if (is("operator", "=")) {
1021                                next();
1022                                a.push([ name, expression(false, no_in) ]);
1023                        } else {
1024                                a.push([ name ]);
1025                        }
1026                        if (!is("punc", ","))
1027                                break;
1028                        next();
1029                }
1030                return a;
1031        };
1032
1033        function var_(no_in) {
1034                return as("var", vardefs(no_in));
1035        };
1036
1037        function const_() {
1038                return as("const", vardefs());
1039        };
1040
1041        function new_() {
1042                var newexp = expr_atom(false), args;
1043                if (is("punc", "(")) {
1044                        next();
1045                        args = expr_list(")");
1046                } else {
1047                        args = [];
1048                }
1049                return subscripts(as("new", newexp, args), true);
1050        };
1051
1052        var expr_atom = maybe_embed_tokens(function(allow_calls) {
1053                if (is("operator", "new")) {
1054                        next();
1055                        return new_();
1056                }
1057                if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
1058                        return make_unary("unary-prefix",
1059                                          prog1(S.token.value, next),
1060                                          expr_atom(allow_calls));
1061                }
1062                if (is("punc")) {
1063                        switch (S.token.value) {
1064                            case "(":
1065                                next();
1066                                return subscripts(prog1(expression, curry(expect, ")")), allow_calls);
1067                            case "[":
1068                                next();
1069                                return subscripts(array_(), allow_calls);
1070                            case "{":
1071                                next();
1072                                return subscripts(object_(), allow_calls);
1073                        }
1074                        unexpected();
1075                }
1076                if (is("keyword", "function")) {
1077                        next();
1078                        return subscripts(function_(false), allow_calls);
1079                }
1080                if (HOP(ATOMIC_START_TOKEN, S.token.type)) {
1081                        var atom = S.token.type == "regexp"
1082                                ? as("regexp", S.token.value[0], S.token.value[1])
1083                                : as(S.token.type, S.token.value);
1084                        return subscripts(prog1(atom, next), allow_calls);
1085                }
1086                unexpected();
1087        });
1088
1089        function expr_list(closing, allow_trailing_comma, allow_empty) {
1090                var first = true, a = [];
1091                while (!is("punc", closing)) {
1092                        if (first) first = false; else expect(",");
1093                        if (allow_trailing_comma && is("punc", closing)) break;
1094                        if (is("punc", ",") && allow_empty) {
1095                                a.push([ "atom", "undefined" ]);
1096                        } else {
1097                                a.push(expression(false));
1098                        }
1099                }
1100                next();
1101                return a;
1102        };
1103
1104        function array_() {
1105                return as("array", expr_list("]", !exigent_mode, true));
1106        };
1107
1108        function object_() {
1109                var first = true, a = [];
1110                while (!is("punc", "}")) {
1111                        if (first) first = false; else expect(",");
1112                        if (!exigent_mode && is("punc", "}"))
1113                                // allow trailing comma
1114                                break;
1115                        var type = S.token.type;
1116                        var name = as_property_name();
1117                        if (type == "name" && (name == "get" || name == "set") && !is("punc", ":")) {
1118                                a.push([ as_name(), function_(false), name ]);
1119                        } else {
1120                                expect(":");
1121                                a.push([ name, expression(false) ]);
1122                        }
1123                }
1124                next();
1125                return as("object", a);
1126        };
1127
1128        function as_property_name() {
1129                switch (S.token.type) {
1130                    case "num":
1131                    case "string":
1132                        return prog1(S.token.value, next);
1133                }
1134                return as_name();
1135        };
1136
1137        function as_name() {
1138                switch (S.token.type) {
1139                    case "name":
1140                    case "operator":
1141                    case "keyword":
1142                    case "atom":
1143                        return prog1(S.token.value, next);
1144                    default:
1145                        unexpected();
1146                }
1147        };
1148
1149        function subscripts(expr, allow_calls) {
1150                if (is("punc", ".")) {
1151                        next();
1152                        return subscripts(as("dot", expr, as_name()), allow_calls);
1153                }
1154                if (is("punc", "[")) {
1155                        next();
1156                        return subscripts(as("sub", expr, prog1(expression, curry(expect, "]"))), allow_calls);
1157                }
1158                if (allow_calls && is("punc", "(")) {
1159                        next();
1160                        return subscripts(as("call", expr, expr_list(")")), true);
1161                }
1162                if (allow_calls && is("operator") && HOP(UNARY_POSTFIX, S.token.value)) {
1163                        return prog1(curry(make_unary, "unary-postfix", S.token.value, expr),
1164                                     next);
1165                }
1166                return expr;
1167        };
1168
1169        function make_unary(tag, op, expr) {
1170                if ((op == "++" || op == "--") && !is_assignable(expr))
1171                        croak("Invalid use of " + op + " operator");
1172                return as(tag, op, expr);
1173        };
1174
1175        function expr_op(left, min_prec, no_in) {
1176                var op = is("operator") ? S.token.value : null;
1177                if (op && op == "in" && no_in) op = null;
1178                var prec = op != null ? PRECEDENCE[op] : null;
1179                if (prec != null && prec > min_prec) {
1180                        next();
1181                        var right = expr_op(expr_atom(true), prec, no_in);
1182                        return expr_op(as("binary", op, left, right), min_prec, no_in);
1183                }
1184                return left;
1185        };
1186
1187        function expr_ops(no_in) {
1188                return expr_op(expr_atom(true), 0, no_in);
1189        };
1190
1191        function maybe_conditional(no_in) {
1192                var expr = expr_ops(no_in);
1193                if (is("operator", "?")) {
1194                        next();
1195                        var yes = expression(false);
1196                        expect(":");
1197                        return as("conditional", expr, yes, expression(false, no_in));
1198                }
1199                return expr;
1200        };
1201
1202        function is_assignable(expr) {
1203                if (!exigent_mode) return true;
1204                switch (expr[0]) {
1205                    case "dot":
1206                    case "sub":
1207                    case "new":
1208                    case "call":
1209                        return true;
1210                    case "name":
1211                        return expr[1] != "this";
1212                }
1213        };
1214
1215        function maybe_assign(no_in) {
1216                var left = maybe_conditional(no_in), val = S.token.value;
1217                if (is("operator") && HOP(ASSIGNMENT, val)) {
1218                        if (is_assignable(left)) {
1219                                next();
1220                                return as("assign", ASSIGNMENT[val], left, maybe_assign(no_in));
1221                        }
1222                        croak("Invalid assignment");
1223                }
1224                return left;
1225        };
1226
1227        var expression = maybe_embed_tokens(function(commas, no_in) {
1228                if (arguments.length == 0)
1229                        commas = true;
1230                var expr = maybe_assign(no_in);
1231                if (commas && is("punc", ",")) {
1232                        next();
1233                        return as("seq", expr, expression(true, no_in));
1234                }
1235                return expr;
1236        });
1237
1238        function in_loop(cont) {
1239                try {
1240                        ++S.in_loop;
1241                        return cont();
1242                } finally {
1243                        --S.in_loop;
1244                }
1245        };
1246
1247        return as("toplevel", (function(a){
1248                while (!is("eof"))
1249                        a.push(statement());
1250                return a;
1251        })([]));
1252
1253};
1254
1255/* -----[ Utilities ]----- */
1256
1257function curry(f) {
1258        var args = slice(arguments, 1);
1259        return function() { return f.apply(this, args.concat(slice(arguments))); };
1260};
1261
1262function prog1(ret) {
1263        if (ret instanceof Function)
1264                ret = ret();
1265        for (var i = 1, n = arguments.length; --n > 0; ++i)
1266                arguments[i]();
1267        return ret;
1268};
1269
1270function array_to_hash(a) {
1271        var ret = {};
1272        for (var i = 0; i < a.length; ++i)
1273                ret[a[i]] = true;
1274        return ret;
1275};
1276
1277function slice(a, start) {
1278        return Array.prototype.slice.call(a, start == null ? 0 : start);
1279};
1280
1281function characters(str) {
1282        return str.split("");
1283};
1284
1285function member(name, array) {
1286        for (var i = array.length; --i >= 0;)
1287                if (array[i] === name)
1288                        return true;
1289        return false;
1290};
1291
1292function HOP(obj, prop) {
1293        return Object.prototype.hasOwnProperty.call(obj, prop);
1294};
1295
1296var warn = function() {};
1297
1298/* -----[ Exports ]----- */
1299
1300exports.tokenizer = tokenizer;
1301exports.parse = parse;
1302exports.slice = slice;
1303exports.curry = curry;
1304exports.member = member;
1305exports.array_to_hash = array_to_hash;
1306exports.PRECEDENCE = PRECEDENCE;
1307exports.KEYWORDS_ATOM = KEYWORDS_ATOM;
1308exports.RESERVED_WORDS = RESERVED_WORDS;
1309exports.KEYWORDS = KEYWORDS;
1310exports.ATOMIC_START_TOKEN = ATOMIC_START_TOKEN;
1311exports.OPERATORS = OPERATORS;
1312exports.is_alphanumeric_char = is_alphanumeric_char;
1313exports.set_logger = function(logger) {
1314        warn = logger;
1315};