Remove duplicated work from NetflixSession.parse_seasons().
[plugin.video.netflix.git] / resources / lib / pyjsparser / parser.py
1 # The MIT License
2 #
3 # Copyright 2014, 2015 Piotr Dabkowski
4 #
5 # Permission is hereby granted, free of charge, to any person obtaining
6 # a copy of this software and associated documentation files (the 'Software'),
7 # to deal in the Software without restriction, including without limitation the rights
8 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9 # the Software, and to permit persons to whom the Software is furnished to do so, subject
10 # to the following conditions:
11 #
12 # The above copyright notice and this permission notice shall be included in all copies or
13 # substantial portions of the Software.
14 #
15 # THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
16 # LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
17 # IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
18 # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
19 #  OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
20 from __future__ import unicode_literals
21 from .pyjsparserdata import *
22 from .std_nodes import *
23 from pprint import pprint
24 import sys
25
26 __all__ = ['PyJsParser', 'parse', 'ENABLE_JS2PY_ERRORS', 'ENABLE_PYIMPORT', 'JsSyntaxError']
27 REGEXP_SPECIAL_SINGLE = ('\\', '^', '$', '*', '+', '?', '.', '[', ']', '(', ')', '{', '{', '|', '-')
28 ENABLE_PYIMPORT = False
29 ENABLE_JS2PY_ERRORS = False
30
31 PY3 = sys.version_info >= (3,0)
32
33 if PY3:
34     basestring = str
35     long = int
36     xrange = range
37     unicode = str
38
39 ESPRIMA_VERSION = '2.2.0'
40 DEBUG = False
41 # Small naming convention changes
42 # len -> leng
43 # id -> d
44 # type -> typ
45 # str -> st
46 true = True
47 false = False
48 null = None
49
50
51 class PyJsParser:
52     """ Usage:
53         parser = PyJsParser()
54         parser.parse('var JavaScriptCode = 5.1')
55     """
56
57     def __init__(self):
58         self.clean()
59
60     def test(self, code):
61         pprint(self.parse(code))
62
63     def clean(self):
64         self.strict = None
65         self.sourceType = None
66         self.index = 0
67         self.lineNumber = 1
68         self.lineStart = 0
69         self.hasLineTerminator = None
70         self.lastIndex = None
71         self.lastLineNumber = None
72         self.lastLineStart = None
73         self.startIndex = None
74         self.startLineNumber = None
75         self.startLineStart = None
76         self.scanning = None
77         self.lookahead = None
78         self.state = None
79         self.extra = None
80         self.isBindingElement = None
81         self.isAssignmentTarget = None
82         self.firstCoverInitializedNameError = None
83
84     # 7.4 Comments
85
86     def skipSingleLineComment(self, offset):
87         start = self.index - offset;
88         while self.index < self.length:
89             ch = self.source[self.index];
90             self.index += 1
91             if isLineTerminator(ch):
92                 if (ord(ch) == 13 and ord(self.source[self.index]) == 10):
93                     self.index += 1
94                 self.lineNumber += 1
95                 self.hasLineTerminator = True
96                 self.lineStart = self.index
97                 return
98
99     def skipMultiLineComment(self):
100         while self.index < self.length:
101             ch = ord(self.source[self.index])
102             if isLineTerminator(ch):
103                 if (ch == 0x0D and ord(self.source[self.index + 1]) == 0x0A):
104                     self.index += 1
105                 self.lineNumber += 1
106                 self.index += 1
107                 self.hasLineTerminator = True
108                 self.lineStart = self.index
109             elif ch == 0x2A:
110                 # Block comment ends with '*/'.
111                 if ord(self.source[self.index + 1]) == 0x2F:
112                     self.index += 2
113                     return
114                 self.index += 1
115             else:
116                 self.index += 1
117         self.tolerateUnexpectedToken()
118
119     def skipComment(self):
120         self.hasLineTerminator = False
121         start = (self.index == 0)
122         while self.index < self.length:
123             ch = ord(self.source[self.index])
124             if isWhiteSpace(ch):
125                 self.index += 1
126             elif isLineTerminator(ch):
127                 self.hasLineTerminator = True
128                 self.index += 1
129                 if (ch == 0x0D and ord(self.source[self.index]) == 0x0A):
130                     self.index += 1
131                 self.lineNumber += 1
132                 self.lineStart = self.index
133                 start = True
134             elif (ch == 0x2F):  # U+002F is '/'
135                 ch = ord(self.source[self.index + 1])
136                 if (ch == 0x2F):
137                     self.index += 2
138                     self.skipSingleLineComment(2)
139                     start = True
140                 elif (ch == 0x2A):  # U+002A is '*'
141                     self.index += 2
142                     self.skipMultiLineComment()
143                 else:
144                     break
145             elif (start and ch == 0x2D):  # U+002D is '-'
146                 # U+003E is '>'
147                 if (ord(self.source[self.index + 1]) == 0x2D) and (ord(self.source[self.index + 2]) == 0x3E):
148                     # '-->' is a single-line comment
149                     self.index += 3
150                     self.skipSingleLineComment(3)
151                 else:
152                     break
153             elif (ch == 0x3C):  # U+003C is '<'
154                 if self.source[self.index + 1: self.index + 4] == '!--':
155                     # <!--
156                     self.index += 4
157                     self.skipSingleLineComment(4)
158                 else:
159                     break
160             else:
161                 break
162
163     def scanHexEscape(self, prefix):
164         code = 0
165         leng = 4 if (prefix == 'u') else 2
166         for i in xrange(leng):
167             if self.index < self.length and isHexDigit(self.source[self.index]):
168                 ch = self.source[self.index]
169                 self.index += 1
170                 code = code * 16 + HEX_CONV[ch]
171             else:
172                 return ''
173         return unichr(code)
174
175     def scanUnicodeCodePointEscape(self):
176         ch = self.source[self.index]
177         code = 0
178         # At least, one hex digit is required.
179         if ch == '}':
180             self.throwUnexpectedToken()
181         while (self.index < self.length):
182             ch = self.source[self.index]
183             self.index += 1
184             if not isHexDigit(ch):
185                 break
186             code = code * 16 + HEX_CONV[ch]
187         if code > 0x10FFFF or ch != '}':
188             self.throwUnexpectedToken()
189         # UTF-16 Encoding
190         if (code <= 0xFFFF):
191             return unichr(code)
192         cu1 = ((code - 0x10000) >> 10) + 0xD800;
193         cu2 = ((code - 0x10000) & 1023) + 0xDC00;
194         return unichr(cu1) + unichr(cu2)
195
196     def ccode(self, offset=0):
197         return ord(self.source[self.index + offset])
198
199     def log_err_case(self):
200         if not DEBUG:
201             return
202         print('INDEX', self.index)
203         print(self.source[self.index - 10:self.index + 10])
204         print('')
205
206     def at(self, loc):
207         return None if loc >= self.length else self.source[loc]
208
209     def substr(self, le, offset=0):
210         return self.source[self.index + offset:self.index + offset + le]
211
212     def getEscapedIdentifier(self):
213         d = self.source[self.index]
214         ch = ord(d)
215         self.index += 1
216         # '\u' (U+005C, U+0075) denotes an escaped character.
217         if (ch == 0x5C):
218             if (ord(self.source[self.index]) != 0x75):
219                 self.throwUnexpectedToken()
220             self.index += 1
221             ch = self.scanHexEscape('u')
222             if not ch or ch == '\\' or not isIdentifierStart(ch[0]):
223                 self.throwUnexpectedToken()
224             d = ch
225         while (self.index < self.length):
226             ch = self.ccode()
227             if not isIdentifierPart(ch):
228                 break
229             self.index += 1
230             d += unichr(ch)
231
232             # '\u' (U+005C, U+0075) denotes an escaped character.
233             if (ch == 0x5C):
234                 d = d[0: len(d) - 1]
235                 if (self.ccode() != 0x75):
236                     self.throwUnexpectedToken()
237                 self.index += 1
238                 ch = self.scanHexEscape('u');
239                 if (not ch or ch == '\\' or not isIdentifierPart(ch[0])):
240                     self.throwUnexpectedToken()
241                 d += ch
242         return d
243
244     def getIdentifier(self):
245         start = self.index
246         self.index += 1
247         while (self.index < self.length):
248             ch = self.ccode()
249             if (ch == 0x5C):
250                 # Blackslash (U+005C) marks Unicode escape sequence.
251                 self.index = start
252                 return self.getEscapedIdentifier()
253             if (isIdentifierPart(ch)):
254                 self.index += 1
255             else:
256                 break
257         return self.source[start: self.index]
258
259     def scanIdentifier(self):
260         start = self.index
261
262         # Backslash (U+005C) starts an escaped character.
263         d = self.getEscapedIdentifier() if (self.ccode() == 0x5C) else self.getIdentifier()
264
265         # There is no keyword or literal with only one character.
266         # Thus, it must be an identifier.
267         if (len(d) == 1):
268             type = Token.Identifier
269         elif (isKeyword(d)):
270             type = Token.Keyword
271         elif (d == 'null'):
272             type = Token.NullLiteral
273         elif (i == 'true' or d == 'false'):
274             type = Token.BooleanLiteral
275         else:
276             type = Token.Identifier;
277         return {
278             'type': type,
279             'value': d,
280             'lineNumber': self.lineNumber,
281             'lineStart': self.lineStart,
282             'start': start,
283             'end': self.index
284         }
285
286     # 7.7 Punctuators
287
288     def scanPunctuator(self):
289         token = {
290             'type': Token.Punctuator,
291             'value': '',
292             'lineNumber': self.lineNumber,
293             'lineStart': self.lineStart,
294             'start': self.index,
295             'end': self.index
296         }
297         # Check for most common single-character punctuators.
298         st = self.source[self.index]
299         if st == '{':
300             self.state['curlyStack'].append('{')
301             self.index += 1
302         elif st == '}':
303             self.index += 1
304             self.state['curlyStack'].pop()
305         elif st in ('.', '(', ')', ';', ',', '[', ']', ':', '?', '~'):
306             self.index += 1
307         else:
308             # 4-character punctuator.
309             st = self.substr(4)
310             if (st == '>>>='):
311                 self.index += 4
312             else:
313                 # 3-character punctuators.
314                 st = st[0:3]
315                 if st in ('===', '!==', '>>>', '<<=', '>>='):
316                     self.index += 3
317                 else:
318                     # 2-character punctuators.
319                     st = st[0:2]
320                     if st in ('&&', '||', '==', '!=', '+=', '-=', '*=', '/=', '++', '--', '<<', '>>', '&=', '|=', '^=',
321                               '%=', '<=', '>=', '=>'):
322                         self.index += 2
323                     else:
324                         # 1-character punctuators.
325                         st = self.source[self.index]
326                         if st in ('<', '>', '=', '!', '+', '-', '*', '%', '&', '|', '^', '/'):
327                             self.index += 1
328         if self.index == token['start']:
329             self.throwUnexpectedToken()
330         token['end'] = self.index;
331         token['value'] = st
332         return token
333
334     # 7.8.3 Numeric Literals
335
336     def scanHexLiteral(self, start):
337         number = ''
338         while (self.index < self.length):
339             if (not isHexDigit(self.source[self.index])):
340                 break
341             number += self.source[self.index]
342             self.index += 1
343         if not number:
344             self.throwUnexpectedToken()
345         if isIdentifierStart(self.ccode()):
346             self.throwUnexpectedToken()
347         return {
348             'type': Token.NumericLiteral,
349             'value': int(number, 16),
350             'lineNumber': self.lineNumber,
351             'lineStart': self.lineStart,
352             'start': start,
353             'end': self.index}
354
355     def scanBinaryLiteral(self, start):
356         number = ''
357         while (self.index < self.length):
358             ch = self.source[self.index]
359             if (ch != '0' and ch != '1'):
360                 break
361             number += self.source[self.index]
362             self.index += 1
363
364         if not number:
365             # only 0b or 0B
366             self.throwUnexpectedToken()
367         if (self.index < self.length):
368             ch = self.source[self.index]
369             # istanbul ignore else
370             if (isIdentifierStart(ch) or isDecimalDigit(ch)):
371                 self.throwUnexpectedToken();
372         return {
373             'type': Token.NumericLiteral,
374             'value': int(number, 2),
375             'lineNumber': self.lineNumber,
376             'lineStart': self.lineStart,
377             'start': start,
378             'end': self.index}
379
380     def scanOctalLiteral(self, prefix, start):
381         if isOctalDigit(prefix):
382             octal = True
383             number = '0' + self.source[self.index]
384             self.index += 1
385         else:
386             octal = False
387             self.index += 1
388             number = ''
389         while (self.index < self.length):
390             if (not isOctalDigit(self.source[self.index])):
391                 break
392             number += self.source[self.index]
393             self.index += 1
394         if (not octal and not number):
395             # only 0o or 0O
396             self.throwUnexpectedToken()
397         if (isIdentifierStart(self.ccode()) or isDecimalDigit(self.ccode())):
398             self.throwUnexpectedToken()
399         return {
400             'type': Token.NumericLiteral,
401             'value': int(number, 8),
402             'lineNumber': self.lineNumber,
403             'lineStart': self.lineStart,
404             'start': start,
405             'end': self.index}
406
407     def octalToDecimal(self, ch):
408         # \0 is not octal escape sequence
409         octal = (ch != '0')
410         code = int(ch, 8)
411
412         if (self.index < self.length and isOctalDigit(self.source[self.index])):
413             octal = True
414             code = code * 8 + int(self.source[self.index], 8)
415             self.index += 1
416
417             # 3 digits are only allowed when string starts
418             # with 0, 1, 2, 3
419             if (ch in '0123' and self.index < self.length and isOctalDigit(self.source[self.index])):
420                 code = code * 8 + int((self.source[self.index]), 8)
421                 self.index += 1
422         return {
423             'code': code,
424             'octal': octal}
425
426     def isImplicitOctalLiteral(self):
427         # Implicit octal, unless there is a non-octal digit.
428         # (Annex B.1.1 on Numeric Literals)
429         for i in xrange(self.index + 1, self.length):
430             ch = self.source[i];
431             if (ch == '8' or ch == '9'):
432                 return False;
433             if (not isOctalDigit(ch)):
434                 return True
435         return True
436
437     def scanNumericLiteral(self):
438         ch = self.source[self.index]
439         assert isDecimalDigit(ch) or (ch == '.'), 'Numeric literal must start with a decimal digit or a decimal point'
440         start = self.index
441         number = ''
442         if ch != '.':
443             number = self.source[self.index]
444             self.index += 1
445             ch = self.source[self.index]
446             # Hex number starts with '0x'.
447             # Octal number starts with '0'.
448             # Octal number in ES6 starts with '0o'.
449             # Binary number in ES6 starts with '0b'.
450             if (number == '0'):
451                 if (ch == 'x' or ch == 'X'):
452                     self.index += 1
453                     return self.scanHexLiteral(start);
454                 if (ch == 'b' or ch == 'B'):
455                     self.index += 1
456                     return self.scanBinaryLiteral(start)
457                 if (ch == 'o' or ch == 'O'):
458                     return self.scanOctalLiteral(ch, start)
459                 if (isOctalDigit(ch)):
460                     if (self.isImplicitOctalLiteral()):
461                         return self.scanOctalLiteral(ch, start);
462             while (isDecimalDigit(self.ccode())):
463                 number += self.source[self.index]
464                 self.index += 1
465             ch = self.source[self.index];
466         if (ch == '.'):
467             number += self.source[self.index]
468             self.index += 1
469             while (isDecimalDigit(self.source[self.index])):
470                 number += self.source[self.index]
471                 self.index += 1
472             ch = self.source[self.index]
473         if (ch == 'e' or ch == 'E'):
474             number += self.source[self.index]
475             self.index += 1
476             ch = self.source[self.index]
477             if (ch == '+' or ch == '-'):
478                 number += self.source[self.index]
479                 self.index += 1
480             if (isDecimalDigit(self.source[self.index])):
481                 while (isDecimalDigit(self.source[self.index])):
482                     number += self.source[self.index]
483                     self.index += 1
484             else:
485                 self.throwUnexpectedToken()
486         if (isIdentifierStart(self.source[self.index])):
487             self.throwUnexpectedToken();
488         return {
489             'type': Token.NumericLiteral,
490             'value': float(number),
491             'lineNumber': self.lineNumber,
492             'lineStart': self.lineStart,
493             'start': start,
494             'end': self.index}
495
496     # 7.8.4 String Literals
497
498     def _interpret_regexp(self, string, flags):
499         '''Perform sctring escape - for regexp literals'''
500         self.index = 0
501         self.length = len(string)
502         self.source = string
503         self.lineNumber = 0
504         self.lineStart = 0
505         octal = False
506         st = ''
507         inside_square = 0
508         while (self.index < self.length):
509             template = '[%s]' if not inside_square else '%s'
510             ch = self.source[self.index]
511             self.index += 1
512             if ch == '\\':
513                 ch = self.source[self.index]
514                 self.index += 1
515                 if (not isLineTerminator(ch)):
516                     if ch == 'u':
517                         digs = self.source[self.index:self.index + 4]
518                         if len(digs) == 4 and all(isHexDigit(d) for d in digs):
519                             st += template % unichr(int(digs, 16))
520                             self.index += 4
521                         else:
522                             st += 'u'
523                     elif ch == 'x':
524                         digs = self.source[self.index:self.index + 2]
525                         if len(digs) == 2 and all(isHexDigit(d) for d in digs):
526                             st += template % unichr(int(digs, 16))
527                             self.index += 2
528                         else:
529                             st += 'x'
530                     # special meaning - single char.
531                     elif ch == '0':
532                         st += '\\0'
533                     elif ch == 'n':
534                         st += '\\n'
535                     elif ch == 'r':
536                         st += '\\r'
537                     elif ch == 't':
538                         st += '\\t'
539                     elif ch == 'f':
540                         st += '\\f'
541                     elif ch == 'v':
542                         st += '\\v'
543
544                     # unescape special single characters like . so that they are interpreted literally
545                     elif ch in REGEXP_SPECIAL_SINGLE:
546                         st += '\\' + ch
547
548                     # character groups
549                     elif ch == 'b':
550                         st += '\\b'
551                     elif ch == 'B':
552                         st += '\\B'
553                     elif ch == 'w':
554                         st += '\\w'
555                     elif ch == 'W':
556                         st += '\\W'
557                     elif ch == 'd':
558                         st += '\\d'
559                     elif ch == 'D':
560                         st += '\\D'
561                     elif ch == 's':
562                         st += template % u' \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff'
563                     elif ch == 'S':
564                         st += template % u'\u0000-\u0008\u000e-\u001f\u0021-\u009f\u00a1-\u167f\u1681-\u180d\u180f-\u1fff\u200b-\u2027\u202a-\u202e\u2030-\u205e\u2060-\u2fff\u3001-\ufefe\uff00-\uffff'
565                     else:
566                         if isDecimalDigit(ch):
567                             num = ch
568                             while self.index < self.length and isDecimalDigit(self.source[self.index]):
569                                 num += self.source[self.index]
570                                 self.index += 1
571                             st += '\\' + num
572
573                         else:
574                             st += ch  # DONT ESCAPE!!!
575                 else:
576                     self.lineNumber += 1
577                     if (ch == '\r' and self.source[self.index] == '\n'):
578                         self.index += 1
579                     self.lineStart = self.index
580             else:
581                 if ch == '[':
582                     inside_square = True
583                 elif ch == ']':
584                     inside_square = False
585                 st += ch
586         # print string, 'was transformed to', st
587         return st
588
589     def scanStringLiteral(self):
590         st = ''
591         octal = False
592
593         quote = self.source[self.index]
594         assert quote == '\'' or quote == '"', 'String literal must starts with a quote'
595         start = self.index;
596         self.index += 1
597
598         while (self.index < self.length):
599             ch = self.source[self.index]
600             self.index += 1
601             if (ch == quote):
602                 quote = ''
603                 break
604             elif (ch == '\\'):
605                 ch = self.source[self.index]
606                 self.index += 1
607                 if (not isLineTerminator(ch)):
608                     if ch in 'ux':
609                         if (self.source[self.index] == '{'):
610                             self.index += 1
611                             st += self.scanUnicodeCodePointEscape()
612                         else:
613                             unescaped = self.scanHexEscape(ch)
614                             if (not unescaped):
615                                 self.throwUnexpectedToken()  # with throw I don't know whats the difference
616                             st += unescaped
617                     elif ch == 'n':
618                         st += '\n';
619                     elif ch == 'r':
620                         st += '\r';
621                     elif ch == 't':
622                         st += '\t';
623                     elif ch == 'b':
624                         st += '\b';
625                     elif ch == 'f':
626                         st += '\f';
627                     elif ch == 'v':
628                         st += '\x0B'
629                     # elif ch in '89':
630                     #    self.throwUnexpectedToken() # again with throw....
631                     else:
632                         if isOctalDigit(ch):
633                             octToDec = self.octalToDecimal(ch)
634                             octal = octToDec.get('octal') or octal
635                             st += unichr(octToDec['code'])
636                         else:
637                             st += ch
638                 else:
639                     self.lineNumber += 1
640                     if (ch == '\r' and self.source[self.index] == '\n'):
641                         self.index += 1
642                     self.lineStart = self.index
643             elif isLineTerminator(ch):
644                 break
645             else:
646                 st += ch;
647         if (quote != ''):
648             self.throwUnexpectedToken()
649         return {
650             'type': Token.StringLiteral,
651             'value': st,
652             'octal': octal,
653             'lineNumber': self.lineNumber,
654             'lineStart': self.startLineStart,
655             'start': start,
656             'end': self.index}
657
658     def scanTemplate(self):
659         cooked = ''
660         terminated = False
661         tail = False
662         start = self.index
663         head = (self.source[self.index] == '`')
664         rawOffset = 2
665
666         self.index += 1
667
668         while (self.index < self.length):
669             ch = self.source[self.index]
670             self.index += 1
671             if (ch == '`'):
672                 rawOffset = 1;
673                 tail = True
674                 terminated = True
675                 break
676             elif (ch == '$'):
677                 if (self.source[self.index] == '{'):
678                     self.state['curlyStack'].append('${')
679                     self.index += 1
680                     terminated = True
681                     break;
682                 cooked += ch
683             elif (ch == '\\'):
684                 ch = self.source[self.index]
685                 self.index += 1
686                 if (not isLineTerminator(ch)):
687                     if ch == 'n':
688                         cooked += '\n'
689                     elif ch == 'r':
690                         cooked += '\r'
691                     elif ch == 't':
692                         cooked += '\t'
693                     elif ch in 'ux':
694                         if (self.source[self.index] == '{'):
695                             self.index += 1
696                             cooked += self.scanUnicodeCodePointEscape()
697                         else:
698                             restore = self.index
699                             unescaped = self.scanHexEscape(ch)
700                             if (unescaped):
701                                 cooked += unescaped
702                             else:
703                                 self.index = restore
704                                 cooked += ch
705                     elif ch == 'b':
706                         cooked += '\b'
707                     elif ch == 'f':
708                         cooked += '\f'
709                     elif ch == 'v':
710                         cooked += '\v'
711                     else:
712                         if (ch == '0'):
713                             if isDecimalDigit(self.ccode()):
714                                 # Illegal: \01 \02 and so on
715                                 self.throwError(Messages.TemplateOctalLiteral)
716                             cooked += '\0'
717                         elif (isOctalDigit(ch)):
718                             # Illegal: \1 \2
719                             self.throwError(Messages.TemplateOctalLiteral)
720                         else:
721                             cooked += ch
722                 else:
723                     self.lineNumber += 1
724                     if (ch == '\r' and self.source[self.index] == '\n'):
725                         self.index += 1
726                     self.lineStart = self.index
727             elif (isLineTerminator(ch)):
728                 self.lineNumber += 1
729                 if (ch == '\r' and self.source[self.index] == '\n'):
730                     self.index += 1
731                 self.lineStart = self.index
732                 cooked += '\n'
733             else:
734                 cooked += ch;
735         if (not terminated):
736             self.throwUnexpectedToken()
737
738         if (not head):
739             self.state['curlyStack'].pop();
740
741         return {
742             'type': Token.Template,
743             'value': {
744                 'cooked': cooked,
745                 'raw': self.source[start + 1:self.index - rawOffset]},
746             'head': head,
747             'tail': tail,
748             'lineNumber': self.lineNumber,
749             'lineStart': self.lineStart,
750             'start': start,
751             'end': self.index}
752
753     def testRegExp(self, pattern, flags):
754         # todo: you should return python regexp object
755         return (pattern, flags)
756
757     def scanRegExpBody(self):
758         ch = self.source[self.index]
759         assert ch == '/', 'Regular expression literal must start with a slash'
760         st = ch
761         self.index += 1
762
763         classMarker = False
764         terminated = False
765         while (self.index < self.length):
766             ch = self.source[self.index]
767             self.index += 1
768             st += ch
769             if (ch == '\\'):
770                 ch = self.source[self.index]
771                 self.index += 1
772                 # ECMA-262 7.8.5
773                 if (isLineTerminator(ch)):
774                     self.throwUnexpectedToken(None, Messages.UnterminatedRegExp)
775                 st += ch
776             elif (isLineTerminator(ch)):
777                 self.throwUnexpectedToken(None, Messages.UnterminatedRegExp)
778             elif (classMarker):
779                 if (ch == ']'):
780                     classMarker = False
781             else:
782                 if (ch == '/'):
783                     terminated = True
784                     break
785                 elif (ch == '['):
786                     classMarker = True;
787         if (not terminated):
788             self.throwUnexpectedToken(None, Messages.UnterminatedRegExp)
789
790         # Exclude leading and trailing slash.
791         body = st[1:-1]
792         return {
793             'value': body,
794             'literal': st}
795
796     def scanRegExpFlags(self):
797         st = ''
798         flags = ''
799         while (self.index < self.length):
800             ch = self.source[self.index]
801             if (not isIdentifierPart(ch)):
802                 break
803             self.index += 1
804             if (ch == '\\' and self.index < self.length):
805                 ch = self.source[self.index]
806                 if (ch == 'u'):
807                     self.index += 1
808                     restore = self.index
809                     ch = self.scanHexEscape('u')
810                     if (ch):
811                         flags += ch
812                         st += '\\u'
813                         while restore < self.index:
814                             st += self.source[restore]
815                             restore += 1
816                     else:
817                         self.index = restore
818                         flags += 'u'
819                         st += '\\u'
820                     self.tolerateUnexpectedToken()
821                 else:
822                     st += '\\'
823                     self.tolerateUnexpectedToken()
824             else:
825                 flags += ch
826                 st += ch
827         return {
828             'value': flags,
829             'literal': st}
830
831     def scanRegExp(self):
832         self.scanning = True
833         self.lookahead = None
834         self.skipComment()
835         start = self.index
836
837         body = self.scanRegExpBody()
838         flags = self.scanRegExpFlags()
839         value = self.testRegExp(body['value'], flags['value'])
840         scanning = False
841         return {
842             'literal': body['literal'] + flags['literal'],
843             'value': value,
844             'regex': {
845                 'pattern': body['value'],
846                 'flags': flags['value']
847             },
848             'start': start,
849             'end': self.index}
850
851     def collectRegex(self):
852         self.skipComment();
853         return self.scanRegExp()
854
855     def isIdentifierName(self, token):
856         return token['type'] in (1, 3, 4, 5)
857
858     # def advanceSlash(self): ???
859
860     def advance(self):
861         if (self.index >= self.length):
862             return {
863                 'type': Token.EOF,
864                 'lineNumber': self.lineNumber,
865                 'lineStart': self.lineStart,
866                 'start': self.index,
867                 'end': self.index}
868         ch = self.ccode()
869
870         if isIdentifierStart(ch):
871             token = self.scanIdentifier()
872             if (self.strict and isStrictModeReservedWord(token['value'])):
873                 token['type'] = Token.Keyword
874             return token
875         # Very common: ( and ) and ;
876         if (ch == 0x28 or ch == 0x29 or ch == 0x3B):
877             return self.scanPunctuator()
878
879         # String literal starts with single quote (U+0027) or double quote (U+0022).
880         if (ch == 0x27 or ch == 0x22):
881             return self.scanStringLiteral()
882
883         # Dot (.) U+002E can also start a floating-point number, hence the need
884         # to check the next character.
885         if (ch == 0x2E):
886             if (isDecimalDigit(self.ccode(1))):
887                 return self.scanNumericLiteral()
888             return self.scanPunctuator();
889
890         if (isDecimalDigit(ch)):
891             return self.scanNumericLiteral()
892
893         # Slash (/) U+002F can also start a regex.
894         # if (extra.tokenize && ch == 0x2F):
895         #    return advanceSlash();
896
897         # Template literals start with ` (U+0060) for template head
898         # or } (U+007D) for template middle or template tail.
899         if (ch == 0x60 or (ch == 0x7D and self.state['curlyStack'][len(self.state['curlyStack']) - 1] == '${')):
900             return self.scanTemplate()
901         return self.scanPunctuator();
902
903     # def collectToken(self):
904     #    loc = {
905     #        'start': {
906     #            'line': self.lineNumber,
907     #            'column': self.index - self.lineStart}}
908     #
909     #    token = self.advance()
910     #
911     #    loc['end'] = {
912     #        'line': self.lineNumber,
913     #        'column': self.index - self.lineStart}
914     #    if (token['type'] != Token.EOF):
915     #        value = self.source[token['start']: token['end']]
916     #        entry = {
917     #            'type': TokenName[token['type']],
918     #            'value': value,
919     #            'range': [token['start'], token['end']],
920     #            'loc': loc}
921     #        if (token.get('regex')):
922     #            entry['regex'] = {
923     #                'pattern': token['regex']['pattern'],
924     #                'flags': token['regex']['flags']}
925     #        self.extra['tokens'].append(entry)
926     #    return token;
927
928
929     def lex(self):
930         self.scanning = True
931
932         self.lastIndex = self.index
933         self.lastLineNumber = self.lineNumber
934         self.lastLineStart = self.lineStart
935
936         self.skipComment()
937
938         token = self.lookahead
939
940         self.startIndex = self.index
941         self.startLineNumber = self.lineNumber
942         self.startLineStart = self.lineStart
943
944         self.lookahead = self.advance()
945         self.scanning = False
946         return token
947
948     def peek(self):
949         self.scanning = True
950
951         self.skipComment()
952
953         self.lastIndex = self.index
954         self.lastLineNumber = self.lineNumber
955         self.lastLineStart = self.lineStart
956
957         self.startIndex = self.index
958         self.startLineNumber = self.lineNumber
959         self.startLineStart = self.lineStart
960
961         self.lookahead = self.advance()
962         self.scanning = False
963
964     def createError(self, line, pos, description):
965         global ENABLE_PYIMPORT
966         if ENABLE_JS2PY_ERRORS:
967             old_pyimport = ENABLE_PYIMPORT  # ENABLE_PYIMPORT will be affected by js2py import
968             self.log_err_case()
969             try:
970                 from js2py.base import ERRORS, Js, JsToPyException
971             except:
972                 raise Exception("ENABLE_JS2PY_ERRORS was set to True, but Js2Py was not found!")
973             ENABLE_PYIMPORT = old_pyimport
974             error = ERRORS['SyntaxError']('Line ' + unicode(line) + ': ' + unicode(description))
975             error.put('index', Js(pos))
976             error.put('lineNumber', Js(line))
977             error.put('column', Js(pos - (self.lineStart if self.scanning else self.lastLineStart) + 1))
978             error.put('description', Js(description))
979             return JsToPyException(error)
980         else:
981             return JsSyntaxError('Line ' + unicode(line) + ': ' + unicode(description))
982
983
984     # Throw an exception
985
986     def throwError(self, messageFormat, *args):
987         msg = messageFormat % tuple(unicode(e) for e in args)
988         raise self.createError(self.lastLineNumber, self.lastIndex, msg);
989
990     def tolerateError(self, messageFormat, *args):
991         return self.throwError(messageFormat, *args)
992
993     # Throw an exception because of the token.
994
995     def unexpectedTokenError(self, token={}, message=''):
996         msg = message or Messages.UnexpectedToken
997         if (token):
998             typ = token['type']
999             if (not message):
1000                 if typ == Token.EOF:
1001                     msg = Messages.UnexpectedEOS
1002                 elif (typ == Token.Identifier):
1003                     msg = Messages.UnexpectedIdentifier
1004                 elif (typ == Token.NumericLiteral):
1005                     msg = Messages.UnexpectedNumber
1006                 elif (typ == Token.StringLiteral):
1007                     msg = Messages.UnexpectedString
1008                 elif (typ == Token.Template):
1009                     msg = Messages.UnexpectedTemplate
1010                 else:
1011                     msg = Messages.UnexpectedToken;
1012                 if (typ == Token.Keyword):
1013                     if (isFutureReservedWord(token['value'])):
1014                         msg = Messages.UnexpectedReserved
1015                     elif (self.strict and isStrictModeReservedWord(token['value'])):
1016                         msg = Messages.StrictReservedWord
1017             value = token['value']['raw'] if (typ == Token.Template)  else token.get('value')
1018         else:
1019             value = 'ILLEGAL'
1020         msg = msg.replace('%s', unicode(value))
1021
1022         return (self.createError(token['lineNumber'], token['start'], msg) if (token and token.get('lineNumber')) else
1023                 self.createError(self.lineNumber if self.scanning else self.lastLineNumber,
1024                                  self.index if self.scanning else self.lastIndex, msg))
1025
1026     def throwUnexpectedToken(self, token={}, message=''):
1027         raise self.unexpectedTokenError(token, message)
1028
1029     def tolerateUnexpectedToken(self, token={}, message=''):
1030         self.throwUnexpectedToken(token, message)
1031
1032     # Expect the next token to match the specified punctuator.
1033     # If not, an exception will be thrown.
1034
1035     def expect(self, value):
1036         token = self.lex()
1037         if (token['type'] != Token.Punctuator or token['value'] != value):
1038             self.throwUnexpectedToken(token)
1039
1040     # /**
1041     # * @name expectCommaSeparator
1042     # * @description Quietly expect a comma when in tolerant mode, otherwise delegates
1043     # * to <code>expect(value)</code>
1044     # * @since 2.0
1045     # */
1046     def expectCommaSeparator(self):
1047         self.expect(',')
1048
1049     # Expect the next token to match the specified keyword.
1050     # If not, an exception will be thrown.
1051
1052     def expectKeyword(self, keyword):
1053         token = self.lex();
1054         if (token['type'] != Token.Keyword or token['value'] != keyword):
1055             self.throwUnexpectedToken(token)
1056
1057     # Return true if the next token matches the specified punctuator.
1058
1059     def match(self, value):
1060         return self.lookahead['type'] == Token.Punctuator and self.lookahead['value'] == value
1061
1062     # Return true if the next token matches the specified keyword
1063
1064     def matchKeyword(self, keyword):
1065         return self.lookahead['type'] == Token.Keyword and self.lookahead['value'] == keyword
1066
1067     # Return true if the next token matches the specified contextual keyword
1068     # (where an identifier is sometimes a keyword depending on the context)
1069
1070     def matchContextualKeyword(self, keyword):
1071         return self.lookahead['type'] == Token.Identifier and self.lookahead['value'] == keyword
1072
1073     # Return true if the next token is an assignment operator
1074
1075     def matchAssign(self):
1076         if (self.lookahead['type'] != Token.Punctuator):
1077             return False;
1078         op = self.lookahead['value']
1079         return op in ('=', '*=', '/=', '%=', '+=', '-=', '<<=', '>>=', '>>>=', '&=', '^=', '|=')
1080
1081     def consumeSemicolon(self):
1082         # Catch the very common case first: immediately a semicolon (U+003B).
1083
1084         if (self.at(self.startIndex) == ';' or self.match(';')):
1085             self.lex()
1086             return
1087
1088         if (self.hasLineTerminator):
1089             return
1090
1091         # TODO: FIXME(ikarienator): this is seemingly an issue in the previous location info convention.
1092         self.lastIndex = self.startIndex
1093         self.lastLineNumber = self.startLineNumber
1094         self.lastLineStart = self.startLineStart
1095
1096         if (self.lookahead['type'] != Token.EOF and not self.match('}')):
1097             self.throwUnexpectedToken(self.lookahead)
1098
1099     # // Cover grammar support.
1100     # //
1101     # // When an assignment expression position starts with an left parenthesis, the determination of the type
1102     # // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)
1103     # // or the first comma. This situation also defers the determination of all the expressions nested in the pair.
1104     # //
1105     # // There are three productions that can be parsed in a parentheses pair that needs to be determined
1106     # // after the outermost pair is closed. They are:
1107     # //
1108     # //   1. AssignmentExpression
1109     # //   2. BindingElements
1110     # //   3. AssignmentTargets
1111     # //
1112     # // In order to avoid exponential backtracking, we use two flags to denote if the production can be
1113     # // binding element or assignment target.
1114     # //
1115     # // The three productions have the relationship:
1116     # //
1117     # //   BindingElements <= AssignmentTargets <= AssignmentExpression
1118     # //
1119     # // with a single exception that CoverInitializedName when used directly in an Expression, generates
1120     # // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the
1121     # // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.
1122     # //
1123     # // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not
1124     # // effect the current flags. This means the production the parser parses is only used as an expression. Therefore
1125     # // the CoverInitializedName check is conducted.
1126     # //
1127     # // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates
1128     # // the flags outside of the parser. This means the production the parser parses is used as a part of a potential
1129     # // pattern. The CoverInitializedName check is deferred.
1130
1131     def isolateCoverGrammar(self, parser):
1132         oldIsBindingElement = self.isBindingElement
1133         oldIsAssignmentTarget = self.isAssignmentTarget
1134         oldFirstCoverInitializedNameError = self.firstCoverInitializedNameError
1135         self.isBindingElement = true
1136         self.isAssignmentTarget = true
1137         self.firstCoverInitializedNameError = null
1138         result = parser()
1139         if (self.firstCoverInitializedNameError != null):
1140             self.throwUnexpectedToken(self.firstCoverInitializedNameError)
1141         self.isBindingElement = oldIsBindingElement
1142         self.isAssignmentTarget = oldIsAssignmentTarget
1143         self.firstCoverInitializedNameError = oldFirstCoverInitializedNameError
1144         return result
1145
1146     def inheritCoverGrammar(self, parser):
1147         oldIsBindingElement = self.isBindingElement
1148         oldIsAssignmentTarget = self.isAssignmentTarget
1149         oldFirstCoverInitializedNameError = self.firstCoverInitializedNameError
1150         self.isBindingElement = true
1151         self.isAssignmentTarget = true
1152         self.firstCoverInitializedNameError = null
1153         result = parser()
1154         self.isBindingElement = self.isBindingElement and oldIsBindingElement
1155         self.isAssignmentTarget = self.isAssignmentTarget and oldIsAssignmentTarget
1156         self.firstCoverInitializedNameError = oldFirstCoverInitializedNameError or self.firstCoverInitializedNameError
1157         return result
1158
1159     def parseArrayPattern(self):
1160         node = Node()
1161         elements = []
1162         self.expect('[');
1163         while (not self.match(']')):
1164             if (self.match(',')):
1165                 self.lex()
1166                 elements.append(null)
1167             else:
1168                 if (self.match('...')):
1169                     restNode = Node()
1170                     self.lex()
1171                     rest = self.parseVariableIdentifier()
1172                     elements.append(restNode.finishRestElement(rest))
1173                     break
1174                 else:
1175                     elements.append(self.parsePatternWithDefault())
1176                 if (not self.match(']')):
1177                     self.expect(',')
1178         self.expect(']')
1179         return node.finishArrayPattern(elements)
1180
1181     def parsePropertyPattern(self):
1182         node = Node()
1183         computed = self.match('[')
1184         if (self.lookahead['type'] == Token.Identifier):
1185             key = self.parseVariableIdentifier()
1186             if (self.match('=')):
1187                 self.lex();
1188                 init = self.parseAssignmentExpression()
1189                 return node.finishProperty(
1190                     'init', key, false, WrappingNode(key).finishAssignmentPattern(key, init), false, false)
1191             elif (not self.match(':')):
1192                 return node.finishProperty('init', key, false, key, false, true)
1193         else:
1194             key = self.parseObjectPropertyKey()
1195         self.expect(':')
1196         init = self.parsePatternWithDefault()
1197         return node.finishProperty('init', key, computed, init, false, false)
1198
1199     def parseObjectPattern(self):
1200         node = Node()
1201         properties = []
1202         self.expect('{')
1203         while (not self.match('}')):
1204             properties.append(self.parsePropertyPattern())
1205             if (not self.match('}')):
1206                 self.expect(',')
1207         self.lex()
1208         return node.finishObjectPattern(properties)
1209
1210     def parsePattern(self):
1211         if (self.lookahead['type'] == Token.Identifier):
1212             return self.parseVariableIdentifier()
1213         elif (self.match('[')):
1214             return self.parseArrayPattern()
1215         elif (self.match('{')):
1216             return self.parseObjectPattern()
1217         self.throwUnexpectedToken(self.lookahead)
1218
1219     def parsePatternWithDefault(self):
1220         startToken = self.lookahead
1221
1222         pattern = self.parsePattern()
1223         if (self.match('=')):
1224             self.lex()
1225             right = self.isolateCoverGrammar(self.parseAssignmentExpression)
1226             pattern = WrappingNode(startToken).finishAssignmentPattern(pattern, right)
1227         return pattern
1228
1229     # 11.1.4 Array Initialiser
1230
1231     def parseArrayInitialiser(self):
1232         elements = []
1233         node = Node()
1234
1235         self.expect('[')
1236
1237         while (not self.match(']')):
1238             if (self.match(',')):
1239                 self.lex()
1240                 elements.append(null)
1241             elif (self.match('...')):
1242                 restSpread = Node()
1243                 self.lex()
1244                 restSpread.finishSpreadElement(self.inheritCoverGrammar(self.parseAssignmentExpression))
1245                 if (not self.match(']')):
1246                     self.isAssignmentTarget = self.isBindingElement = false
1247                     self.expect(',')
1248                 elements.append(restSpread)
1249             else:
1250                 elements.append(self.inheritCoverGrammar(self.parseAssignmentExpression))
1251                 if (not self.match(']')):
1252                     self.expect(',')
1253         self.lex();
1254
1255         return node.finishArrayExpression(elements)
1256
1257     # 11.1.5 Object Initialiser
1258
1259     def parsePropertyFunction(self, node, paramInfo):
1260
1261         self.isAssignmentTarget = self.isBindingElement = false;
1262
1263         previousStrict = self.strict;
1264         body = self.isolateCoverGrammar(self.parseFunctionSourceElements);
1265
1266         if (self.strict and paramInfo['firstRestricted']):
1267             self.tolerateUnexpectedToken(paramInfo['firstRestricted'], paramInfo.get('message'))
1268         if (self.strict and paramInfo['stricted']):
1269             self.tolerateUnexpectedToken(paramInfo['stricted'], paramInfo.get('message'));
1270
1271         self.strict = previousStrict;
1272         return node.finishFunctionExpression(null, paramInfo['params'], paramInfo['defaults'], body)
1273
1274     def parsePropertyMethodFunction(self):
1275         node = Node();
1276
1277         params = self.parseParams();
1278         method = self.parsePropertyFunction(node, params);
1279         return method;
1280
1281     def parseObjectPropertyKey(self):
1282         node = Node()
1283
1284         token = self.lex();
1285
1286         # // Note: This function is called only from parseObjectProperty(), where
1287         # // EOF and Punctuator tokens are already filtered out.
1288
1289         typ = token['type']
1290
1291         if typ in [Token.StringLiteral, Token.NumericLiteral]:
1292             if self.strict and token.get('octal'):
1293                 self.tolerateUnexpectedToken(token, Messages.StrictOctalLiteral);
1294             return node.finishLiteral(token);
1295         elif typ in (Token.Identifier, Token.BooleanLiteral, Token.NullLiteral, Token.Keyword):
1296             return node.finishIdentifier(token['value']);
1297         elif typ == Token.Punctuator:
1298             if (token['value'] == '['):
1299                 expr = self.isolateCoverGrammar(self.parseAssignmentExpression)
1300                 self.expect(']')
1301                 return expr
1302         self.throwUnexpectedToken(token)
1303
1304     def lookaheadPropertyName(self):
1305         typ = self.lookahead['type']
1306         if typ in (Token.Identifier, Token.StringLiteral, Token.BooleanLiteral, Token.NullLiteral, Token.NumericLiteral,
1307                    Token.Keyword):
1308             return true
1309         if typ == Token.Punctuator:
1310             return self.lookahead['value'] == '['
1311         return false
1312
1313     # // This function is to try to parse a MethodDefinition as defined in 14.3. But in the case of object literals,
1314     # // it might be called at a position where there is in fact a short hand identifier pattern or a data property.
1315     # // This can only be determined after we consumed up to the left parentheses.
1316     # //
1317     # // In order to avoid back tracking, it returns `null` if the position is not a MethodDefinition and the caller
1318     # // is responsible to visit other options.
1319     def tryParseMethodDefinition(self, token, key, computed, node):
1320         if (token['type'] == Token.Identifier):
1321             # check for `get` and `set`;
1322
1323             if (token['value'] == 'get' and self.lookaheadPropertyName()):
1324                 computed = self.match('[');
1325                 key = self.parseObjectPropertyKey()
1326                 methodNode = Node()
1327                 self.expect('(')
1328                 self.expect(')')
1329                 value = self.parsePropertyFunction(methodNode, {
1330                     'params': [],
1331                     'defaults': [],
1332                     'stricted': null,
1333                     'firstRestricted': null,
1334                     'message': null
1335                 })
1336                 return node.finishProperty('get', key, computed, value, false, false)
1337             elif (token['value'] == 'set' and self.lookaheadPropertyName()):
1338                 computed = self.match('[')
1339                 key = self.parseObjectPropertyKey()
1340                 methodNode = Node()
1341                 self.expect('(')
1342
1343                 options = {
1344                     'params': [],
1345                     'defaultCount': 0,
1346                     'defaults': [],
1347                     'firstRestricted': null,
1348                     'paramSet': {}
1349                 }
1350                 if (self.match(')')):
1351                     self.tolerateUnexpectedToken(self.lookahead);
1352                 else:
1353                     self.parseParam(options);
1354                     if (options['defaultCount'] == 0):
1355                         options['defaults'] = []
1356                 self.expect(')')
1357
1358                 value = self.parsePropertyFunction(methodNode, options);
1359                 return node.finishProperty('set', key, computed, value, false, false);
1360         if (self.match('(')):
1361             value = self.parsePropertyMethodFunction();
1362             return node.finishProperty('init', key, computed, value, true, false)
1363         return null;
1364
1365     def checkProto(self, key, computed, hasProto):
1366         if (computed == false and (key['type'] == Syntax.Identifier and key['name'] == '__proto__' or
1367                                                key['type'] == Syntax.Literal and key['value'] == '__proto__')):
1368             if (hasProto['value']):
1369                 self.tolerateError(Messages.DuplicateProtoProperty);
1370             else:
1371                 hasProto['value'] = true;
1372
1373     def parseObjectProperty(self, hasProto):
1374         token = self.lookahead
1375         node = Node()
1376
1377         computed = self.match('[');
1378         key = self.parseObjectPropertyKey();
1379         maybeMethod = self.tryParseMethodDefinition(token, key, computed, node)
1380
1381         if (maybeMethod):
1382             self.checkProto(maybeMethod['key'], maybeMethod['computed'], hasProto);
1383             return maybeMethod;
1384
1385         # // init property or short hand property.
1386         self.checkProto(key, computed, hasProto);
1387
1388         if (self.match(':')):
1389             self.lex();
1390             value = self.inheritCoverGrammar(self.parseAssignmentExpression)
1391             return node.finishProperty('init', key, computed, value, false, false)
1392
1393         if (token['type'] == Token.Identifier):
1394             if (self.match('=')):
1395                 self.firstCoverInitializedNameError = self.lookahead;
1396                 self.lex();
1397                 value = self.isolateCoverGrammar(self.parseAssignmentExpression);
1398                 return node.finishProperty('init', key, computed,
1399                                            WrappingNode(token).finishAssignmentPattern(key, value), false, true)
1400             return node.finishProperty('init', key, computed, key, false, true)
1401         self.throwUnexpectedToken(self.lookahead)
1402
1403     def parseObjectInitialiser(self):
1404         properties = []
1405         hasProto = {'value': false}
1406         node = Node();
1407
1408         self.expect('{');
1409
1410         while (not self.match('}')):
1411             properties.append(self.parseObjectProperty(hasProto));
1412
1413             if (not self.match('}')):
1414                 self.expectCommaSeparator()
1415         self.expect('}');
1416         return node.finishObjectExpression(properties)
1417
1418     def reinterpretExpressionAsPattern(self, expr):
1419         typ = (expr['type'])
1420         if typ in (Syntax.Identifier, Syntax.MemberExpression, Syntax.RestElement, Syntax.AssignmentPattern):
1421             pass
1422         elif typ == Syntax.SpreadElement:
1423             expr['type'] = Syntax.RestElement
1424             self.reinterpretExpressionAsPattern(expr.argument)
1425         elif typ == Syntax.ArrayExpression:
1426             expr['type'] = Syntax.ArrayPattern
1427             for i in xrange(len(expr['elements'])):
1428                 if (expr['elements'][i] != null):
1429                     self.reinterpretExpressionAsPattern(expr['elements'][i])
1430         elif typ == Syntax.ObjectExpression:
1431             expr['type'] = Syntax.ObjectPattern
1432             for i in xrange(len(expr['properties'])):
1433                 self.reinterpretExpressionAsPattern(expr['properties'][i]['value']);
1434         elif Syntax.AssignmentExpression:
1435             expr['type'] = Syntax.AssignmentPattern;
1436             self.reinterpretExpressionAsPattern(expr['left'])
1437         else:
1438             # // Allow other node type for tolerant parsing.
1439             return
1440
1441     def parseTemplateElement(self, option):
1442
1443         if (self.lookahead['type'] != Token.Template or (option['head'] and not self.lookahead['head'])):
1444             self.throwUnexpectedToken()
1445
1446         node = Node();
1447         token = self.lex();
1448
1449         return node.finishTemplateElement({'raw': token['value']['raw'], 'cooked': token['value']['cooked']},
1450                                           token['tail'])
1451
1452     def parseTemplateLiteral(self):
1453         node = Node()
1454
1455         quasi = self.parseTemplateElement({'head': true})
1456         quasis = [quasi]
1457         expressions = []
1458
1459         while (not quasi['tail']):
1460             expressions.append(self.parseExpression());
1461             quasi = self.parseTemplateElement({'head': false});
1462             quasis.append(quasi)
1463         return node.finishTemplateLiteral(quasis, expressions)
1464
1465     # 11.1.6 The Grouping Operator
1466
1467     def parseGroupExpression(self):
1468         self.expect('(');
1469
1470         if (self.match(')')):
1471             self.lex();
1472             if (not self.match('=>')):
1473                 self.expect('=>')
1474             return {
1475                 'type': PlaceHolders.ArrowParameterPlaceHolder,
1476                 'params': []}
1477
1478         startToken = self.lookahead
1479         if (self.match('...')):
1480             expr = self.parseRestElement();
1481             self.expect(')');
1482             if (not self.match('=>')):
1483                 self.expect('=>')
1484             return {
1485                 'type': PlaceHolders.ArrowParameterPlaceHolder,
1486                 'params': [expr]}
1487
1488         self.isBindingElement = true;
1489         expr = self.inheritCoverGrammar(self.parseAssignmentExpression);
1490
1491         if (self.match(',')):
1492             self.isAssignmentTarget = false;
1493             expressions = [expr]
1494
1495             while (self.startIndex < self.length):
1496                 if (not self.match(',')):
1497                     break
1498                 self.lex();
1499
1500                 if (self.match('...')):
1501                     if (not self.isBindingElement):
1502                         self.throwUnexpectedToken(self.lookahead)
1503                     expressions.append(self.parseRestElement())
1504                     self.expect(')');
1505                     if (not self.match('=>')):
1506                         self.expect('=>');
1507                     self.isBindingElement = false
1508                     for i in xrange(len(expressions)):
1509                         self.reinterpretExpressionAsPattern(expressions[i])
1510                     return {
1511                         'type': PlaceHolders.ArrowParameterPlaceHolder,
1512                         'params': expressions}
1513                 expressions.append(self.inheritCoverGrammar(self.parseAssignmentExpression))
1514             expr = WrappingNode(startToken).finishSequenceExpression(expressions);
1515         self.expect(')')
1516
1517         if (self.match('=>')):
1518             if (not self.isBindingElement):
1519                 self.throwUnexpectedToken(self.lookahead);
1520             if (expr['type'] == Syntax.SequenceExpression):
1521                 for i in xrange(len(expr.expressions)):
1522                     self.reinterpretExpressionAsPattern(expr['expressions'][i])
1523             else:
1524                 self.reinterpretExpressionAsPattern(expr);
1525             expr = {
1526                 'type': PlaceHolders.ArrowParameterPlaceHolder,
1527                 'params': expr['expressions'] if expr['type'] == Syntax.SequenceExpression  else [expr]}
1528         self.isBindingElement = false
1529         return expr
1530
1531     # 11.1 Primary Expressions
1532
1533     def parsePrimaryExpression(self):
1534         if (self.match('(')):
1535             self.isBindingElement = false;
1536             return self.inheritCoverGrammar(self.parseGroupExpression)
1537         if (self.match('[')):
1538             return self.inheritCoverGrammar(self.parseArrayInitialiser)
1539
1540         if (self.match('{')):
1541             return self.inheritCoverGrammar(self.parseObjectInitialiser)
1542
1543         typ = self.lookahead['type']
1544         node = Node();
1545
1546         if (typ == Token.Identifier):
1547             expr = node.finishIdentifier(self.lex()['value']);
1548         elif (typ == Token.StringLiteral or typ == Token.NumericLiteral):
1549             self.isAssignmentTarget = self.isBindingElement = false
1550             if (self.strict and self.lookahead.get('octal')):
1551                 self.tolerateUnexpectedToken(self.lookahead, Messages.StrictOctalLiteral)
1552             expr = node.finishLiteral(self.lex())
1553         elif (typ == Token.Keyword):
1554             self.isAssignmentTarget = self.isBindingElement = false
1555             if (self.matchKeyword('function')):
1556                 return self.parseFunctionExpression()
1557             if (self.matchKeyword('this')):
1558                 self.lex()
1559                 return node.finishThisExpression()
1560             if (self.matchKeyword('class')):
1561                 return self.parseClassExpression()
1562             self.throwUnexpectedToken(self.lex())
1563         elif (typ == Token.BooleanLiteral):
1564             isAssignmentTarget = self.isBindingElement = false
1565             token = self.lex();
1566             token['value'] = (token['value'] == 'true')
1567             expr = node.finishLiteral(token)
1568         elif (typ == Token.NullLiteral):
1569             self.isAssignmentTarget = self.isBindingElement = false
1570             token = self.lex()
1571             token['value'] = null;
1572             expr = node.finishLiteral(token)
1573         elif (self.match('/') or self.match('/=')):
1574             self.isAssignmentTarget = self.isBindingElement = false;
1575             self.index = self.startIndex;
1576             token = self.scanRegExp();  # hehe, here you are!
1577             self.lex();
1578             expr = node.finishLiteral(token);
1579         elif (typ == Token.Template):
1580             expr = self.parseTemplateLiteral()
1581         else:
1582             self.throwUnexpectedToken(self.lex());
1583         return expr;
1584
1585     # 11.2 Left-Hand-Side Expressions
1586
1587     def parseArguments(self):
1588         args = [];
1589
1590         self.expect('(');
1591         if (not self.match(')')):
1592             while (self.startIndex < self.length):
1593                 args.append(self.isolateCoverGrammar(self.parseAssignmentExpression))
1594                 if (self.match(')')):
1595                     break
1596                 self.expectCommaSeparator()
1597         self.expect(')')
1598         return args;
1599
1600     def parseNonComputedProperty(self):
1601         node = Node()
1602
1603         token = self.lex();
1604
1605         if (not self.isIdentifierName(token)):
1606             self.throwUnexpectedToken(token)
1607         return node.finishIdentifier(token['value'])
1608
1609     def parseNonComputedMember(self):
1610         self.expect('.')
1611         return self.parseNonComputedProperty();
1612
1613     def parseComputedMember(self):
1614         self.expect('[')
1615
1616         expr = self.isolateCoverGrammar(self.parseExpression)
1617         self.expect(']')
1618
1619         return expr
1620
1621     def parseNewExpression(self):
1622         node = Node()
1623         self.expectKeyword('new')
1624         callee = self.isolateCoverGrammar(self.parseLeftHandSideExpression)
1625         args = self.parseArguments() if self.match('(') else []
1626
1627         self.isAssignmentTarget = self.isBindingElement = false
1628
1629         return node.finishNewExpression(callee, args)
1630
1631     def parseLeftHandSideExpressionAllowCall(self):
1632         previousAllowIn = self.state['allowIn']
1633
1634         startToken = self.lookahead;
1635         self.state['allowIn'] = true;
1636
1637         if (self.matchKeyword('super') and self.state['inFunctionBody']):
1638             expr = Node();
1639             self.lex();
1640             expr = expr.finishSuper()
1641             if (not self.match('(') and not self.match('.') and not self.match('[')):
1642                 self.throwUnexpectedToken(self.lookahead);
1643         else:
1644             expr = self.inheritCoverGrammar(
1645                 self.parseNewExpression if self.matchKeyword('new') else self.parsePrimaryExpression)
1646         while True:
1647             if (self.match('.')):
1648                 self.isBindingElement = false;
1649                 self.isAssignmentTarget = true;
1650                 property = self.parseNonComputedMember();
1651                 expr = WrappingNode(startToken).finishMemberExpression('.', expr, property)
1652             elif (self.match('(')):
1653                 self.isBindingElement = false;
1654                 self.isAssignmentTarget = false;
1655                 args = self.parseArguments();
1656                 expr = WrappingNode(startToken).finishCallExpression(expr, args)
1657             elif (self.match('[')):
1658                 self.isBindingElement = false;
1659                 self.isAssignmentTarget = true;
1660                 property = self.parseComputedMember();
1661                 expr = WrappingNode(startToken).finishMemberExpression('[', expr, property)
1662             elif (self.lookahead['type'] == Token.Template and self.lookahead['head']):
1663                 quasi = self.parseTemplateLiteral()
1664                 expr = WrappingNode(startToken).finishTaggedTemplateExpression(expr, quasi)
1665             else:
1666                 break
1667         self.state['allowIn'] = previousAllowIn
1668
1669         return expr
1670
1671     def parseLeftHandSideExpression(self):
1672         assert self.state['allowIn'], 'callee of new expression always allow in keyword.'
1673
1674         startToken = self.lookahead
1675
1676         if (self.matchKeyword('super') and self.state['inFunctionBody']):
1677             expr = Node();
1678             self.lex();
1679             expr = expr.finishSuper();
1680             if (not self.match('[') and not self.match('.')):
1681                 self.throwUnexpectedToken(self.lookahead)
1682         else:
1683             expr = self.inheritCoverGrammar(
1684                 self.parseNewExpression if self.matchKeyword('new') else self.parsePrimaryExpression);
1685
1686         while True:
1687             if (self.match('[')):
1688                 self.isBindingElement = false;
1689                 self.isAssignmentTarget = true;
1690                 property = self.parseComputedMember();
1691                 expr = WrappingNode(startToken).finishMemberExpression('[', expr, property)
1692             elif (self.match('.')):
1693                 self.isBindingElement = false;
1694                 self.isAssignmentTarget = true;
1695                 property = self.parseNonComputedMember();
1696                 expr = WrappingNode(startToken).finishMemberExpression('.', expr, property);
1697             elif (self.lookahead['type'] == Token.Template and self.lookahead['head']):
1698                 quasi = self.parseTemplateLiteral();
1699                 expr = WrappingNode(startToken).finishTaggedTemplateExpression(expr, quasi)
1700             else:
1701                 break
1702         return expr
1703
1704     # 11.3 Postfix Expressions
1705
1706     def parsePostfixExpression(self):
1707         startToken = self.lookahead
1708
1709         expr = self.inheritCoverGrammar(self.parseLeftHandSideExpressionAllowCall)
1710
1711         if (not self.hasLineTerminator and self.lookahead['type'] == Token.Punctuator):
1712             if (self.match('++') or self.match('--')):
1713                 # 11.3.1, 11.3.2
1714                 if (self.strict and expr.type == Syntax.Identifier and isRestrictedWord(expr.name)):
1715                     self.tolerateError(Messages.StrictLHSPostfix)
1716                 if (not self.isAssignmentTarget):
1717                     self.tolerateError(Messages.InvalidLHSInAssignment);
1718                 self.isAssignmentTarget = self.isBindingElement = false;
1719
1720                 token = self.lex();
1721                 expr = WrappingNode(startToken).finishPostfixExpression(token['value'], expr);
1722         return expr;
1723
1724     # 11.4 Unary Operators
1725
1726     def parseUnaryExpression(self):
1727
1728         if (self.lookahead['type'] != Token.Punctuator and self.lookahead['type'] != Token.Keyword):
1729             expr = self.parsePostfixExpression();
1730         elif (self.match('++') or self.match('--')):
1731             startToken = self.lookahead;
1732             token = self.lex();
1733             expr = self.inheritCoverGrammar(self.parseUnaryExpression);
1734             # 11.4.4, 11.4.5
1735             if (self.strict and expr.type == Syntax.Identifier and isRestrictedWord(expr.name)):
1736                 self.tolerateError(Messages.StrictLHSPrefix)
1737             if (not self.isAssignmentTarget):
1738                 self.tolerateError(Messages.InvalidLHSInAssignment)
1739             expr = WrappingNode(startToken).finishUnaryExpression(token['value'], expr)
1740             self.isAssignmentTarget = self.isBindingElement = false
1741         elif (self.match('+') or self.match('-') or self.match('~') or self.match('!')):
1742             startToken = self.lookahead;
1743             token = self.lex();
1744             expr = self.inheritCoverGrammar(self.parseUnaryExpression);
1745             expr = WrappingNode(startToken).finishUnaryExpression(token['value'], expr)
1746             self.isAssignmentTarget = self.isBindingElement = false;
1747         elif (self.matchKeyword('delete') or self.matchKeyword('void') or self.matchKeyword('typeof')):
1748             startToken = self.lookahead;
1749             token = self.lex();
1750             expr = self.inheritCoverGrammar(self.parseUnaryExpression);
1751             expr = WrappingNode(startToken).finishUnaryExpression(token['value'], expr);
1752             if (self.strict and expr.operator == 'delete' and expr.argument.type == Syntax.Identifier):
1753                 self.tolerateError(Messages.StrictDelete)
1754             self.isAssignmentTarget = self.isBindingElement = false;
1755         else:
1756             expr = self.parsePostfixExpression()
1757         return expr
1758
1759     def binaryPrecedence(self, token, allowIn):
1760         prec = 0;
1761         typ = token['type']
1762         if (typ != Token.Punctuator and typ != Token.Keyword):
1763             return 0;
1764         val = token['value']
1765         if val == 'in' and not allowIn:
1766             return 0
1767         return PRECEDENCE.get(val, 0)
1768
1769     # 11.5 Multiplicative Operators
1770     # 11.6 Additive Operators
1771     # 11.7 Bitwise Shift Operators
1772     # 11.8 Relational Operators
1773     # 11.9 Equality Operators
1774     # 11.10 Binary Bitwise Operators
1775     # 11.11 Binary Logical Operators
1776
1777     def parseBinaryExpression(self):
1778
1779         marker = self.lookahead;
1780         left = self.inheritCoverGrammar(self.parseUnaryExpression);
1781
1782         token = self.lookahead;
1783         prec = self.binaryPrecedence(token, self.state['allowIn']);
1784         if (prec == 0):
1785             return left
1786         self.isAssignmentTarget = self.isBindingElement = false;
1787         token['prec'] = prec
1788         self.lex()
1789
1790         markers = [marker, self.lookahead];
1791         right = self.isolateCoverGrammar(self.parseUnaryExpression);
1792
1793         stack = [left, token, right];
1794
1795         while True:
1796             prec = self.binaryPrecedence(self.lookahead, self.state['allowIn'])
1797             if not prec > 0:
1798                 break
1799             # Reduce: make a binary expression from the three topmost entries.
1800             while ((len(stack) > 2) and (prec <= stack[len(stack) - 2]['prec'])):
1801                 right = stack.pop();
1802                 operator = stack.pop()['value']
1803                 left = stack.pop()
1804                 markers.pop()
1805                 expr = WrappingNode(markers[len(markers) - 1]).finishBinaryExpression(operator, left, right)
1806                 stack.append(expr)
1807
1808             # Shift
1809             token = self.lex();
1810             token['prec'] = prec;
1811             stack.append(token);
1812             markers.append(self.lookahead);
1813             expr = self.isolateCoverGrammar(self.parseUnaryExpression);
1814             stack.append(expr);
1815
1816         # Final reduce to clean-up the stack.
1817         i = len(stack) - 1;
1818         expr = stack[i]
1819         markers.pop()
1820         while (i > 1):
1821             expr = WrappingNode(markers.pop()).finishBinaryExpression(stack[i - 1]['value'], stack[i - 2], expr);
1822             i -= 2
1823         return expr
1824
1825     # 11.12 Conditional Operator
1826
1827     def parseConditionalExpression(self):
1828
1829         startToken = self.lookahead
1830
1831         expr = self.inheritCoverGrammar(self.parseBinaryExpression);
1832         if (self.match('?')):
1833             self.lex()
1834             previousAllowIn = self.state['allowIn']
1835             self.state['allowIn'] = true;
1836             consequent = self.isolateCoverGrammar(self.parseAssignmentExpression);
1837             self.state['allowIn'] = previousAllowIn;
1838             self.expect(':');
1839             alternate = self.isolateCoverGrammar(self.parseAssignmentExpression)
1840
1841             expr = WrappingNode(startToken).finishConditionalExpression(expr, consequent, alternate);
1842             self.isAssignmentTarget = self.isBindingElement = false;
1843         return expr
1844
1845     # [ES6] 14.2 Arrow Function
1846
1847     def parseConciseBody(self):
1848         if (self.match('{')):
1849             return self.parseFunctionSourceElements()
1850         return self.isolateCoverGrammar(self.parseAssignmentExpression)
1851
1852     def checkPatternParam(self, options, param):
1853         typ = param.type
1854         if typ == Syntax.Identifier:
1855             self.validateParam(options, param, param.name);
1856         elif typ == Syntax.RestElement:
1857             self.checkPatternParam(options, param.argument)
1858         elif typ == Syntax.AssignmentPattern:
1859             self.checkPatternParam(options, param.left)
1860         elif typ == Syntax.ArrayPattern:
1861             for i in xrange(len(param.elements)):
1862                 if (param.elements[i] != null):
1863                     self.checkPatternParam(options, param.elements[i]);
1864         else:
1865             assert typ == Syntax.ObjectPattern, 'Invalid type'
1866             for i in xrange(len(param.properties)):
1867                 self.checkPatternParam(options, param.properties[i]['value']);
1868
1869     def reinterpretAsCoverFormalsList(self, expr):
1870         defaults = [];
1871         defaultCount = 0;
1872         params = [expr];
1873         typ = expr.type
1874         if typ == Syntax.Identifier:
1875             pass
1876         elif typ == PlaceHolders.ArrowParameterPlaceHolder:
1877             params = expr.params
1878         else:
1879             return null
1880         options = {
1881             'paramSet': {}}
1882         le = len(params)
1883         for i in xrange(le):
1884             param = params[i]
1885             if param.type == Syntax.AssignmentPattern:
1886                 params[i] = param.left;
1887                 defaults.append(param.right);
1888                 defaultCount += 1
1889                 self.checkPatternParam(options, param.left);
1890             else:
1891                 self.checkPatternParam(options, param);
1892                 params[i] = param;
1893                 defaults.append(null);
1894         if (options.get('message') == Messages.StrictParamDupe):
1895             token = options['stricted'] if self.strict else options['firstRestricted']
1896             self.throwUnexpectedToken(token, options.get('message'));
1897         if (defaultCount == 0):
1898             defaults = []
1899         return {
1900             'params': params,
1901             'defaults': defaults,
1902             'stricted': options['stricted'],
1903             'firstRestricted': options['firstRestricted'],
1904             'message': options.get('message')}
1905
1906     def parseArrowFunctionExpression(self, options, node):
1907         if (self.hasLineTerminator):
1908             self.tolerateUnexpectedToken(self.lookahead)
1909         self.expect('=>')
1910         previousStrict = self.strict;
1911
1912         body = self.parseConciseBody();
1913
1914         if (self.strict and options['firstRestricted']):
1915             self.throwUnexpectedToken(options['firstRestricted'], options.get('message'));
1916         if (self.strict and options['stricted']):
1917             self.tolerateUnexpectedToken(options['stricted'], options['message']);
1918
1919         self.strict = previousStrict
1920
1921         return node.finishArrowFunctionExpression(options['params'], options['defaults'], body,
1922                                                   body.type != Syntax.BlockStatement)
1923
1924     # 11.13 Assignment Operators
1925
1926     def parseAssignmentExpression(self):
1927         startToken = self.lookahead;
1928         token = self.lookahead;
1929
1930         expr = self.parseConditionalExpression();
1931
1932         if (expr.type == PlaceHolders.ArrowParameterPlaceHolder or self.match('=>')):
1933             self.isAssignmentTarget = self.isBindingElement = false;
1934             lis = self.reinterpretAsCoverFormalsList(expr)
1935
1936             if (lis):
1937                 self.firstCoverInitializedNameError = null;
1938                 return self.parseArrowFunctionExpression(lis, WrappingNode(startToken))
1939             return expr
1940
1941         if (self.matchAssign()):
1942             if (not self.isAssignmentTarget):
1943                 self.tolerateError(Messages.InvalidLHSInAssignment)
1944             # 11.13.1
1945
1946             if (self.strict and expr.type == Syntax.Identifier and isRestrictedWord(expr.name)):
1947                 self.tolerateUnexpectedToken(token, Messages.StrictLHSAssignment);
1948             if (not self.match('=')):
1949                 self.isAssignmentTarget = self.isBindingElement = false;
1950             else:
1951                 self.reinterpretExpressionAsPattern(expr)
1952             token = self.lex();
1953             right = self.isolateCoverGrammar(self.parseAssignmentExpression)
1954             expr = WrappingNode(startToken).finishAssignmentExpression(token['value'], expr, right);
1955             self.firstCoverInitializedNameError = null
1956         return expr
1957
1958     # 11.14 Comma Operator
1959
1960     def parseExpression(self):
1961         startToken = self.lookahead
1962         expr = self.isolateCoverGrammar(self.parseAssignmentExpression)
1963
1964         if (self.match(',')):
1965             expressions = [expr];
1966
1967             while (self.startIndex < self.length):
1968                 if (not self.match(',')):
1969                     break
1970                 self.lex();
1971                 expressions.append(self.isolateCoverGrammar(self.parseAssignmentExpression))
1972             expr = WrappingNode(startToken).finishSequenceExpression(expressions);
1973         return expr
1974
1975     # 12.1 Block
1976
1977     def parseStatementListItem(self):
1978         if (self.lookahead['type'] == Token.Keyword):
1979             val = (self.lookahead['value'])
1980             if val == 'export':
1981                 if (self.sourceType != 'module'):
1982                     self.tolerateUnexpectedToken(self.lookahead, Messages.IllegalExportDeclaration)
1983                 return self.parseExportDeclaration();
1984             elif val == 'import':
1985                 if (self.sourceType != 'module'):
1986                     self.tolerateUnexpectedToken(self.lookahead, Messages.IllegalImportDeclaration);
1987                 return self.parseImportDeclaration();
1988             elif val == 'const' or val == 'let':
1989                 return self.parseLexicalDeclaration({'inFor': false});
1990             elif val == 'function':
1991                 return self.parseFunctionDeclaration(Node());
1992             elif val == 'class':
1993                 return self.parseClassDeclaration();
1994             elif ENABLE_PYIMPORT and val == 'pyimport':  # <<<<< MODIFIED HERE
1995                 return self.parsePyimportStatement()
1996         return self.parseStatement();
1997
1998     def parsePyimportStatement(self):
1999         print(ENABLE_PYIMPORT)
2000         assert ENABLE_PYIMPORT
2001         n = Node()
2002         self.lex()
2003         n.finishPyimport(self.parseVariableIdentifier())
2004         self.consumeSemicolon()
2005         return n
2006
2007     def parseStatementList(self):
2008         list = [];
2009         while (self.startIndex < self.length):
2010             if (self.match('}')):
2011                 break
2012             list.append(self.parseStatementListItem())
2013         return list
2014
2015     def parseBlock(self):
2016         node = Node();
2017
2018         self.expect('{');
2019
2020         block = self.parseStatementList()
2021
2022         self.expect('}');
2023
2024         return node.finishBlockStatement(block);
2025
2026     # 12.2 Variable Statement
2027
2028     def parseVariableIdentifier(self):
2029         node = Node()
2030
2031         token = self.lex()
2032
2033         if (token['type'] != Token.Identifier):
2034             if (self.strict and token['type'] == Token.Keyword and isStrictModeReservedWord(token['value'])):
2035                 self.tolerateUnexpectedToken(token, Messages.StrictReservedWord);
2036             else:
2037                 self.throwUnexpectedToken(token)
2038         return node.finishIdentifier(token['value'])
2039
2040     def parseVariableDeclaration(self):
2041         init = null
2042         node = Node();
2043
2044         d = self.parsePattern();
2045
2046         # 12.2.1
2047         if (self.strict and isRestrictedWord(d.name)):
2048             self.tolerateError(Messages.StrictVarName);
2049
2050         if (self.match('=')):
2051             self.lex();
2052             init = self.isolateCoverGrammar(self.parseAssignmentExpression);
2053         elif (d.type != Syntax.Identifier):
2054             self.expect('=')
2055         return node.finishVariableDeclarator(d, init)
2056
2057     def parseVariableDeclarationList(self):
2058         lis = []
2059
2060         while True:
2061             lis.append(self.parseVariableDeclaration())
2062             if (not self.match(',')):
2063                 break
2064             self.lex();
2065             if not (self.startIndex < self.length):
2066                 break
2067
2068         return lis;
2069
2070     def parseVariableStatement(self, node):
2071         self.expectKeyword('var')
2072
2073         declarations = self.parseVariableDeclarationList()
2074
2075         self.consumeSemicolon()
2076
2077         return node.finishVariableDeclaration(declarations)
2078
2079     def parseLexicalBinding(self, kind, options):
2080         init = null
2081         node = Node()
2082
2083         d = self.parsePattern();
2084
2085         # 12.2.1
2086         if (self.strict and d.type == Syntax.Identifier and isRestrictedWord(d.name)):
2087             self.tolerateError(Messages.StrictVarName);
2088
2089         if (kind == 'const'):
2090             if (not self.matchKeyword('in')):
2091                 self.expect('=')
2092                 init = self.isolateCoverGrammar(self.parseAssignmentExpression)
2093         elif ((not options['inFor'] and d.type != Syntax.Identifier) or self.match('=')):
2094             self.expect('=');
2095             init = self.isolateCoverGrammar(self.parseAssignmentExpression);
2096         return node.finishVariableDeclarator(d, init)
2097
2098     def parseBindingList(self, kind, options):
2099         list = [];
2100
2101         while True:
2102             list.append(self.parseLexicalBinding(kind, options));
2103             if (not self.match(',')):
2104                 break
2105             self.lex();
2106             if not (self.startIndex < self.length):
2107                 break
2108         return list;
2109
2110     def parseLexicalDeclaration(self, options):
2111         node = Node();
2112
2113         kind = self.lex()['value']
2114         assert kind == 'let' or kind == 'const', 'Lexical declaration must be either let or const'
2115         declarations = self.parseBindingList(kind, options);
2116         self.consumeSemicolon();
2117         return node.finishLexicalDeclaration(declarations, kind);
2118
2119     def parseRestElement(self):
2120         node = Node();
2121
2122         self.lex();
2123
2124         if (self.match('{')):
2125             self.throwError(Messages.ObjectPatternAsRestParameter)
2126         param = self.parseVariableIdentifier();
2127         if (self.match('=')):
2128             self.throwError(Messages.DefaultRestParameter);
2129
2130         if (not self.match(')')):
2131             self.throwError(Messages.ParameterAfterRestParameter);
2132         return node.finishRestElement(param);
2133
2134     # 12.3 Empty Statement
2135
2136     def parseEmptyStatement(self, node):
2137         self.expect(';');
2138         return node.finishEmptyStatement()
2139
2140     # 12.4 Expression Statement
2141
2142     def parseExpressionStatement(self, node):
2143         expr = self.parseExpression();
2144         self.consumeSemicolon();
2145         return node.finishExpressionStatement(expr);
2146
2147     # 12.5 If statement
2148
2149     def parseIfStatement(self, node):
2150         self.expectKeyword('if');
2151
2152         self.expect('(');
2153
2154         test = self.parseExpression();
2155
2156         self.expect(')');
2157
2158         consequent = self.parseStatement();
2159
2160         if (self.matchKeyword('else')):
2161             self.lex();
2162             alternate = self.parseStatement();
2163         else:
2164             alternate = null;
2165         return node.finishIfStatement(test, consequent, alternate)
2166
2167     # 12.6 Iteration Statements
2168
2169     def parseDoWhileStatement(self, node):
2170
2171         self.expectKeyword('do')
2172
2173         oldInIteration = self.state['inIteration']
2174         self.state['inIteration'] = true
2175
2176         body = self.parseStatement();
2177
2178         self.state['inIteration'] = oldInIteration;
2179
2180         self.expectKeyword('while');
2181
2182         self.expect('(');
2183
2184         test = self.parseExpression();
2185
2186         self.expect(')')
2187
2188         if (self.match(';')):
2189             self.lex()
2190         return node.finishDoWhileStatement(body, test)
2191
2192     def parseWhileStatement(self, node):
2193
2194         self.expectKeyword('while')
2195
2196         self.expect('(')
2197
2198         test = self.parseExpression()
2199
2200         self.expect(')')
2201
2202         oldInIteration = self.state['inIteration']
2203         self.state['inIteration'] = true
2204
2205         body = self.parseStatement()
2206
2207         self.state['inIteration'] = oldInIteration
2208
2209         return node.finishWhileStatement(test, body)
2210
2211     def parseForStatement(self, node):
2212         previousAllowIn = self.state['allowIn']
2213
2214         init = test = update = null
2215
2216         self.expectKeyword('for')
2217
2218         self.expect('(')
2219
2220         if (self.match(';')):
2221             self.lex()
2222         else:
2223             if (self.matchKeyword('var')):
2224                 init = Node()
2225                 self.lex()
2226
2227                 self.state['allowIn'] = false;
2228                 init = init.finishVariableDeclaration(self.parseVariableDeclarationList())
2229                 self.state['allowIn'] = previousAllowIn
2230
2231                 if (len(init.declarations) == 1 and self.matchKeyword('in')):
2232                     self.lex()
2233                     left = init
2234                     right = self.parseExpression()
2235                     init = null
2236                 else:
2237                     self.expect(';')
2238             elif (self.matchKeyword('const') or self.matchKeyword('let')):
2239                 init = Node()
2240                 kind = self.lex()['value']
2241
2242                 self.state['allowIn'] = false
2243                 declarations = self.parseBindingList(kind, {'inFor': true})
2244                 self.state['allowIn'] = previousAllowIn
2245
2246                 if (len(declarations) == 1 and declarations[0].init == null and self.matchKeyword('in')):
2247                     init = init.finishLexicalDeclaration(declarations, kind);
2248                     self.lex();
2249                     left = init;
2250                     right = self.parseExpression();
2251                     init = null;
2252                 else:
2253                     self.consumeSemicolon();
2254                     init = init.finishLexicalDeclaration(declarations, kind);
2255             else:
2256                 initStartToken = self.lookahead
2257                 self.state['allowIn'] = false
2258                 init = self.inheritCoverGrammar(self.parseAssignmentExpression);
2259                 self.state['allowIn'] = previousAllowIn;
2260
2261                 if (self.matchKeyword('in')):
2262                     if (not self.isAssignmentTarget):
2263                         self.tolerateError(Messages.InvalidLHSInForIn)
2264                     self.lex();
2265                     self.reinterpretExpressionAsPattern(init);
2266                     left = init;
2267                     right = self.parseExpression();
2268                     init = null;
2269                 else:
2270                     if (self.match(',')):
2271                         initSeq = [init];
2272                         while (self.match(',')):
2273                             self.lex();
2274                             initSeq.append(self.isolateCoverGrammar(self.parseAssignmentExpression))
2275                         init = WrappingNode(initStartToken).finishSequenceExpression(initSeq)
2276                     self.expect(';');
2277
2278         if ('left' not in locals()):
2279             if (not self.match(';')):
2280                 test = self.parseExpression();
2281
2282             self.expect(';');
2283
2284             if (not self.match(')')):
2285                 update = self.parseExpression();
2286
2287         self.expect(')');
2288
2289         oldInIteration = self.state['inIteration']
2290         self.state['inIteration'] = true;
2291
2292         body = self.isolateCoverGrammar(self.parseStatement)
2293
2294         self.state['inIteration'] = oldInIteration;
2295
2296         return node.finishForStatement(init, test, update, body) if (
2297         'left' not in locals()) else node.finishForInStatement(left, right, body);
2298
2299     # 12.7 The continue statement
2300
2301     def parseContinueStatement(self, node):
2302         label = null
2303
2304         self.expectKeyword('continue');
2305
2306         # Optimize the most common form: 'continue;'.
2307         if ord(self.source[self.startIndex]) == 0x3B:
2308             self.lex();
2309             if (not self.state['inIteration']):
2310                 self.throwError(Messages.IllegalContinue)
2311             return node.finishContinueStatement(null)
2312         if (self.hasLineTerminator):
2313             if (not self.state['inIteration']):
2314                 self.throwError(Messages.IllegalContinue);
2315             return node.finishContinueStatement(null);
2316
2317         if (self.lookahead['type'] == Token.Identifier):
2318             label = self.parseVariableIdentifier();
2319
2320             key = '$' + label.name;
2321             if not key in self.state['labelSet']:  # todo make sure its correct!
2322                 self.throwError(Messages.UnknownLabel, label.name);
2323         self.consumeSemicolon()
2324
2325         if (label == null and not self.state['inIteration']):
2326             self.throwError(Messages.IllegalContinue)
2327         return node.finishContinueStatement(label)
2328
2329     # 12.8 The break statement
2330
2331     def parseBreakStatement(self, node):
2332         label = null
2333
2334         self.expectKeyword('break');
2335
2336         # Catch the very common case first: immediately a semicolon (U+003B).
2337         if (ord(self.source[self.lastIndex]) == 0x3B):
2338             self.lex();
2339
2340             if (not (self.state['inIteration'] or self.state['inSwitch'])):
2341                 self.throwError(Messages.IllegalBreak)
2342             return node.finishBreakStatement(null)
2343         if (self.hasLineTerminator):
2344             if (not (self.state['inIteration'] or self.state['inSwitch'])):
2345                 self.throwError(Messages.IllegalBreak);
2346             return node.finishBreakStatement(null);
2347         if (self.lookahead['type'] == Token.Identifier):
2348             label = self.parseVariableIdentifier();
2349
2350             key = '$' + label.name;
2351             if not (key in self.state['labelSet']):
2352                 self.throwError(Messages.UnknownLabel, label.name);
2353         self.consumeSemicolon();
2354
2355         if (label == null and not (self.state['inIteration'] or self.state['inSwitch'])):
2356             self.throwError(Messages.IllegalBreak)
2357         return node.finishBreakStatement(label);
2358
2359     # 12.9 The return statement
2360
2361     def parseReturnStatement(self, node):
2362         argument = null;
2363
2364         self.expectKeyword('return');
2365
2366         if (not self.state['inFunctionBody']):
2367             self.tolerateError(Messages.IllegalReturn);
2368
2369         # 'return' followed by a space and an identifier is very common.
2370         if (ord(self.source[self.lastIndex]) == 0x20):
2371             if (isIdentifierStart(self.source[self.lastIndex + 1])):
2372                 argument = self.parseExpression();
2373                 self.consumeSemicolon();
2374                 return node.finishReturnStatement(argument)
2375         if (self.hasLineTerminator):
2376             # HACK
2377             return node.finishReturnStatement(null)
2378
2379         if (not self.match(';')):
2380             if (not self.match('}') and self.lookahead['type'] != Token.EOF):
2381                 argument = self.parseExpression();
2382         self.consumeSemicolon();
2383
2384         return node.finishReturnStatement(argument);
2385
2386     # 12.10 The with statement
2387
2388     def parseWithStatement(self, node):
2389         if (self.strict):
2390             self.tolerateError(Messages.StrictModeWith)
2391
2392         self.expectKeyword('with');
2393
2394         self.expect('(');
2395
2396         obj = self.parseExpression();
2397
2398         self.expect(')');
2399
2400         body = self.parseStatement();
2401
2402         return node.finishWithStatement(obj, body);
2403
2404     # 12.10 The swith statement
2405
2406     def parseSwitchCase(self):
2407         consequent = []
2408         node = Node();
2409
2410         if (self.matchKeyword('default')):
2411             self.lex();
2412             test = null;
2413         else:
2414             self.expectKeyword('case');
2415             test = self.parseExpression();
2416
2417         self.expect(':');
2418
2419         while (self.startIndex < self.length):
2420             if (self.match('}') or self.matchKeyword('default') or self.matchKeyword('case')):
2421                 break
2422             statement = self.parseStatementListItem()
2423             consequent.append(statement)
2424         return node.finishSwitchCase(test, consequent)
2425
2426     def parseSwitchStatement(self, node):
2427
2428         self.expectKeyword('switch');
2429
2430         self.expect('(');
2431
2432         discriminant = self.parseExpression();
2433
2434         self.expect(')');
2435
2436         self.expect('{');
2437
2438         cases = [];
2439
2440         if (self.match('}')):
2441             self.lex();
2442             return node.finishSwitchStatement(discriminant, cases);
2443
2444         oldInSwitch = self.state['inSwitch'];
2445         self.state['inSwitch'] = true;
2446         defaultFound = false;
2447
2448         while (self.startIndex < self.length):
2449             if (self.match('}')):
2450                 break;
2451             clause = self.parseSwitchCase();
2452             if (clause.test == null):
2453                 if (defaultFound):
2454                     self.throwError(Messages.MultipleDefaultsInSwitch);
2455                 defaultFound = true;
2456             cases.append(clause);
2457
2458         self.state['inSwitch'] = oldInSwitch;
2459
2460         self.expect('}');
2461
2462         return node.finishSwitchStatement(discriminant, cases);
2463
2464     # 12.13 The throw statement
2465
2466     def parseThrowStatement(self, node):
2467
2468         self.expectKeyword('throw');
2469
2470         if (self.hasLineTerminator):
2471             self.throwError(Messages.NewlineAfterThrow);
2472
2473         argument = self.parseExpression();
2474
2475         self.consumeSemicolon();
2476
2477         return node.finishThrowStatement(argument);
2478
2479     # 12.14 The try statement
2480
2481     def parseCatchClause(self):
2482         node = Node();
2483
2484         self.expectKeyword('catch');
2485
2486         self.expect('(');
2487         if (self.match(')')):
2488             self.throwUnexpectedToken(self.lookahead);
2489         param = self.parsePattern();
2490
2491         # 12.14.1
2492         if (self.strict and isRestrictedWord(param.name)):
2493             self.tolerateError(Messages.StrictCatchVariable);
2494
2495         self.expect(')');
2496         body = self.parseBlock();
2497         return node.finishCatchClause(param, body);
2498
2499     def parseTryStatement(self, node):
2500         handler = null
2501         finalizer = null;
2502
2503         self.expectKeyword('try');
2504
2505         block = self.parseBlock();
2506
2507         if (self.matchKeyword('catch')):
2508             handler = self.parseCatchClause()
2509
2510         if (self.matchKeyword('finally')):
2511             self.lex();
2512             finalizer = self.parseBlock();
2513
2514         if (not handler and not finalizer):
2515             self.throwError(Messages.NoCatchOrFinally)
2516
2517         return node.finishTryStatement(block, handler, finalizer)
2518
2519     # 12.15 The debugger statement
2520
2521     def parseDebuggerStatement(self, node):
2522         self.expectKeyword('debugger');
2523
2524         self.consumeSemicolon();
2525
2526         return node.finishDebuggerStatement();
2527
2528     # 12 Statements
2529
2530     def parseStatement(self):
2531         typ = self.lookahead['type']
2532
2533         if (typ == Token.EOF):
2534             self.throwUnexpectedToken(self.lookahead)
2535
2536         if (typ == Token.Punctuator and self.lookahead['value'] == '{'):
2537             return self.parseBlock()
2538
2539         self.isAssignmentTarget = self.isBindingElement = true;
2540         node = Node();
2541         val = self.lookahead['value']
2542
2543         if (typ == Token.Punctuator):
2544             if val == ';':
2545                 return self.parseEmptyStatement(node);
2546             elif val == '(':
2547                 return self.parseExpressionStatement(node);
2548         elif (typ == Token.Keyword):
2549             if val == 'break':
2550                 return self.parseBreakStatement(node);
2551             elif val == 'continue':
2552                 return self.parseContinueStatement(node);
2553             elif val == 'debugger':
2554                 return self.parseDebuggerStatement(node);
2555             elif val == 'do':
2556                 return self.parseDoWhileStatement(node);
2557             elif val == 'for':
2558                 return self.parseForStatement(node);
2559             elif val == 'function':
2560                 return self.parseFunctionDeclaration(node);
2561             elif val == 'if':
2562                 return self.parseIfStatement(node);
2563             elif val == 'return':
2564                 return self.parseReturnStatement(node);
2565             elif val == 'switch':
2566                 return self.parseSwitchStatement(node);
2567             elif val == 'throw':
2568                 return self.parseThrowStatement(node);
2569             elif val == 'try':
2570                 return self.parseTryStatement(node);
2571             elif val == 'var':
2572                 return self.parseVariableStatement(node);
2573             elif val == 'while':
2574                 return self.parseWhileStatement(node);
2575             elif val == 'with':
2576                 return self.parseWithStatement(node);
2577
2578         expr = self.parseExpression();
2579
2580         # 12.12 Labelled Statements
2581         if ((expr.type == Syntax.Identifier) and self.match(':')):
2582             self.lex();
2583
2584             key = '$' + expr.name
2585             if key in self.state['labelSet']:
2586                 self.throwError(Messages.Redeclaration, 'Label', expr.name);
2587             self.state['labelSet'][key] = true
2588             labeledBody = self.parseStatement()
2589             del self.state['labelSet'][key]
2590             return node.finishLabeledStatement(expr, labeledBody)
2591         self.consumeSemicolon();
2592         return node.finishExpressionStatement(expr)
2593
2594     # 13 Function Definition
2595
2596     def parseFunctionSourceElements(self):
2597         body = []
2598         node = Node()
2599         firstRestricted = None
2600
2601         self.expect('{')
2602
2603         while (self.startIndex < self.length):
2604             if (self.lookahead['type'] != Token.StringLiteral):
2605                 break
2606             token = self.lookahead;
2607
2608             statement = self.parseStatementListItem()
2609             body.append(statement)
2610             if (statement.expression.type != Syntax.Literal):
2611                 # this is not directive
2612                 break
2613             directive = self.source[token['start'] + 1: token['end'] - 1]
2614             if (directive == 'use strict'):
2615                 self.strict = true;
2616                 if (firstRestricted):
2617                     self.tolerateUnexpectedToken(firstRestricted, Messages.StrictOctalLiteral);
2618             else:
2619                 if (not firstRestricted and token.get('octal')):
2620                     firstRestricted = token;
2621
2622         oldLabelSet = self.state['labelSet']
2623         oldInIteration = self.state['inIteration']
2624         oldInSwitch = self.state['inSwitch']
2625         oldInFunctionBody = self.state['inFunctionBody']
2626         oldParenthesisCount = self.state['parenthesizedCount']
2627
2628         self.state['labelSet'] = {}
2629         self.state['inIteration'] = false
2630         self.state['inSwitch'] = false
2631         self.state['inFunctionBody'] = true
2632         self.state['parenthesizedCount'] = 0
2633
2634         while (self.startIndex < self.length):
2635             if (self.match('}')):
2636                 break
2637             body.append(self.parseStatementListItem())
2638         self.expect('}')
2639
2640         self.state['labelSet'] = oldLabelSet;
2641         self.state['inIteration'] = oldInIteration;
2642         self.state['inSwitch'] = oldInSwitch;
2643         self.state['inFunctionBody'] = oldInFunctionBody;
2644         self.state['parenthesizedCount'] = oldParenthesisCount;
2645
2646         return node.finishBlockStatement(body)
2647
2648     def validateParam(self, options, param, name):
2649         key = '$' + name
2650         if (self.strict):
2651             if (isRestrictedWord(name)):
2652                 options['stricted'] = param;
2653                 options['message'] = Messages.StrictParamName
2654             if key in options['paramSet']:
2655                 options['stricted'] = param;
2656                 options['message'] = Messages.StrictParamDupe;
2657         elif (not options['firstRestricted']):
2658             if (isRestrictedWord(name)):
2659                 options['firstRestricted'] = param;
2660                 options['message'] = Messages.StrictParamName;
2661             elif (isStrictModeReservedWord(name)):
2662                 options['firstRestricted'] = param;
2663                 options['message'] = Messages.StrictReservedWord;
2664             elif key in options['paramSet']:
2665                 options['firstRestricted'] = param
2666                 options['message'] = Messages.StrictParamDupe;
2667         options['paramSet'][key] = true
2668
2669     def parseParam(self, options):
2670         token = self.lookahead
2671         de = None
2672         if (token['value'] == '...'):
2673             param = self.parseRestElement();
2674             self.validateParam(options, param.argument, param.argument.name);
2675             options['params'].append(param);
2676             options['defaults'].append(null);
2677             return false
2678         param = self.parsePatternWithDefault();
2679         self.validateParam(options, token, token['value']);
2680
2681         if (param.type == Syntax.AssignmentPattern):
2682             de = param.right;
2683             param = param.left;
2684             options['defaultCount'] += 1
2685         options['params'].append(param);
2686         options['defaults'].append(de)
2687         return not self.match(')')
2688
2689     def parseParams(self, firstRestricted):
2690         options = {
2691             'params': [],
2692             'defaultCount': 0,
2693             'defaults': [],
2694             'firstRestricted': firstRestricted}
2695
2696         self.expect('(');
2697
2698         if (not self.match(')')):
2699             options['paramSet'] = {};
2700             while (self.startIndex < self.length):
2701                 if (not self.parseParam(options)):
2702                     break
2703                 self.expect(',');
2704         self.expect(')');
2705
2706         if (options['defaultCount'] == 0):
2707             options['defaults'] = [];
2708
2709         return {
2710             'params': options['params'],
2711             'defaults': options['defaults'],
2712             'stricted': options.get('stricted'),
2713             'firstRestricted': options.get('firstRestricted'),
2714             'message': options.get('message')}
2715
2716     def parseFunctionDeclaration(self, node, identifierIsOptional=None):
2717         d = null
2718         params = []
2719         defaults = []
2720         message = None
2721         firstRestricted = None
2722
2723         self.expectKeyword('function');
2724         if (identifierIsOptional or not self.match('(')):
2725             token = self.lookahead;
2726             d = self.parseVariableIdentifier();
2727             if (self.strict):
2728                 if (isRestrictedWord(token['value'])):
2729                     self.tolerateUnexpectedToken(token, Messages.StrictFunctionName);
2730             else:
2731                 if (isRestrictedWord(token['value'])):
2732                     firstRestricted = token;
2733                     message = Messages.StrictFunctionName;
2734                 elif (isStrictModeReservedWord(token['value'])):
2735                     firstRestricted = token;
2736                     message = Messages.StrictReservedWord;
2737
2738         tmp = self.parseParams(firstRestricted);
2739         params = tmp['params']
2740         defaults = tmp['defaults']
2741         stricted = tmp['stricted']
2742         firstRestricted = tmp['firstRestricted']
2743         if (tmp.get('message')):
2744             message = tmp['message'];
2745
2746         previousStrict = self.strict;
2747         body = self.parseFunctionSourceElements();
2748         if (self.strict and firstRestricted):
2749             self.throwUnexpectedToken(firstRestricted, message);
2750
2751         if (self.strict and stricted):
2752             self.tolerateUnexpectedToken(stricted, message);
2753         self.strict = previousStrict;
2754
2755         return node.finishFunctionDeclaration(d, params, defaults, body);
2756
2757     def parseFunctionExpression(self):
2758         id = null
2759         params = []
2760         defaults = []
2761         node = Node();
2762         firstRestricted = None
2763         message = None
2764
2765         self.expectKeyword('function');
2766
2767         if (not self.match('(')):
2768             token = self.lookahead;
2769             id = self.parseVariableIdentifier();
2770             if (self.strict):
2771                 if (isRestrictedWord(token['value'])):
2772                     self.tolerateUnexpectedToken(token, Messages.StrictFunctionName);
2773             else:
2774                 if (isRestrictedWord(token['value'])):
2775                     firstRestricted = token;
2776                     message = Messages.StrictFunctionName;
2777                 elif (isStrictModeReservedWord(token['value'])):
2778                     firstRestricted = token;
2779                     message = Messages.StrictReservedWord;
2780         tmp = self.parseParams(firstRestricted);
2781         params = tmp['params']
2782         defaults = tmp['defaults']
2783         stricted = tmp['stricted']
2784         firstRestricted = tmp['firstRestricted']
2785         if (tmp.get('message')):
2786             message = tmp['message']
2787
2788         previousStrict = self.strict;
2789         body = self.parseFunctionSourceElements();
2790         if (self.strict and firstRestricted):
2791             self.throwUnexpectedToken(firstRestricted, message);
2792         if (self.strict and stricted):
2793             self.tolerateUnexpectedToken(stricted, message);
2794         self.strict = previousStrict;
2795
2796         return node.finishFunctionExpression(id, params, defaults, body);
2797
2798     # todo Translate parse class functions!
2799
2800     def parseClassExpression(self):
2801         raise NotImplementedError()
2802
2803     def parseClassDeclaration(self):
2804         raise NotImplementedError()
2805
2806     # 14 Program
2807
2808     def parseScriptBody(self):
2809         body = []
2810         firstRestricted = None
2811
2812         while (self.startIndex < self.length):
2813             token = self.lookahead;
2814             if (token['type'] != Token.StringLiteral):
2815                 break
2816             statement = self.parseStatementListItem();
2817             body.append(statement);
2818             if (statement.expression.type != Syntax.Literal):
2819                 # this is not directive
2820                 break
2821             directive = self.source[token['start'] + 1: token['end'] - 1]
2822             if (directive == 'use strict'):
2823                 self.strict = true;
2824                 if (firstRestricted):
2825                     self.tolerateUnexpectedToken(firstRestricted, Messages.StrictOctalLiteral)
2826             else:
2827                 if (not firstRestricted and token.get('octal')):
2828                     firstRestricted = token;
2829         while (self.startIndex < self.length):
2830             statement = self.parseStatementListItem();
2831             # istanbul ignore if
2832             if (statement is None):
2833                 break
2834             body.append(statement);
2835         return body;
2836
2837     def parseProgram(self):
2838         self.peek()
2839         node = Node()
2840
2841         body = self.parseScriptBody()
2842         return node.finishProgram(body)
2843
2844     # DONE!!!
2845     def parse(self, code, options={}):
2846         if options:
2847             raise NotImplementedError('Options not implemented! You can only use default settings.')
2848
2849         self.clean()
2850         self.source = unicode(code) + ' \n ; //END'  # I have to add it in order not to check for EOF every time
2851         self.index = 0
2852         self.lineNumber = 1 if len(self.source) > 0 else 0
2853         self.lineStart = 0
2854         self.startIndex = self.index
2855         self.startLineNumber = self.lineNumber;
2856         self.startLineStart = self.lineStart;
2857         self.length = len(self.source)
2858         self.lookahead = null;
2859         self.state = {
2860             'allowIn': true,
2861             'labelSet': {},
2862             'inFunctionBody': false,
2863             'inIteration': false,
2864             'inSwitch': false,
2865             'lastCommentStart': -1,
2866             'curlyStack': [],
2867             'parenthesizedCount': None}
2868         self.sourceType = 'script';
2869         self.strict = false;
2870         program = self.parseProgram();
2871         return node_to_dict(program)
2872
2873
2874
2875 def parse(javascript_code):
2876     """Returns syntax tree of javascript_code.
2877        Same as PyJsParser().parse  For your convenience :) """
2878     p = PyJsParser()
2879     return p.parse(javascript_code)
2880
2881
2882 if __name__ == '__main__':
2883     import time
2884
2885     test_path = None
2886     if test_path:
2887         f = open(test_path, 'rb')
2888         x = f.read()
2889         f.close()
2890     else:
2891         x = 'var $ = "Hello!"'
2892     p = PyJsParser()
2893     t = time.time()
2894     res = p.parse(x)
2895     dt = time.time() - t + 0.000000001
2896     if test_path:
2897         print(len(res))
2898     else:
2899         pprint(res)
2900     print()
2901     print('Parsed everyting in', round(dt, 5), 'seconds.')
2902     print('Thats %d characters per second' % int(len(x) / dt))