root/livinglogic.python.xist/src/ll/UL4Parser.py @ 5347:da430915bf69

Revision 5347:da430915bf69, 150.6 KB (checked in by Walter Doerwald <walter@…>, 7 years ago)

Store source code start/end offsets for all AST nodes.

This simplifies str output of most nodes, as they can simply output the
appropriate slice of the original source code.

Line 
1# $ANTLR 3.4 src/ll/UL4.g 2013-02-13 14:41:27
2
3import sys
4from antlr3 import *
5from antlr3.compat import set, frozenset
6
7
8import datetime, ast
9from ll import ul4c, color
10
11
12
13# for convenience in actions
14HIDDEN = BaseRecognizer.HIDDEN
15
16# token types
17EOF=-1
18T__24=24
19T__25=25
20T__26=26
21T__27=27
22T__28=28
23T__29=29
24T__30=30
25T__31=31
26T__32=32
27T__33=33
28T__34=34
29T__35=35
30T__36=36
31T__37=37
32T__38=38
33T__39=39
34T__40=40
35T__41=41
36T__42=42
37T__43=43
38T__44=44
39T__45=45
40T__46=46
41T__47=47
42T__48=48
43T__49=49
44T__50=50
45T__51=51
46T__52=52
47T__53=53
48T__54=54
49T__55=55
50T__56=56
51T__57=57
52T__58=58
53BIN_DIGIT=4
54COLOR=5
55DATE=6
56DIGIT=7
57ESC_SEQ=8
58EXPONENT=9
59FALSE=10
60FLOAT=11
61HEX_DIGIT=12
62INT=13
63NAME=14
64NONE=15
65OCT_DIGIT=16
66STRING=17
67TIME=18
68TRUE=19
69UNICODE1_ESC=20
70UNICODE2_ESC=21
71UNICODE4_ESC=22
72WS=23
73
74# token names
75tokenNames = [
76    "<invalid>", "<EOR>", "<DOWN>", "<UP>",
77    "BIN_DIGIT", "COLOR", "DATE", "DIGIT", "ESC_SEQ", "EXPONENT", "FALSE", 
78    "FLOAT", "HEX_DIGIT", "INT", "NAME", "NONE", "OCT_DIGIT", "STRING", 
79    "TIME", "TRUE", "UNICODE1_ESC", "UNICODE2_ESC", "UNICODE4_ESC", "WS", 
80    "'!='", "'%'", "'%='", "'('", "')'", "'*'", "'**'", "'*='", "'+'", "'+='", 
81    "','", "'-'", "'-='", "'.'", "'/'", "'//'", "'//='", "'/='", "':'", 
82    "'<'", "'<='", "'='", "'=='", "'>'", "'>='", "'['", "']'", "'and'", 
83    "'for'", "'if'", "'in'", "'not'", "'or'", "'{'", "'}'"
84]
85
86
87
88
89class UL4Parser(Parser):
90    grammarFileName = "src/ll/UL4.g"
91    api_version = 1
92    tokenNames = tokenNames
93
94    def __init__(self, input, state=None, *args, **kwargs):
95        if state is None:
96            state = RecognizerSharedState()
97
98        super(UL4Parser, self).__init__(input, state, *args, **kwargs)
99
100
101
102
103        self.delegates = []
104
105
106
107
108             
109    def mismatch(self, input, ttype, follow):
110        raise MismatchedTokenException(ttype, input)
111
112    def recoverFromMismatchedSet(self, input, e, follow):
113        raise e
114
115    def start(self, token):
116       return self.location.startcode + token.start
117
118    def end(self, token):
119       return self.location.startcode + token.stop + 1
120
121
122
123    # $ANTLR start "none"
124    # src/ll/UL4.g:147:1: none returns [node] : NONE ;
125    def none(self, ):
126        node = None
127
128
129        NONE1 = None
130
131        try:
132            try:
133                # src/ll/UL4.g:148:2: ( NONE )
134                # src/ll/UL4.g:148:4: NONE
135                pass 
136                NONE1 = self.match(self.input, NONE, self.FOLLOW_NONE_in_none694)
137
138                if self._state.backtracking == 0:
139                    pass
140                    node = ul4c.Const(self.location, self.start(NONE1), self.end(NONE1), None) 
141
142
143
144
145
146
147                       
148            except RecognitionException as e:
149                raise
150
151        finally:
152            pass
153        return node
154
155    # $ANTLR end "none"
156
157
158
159    # $ANTLR start "true_"
160    # src/ll/UL4.g:151:1: true_ returns [node] : TRUE ;
161    def true_(self, ):
162        node = None
163
164
165        TRUE2 = None
166
167        try:
168            try:
169                # src/ll/UL4.g:152:2: ( TRUE )
170                # src/ll/UL4.g:152:4: TRUE
171                pass 
172                TRUE2 = self.match(self.input, TRUE, self.FOLLOW_TRUE_in_true_711)
173
174                if self._state.backtracking == 0:
175                    pass
176                    node = ul4c.Const(self.location, self.start(TRUE2), self.end(TRUE2), True) 
177
178
179
180
181
182
183                       
184            except RecognitionException as e:
185                raise
186
187        finally:
188            pass
189        return node
190
191    # $ANTLR end "true_"
192
193
194
195    # $ANTLR start "false_"
196    # src/ll/UL4.g:155:1: false_ returns [node] : FALSE ;
197    def false_(self, ):
198        node = None
199
200
201        FALSE3 = None
202
203        try:
204            try:
205                # src/ll/UL4.g:156:2: ( FALSE )
206                # src/ll/UL4.g:156:4: FALSE
207                pass 
208                FALSE3 = self.match(self.input, FALSE, self.FOLLOW_FALSE_in_false_728)
209
210                if self._state.backtracking == 0:
211                    pass
212                    node = ul4c.Const(self.location, self.start(FALSE3), self.end(FALSE3), False) 
213
214
215
216
217
218
219                       
220            except RecognitionException as e:
221                raise
222
223        finally:
224            pass
225        return node
226
227    # $ANTLR end "false_"
228
229
230
231    # $ANTLR start "int_"
232    # src/ll/UL4.g:159:1: int_ returns [node] : INT ;
233    def int_(self, ):
234        node = None
235
236
237        INT4 = None
238
239        try:
240            try:
241                # src/ll/UL4.g:160:2: ( INT )
242                # src/ll/UL4.g:160:4: INT
243                pass 
244                INT4 = self.match(self.input, INT, self.FOLLOW_INT_in_int_745)
245
246                if self._state.backtracking == 0:
247                    pass
248                    node = ul4c.Const(self.location, self.start(INT4), self.end(INT4), int(INT4.text, 0)) 
249
250
251
252
253
254
255                       
256            except RecognitionException as e:
257                raise
258
259        finally:
260            pass
261        return node
262
263    # $ANTLR end "int_"
264
265
266
267    # $ANTLR start "float_"
268    # src/ll/UL4.g:163:1: float_ returns [node] : FLOAT ;
269    def float_(self, ):
270        node = None
271
272
273        FLOAT5 = None
274
275        try:
276            try:
277                # src/ll/UL4.g:164:2: ( FLOAT )
278                # src/ll/UL4.g:164:4: FLOAT
279                pass 
280                FLOAT5 = self.match(self.input, FLOAT, self.FOLLOW_FLOAT_in_float_762)
281
282                if self._state.backtracking == 0:
283                    pass
284                    node = ul4c.Const(self.location, self.start(FLOAT5), self.end(FLOAT5), float(FLOAT5.text)) 
285
286
287
288
289
290
291                       
292            except RecognitionException as e:
293                raise
294
295        finally:
296            pass
297        return node
298
299    # $ANTLR end "float_"
300
301
302
303    # $ANTLR start "string"
304    # src/ll/UL4.g:167:1: string returns [node] : STRING ;
305    def string(self, ):
306        node = None
307
308
309        STRING6 = None
310
311        try:
312            try:
313                # src/ll/UL4.g:168:2: ( STRING )
314                # src/ll/UL4.g:168:4: STRING
315                pass 
316                STRING6 = self.match(self.input, STRING, self.FOLLOW_STRING_in_string779)
317
318                if self._state.backtracking == 0:
319                    pass
320                    node = ul4c.Const(self.location, self.start(STRING6), self.end(STRING6), ast.literal_eval(STRING6.text)) 
321
322
323
324
325
326
327                       
328            except RecognitionException as e:
329                raise
330
331        finally:
332            pass
333        return node
334
335    # $ANTLR end "string"
336
337
338
339    # $ANTLR start "date"
340    # src/ll/UL4.g:171:1: date returns [node] : DATE ;
341    def date(self, ):
342        node = None
343
344
345        DATE7 = None
346
347        try:
348            try:
349                # src/ll/UL4.g:172:2: ( DATE )
350                # src/ll/UL4.g:172:4: DATE
351                pass 
352                DATE7 = self.match(self.input, DATE, self.FOLLOW_DATE_in_date796)
353
354                if self._state.backtracking == 0:
355                    pass
356                    node = ul4c.Const(self.location, self.start(DATE7), self.end(DATE7), datetime.datetime(*map(int, [f for f in ul4c.datesplitter.split(DATE7.text[2:-1]) if f]))) 
357
358
359
360
361
362
363                       
364            except RecognitionException as e:
365                raise
366
367        finally:
368            pass
369        return node
370
371    # $ANTLR end "date"
372
373
374
375    # $ANTLR start "color"
376    # src/ll/UL4.g:175:1: color returns [node] : COLOR ;
377    def color(self, ):
378        node = None
379
380
381        COLOR8 = None
382
383        try:
384            try:
385                # src/ll/UL4.g:176:2: ( COLOR )
386                # src/ll/UL4.g:176:4: COLOR
387                pass 
388                COLOR8 = self.match(self.input, COLOR, self.FOLLOW_COLOR_in_color813)
389
390                if self._state.backtracking == 0:
391                    pass
392                    node = ul4c.Const(self.location, self.start(COLOR8), self.end(COLOR8), color.Color.fromrepr(COLOR8.text)) 
393
394
395
396
397
398
399                       
400            except RecognitionException as e:
401                raise
402
403        finally:
404            pass
405        return node
406
407    # $ANTLR end "color"
408
409
410    class name_return(ParserRuleReturnScope):
411        def __init__(self):
412            super(UL4Parser.name_return, self).__init__()
413
414            self.node = None
415
416
417
418
419
420    # $ANTLR start "name"
421    # src/ll/UL4.g:179:1: name returns [node] : NAME ;
422    def name(self, ):
423        retval = self.name_return()
424        retval.start = self.input.LT(1)
425
426
427        NAME9 = None
428
429        try:
430            try:
431                # src/ll/UL4.g:180:2: ( NAME )
432                # src/ll/UL4.g:180:4: NAME
433                pass 
434                NAME9 = self.match(self.input, NAME, self.FOLLOW_NAME_in_name830)
435
436                if self._state.backtracking == 0:
437                    pass
438                    retval.node = ul4c.Var(self.location, self.start(NAME9), self.end(NAME9), NAME9.text) 
439
440
441
442
443
444                retval.stop = self.input.LT(-1)
445
446
447
448                       
449            except RecognitionException as e:
450                raise
451
452        finally:
453            pass
454        return retval
455
456    # $ANTLR end "name"
457
458
459
460    # $ANTLR start "literal"
461    # src/ll/UL4.g:183:1: literal returns [node] : (e_none= none |e_false= false_ |e_true= true_ |e_int= int_ |e_float= float_ |e_string= string |e_date= date |e_color= color |e_name= name );
462    def literal(self, ):
463        node = None
464
465
466        e_none = None
467
468        e_false = None
469
470        e_true = None
471
472        e_int = None
473
474        e_float = None
475
476        e_string = None
477
478        e_date = None
479
480        e_color = None
481
482        e_name = None
483
484
485        try:
486            try:
487                # src/ll/UL4.g:184:2: (e_none= none |e_false= false_ |e_true= true_ |e_int= int_ |e_float= float_ |e_string= string |e_date= date |e_color= color |e_name= name )
488                alt1 = 9
489                LA1 = self.input.LA(1)
490                if LA1 == NONE:
491                    alt1 = 1
492                elif LA1 == FALSE:
493                    alt1 = 2
494                elif LA1 == TRUE:
495                    alt1 = 3
496                elif LA1 == INT:
497                    alt1 = 4
498                elif LA1 == FLOAT:
499                    alt1 = 5
500                elif LA1 == STRING:
501                    alt1 = 6
502                elif LA1 == DATE:
503                    alt1 = 7
504                elif LA1 == COLOR:
505                    alt1 = 8
506                elif LA1 == NAME:
507                    alt1 = 9
508                else:
509                    if self._state.backtracking > 0:
510                        raise BacktrackingFailed
511
512
513                    nvae = NoViableAltException("", 1, 0, self.input)
514
515                    raise nvae
516
517
518                if alt1 == 1:
519                    # src/ll/UL4.g:184:4: e_none= none
520                    pass 
521                    self._state.following.append(self.FOLLOW_none_in_literal849)
522                    e_none = self.none()
523
524                    self._state.following.pop()
525
526                    if self._state.backtracking == 0:
527                        pass
528                        node =  e_none
529
530
531
532
533                elif alt1 == 2:
534                    # src/ll/UL4.g:185:4: e_false= false_
535                    pass 
536                    self._state.following.append(self.FOLLOW_false__in_literal858)
537                    e_false = self.false_()
538
539                    self._state.following.pop()
540
541                    if self._state.backtracking == 0:
542                        pass
543                        node =  e_false
544
545
546
547
548                elif alt1 == 3:
549                    # src/ll/UL4.g:186:4: e_true= true_
550                    pass 
551                    self._state.following.append(self.FOLLOW_true__in_literal867)
552                    e_true = self.true_()
553
554                    self._state.following.pop()
555
556                    if self._state.backtracking == 0:
557                        pass
558                        node =  e_true
559
560
561
562
563                elif alt1 == 4:
564                    # src/ll/UL4.g:187:4: e_int= int_
565                    pass 
566                    self._state.following.append(self.FOLLOW_int__in_literal876)
567                    e_int = self.int_()
568
569                    self._state.following.pop()
570
571                    if self._state.backtracking == 0:
572                        pass
573                        node =  e_int
574
575
576
577
578                elif alt1 == 5:
579                    # src/ll/UL4.g:188:4: e_float= float_
580                    pass 
581                    self._state.following.append(self.FOLLOW_float__in_literal885)
582                    e_float = self.float_()
583
584                    self._state.following.pop()
585
586                    if self._state.backtracking == 0:
587                        pass
588                        node =  e_float
589
590
591
592
593                elif alt1 == 6:
594                    # src/ll/UL4.g:189:4: e_string= string
595                    pass 
596                    self._state.following.append(self.FOLLOW_string_in_literal894)
597                    e_string = self.string()
598
599                    self._state.following.pop()
600
601                    if self._state.backtracking == 0:
602                        pass
603                        node =  e_string
604
605
606
607
608                elif alt1 == 7:
609                    # src/ll/UL4.g:190:4: e_date= date
610                    pass 
611                    self._state.following.append(self.FOLLOW_date_in_literal903)
612                    e_date = self.date()
613
614                    self._state.following.pop()
615
616                    if self._state.backtracking == 0:
617                        pass
618                        node =  e_date
619
620
621
622
623                elif alt1 == 8:
624                    # src/ll/UL4.g:191:4: e_color= color
625                    pass 
626                    self._state.following.append(self.FOLLOW_color_in_literal912)
627                    e_color = self.color()
628
629                    self._state.following.pop()
630
631                    if self._state.backtracking == 0:
632                        pass
633                        node =  e_color
634
635
636
637
638                elif alt1 == 9:
639                    # src/ll/UL4.g:192:4: e_name= name
640                    pass 
641                    self._state.following.append(self.FOLLOW_name_in_literal921)
642                    e_name = self.name()
643
644                    self._state.following.pop()
645
646                    if self._state.backtracking == 0:
647                        pass
648                        node =  ((e_name is not None) and [e_name.node] or [None])[0] 
649
650
651
652
653
654                       
655            except RecognitionException as e:
656                raise
657
658        finally:
659            pass
660        return node
661
662    # $ANTLR end "literal"
663
664
665
666    # $ANTLR start "list"
667    # src/ll/UL4.g:196:1: list returns [node] : (bracket_open= '[' bracket_close= ']' |bracket_open= '[' e1= expr1 ( ',' e2= expr1 )* ( ',' )? bracket_close= ']' );
668    def list(self, ):
669        node = None
670
671
672        bracket_open = None
673        bracket_close = None
674        e1 = None
675
676        e2 = None
677
678
679        try:
680            try:
681                # src/ll/UL4.g:197:2: (bracket_open= '[' bracket_close= ']' |bracket_open= '[' e1= expr1 ( ',' e2= expr1 )* ( ',' )? bracket_close= ']' )
682                alt4 = 2
683                LA4_0 = self.input.LA(1)
684
685                if (LA4_0 == 49) :
686                    LA4_1 = self.input.LA(2)
687
688                    if (LA4_1 == 50) :
689                        alt4 = 1
690                    elif ((COLOR <= LA4_1 <= DATE) or (FALSE <= LA4_1 <= FLOAT) or (INT <= LA4_1 <= NONE) or LA4_1 == STRING or LA4_1 == TRUE or LA4_1 == 27 or LA4_1 == 35 or LA4_1 == 49 or LA4_1 == 55 or LA4_1 == 57) :
691                        alt4 = 2
692                    else:
693                        if self._state.backtracking > 0:
694                            raise BacktrackingFailed
695
696
697                        nvae = NoViableAltException("", 4, 1, self.input)
698
699                        raise nvae
700
701
702                else:
703                    if self._state.backtracking > 0:
704                        raise BacktrackingFailed
705
706
707                    nvae = NoViableAltException("", 4, 0, self.input)
708
709                    raise nvae
710
711
712                if alt4 == 1:
713                    # src/ll/UL4.g:198:3: bracket_open= '[' bracket_close= ']'
714                    pass 
715                    bracket_open = self.match(self.input, 49, self.FOLLOW_49_in_list944)
716
717                    bracket_close = self.match(self.input, 50, self.FOLLOW_50_in_list950)
718
719                    if self._state.backtracking == 0:
720                        pass
721                        node = ul4c.List(self.location, self.start(bracket_open), self.end(bracket_close)) 
722
723
724
725
726                elif alt4 == 2:
727                    # src/ll/UL4.g:201:3: bracket_open= '[' e1= expr1 ( ',' e2= expr1 )* ( ',' )? bracket_close= ']'
728                    pass 
729                    bracket_open = self.match(self.input, 49, self.FOLLOW_49_in_list961)
730
731                    if self._state.backtracking == 0:
732                        pass
733                        node = ul4c.List(self.location, self.start(bracket_open), None) 
734
735
736
737                    self._state.following.append(self.FOLLOW_expr1_in_list969)
738                    e1 = self.expr1()
739
740                    self._state.following.pop()
741
742                    if self._state.backtracking == 0:
743                        pass
744                        node.items.append(e1) 
745
746
747
748                    # src/ll/UL4.g:203:3: ( ',' e2= expr1 )*
749                    while True: #loop2
750                        alt2 = 2
751                        LA2_0 = self.input.LA(1)
752
753                        if (LA2_0 == 34) :
754                            LA2_1 = self.input.LA(2)
755
756                            if ((COLOR <= LA2_1 <= DATE) or (FALSE <= LA2_1 <= FLOAT) or (INT <= LA2_1 <= NONE) or LA2_1 == STRING or LA2_1 == TRUE or LA2_1 == 27 or LA2_1 == 35 or LA2_1 == 49 or LA2_1 == 55 or LA2_1 == 57) :
757                                alt2 = 1
758
759
760
761
762                        if alt2 == 1:
763                            # src/ll/UL4.g:204:4: ',' e2= expr1
764                            pass 
765                            self.match(self.input, 34, self.FOLLOW_34_in_list980)
766
767                            self._state.following.append(self.FOLLOW_expr1_in_list987)
768                            e2 = self.expr1()
769
770                            self._state.following.pop()
771
772                            if self._state.backtracking == 0:
773                                pass
774                                node.items.append(e2) 
775
776
777
778
779                        else:
780                            break #loop2
781
782
783                    # src/ll/UL4.g:207:3: ( ',' )?
784                    alt3 = 2
785                    LA3_0 = self.input.LA(1)
786
787                    if (LA3_0 == 34) :
788                        alt3 = 1
789                    if alt3 == 1:
790                        # src/ll/UL4.g:207:3: ','
791                        pass 
792                        self.match(self.input, 34, self.FOLLOW_34_in_list998)
793
794
795
796
797                    bracket_close = self.match(self.input, 50, self.FOLLOW_50_in_list1005)
798
799                    if self._state.backtracking == 0:
800                        pass
801                        node.end = self.end(bracket_close) 
802
803
804
805
806
807                       
808            except RecognitionException as e:
809                raise
810
811        finally:
812            pass
813        return node
814
815    # $ANTLR end "list"
816
817
818
819    # $ANTLR start "listcomprehension"
820    # src/ll/UL4.g:211:1: listcomprehension returns [node] : bracket_open= '[' item= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? bracket_close= ']' ;
821    def listcomprehension(self, ):
822        node = None
823
824
825        bracket_open = None
826        bracket_close = None
827        item = None
828
829        n = None
830
831        container = None
832
833        condition = None
834
835
836         
837        _condition = None;
838           
839        try:
840            try:
841                # src/ll/UL4.g:216:2: (bracket_open= '[' item= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? bracket_close= ']' )
842                # src/ll/UL4.g:217:3: bracket_open= '[' item= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? bracket_close= ']'
843                pass 
844                bracket_open = self.match(self.input, 49, self.FOLLOW_49_in_listcomprehension1033)
845
846                self._state.following.append(self.FOLLOW_expr1_in_listcomprehension1039)
847                item = self.expr1()
848
849                self._state.following.pop()
850
851                self.match(self.input, 52, self.FOLLOW_52_in_listcomprehension1043)
852
853                self._state.following.append(self.FOLLOW_nestedname_in_listcomprehension1049)
854                n = self.nestedname()
855
856                self._state.following.pop()
857
858                self.match(self.input, 54, self.FOLLOW_54_in_listcomprehension1053)
859
860                self._state.following.append(self.FOLLOW_expr1_in_listcomprehension1059)
861                container = self.expr1()
862
863                self._state.following.pop()
864
865                # src/ll/UL4.g:223:3: ( 'if' condition= expr1 )?
866                alt5 = 2
867                LA5_0 = self.input.LA(1)
868
869                if (LA5_0 == 53) :
870                    alt5 = 1
871                if alt5 == 1:
872                    # src/ll/UL4.g:224:4: 'if' condition= expr1
873                    pass 
874                    self.match(self.input, 53, self.FOLLOW_53_in_listcomprehension1068)
875
876                    self._state.following.append(self.FOLLOW_expr1_in_listcomprehension1075)
877                    condition = self.expr1()
878
879                    self._state.following.pop()
880
881                    if self._state.backtracking == 0:
882                        pass
883                        _condition = condition; 
884
885
886
887
888
889
890                bracket_close = self.match(self.input, 50, self.FOLLOW_50_in_listcomprehension1088)
891
892                if self._state.backtracking == 0:
893                    pass
894                    node = ul4c.ListComp(self.location, self.start(bracket_open), self.end(bracket_close), item, ((n is not None) and [n.varname] or [None])[0], container, _condition) 
895
896
897
898
899
900
901                       
902            except RecognitionException as e:
903                raise
904
905        finally:
906            pass
907        return node
908
909    # $ANTLR end "listcomprehension"
910
911
912
913    # $ANTLR start "dictitem"
914    # src/ll/UL4.g:232:1: fragment dictitem returns [node] : k= expr1 ':' v= expr1 ;
915    def dictitem(self, ):
916        node = None
917
918
919        k = None
920
921        v = None
922
923
924        try:
925            try:
926                # src/ll/UL4.g:233:2: (k= expr1 ':' v= expr1 )
927                # src/ll/UL4.g:234:3: k= expr1 ':' v= expr1
928                pass 
929                self._state.following.append(self.FOLLOW_expr1_in_dictitem1113)
930                k = self.expr1()
931
932                self._state.following.pop()
933
934                self.match(self.input, 42, self.FOLLOW_42_in_dictitem1117)
935
936                self._state.following.append(self.FOLLOW_expr1_in_dictitem1123)
937                v = self.expr1()
938
939                self._state.following.pop()
940
941                if self._state.backtracking == 0:
942                    pass
943                    node = (k, v) 
944
945
946
947
948
949
950                       
951            except RecognitionException as e:
952                raise
953
954        finally:
955            pass
956        return node
957
958    # $ANTLR end "dictitem"
959
960
961
962    # $ANTLR start "dict"
963    # src/ll/UL4.g:239:1: dict returns [node] : (brace_open= '{' brace_close= '}' |brace_open= '{' i1= dictitem ( ',' i2= dictitem )* ( ',' )? brace_close= '}' );
964    def dict(self, ):
965        node = None
966
967
968        brace_open = None
969        brace_close = None
970        i1 = None
971
972        i2 = None
973
974
975        try:
976            try:
977                # src/ll/UL4.g:240:2: (brace_open= '{' brace_close= '}' |brace_open= '{' i1= dictitem ( ',' i2= dictitem )* ( ',' )? brace_close= '}' )
978                alt8 = 2
979                LA8_0 = self.input.LA(1)
980
981                if (LA8_0 == 57) :
982                    LA8_1 = self.input.LA(2)
983
984                    if (LA8_1 == 58) :
985                        alt8 = 1
986                    elif ((COLOR <= LA8_1 <= DATE) or (FALSE <= LA8_1 <= FLOAT) or (INT <= LA8_1 <= NONE) or LA8_1 == STRING or LA8_1 == TRUE or LA8_1 == 27 or LA8_1 == 35 or LA8_1 == 49 or LA8_1 == 55 or LA8_1 == 57) :
987                        alt8 = 2
988                    else:
989                        if self._state.backtracking > 0:
990                            raise BacktrackingFailed
991
992
993                        nvae = NoViableAltException("", 8, 1, self.input)
994
995                        raise nvae
996
997
998                else:
999                    if self._state.backtracking > 0:
1000                        raise BacktrackingFailed
1001
1002
1003                    nvae = NoViableAltException("", 8, 0, self.input)
1004
1005                    raise nvae
1006
1007
1008                if alt8 == 1:
1009                    # src/ll/UL4.g:241:3: brace_open= '{' brace_close= '}'
1010                    pass 
1011                    brace_open = self.match(self.input, 57, self.FOLLOW_57_in_dict1144)
1012
1013                    brace_close = self.match(self.input, 58, self.FOLLOW_58_in_dict1150)
1014
1015                    if self._state.backtracking == 0:
1016                        pass
1017                        node = ul4c.Dict(self.location, self.start(brace_open), self.end(brace_close)) 
1018
1019
1020
1021
1022                elif alt8 == 2:
1023                    # src/ll/UL4.g:244:3: brace_open= '{' i1= dictitem ( ',' i2= dictitem )* ( ',' )? brace_close= '}'
1024                    pass 
1025                    brace_open = self.match(self.input, 57, self.FOLLOW_57_in_dict1161)
1026
1027                    if self._state.backtracking == 0:
1028                        pass
1029                        node = ul4c.Dict(self.location, self.start(brace_open), None) 
1030
1031
1032
1033                    self._state.following.append(self.FOLLOW_dictitem_in_dict1169)
1034                    i1 = self.dictitem()
1035
1036                    self._state.following.pop()
1037
1038                    if self._state.backtracking == 0:
1039                        pass
1040                        node.items.append(i1) 
1041
1042
1043
1044                    # src/ll/UL4.g:246:3: ( ',' i2= dictitem )*
1045                    while True: #loop6
1046                        alt6 = 2
1047                        LA6_0 = self.input.LA(1)
1048
1049                        if (LA6_0 == 34) :
1050                            LA6_1 = self.input.LA(2)
1051
1052                            if ((COLOR <= LA6_1 <= DATE) or (FALSE <= LA6_1 <= FLOAT) or (INT <= LA6_1 <= NONE) or LA6_1 == STRING or LA6_1 == TRUE or LA6_1 == 27 or LA6_1 == 35 or LA6_1 == 49 or LA6_1 == 55 or LA6_1 == 57) :
1053                                alt6 = 1
1054
1055
1056
1057
1058                        if alt6 == 1:
1059                            # src/ll/UL4.g:247:4: ',' i2= dictitem
1060                            pass 
1061                            self.match(self.input, 34, self.FOLLOW_34_in_dict1180)
1062
1063                            self._state.following.append(self.FOLLOW_dictitem_in_dict1187)
1064                            i2 = self.dictitem()
1065
1066                            self._state.following.pop()
1067
1068                            if self._state.backtracking == 0:
1069                                pass
1070                                node.items.append(i2) 
1071
1072
1073
1074
1075                        else:
1076                            break #loop6
1077
1078
1079                    # src/ll/UL4.g:250:3: ( ',' )?
1080                    alt7 = 2
1081                    LA7_0 = self.input.LA(1)
1082
1083                    if (LA7_0 == 34) :
1084                        alt7 = 1
1085                    if alt7 == 1:
1086                        # src/ll/UL4.g:250:3: ','
1087                        pass 
1088                        self.match(self.input, 34, self.FOLLOW_34_in_dict1198)
1089
1090
1091
1092
1093                    brace_close = self.match(self.input, 58, self.FOLLOW_58_in_dict1205)
1094
1095                    if self._state.backtracking == 0:
1096                        pass
1097                        node.end = self.end(brace_close) 
1098
1099
1100
1101
1102
1103                       
1104            except RecognitionException as e:
1105                raise
1106
1107        finally:
1108            pass
1109        return node
1110
1111    # $ANTLR end "dict"
1112
1113
1114
1115    # $ANTLR start "dictcomprehension"
1116    # src/ll/UL4.g:254:1: dictcomprehension returns [node] : brace_open= '{' key= expr1 ':' value= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? brace_close= '}' ;
1117    def dictcomprehension(self, ):
1118        node = None
1119
1120
1121        brace_open = None
1122        brace_close = None
1123        key = None
1124
1125        value = None
1126
1127        n = None
1128
1129        container = None
1130
1131        condition = None
1132
1133
1134         
1135        _condition = None;
1136           
1137        try:
1138            try:
1139                # src/ll/UL4.g:259:2: (brace_open= '{' key= expr1 ':' value= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? brace_close= '}' )
1140                # src/ll/UL4.g:260:3: brace_open= '{' key= expr1 ':' value= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? brace_close= '}'
1141                pass 
1142                brace_open = self.match(self.input, 57, self.FOLLOW_57_in_dictcomprehension1233)
1143
1144                self._state.following.append(self.FOLLOW_expr1_in_dictcomprehension1239)
1145                key = self.expr1()
1146
1147                self._state.following.pop()
1148
1149                self.match(self.input, 42, self.FOLLOW_42_in_dictcomprehension1243)
1150
1151                self._state.following.append(self.FOLLOW_expr1_in_dictcomprehension1249)
1152                value = self.expr1()
1153
1154                self._state.following.pop()
1155
1156                self.match(self.input, 52, self.FOLLOW_52_in_dictcomprehension1253)
1157
1158                self._state.following.append(self.FOLLOW_nestedname_in_dictcomprehension1259)
1159                n = self.nestedname()
1160
1161                self._state.following.pop()
1162
1163                self.match(self.input, 54, self.FOLLOW_54_in_dictcomprehension1263)
1164
1165                self._state.following.append(self.FOLLOW_expr1_in_dictcomprehension1269)
1166                container = self.expr1()
1167
1168                self._state.following.pop()
1169
1170                # src/ll/UL4.g:268:3: ( 'if' condition= expr1 )?
1171                alt9 = 2
1172                LA9_0 = self.input.LA(1)
1173
1174                if (LA9_0 == 53) :
1175                    alt9 = 1
1176                if alt9 == 1:
1177                    # src/ll/UL4.g:269:4: 'if' condition= expr1
1178                    pass 
1179                    self.match(self.input, 53, self.FOLLOW_53_in_dictcomprehension1278)
1180
1181                    self._state.following.append(self.FOLLOW_expr1_in_dictcomprehension1285)
1182                    condition = self.expr1()
1183
1184                    self._state.following.pop()
1185
1186                    if self._state.backtracking == 0:
1187                        pass
1188                        _condition = condition; 
1189
1190
1191
1192
1193
1194
1195                brace_close = self.match(self.input, 58, self.FOLLOW_58_in_dictcomprehension1298)
1196
1197                if self._state.backtracking == 0:
1198                    pass
1199                    node = ul4c.DictComp(self.location, self.start(brace_open), self.end(brace_close), key, value, ((n is not None) and [n.varname] or [None])[0], container, _condition) 
1200
1201
1202
1203
1204
1205
1206                       
1207            except RecognitionException as e:
1208                raise
1209
1210        finally:
1211            pass
1212        return node
1213
1214    # $ANTLR end "dictcomprehension"
1215
1216
1217
1218    # $ANTLR start "generatorexpression"
1219    # src/ll/UL4.g:275:1: generatorexpression returns [node] : item= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? ;
1220    def generatorexpression(self, ):
1221        node = None
1222
1223
1224        item = None
1225
1226        n = None
1227
1228        container = None
1229
1230        condition = None
1231
1232
1233         
1234        _condition = None
1235        _end = None
1236           
1237        try:
1238            try:
1239                # src/ll/UL4.g:281:2: (item= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? )
1240                # src/ll/UL4.g:282:3: item= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )?
1241                pass 
1242                self._state.following.append(self.FOLLOW_expr1_in_generatorexpression1326)
1243                item = self.expr1()
1244
1245                self._state.following.pop()
1246
1247                if self._state.backtracking == 0:
1248                    pass
1249                    _start = item.start
1250
1251
1252
1253                self.match(self.input, 52, self.FOLLOW_52_in_generatorexpression1332)
1254
1255                self._state.following.append(self.FOLLOW_nestedname_in_generatorexpression1338)
1256                n = self.nestedname()
1257
1258                self._state.following.pop()
1259
1260                self.match(self.input, 54, self.FOLLOW_54_in_generatorexpression1342)
1261
1262                self._state.following.append(self.FOLLOW_expr1_in_generatorexpression1348)
1263                container = self.expr1()
1264
1265                self._state.following.pop()
1266
1267                if self._state.backtracking == 0:
1268                    pass
1269                    _end = container.end
1270
1271
1272
1273                # src/ll/UL4.g:287:3: ( 'if' condition= expr1 )?
1274                alt10 = 2
1275                LA10_0 = self.input.LA(1)
1276
1277                if (LA10_0 == 53) :
1278                    alt10 = 1
1279                if alt10 == 1:
1280                    # src/ll/UL4.g:288:4: 'if' condition= expr1
1281                    pass 
1282                    self.match(self.input, 53, self.FOLLOW_53_in_generatorexpression1359)
1283
1284                    self._state.following.append(self.FOLLOW_expr1_in_generatorexpression1366)
1285                    condition = self.expr1()
1286
1287                    self._state.following.pop()
1288
1289                    if self._state.backtracking == 0:
1290                        pass
1291                        _condition = condition; _end = condition.end
1292
1293
1294
1295
1296
1297
1298                if self._state.backtracking == 0:
1299                    pass
1300                    node = ul4c.GenExpr(self.location, item.start, _end, item, ((n is not None) and [n.varname] or [None])[0], container, _condition) 
1301
1302
1303
1304
1305
1306
1307                       
1308            except RecognitionException as e:
1309                raise
1310
1311        finally:
1312            pass
1313        return node
1314
1315    # $ANTLR end "generatorexpression"
1316
1317
1318
1319    # $ANTLR start "atom"
1320    # src/ll/UL4.g:293:1: atom returns [node] : (e_literal= literal |e_list= list |e_listcomp= listcomprehension |e_dict= dict |e_dictcomp= dictcomprehension | '(' e_genexpr= generatorexpression ')' | '(' e_bracket= expr1 ')' );
1321    def atom(self, ):
1322        node = None
1323
1324
1325        e_literal = None
1326
1327        e_list = None
1328
1329        e_listcomp = None
1330
1331        e_dict = None
1332
1333        e_dictcomp = None
1334
1335        e_genexpr = None
1336
1337        e_bracket = None
1338
1339
1340        try:
1341            try:
1342                # src/ll/UL4.g:294:2: (e_literal= literal |e_list= list |e_listcomp= listcomprehension |e_dict= dict |e_dictcomp= dictcomprehension | '(' e_genexpr= generatorexpression ')' | '(' e_bracket= expr1 ')' )
1343                alt11 = 7
1344                LA11 = self.input.LA(1)
1345                if LA11 == COLOR or LA11 == DATE or LA11 == FALSE or LA11 == FLOAT or LA11 == INT or LA11 == NAME or LA11 == NONE or LA11 == STRING or LA11 == TRUE:
1346                    alt11 = 1
1347                elif LA11 == 49:
1348                    LA11_10 = self.input.LA(2)
1349
1350                    if (self.synpred19_UL4()) :
1351                        alt11 = 2
1352                    elif (self.synpred20_UL4()) :
1353                        alt11 = 3
1354                    else:
1355                        if self._state.backtracking > 0:
1356                            raise BacktrackingFailed
1357
1358
1359                        nvae = NoViableAltException("", 11, 10, self.input)
1360
1361                        raise nvae
1362
1363
1364                elif LA11 == 57:
1365                    LA11_11 = self.input.LA(2)
1366
1367                    if (self.synpred21_UL4()) :
1368                        alt11 = 4
1369                    elif (self.synpred22_UL4()) :
1370                        alt11 = 5
1371                    else:
1372                        if self._state.backtracking > 0:
1373                            raise BacktrackingFailed
1374
1375
1376                        nvae = NoViableAltException("", 11, 11, self.input)
1377
1378                        raise nvae
1379
1380
1381                elif LA11 == 27:
1382                    LA11_12 = self.input.LA(2)
1383
1384                    if (self.synpred23_UL4()) :
1385                        alt11 = 6
1386                    elif (True) :
1387                        alt11 = 7
1388                    else:
1389                        if self._state.backtracking > 0:
1390                            raise BacktrackingFailed
1391
1392
1393                        nvae = NoViableAltException("", 11, 12, self.input)
1394
1395                        raise nvae
1396
1397
1398                else:
1399                    if self._state.backtracking > 0:
1400                        raise BacktrackingFailed
1401
1402
1403                    nvae = NoViableAltException("", 11, 0, self.input)
1404
1405                    raise nvae
1406
1407
1408                if alt11 == 1:
1409                    # src/ll/UL4.g:294:4: e_literal= literal
1410                    pass 
1411                    self._state.following.append(self.FOLLOW_literal_in_atom1392)
1412                    e_literal = self.literal()
1413
1414                    self._state.following.pop()
1415
1416                    if self._state.backtracking == 0:
1417                        pass
1418                        node =  e_literal
1419
1420
1421
1422
1423                elif alt11 == 2:
1424                    # src/ll/UL4.g:295:4: e_list= list
1425                    pass 
1426                    self._state.following.append(self.FOLLOW_list_in_atom1401)
1427                    e_list = self.list()
1428
1429                    self._state.following.pop()
1430
1431                    if self._state.backtracking == 0:
1432                        pass
1433                        node =  e_list
1434
1435
1436
1437
1438                elif alt11 == 3:
1439                    # src/ll/UL4.g:296:4: e_listcomp= listcomprehension
1440                    pass 
1441                    self._state.following.append(self.FOLLOW_listcomprehension_in_atom1410)
1442                    e_listcomp = self.listcomprehension()
1443
1444                    self._state.following.pop()
1445
1446                    if self._state.backtracking == 0:
1447                        pass
1448                        node =  e_listcomp
1449
1450
1451
1452
1453                elif alt11 == 4:
1454                    # src/ll/UL4.g:297:4: e_dict= dict
1455                    pass 
1456                    self._state.following.append(self.FOLLOW_dict_in_atom1419)
1457                    e_dict = self.dict()
1458
1459                    self._state.following.pop()
1460
1461                    if self._state.backtracking == 0:
1462                        pass
1463                        node =  e_dict
1464
1465
1466
1467
1468                elif alt11 == 5:
1469                    # src/ll/UL4.g:298:4: e_dictcomp= dictcomprehension
1470                    pass 
1471                    self._state.following.append(self.FOLLOW_dictcomprehension_in_atom1428)
1472                    e_dictcomp = self.dictcomprehension()
1473
1474                    self._state.following.pop()
1475
1476                    if self._state.backtracking == 0:
1477                        pass
1478                        node =  e_dictcomp
1479
1480
1481
1482
1483                elif alt11 == 6:
1484                    # src/ll/UL4.g:299:4: '(' e_genexpr= generatorexpression ')'
1485                    pass 
1486                    self.match(self.input, 27, self.FOLLOW_27_in_atom1435)
1487
1488                    self._state.following.append(self.FOLLOW_generatorexpression_in_atom1439)
1489                    e_genexpr = self.generatorexpression()
1490
1491                    self._state.following.pop()
1492
1493                    self.match(self.input, 28, self.FOLLOW_28_in_atom1441)
1494
1495                    if self._state.backtracking == 0:
1496                        pass
1497                        node =  e_genexpr
1498
1499
1500
1501
1502                elif alt11 == 7:
1503                    # src/ll/UL4.g:300:4: '(' e_bracket= expr1 ')'
1504                    pass 
1505                    self.match(self.input, 27, self.FOLLOW_27_in_atom1448)
1506
1507                    self._state.following.append(self.FOLLOW_expr1_in_atom1452)
1508                    e_bracket = self.expr1()
1509
1510                    self._state.following.pop()
1511
1512                    self.match(self.input, 28, self.FOLLOW_28_in_atom1454)
1513
1514                    if self._state.backtracking == 0:
1515                        pass
1516                        node =  e_bracket
1517
1518
1519
1520
1521
1522                       
1523            except RecognitionException as e:
1524                raise
1525
1526        finally:
1527            pass
1528        return node
1529
1530    # $ANTLR end "atom"
1531
1532
1533    class nestedname_return(ParserRuleReturnScope):
1534        def __init__(self):
1535            super(UL4Parser.nestedname_return, self).__init__()
1536
1537            self.varname = None
1538
1539
1540
1541
1542
1543    # $ANTLR start "nestedname"
1544    # src/ll/UL4.g:304:1: nestedname returns [varname] : (n= name | '(' n0= nestedname ',' ')' | '(' n1= nestedname ',' n2= nestedname ( ',' n3= nestedname )* ( ',' )? ')' );
1545    def nestedname(self, ):
1546        retval = self.nestedname_return()
1547        retval.start = self.input.LT(1)
1548
1549
1550        n = None
1551
1552        n0 = None
1553
1554        n1 = None
1555
1556        n2 = None
1557
1558        n3 = None
1559
1560
1561        try:
1562            try:
1563                # src/ll/UL4.g:305:2: (n= name | '(' n0= nestedname ',' ')' | '(' n1= nestedname ',' n2= nestedname ( ',' n3= nestedname )* ( ',' )? ')' )
1564                alt14 = 3
1565                LA14_0 = self.input.LA(1)
1566
1567                if (LA14_0 == NAME) :
1568                    alt14 = 1
1569                elif (LA14_0 == 27) :
1570                    LA14_2 = self.input.LA(2)
1571
1572                    if (self.synpred25_UL4()) :
1573                        alt14 = 2
1574                    elif (True) :
1575                        alt14 = 3
1576                    else:
1577                        if self._state.backtracking > 0:
1578                            raise BacktrackingFailed
1579
1580
1581                        nvae = NoViableAltException("", 14, 2, self.input)
1582
1583                        raise nvae
1584
1585
1586                else:
1587                    if self._state.backtracking > 0:
1588                        raise BacktrackingFailed
1589
1590
1591                    nvae = NoViableAltException("", 14, 0, self.input)
1592
1593                    raise nvae
1594
1595
1596                if alt14 == 1:
1597                    # src/ll/UL4.g:306:3: n= name
1598                    pass 
1599                    self._state.following.append(self.FOLLOW_name_in_nestedname1477)
1600                    n = self.name()
1601
1602                    self._state.following.pop()
1603
1604                    if self._state.backtracking == 0:
1605                        pass
1606                        retval.varname =  ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0] 
1607
1608
1609
1610
1611                elif alt14 == 2:
1612                    # src/ll/UL4.g:308:3: '(' n0= nestedname ',' ')'
1613                    pass 
1614                    self.match(self.input, 27, self.FOLLOW_27_in_nestedname1486)
1615
1616                    self._state.following.append(self.FOLLOW_nestedname_in_nestedname1490)
1617                    n0 = self.nestedname()
1618
1619                    self._state.following.pop()
1620
1621                    self.match(self.input, 34, self.FOLLOW_34_in_nestedname1492)
1622
1623                    self.match(self.input, 28, self.FOLLOW_28_in_nestedname1494)
1624
1625                    if self._state.backtracking == 0:
1626                        pass
1627                        retval.varname = (((n0 is not None) and [n0.varname] or [None])[0],) 
1628
1629
1630
1631
1632                elif alt14 == 3:
1633                    # src/ll/UL4.g:310:3: '(' n1= nestedname ',' n2= nestedname ( ',' n3= nestedname )* ( ',' )? ')'
1634                    pass 
1635                    self.match(self.input, 27, self.FOLLOW_27_in_nestedname1503)
1636
1637                    self._state.following.append(self.FOLLOW_nestedname_in_nestedname1509)
1638                    n1 = self.nestedname()
1639
1640                    self._state.following.pop()
1641
1642                    self.match(self.input, 34, self.FOLLOW_34_in_nestedname1513)
1643
1644                    self._state.following.append(self.FOLLOW_nestedname_in_nestedname1519)
1645                    n2 = self.nestedname()
1646
1647                    self._state.following.pop()
1648
1649                    if self._state.backtracking == 0:
1650                        pass
1651                        retval.varname = (((n1 is not None) and [n1.varname] or [None])[0], ((n2 is not None) and [n2.varname] or [None])[0]) 
1652
1653
1654
1655                    # src/ll/UL4.g:314:3: ( ',' n3= nestedname )*
1656                    while True: #loop12
1657                        alt12 = 2
1658                        LA12_0 = self.input.LA(1)
1659
1660                        if (LA12_0 == 34) :
1661                            LA12_1 = self.input.LA(2)
1662
1663                            if (LA12_1 == NAME or LA12_1 == 27) :
1664                                alt12 = 1
1665
1666
1667
1668
1669                        if alt12 == 1:
1670                            # src/ll/UL4.g:315:4: ',' n3= nestedname
1671                            pass 
1672                            self.match(self.input, 34, self.FOLLOW_34_in_nestedname1530)
1673
1674                            self._state.following.append(self.FOLLOW_nestedname_in_nestedname1537)
1675                            n3 = self.nestedname()
1676
1677                            self._state.following.pop()
1678
1679                            if self._state.backtracking == 0:
1680                                pass
1681                                retval.varname += (((n3 is not None) and [n3.varname] or [None])[0],) 
1682
1683
1684
1685
1686                        else:
1687                            break #loop12
1688
1689
1690                    # src/ll/UL4.g:318:3: ( ',' )?
1691                    alt13 = 2
1692                    LA13_0 = self.input.LA(1)
1693
1694                    if (LA13_0 == 34) :
1695                        alt13 = 1
1696                    if alt13 == 1:
1697                        # src/ll/UL4.g:318:3: ','
1698                        pass 
1699                        self.match(self.input, 34, self.FOLLOW_34_in_nestedname1548)
1700
1701
1702
1703
1704                    self.match(self.input, 28, self.FOLLOW_28_in_nestedname1553)
1705
1706
1707                retval.stop = self.input.LT(-1)
1708
1709
1710
1711                       
1712            except RecognitionException as e:
1713                raise
1714
1715        finally:
1716            pass
1717        return retval
1718
1719    # $ANTLR end "nestedname"
1720
1721
1722
1723    # $ANTLR start "expr9"
1724    # src/ll/UL4.g:323:1: expr9 returns [node] : e1= atom ( '.' n= name | '(' (| '**' rkwargs= exprarg ( ',' )? | '*' rargs= exprarg ( ',' '**' rkwargs= exprarg )? ( ',' )? |a1= exprarg ( ',' a2= exprarg )* ( ',' an3= name '=' av3= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? |an1= name '=' av1= exprarg ( ',' an2= name '=' av2= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? ) paren_close= ')' | '[' ( ':' (e2= expr1 )? |e2= expr1 ( ':' (e3= expr1 )? )? ) bracket_close= ']' )* ;
1725    def expr9(self, ):
1726        node = None
1727
1728
1729        paren_close = None
1730        bracket_close = None
1731        e1 = None
1732
1733        n = None
1734
1735        rkwargs = None
1736
1737        rargs = None
1738
1739        a1 = None
1740
1741        a2 = None
1742
1743        an3 = None
1744
1745        av3 = None
1746
1747        an1 = None
1748
1749        av1 = None
1750
1751        an2 = None
1752
1753        av2 = None
1754
1755        e2 = None
1756
1757        e3 = None
1758
1759
1760         
1761        callmeth = False
1762        index1 = None
1763        index2 = None
1764        slice = False
1765           
1766        try:
1767            try:
1768                # src/ll/UL4.g:331:2: (e1= atom ( '.' n= name | '(' (| '**' rkwargs= exprarg ( ',' )? | '*' rargs= exprarg ( ',' '**' rkwargs= exprarg )? ( ',' )? |a1= exprarg ( ',' a2= exprarg )* ( ',' an3= name '=' av3= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? |an1= name '=' av1= exprarg ( ',' an2= name '=' av2= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? ) paren_close= ')' | '[' ( ':' (e2= expr1 )? |e2= expr1 ( ':' (e3= expr1 )? )? ) bracket_close= ']' )* )
1769                # src/ll/UL4.g:332:3: e1= atom ( '.' n= name | '(' (| '**' rkwargs= exprarg ( ',' )? | '*' rargs= exprarg ( ',' '**' rkwargs= exprarg )? ( ',' )? |a1= exprarg ( ',' a2= exprarg )* ( ',' an3= name '=' av3= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? |an1= name '=' av1= exprarg ( ',' an2= name '=' av2= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? ) paren_close= ')' | '[' ( ':' (e2= expr1 )? |e2= expr1 ( ':' (e3= expr1 )? )? ) bracket_close= ']' )*
1770                pass 
1771                self._state.following.append(self.FOLLOW_atom_in_expr91582)
1772                e1 = self.atom()
1773
1774                self._state.following.pop()
1775
1776                if self._state.backtracking == 0:
1777                    pass
1778                    node =  e1
1779
1780
1781
1782                # src/ll/UL4.g:333:3: ( '.' n= name | '(' (| '**' rkwargs= exprarg ( ',' )? | '*' rargs= exprarg ( ',' '**' rkwargs= exprarg )? ( ',' )? |a1= exprarg ( ',' a2= exprarg )* ( ',' an3= name '=' av3= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? |an1= name '=' av1= exprarg ( ',' an2= name '=' av2= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? ) paren_close= ')' | '[' ( ':' (e2= expr1 )? |e2= expr1 ( ':' (e3= expr1 )? )? ) bracket_close= ']' )*
1783                while True: #loop32
1784                    alt32 = 4
1785                    LA32 = self.input.LA(1)
1786                    if LA32 == 37:
1787                        alt32 = 1
1788                    elif LA32 == 27:
1789                        alt32 = 2
1790                    elif LA32 == 49:
1791                        alt32 = 3
1792
1793                    if alt32 == 1:
1794                        # src/ll/UL4.g:335:4: '.' n= name
1795                        pass 
1796                        self.match(self.input, 37, self.FOLLOW_37_in_expr91598)
1797
1798                        self._state.following.append(self.FOLLOW_name_in_expr91605)
1799                        n = self.name()
1800
1801                        self._state.following.pop()
1802
1803                        if self._state.backtracking == 0:
1804                            pass
1805                            node = ul4c.GetAttr(self.location, node.start, self.end(n.stop), node, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0]) 
1806
1807
1808
1809
1810                    elif alt32 == 2:
1811                        # src/ll/UL4.g:339:4: '(' (| '**' rkwargs= exprarg ( ',' )? | '*' rargs= exprarg ( ',' '**' rkwargs= exprarg )? ( ',' )? |a1= exprarg ( ',' a2= exprarg )* ( ',' an3= name '=' av3= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? |an1= name '=' av1= exprarg ( ',' an2= name '=' av2= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? ) paren_close= ')'
1812                        pass 
1813                        self.match(self.input, 27, self.FOLLOW_27_in_expr91621)
1814
1815                        if self._state.backtracking == 0:
1816                            pass
1817                            node = ul4c.CallMeth(self.location, node.start, None, node.obj, node.attrname) if isinstance(node, ul4c.GetAttr) else ul4c.CallFunc(self.location, node.start, None, node) 
1818
1819
1820
1821                        # src/ll/UL4.g:340:4: (| '**' rkwargs= exprarg ( ',' )? | '*' rargs= exprarg ( ',' '**' rkwargs= exprarg )? ( ',' )? |a1= exprarg ( ',' a2= exprarg )* ( ',' an3= name '=' av3= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? |an1= name '=' av1= exprarg ( ',' an2= name '=' av2= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )? )
1822                        alt27 = 5
1823                        LA27 = self.input.LA(1)
1824                        if LA27 == 28:
1825                            alt27 = 1
1826                        elif LA27 == 30:
1827                            alt27 = 2
1828                        elif LA27 == 29:
1829                            alt27 = 3
1830                        elif LA27 == COLOR or LA27 == DATE or LA27 == FALSE or LA27 == FLOAT or LA27 == INT or LA27 == NONE or LA27 == STRING or LA27 == TRUE or LA27 == 27 or LA27 == 35 or LA27 == 49 or LA27 == 55 or LA27 == 57:
1831                            alt27 = 4
1832                        elif LA27 == NAME:
1833                            LA27_5 = self.input.LA(2)
1834
1835                            if ((24 <= LA27_5 <= 25) or (27 <= LA27_5 <= 29) or LA27_5 == 32 or (34 <= LA27_5 <= 35) or (37 <= LA27_5 <= 39) or (43 <= LA27_5 <= 44) or (46 <= LA27_5 <= 49) or (51 <= LA27_5 <= 52) or (54 <= LA27_5 <= 56)) :
1836                                alt27 = 4
1837                            elif (LA27_5 == 45) :
1838                                alt27 = 5
1839                            else:
1840                                if self._state.backtracking > 0:
1841                                    raise BacktrackingFailed
1842
1843
1844                                nvae = NoViableAltException("", 27, 5, self.input)
1845
1846                                raise nvae
1847
1848
1849                        else:
1850                            if self._state.backtracking > 0:
1851                                raise BacktrackingFailed
1852
1853
1854                            nvae = NoViableAltException("", 27, 0, self.input)
1855
1856                            raise nvae
1857
1858
1859                        if alt27 == 1:
1860                            # src/ll/UL4.g:342:4:
1861                            pass 
1862
1863                        elif alt27 == 2:
1864                            # src/ll/UL4.g:344:5: '**' rkwargs= exprarg ( ',' )?
1865                            pass 
1866                            self.match(self.input, 30, self.FOLLOW_30_in_expr91651)
1867
1868                            self._state.following.append(self.FOLLOW_exprarg_in_expr91655)
1869                            rkwargs = self.exprarg()
1870
1871                            self._state.following.pop()
1872
1873                            if self._state.backtracking == 0:
1874                                pass
1875                                node.remkwargs = rkwargs; 
1876
1877
1878
1879                            # src/ll/UL4.g:345:5: ( ',' )?
1880                            alt15 = 2
1881                            LA15_0 = self.input.LA(1)
1882
1883                            if (LA15_0 == 34) :
1884                                alt15 = 1
1885                            if alt15 == 1:
1886                                # src/ll/UL4.g:345:5: ','
1887                                pass 
1888                                self.match(self.input, 34, self.FOLLOW_34_in_expr91663)
1889
1890
1891
1892
1893
1894                        elif alt27 == 3:
1895                            # src/ll/UL4.g:348:5: '*' rargs= exprarg ( ',' '**' rkwargs= exprarg )? ( ',' )?
1896                            pass 
1897                            self.match(self.input, 29, self.FOLLOW_29_in_expr91681)
1898
1899                            self._state.following.append(self.FOLLOW_exprarg_in_expr91685)
1900                            rargs = self.exprarg()
1901
1902                            self._state.following.pop()
1903
1904                            if self._state.backtracking == 0:
1905                                pass
1906                                node.remargs = rargs; 
1907
1908
1909
1910                            # src/ll/UL4.g:349:5: ( ',' '**' rkwargs= exprarg )?
1911                            alt16 = 2
1912                            LA16_0 = self.input.LA(1)
1913
1914                            if (LA16_0 == 34) :
1915                                LA16_1 = self.input.LA(2)
1916
1917                                if (LA16_1 == 30) :
1918                                    alt16 = 1
1919                            if alt16 == 1:
1920                                # src/ll/UL4.g:350:6: ',' '**' rkwargs= exprarg
1921                                pass 
1922                                self.match(self.input, 34, self.FOLLOW_34_in_expr91700)
1923
1924                                self.match(self.input, 30, self.FOLLOW_30_in_expr91707)
1925
1926                                self._state.following.append(self.FOLLOW_exprarg_in_expr91711)
1927                                rkwargs = self.exprarg()
1928
1929                                self._state.following.pop()
1930
1931                                if self._state.backtracking == 0:
1932                                    pass
1933                                    node.remkwargs = rkwargs; 
1934
1935
1936
1937
1938
1939
1940                            # src/ll/UL4.g:353:5: ( ',' )?
1941                            alt17 = 2
1942                            LA17_0 = self.input.LA(1)
1943
1944                            if (LA17_0 == 34) :
1945                                alt17 = 1
1946                            if alt17 == 1:
1947                                # src/ll/UL4.g:353:5: ','
1948                                pass 
1949                                self.match(self.input, 34, self.FOLLOW_34_in_expr91726)
1950
1951
1952
1953
1954
1955                        elif alt27 == 4:
1956                            # src/ll/UL4.g:356:5: a1= exprarg ( ',' a2= exprarg )* ( ',' an3= name '=' av3= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )?
1957                            pass 
1958                            self._state.following.append(self.FOLLOW_exprarg_in_expr91746)
1959                            a1 = self.exprarg()
1960
1961                            self._state.following.pop()
1962
1963                            if self._state.backtracking == 0:
1964                                pass
1965                                node.args.append(a1) 
1966
1967
1968
1969                            # src/ll/UL4.g:357:5: ( ',' a2= exprarg )*
1970                            while True: #loop18
1971                                alt18 = 2
1972                                LA18_0 = self.input.LA(1)
1973
1974                                if (LA18_0 == 34) :
1975                                    LA18_1 = self.input.LA(2)
1976
1977                                    if (LA18_1 == NAME) :
1978                                        LA18_3 = self.input.LA(3)
1979
1980                                        if ((24 <= LA18_3 <= 25) or (27 <= LA18_3 <= 29) or LA18_3 == 32 or (34 <= LA18_3 <= 35) or (37 <= LA18_3 <= 39) or (43 <= LA18_3 <= 44) or (46 <= LA18_3 <= 49) or (51 <= LA18_3 <= 52) or (54 <= LA18_3 <= 56)) :
1981                                            alt18 = 1
1982
1983
1984                                    elif ((COLOR <= LA18_1 <= DATE) or (FALSE <= LA18_1 <= FLOAT) or LA18_1 == INT or LA18_1 == NONE or LA18_1 == STRING or LA18_1 == TRUE or LA18_1 == 27 or LA18_1 == 35 or LA18_1 == 49 or LA18_1 == 55 or LA18_1 == 57) :
1985                                        alt18 = 1
1986
1987
1988
1989
1990                                if alt18 == 1:
1991                                    # src/ll/UL4.g:358:6: ',' a2= exprarg
1992                                    pass 
1993                                    self.match(self.input, 34, self.FOLLOW_34_in_expr91761)
1994
1995                                    self._state.following.append(self.FOLLOW_exprarg_in_expr91770)
1996                                    a2 = self.exprarg()
1997
1998                                    self._state.following.pop()
1999
2000                                    if self._state.backtracking == 0:
2001                                        pass
2002                                        node.args.append(a2) 
2003
2004
2005
2006
2007                                else:
2008                                    break #loop18
2009
2010
2011                            # src/ll/UL4.g:361:5: ( ',' an3= name '=' av3= exprarg )*
2012                            while True: #loop19
2013                                alt19 = 2
2014                                LA19_0 = self.input.LA(1)
2015
2016                                if (LA19_0 == 34) :
2017                                    LA19_1 = self.input.LA(2)
2018
2019                                    if (LA19_1 == NAME) :
2020                                        alt19 = 1
2021
2022
2023
2024
2025                                if alt19 == 1:
2026                                    # src/ll/UL4.g:362:6: ',' an3= name '=' av3= exprarg
2027                                    pass 
2028                                    self.match(self.input, 34, self.FOLLOW_34_in_expr91792)
2029
2030                                    self._state.following.append(self.FOLLOW_name_in_expr91801)
2031                                    an3 = self.name()
2032
2033                                    self._state.following.pop()
2034
2035                                    self.match(self.input, 45, self.FOLLOW_45_in_expr91803)
2036
2037                                    self._state.following.append(self.FOLLOW_exprarg_in_expr91807)
2038                                    av3 = self.exprarg()
2039
2040                                    self._state.following.pop()
2041
2042                                    if self._state.backtracking == 0:
2043                                        pass
2044                                        node.kwargs.append((((an3 is not None) and [self.input.toString(an3.start,an3.stop)] or [None])[0], av3)) 
2045
2046
2047
2048
2049                                else:
2050                                    break #loop19
2051
2052
2053                            # src/ll/UL4.g:365:5: ( ',' '*' rargs= exprarg )?
2054                            alt20 = 2
2055                            LA20_0 = self.input.LA(1)
2056
2057                            if (LA20_0 == 34) :
2058                                LA20_1 = self.input.LA(2)
2059
2060                                if (LA20_1 == 29) :
2061                                    alt20 = 1
2062                            if alt20 == 1:
2063                                # src/ll/UL4.g:366:6: ',' '*' rargs= exprarg
2064                                pass 
2065                                self.match(self.input, 34, self.FOLLOW_34_in_expr91829)
2066
2067                                self.match(self.input, 29, self.FOLLOW_29_in_expr91836)
2068
2069                                self._state.following.append(self.FOLLOW_exprarg_in_expr91840)
2070                                rargs = self.exprarg()
2071
2072                                self._state.following.pop()
2073
2074                                if self._state.backtracking == 0:
2075                                    pass
2076                                    node.remargs = rargs; 
2077
2078
2079
2080
2081
2082
2083                            # src/ll/UL4.g:369:5: ( ',' '**' rkwargs= exprarg )?
2084                            alt21 = 2
2085                            LA21_0 = self.input.LA(1)
2086
2087                            if (LA21_0 == 34) :
2088                                LA21_1 = self.input.LA(2)
2089
2090                                if (LA21_1 == 30) :
2091                                    alt21 = 1
2092                            if alt21 == 1:
2093                                # src/ll/UL4.g:370:6: ',' '**' rkwargs= exprarg
2094                                pass 
2095                                self.match(self.input, 34, self.FOLLOW_34_in_expr91862)
2096
2097                                self.match(self.input, 30, self.FOLLOW_30_in_expr91869)
2098
2099                                self._state.following.append(self.FOLLOW_exprarg_in_expr91873)
2100                                rkwargs = self.exprarg()
2101
2102                                self._state.following.pop()
2103
2104                                if self._state.backtracking == 0:
2105                                    pass
2106                                    node.remkwargs = rkwargs; 
2107
2108
2109
2110
2111
2112
2113                            # src/ll/UL4.g:373:5: ( ',' )?
2114                            alt22 = 2
2115                            LA22_0 = self.input.LA(1)
2116
2117                            if (LA22_0 == 34) :
2118                                alt22 = 1
2119                            if alt22 == 1:
2120                                # src/ll/UL4.g:373:5: ','
2121                                pass 
2122                                self.match(self.input, 34, self.FOLLOW_34_in_expr91888)
2123
2124
2125
2126
2127
2128                        elif alt27 == 5:
2129                            # src/ll/UL4.g:376:5: an1= name '=' av1= exprarg ( ',' an2= name '=' av2= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )?
2130                            pass 
2131                            self._state.following.append(self.FOLLOW_name_in_expr91908)
2132                            an1 = self.name()
2133
2134                            self._state.following.pop()
2135
2136                            self.match(self.input, 45, self.FOLLOW_45_in_expr91910)
2137
2138                            self._state.following.append(self.FOLLOW_exprarg_in_expr91914)
2139                            av1 = self.exprarg()
2140
2141                            self._state.following.pop()
2142
2143                            if self._state.backtracking == 0:
2144                                pass
2145                                node.kwargs.append((((an1 is not None) and [self.input.toString(an1.start,an1.stop)] or [None])[0], av1)) 
2146
2147
2148
2149                            # src/ll/UL4.g:377:5: ( ',' an2= name '=' av2= exprarg )*
2150                            while True: #loop23
2151                                alt23 = 2
2152                                LA23_0 = self.input.LA(1)
2153
2154                                if (LA23_0 == 34) :
2155                                    LA23_1 = self.input.LA(2)
2156
2157                                    if (LA23_1 == NAME) :
2158                                        alt23 = 1
2159
2160
2161
2162
2163                                if alt23 == 1:
2164                                    # src/ll/UL4.g:378:6: ',' an2= name '=' av2= exprarg
2165                                    pass 
2166                                    self.match(self.input, 34, self.FOLLOW_34_in_expr91929)
2167
2168                                    self._state.following.append(self.FOLLOW_name_in_expr91938)
2169                                    an2 = self.name()
2170
2171                                    self._state.following.pop()
2172
2173                                    self.match(self.input, 45, self.FOLLOW_45_in_expr91940)
2174
2175                                    self._state.following.append(self.FOLLOW_exprarg_in_expr91944)
2176                                    av2 = self.exprarg()
2177
2178                                    self._state.following.pop()
2179
2180                                    if self._state.backtracking == 0:
2181                                        pass
2182                                        node.kwargs.append((((an2 is not None) and [self.input.toString(an2.start,an2.stop)] or [None])[0], av2)) 
2183
2184
2185
2186
2187                                else:
2188                                    break #loop23
2189
2190
2191                            # src/ll/UL4.g:381:5: ( ',' '*' rargs= exprarg )?
2192                            alt24 = 2
2193                            LA24_0 = self.input.LA(1)
2194
2195                            if (LA24_0 == 34) :
2196                                LA24_1 = self.input.LA(2)
2197
2198                                if (LA24_1 == 29) :
2199                                    alt24 = 1
2200                            if alt24 == 1:
2201                                # src/ll/UL4.g:382:6: ',' '*' rargs= exprarg
2202                                pass 
2203                                self.match(self.input, 34, self.FOLLOW_34_in_expr91966)
2204
2205                                self.match(self.input, 29, self.FOLLOW_29_in_expr91973)
2206
2207                                self._state.following.append(self.FOLLOW_exprarg_in_expr91977)
2208                                rargs = self.exprarg()
2209
2210                                self._state.following.pop()
2211
2212                                if self._state.backtracking == 0:
2213                                    pass
2214                                    node.remargs = rargs; 
2215
2216
2217
2218
2219
2220
2221                            # src/ll/UL4.g:385:5: ( ',' '**' rkwargs= exprarg )?
2222                            alt25 = 2
2223                            LA25_0 = self.input.LA(1)
2224
2225                            if (LA25_0 == 34) :
2226                                LA25_1 = self.input.LA(2)
2227
2228                                if (LA25_1 == 30) :
2229                                    alt25 = 1
2230                            if alt25 == 1:
2231                                # src/ll/UL4.g:386:6: ',' '**' rkwargs= exprarg
2232                                pass 
2233                                self.match(self.input, 34, self.FOLLOW_34_in_expr91999)
2234
2235                                self.match(self.input, 30, self.FOLLOW_30_in_expr92006)
2236
2237                                self._state.following.append(self.FOLLOW_exprarg_in_expr92010)
2238                                rkwargs = self.exprarg()
2239
2240                                self._state.following.pop()
2241
2242                                if self._state.backtracking == 0:
2243                                    pass
2244                                    node.remkwargs = rkwargs; 
2245
2246
2247
2248
2249
2250
2251                            # src/ll/UL4.g:389:5: ( ',' )?
2252                            alt26 = 2
2253                            LA26_0 = self.input.LA(1)
2254
2255                            if (LA26_0 == 34) :
2256                                alt26 = 1
2257                            if alt26 == 1:
2258                                # src/ll/UL4.g:389:5: ','
2259                                pass 
2260                                self.match(self.input, 34, self.FOLLOW_34_in_expr92025)
2261
2262
2263
2264
2265
2266
2267
2268                        paren_close = self.match(self.input, 28, self.FOLLOW_28_in_expr92038)
2269
2270                        if self._state.backtracking == 0:
2271                            pass
2272                            node.end = self.end(paren_close) 
2273
2274
2275
2276
2277                    elif alt32 == 3:
2278                        # src/ll/UL4.g:394:4: '[' ( ':' (e2= expr1 )? |e2= expr1 ( ':' (e3= expr1 )? )? ) bracket_close= ']'
2279                        pass 
2280                        self.match(self.input, 49, self.FOLLOW_49_in_expr92054)
2281
2282                        # src/ll/UL4.g:395:4: ( ':' (e2= expr1 )? |e2= expr1 ( ':' (e3= expr1 )? )? )
2283                        alt31 = 2
2284                        LA31_0 = self.input.LA(1)
2285
2286                        if (LA31_0 == 42) :
2287                            alt31 = 1
2288                        elif ((COLOR <= LA31_0 <= DATE) or (FALSE <= LA31_0 <= FLOAT) or (INT <= LA31_0 <= NONE) or LA31_0 == STRING or LA31_0 == TRUE or LA31_0 == 27 or LA31_0 == 35 or LA31_0 == 49 or LA31_0 == 55 or LA31_0 == 57) :
2289                            alt31 = 2
2290                        else:
2291                            if self._state.backtracking > 0:
2292                                raise BacktrackingFailed
2293
2294
2295                            nvae = NoViableAltException("", 31, 0, self.input)
2296
2297                            raise nvae
2298
2299
2300                        if alt31 == 1:
2301                            # src/ll/UL4.g:396:5: ':' (e2= expr1 )?
2302                            pass 
2303                            self.match(self.input, 42, self.FOLLOW_42_in_expr92065)
2304
2305                            # src/ll/UL4.g:397:5: (e2= expr1 )?
2306                            alt28 = 2
2307                            LA28_0 = self.input.LA(1)
2308
2309                            if ((COLOR <= LA28_0 <= DATE) or (FALSE <= LA28_0 <= FLOAT) or (INT <= LA28_0 <= NONE) or LA28_0 == STRING or LA28_0 == TRUE or LA28_0 == 27 or LA28_0 == 35 or LA28_0 == 49 or LA28_0 == 55 or LA28_0 == 57) :
2310                                alt28 = 1
2311                            if alt28 == 1:
2312                                # src/ll/UL4.g:398:6: e2= expr1
2313                                pass 
2314                                self._state.following.append(self.FOLLOW_expr1_in_expr92080)
2315                                e2 = self.expr1()
2316
2317                                self._state.following.pop()
2318
2319                                if self._state.backtracking == 0:
2320                                    pass
2321                                    index2 = e2; 
2322
2323
2324
2325
2326
2327
2328                            if self._state.backtracking == 0:
2329                                pass
2330                                node = ul4c.GetSlice(self.location, node.start, None, node, None, index2) 
2331
2332
2333
2334
2335                        elif alt31 == 2:
2336                            # src/ll/UL4.g:401:5: e2= expr1 ( ':' (e3= expr1 )? )?
2337                            pass 
2338                            self._state.following.append(self.FOLLOW_expr1_in_expr92104)
2339                            e2 = self.expr1()
2340
2341                            self._state.following.pop()
2342
2343                            if self._state.backtracking == 0:
2344                                pass
2345                                index1 = e2; 
2346
2347
2348
2349                            # src/ll/UL4.g:402:5: ( ':' (e3= expr1 )? )?
2350                            alt30 = 2
2351                            LA30_0 = self.input.LA(1)
2352
2353                            if (LA30_0 == 42) :
2354                                alt30 = 1
2355                            if alt30 == 1:
2356                                # src/ll/UL4.g:403:6: ':' (e3= expr1 )?
2357                                pass 
2358                                self.match(self.input, 42, self.FOLLOW_42_in_expr92119)
2359
2360                                if self._state.backtracking == 0:
2361                                    pass
2362                                    slice = True; 
2363
2364
2365
2366                                # src/ll/UL4.g:404:6: (e3= expr1 )?
2367                                alt29 = 2
2368                                LA29_0 = self.input.LA(1)
2369
2370                                if ((COLOR <= LA29_0 <= DATE) or (FALSE <= LA29_0 <= FLOAT) or (INT <= LA29_0 <= NONE) or LA29_0 == STRING or LA29_0 == TRUE or LA29_0 == 27 or LA29_0 == 35 or LA29_0 == 49 or LA29_0 == 55 or LA29_0 == 57) :
2371                                    alt29 = 1
2372                                if alt29 == 1:
2373                                    # src/ll/UL4.g:405:7: e3= expr1
2374                                    pass 
2375                                    self._state.following.append(self.FOLLOW_expr1_in_expr92138)
2376                                    e3 = self.expr1()
2377
2378                                    self._state.following.pop()
2379
2380                                    if self._state.backtracking == 0:
2381                                        pass
2382                                        index2 = e3; 
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392                            if self._state.backtracking == 0:
2393                                pass
2394                                node = ul4c.GetSlice(self.location, node.start, None, node, index1, index2) if slice else ul4c.GetItem(self.location, e1.start, None, node, index1) 
2395
2396
2397
2398
2399
2400
2401                        bracket_close = self.match(self.input, 50, self.FOLLOW_50_in_expr92169)
2402
2403                        if self._state.backtracking == 0:
2404                            pass
2405                            node.end = self.end(bracket_close) 
2406
2407
2408
2409
2410                    else:
2411                        break #loop32
2412
2413
2414
2415
2416
2417                       
2418            except RecognitionException as e:
2419                raise
2420
2421        finally:
2422            pass
2423        return node
2424
2425    # $ANTLR end "expr9"
2426
2427
2428
2429    # $ANTLR start "expr8"
2430    # src/ll/UL4.g:414:1: expr8 returns [node] : (e1= expr9 |minus= '-' e2= expr8 );
2431    def expr8(self, ):
2432        node = None
2433
2434
2435        minus = None
2436        e1 = None
2437
2438        e2 = None
2439
2440
2441        try:
2442            try:
2443                # src/ll/UL4.g:415:2: (e1= expr9 |minus= '-' e2= expr8 )
2444                alt33 = 2
2445                LA33_0 = self.input.LA(1)
2446
2447                if ((COLOR <= LA33_0 <= DATE) or (FALSE <= LA33_0 <= FLOAT) or (INT <= LA33_0 <= NONE) or LA33_0 == STRING or LA33_0 == TRUE or LA33_0 == 27 or LA33_0 == 49 or LA33_0 == 57) :
2448                    alt33 = 1
2449                elif (LA33_0 == 35) :
2450                    alt33 = 2
2451                else:
2452                    if self._state.backtracking > 0:
2453                        raise BacktrackingFailed
2454
2455
2456                    nvae = NoViableAltException("", 33, 0, self.input)
2457
2458                    raise nvae
2459
2460
2461                if alt33 == 1:
2462                    # src/ll/UL4.g:416:3: e1= expr9
2463                    pass 
2464                    self._state.following.append(self.FOLLOW_expr9_in_expr82197)
2465                    e1 = self.expr9()
2466
2467                    self._state.following.pop()
2468
2469                    if self._state.backtracking == 0:
2470                        pass
2471                        node =  e1
2472
2473
2474
2475
2476                elif alt33 == 2:
2477                    # src/ll/UL4.g:418:3: minus= '-' e2= expr8
2478                    pass 
2479                    minus = self.match(self.input, 35, self.FOLLOW_35_in_expr82208)
2480
2481                    self._state.following.append(self.FOLLOW_expr8_in_expr82212)
2482                    e2 = self.expr8()
2483
2484                    self._state.following.pop()
2485
2486                    if self._state.backtracking == 0:
2487                        pass
2488                        node = ul4c.Neg.make(self.location, self.start(minus), e2.end, e2) 
2489
2490
2491
2492
2493
2494                       
2495            except RecognitionException as e:
2496                raise
2497
2498        finally:
2499            pass
2500        return node
2501
2502    # $ANTLR end "expr8"
2503
2504
2505
2506    # $ANTLR start "expr7"
2507    # src/ll/UL4.g:422:1: expr7 returns [node] : e1= expr8 ( ( '*' | '/' | '//' | '%' ) e2= expr8 )* ;
2508    def expr7(self, ):
2509        node = None
2510
2511
2512        e1 = None
2513
2514        e2 = None
2515
2516
2517        try:
2518            try:
2519                # src/ll/UL4.g:423:2: (e1= expr8 ( ( '*' | '/' | '//' | '%' ) e2= expr8 )* )
2520                # src/ll/UL4.g:424:3: e1= expr8 ( ( '*' | '/' | '//' | '%' ) e2= expr8 )*
2521                pass 
2522                self._state.following.append(self.FOLLOW_expr8_in_expr72235)
2523                e1 = self.expr8()
2524
2525                self._state.following.pop()
2526
2527                if self._state.backtracking == 0:
2528                    pass
2529                    node =  e1
2530
2531
2532
2533                # src/ll/UL4.g:425:3: ( ( '*' | '/' | '//' | '%' ) e2= expr8 )*
2534                while True: #loop35
2535                    alt35 = 2
2536                    LA35_0 = self.input.LA(1)
2537
2538                    if (LA35_0 == 25 or LA35_0 == 29 or (38 <= LA35_0 <= 39)) :
2539                        alt35 = 1
2540
2541
2542                    if alt35 == 1:
2543                        # src/ll/UL4.g:426:4: ( '*' | '/' | '//' | '%' ) e2= expr8
2544                        pass 
2545                        # src/ll/UL4.g:426:4: ( '*' | '/' | '//' | '%' )
2546                        alt34 = 4
2547                        LA34 = self.input.LA(1)
2548                        if LA34 == 29:
2549                            alt34 = 1
2550                        elif LA34 == 38:
2551                            alt34 = 2
2552                        elif LA34 == 39:
2553                            alt34 = 3
2554                        elif LA34 == 25:
2555                            alt34 = 4
2556                        else:
2557                            if self._state.backtracking > 0:
2558                                raise BacktrackingFailed
2559
2560
2561                            nvae = NoViableAltException("", 34, 0, self.input)
2562
2563                            raise nvae
2564
2565
2566                        if alt34 == 1:
2567                            # src/ll/UL4.g:427:5: '*'
2568                            pass 
2569                            self.match(self.input, 29, self.FOLLOW_29_in_expr72252)
2570
2571                            if self._state.backtracking == 0:
2572                                pass
2573                                cls = ul4c.Mul; 
2574
2575
2576
2577
2578                        elif alt34 == 2:
2579                            # src/ll/UL4.g:429:5: '/'
2580                            pass 
2581                            self.match(self.input, 38, self.FOLLOW_38_in_expr72265)
2582
2583                            if self._state.backtracking == 0:
2584                                pass
2585                                cls = ul4c.TrueDiv; 
2586
2587
2588
2589
2590                        elif alt34 == 3:
2591                            # src/ll/UL4.g:431:5: '//'
2592                            pass 
2593                            self.match(self.input, 39, self.FOLLOW_39_in_expr72278)
2594
2595                            if self._state.backtracking == 0:
2596                                pass
2597                                cls = ul4c.FloorDiv; 
2598
2599
2600
2601
2602                        elif alt34 == 4:
2603                            # src/ll/UL4.g:433:5: '%'
2604                            pass 
2605                            self.match(self.input, 25, self.FOLLOW_25_in_expr72291)
2606
2607                            if self._state.backtracking == 0:
2608                                pass
2609                                cls = ul4c.Mod; 
2610
2611
2612
2613
2614
2615
2616                        self._state.following.append(self.FOLLOW_expr8_in_expr72305)
2617                        e2 = self.expr8()
2618
2619                        self._state.following.pop()
2620
2621                        if self._state.backtracking == 0:
2622                            pass
2623                            node = cls.make(self.location, node.start, e2.end, node, e2) 
2624
2625
2626
2627
2628                    else:
2629                        break #loop35
2630
2631
2632
2633
2634
2635                       
2636            except RecognitionException as e:
2637                raise
2638
2639        finally:
2640            pass
2641        return node
2642
2643    # $ANTLR end "expr7"
2644
2645
2646
2647    # $ANTLR start "expr6"
2648    # src/ll/UL4.g:440:1: expr6 returns [node] : e1= expr7 ( ( '+' | '-' ) e2= expr7 )* ;
2649    def expr6(self, ):
2650        node = None
2651
2652
2653        e1 = None
2654
2655        e2 = None
2656
2657
2658        try:
2659            try:
2660                # src/ll/UL4.g:441:2: (e1= expr7 ( ( '+' | '-' ) e2= expr7 )* )
2661                # src/ll/UL4.g:442:3: e1= expr7 ( ( '+' | '-' ) e2= expr7 )*
2662                pass 
2663                self._state.following.append(self.FOLLOW_expr7_in_expr62333)
2664                e1 = self.expr7()
2665
2666                self._state.following.pop()
2667
2668                if self._state.backtracking == 0:
2669                    pass
2670                    node =  e1
2671
2672
2673
2674                # src/ll/UL4.g:443:3: ( ( '+' | '-' ) e2= expr7 )*
2675                while True: #loop37
2676                    alt37 = 2
2677                    LA37_0 = self.input.LA(1)
2678
2679                    if (LA37_0 == 32 or LA37_0 == 35) :
2680                        alt37 = 1
2681
2682
2683                    if alt37 == 1:
2684                        # src/ll/UL4.g:444:4: ( '+' | '-' ) e2= expr7
2685                        pass 
2686                        # src/ll/UL4.g:444:4: ( '+' | '-' )
2687                        alt36 = 2
2688                        LA36_0 = self.input.LA(1)
2689
2690                        if (LA36_0 == 32) :
2691                            alt36 = 1
2692                        elif (LA36_0 == 35) :
2693                            alt36 = 2
2694                        else:
2695                            if self._state.backtracking > 0:
2696                                raise BacktrackingFailed
2697
2698
2699                            nvae = NoViableAltException("", 36, 0, self.input)
2700
2701                            raise nvae
2702
2703
2704                        if alt36 == 1:
2705                            # src/ll/UL4.g:445:5: '+'
2706                            pass 
2707                            self.match(self.input, 32, self.FOLLOW_32_in_expr62350)
2708
2709                            if self._state.backtracking == 0:
2710                                pass
2711                                cls = ul4c.Add; 
2712
2713
2714
2715
2716                        elif alt36 == 2:
2717                            # src/ll/UL4.g:447:5: '-'
2718                            pass 
2719                            self.match(self.input, 35, self.FOLLOW_35_in_expr62363)
2720
2721                            if self._state.backtracking == 0:
2722                                pass
2723                                cls = ul4c.Sub; 
2724
2725
2726
2727
2728
2729
2730                        self._state.following.append(self.FOLLOW_expr7_in_expr62377)
2731                        e2 = self.expr7()
2732
2733                        self._state.following.pop()
2734
2735                        if self._state.backtracking == 0:
2736                            pass
2737                            node = cls.make(self.location, node.start, e2.end, node, e2) 
2738
2739
2740
2741
2742                    else:
2743                        break #loop37
2744
2745
2746
2747
2748
2749                       
2750            except RecognitionException as e:
2751                raise
2752
2753        finally:
2754            pass
2755        return node
2756
2757    # $ANTLR end "expr6"
2758
2759
2760
2761    # $ANTLR start "expr5"
2762    # src/ll/UL4.g:454:1: expr5 returns [node] : e1= expr6 ( ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6 )* ;
2763    def expr5(self, ):
2764        node = None
2765
2766
2767        e1 = None
2768
2769        e2 = None
2770
2771
2772        try:
2773            try:
2774                # src/ll/UL4.g:455:2: (e1= expr6 ( ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6 )* )
2775                # src/ll/UL4.g:456:3: e1= expr6 ( ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6 )*
2776                pass 
2777                self._state.following.append(self.FOLLOW_expr6_in_expr52405)
2778                e1 = self.expr6()
2779
2780                self._state.following.pop()
2781
2782                if self._state.backtracking == 0:
2783                    pass
2784                    node =  e1
2785
2786
2787
2788                # src/ll/UL4.g:457:3: ( ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6 )*
2789                while True: #loop39
2790                    alt39 = 2
2791                    LA39_0 = self.input.LA(1)
2792
2793                    if (LA39_0 == 24 or (43 <= LA39_0 <= 44) or (46 <= LA39_0 <= 48)) :
2794                        alt39 = 1
2795
2796
2797                    if alt39 == 1:
2798                        # src/ll/UL4.g:458:4: ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6
2799                        pass 
2800                        # src/ll/UL4.g:458:4: ( '==' | '!=' | '<' | '<=' | '>' | '>=' )
2801                        alt38 = 6
2802                        LA38 = self.input.LA(1)
2803                        if LA38 == 46:
2804                            alt38 = 1
2805                        elif LA38 == 24:
2806                            alt38 = 2
2807                        elif LA38 == 43:
2808                            alt38 = 3
2809                        elif LA38 == 44:
2810                            alt38 = 4
2811                        elif LA38 == 47:
2812                            alt38 = 5
2813                        elif LA38 == 48:
2814                            alt38 = 6
2815                        else:
2816                            if self._state.backtracking > 0:
2817                                raise BacktrackingFailed
2818
2819
2820                            nvae = NoViableAltException("", 38, 0, self.input)
2821
2822                            raise nvae
2823
2824
2825                        if alt38 == 1:
2826                            # src/ll/UL4.g:459:5: '=='
2827                            pass 
2828                            self.match(self.input, 46, self.FOLLOW_46_in_expr52422)
2829
2830                            if self._state.backtracking == 0:
2831                                pass
2832                                cls = ul4c.EQ; 
2833
2834
2835
2836
2837                        elif alt38 == 2:
2838                            # src/ll/UL4.g:461:5: '!='
2839                            pass 
2840                            self.match(self.input, 24, self.FOLLOW_24_in_expr52435)
2841
2842                            if self._state.backtracking == 0:
2843                                pass
2844                                cls = ul4c.NE; 
2845
2846
2847
2848
2849                        elif alt38 == 3:
2850                            # src/ll/UL4.g:463:5: '<'
2851                            pass 
2852                            self.match(self.input, 43, self.FOLLOW_43_in_expr52448)
2853
2854                            if self._state.backtracking == 0:
2855                                pass
2856                                cls = ul4c.LT; 
2857
2858
2859
2860
2861                        elif alt38 == 4:
2862                            # src/ll/UL4.g:465:5: '<='
2863                            pass 
2864                            self.match(self.input, 44, self.FOLLOW_44_in_expr52461)
2865
2866                            if self._state.backtracking == 0:
2867                                pass
2868                                cls = ul4c.LE; 
2869
2870
2871
2872
2873                        elif alt38 == 5:
2874                            # src/ll/UL4.g:467:5: '>'
2875                            pass 
2876                            self.match(self.input, 47, self.FOLLOW_47_in_expr52474)
2877
2878                            if self._state.backtracking == 0:
2879                                pass
2880                                cls = ul4c.GT; 
2881
2882
2883
2884
2885                        elif alt38 == 6:
2886                            # src/ll/UL4.g:469:5: '>='
2887                            pass 
2888                            self.match(self.input, 48, self.FOLLOW_48_in_expr52487)
2889
2890                            if self._state.backtracking == 0:
2891                                pass
2892                                cls = ul4c.GE; 
2893
2894
2895
2896
2897
2898
2899                        self._state.following.append(self.FOLLOW_expr6_in_expr52501)
2900                        e2 = self.expr6()
2901
2902                        self._state.following.pop()
2903
2904                        if self._state.backtracking == 0:
2905                            pass
2906                            node = cls.make(self.location, node.start, e2.end, node, e2) 
2907
2908
2909
2910
2911                    else:
2912                        break #loop39
2913
2914
2915
2916
2917
2918                       
2919            except RecognitionException as e:
2920                raise
2921
2922        finally:
2923            pass
2924        return node
2925
2926    # $ANTLR end "expr5"
2927
2928
2929
2930    # $ANTLR start "expr4"
2931    # src/ll/UL4.g:476:1: expr4 returns [node] : e1= expr5 ( ( 'not' )? 'in' e2= expr5 )? ;
2932    def expr4(self, ):
2933        node = None
2934
2935
2936        e1 = None
2937
2938        e2 = None
2939
2940
2941        try:
2942            try:
2943                # src/ll/UL4.g:477:2: (e1= expr5 ( ( 'not' )? 'in' e2= expr5 )? )
2944                # src/ll/UL4.g:478:3: e1= expr5 ( ( 'not' )? 'in' e2= expr5 )?
2945                pass 
2946                self._state.following.append(self.FOLLOW_expr5_in_expr42529)
2947                e1 = self.expr5()
2948
2949                self._state.following.pop()
2950
2951                if self._state.backtracking == 0:
2952                    pass
2953                    node = e1
2954
2955
2956
2957                # src/ll/UL4.g:479:3: ( ( 'not' )? 'in' e2= expr5 )?
2958                alt41 = 2
2959                LA41_0 = self.input.LA(1)
2960
2961                if ((54 <= LA41_0 <= 55)) :
2962                    alt41 = 1
2963                if alt41 == 1:
2964                    # src/ll/UL4.g:480:4: ( 'not' )? 'in' e2= expr5
2965                    pass 
2966                    if self._state.backtracking == 0:
2967                        pass
2968                        cls = ul4c.Contains
2969
2970
2971
2972                    # src/ll/UL4.g:481:4: ( 'not' )?
2973                    alt40 = 2
2974                    LA40_0 = self.input.LA(1)
2975
2976                    if (LA40_0 == 55) :
2977                        alt40 = 1
2978                    if alt40 == 1:
2979                        # src/ll/UL4.g:482:5: 'not'
2980                        pass 
2981                        self.match(self.input, 55, self.FOLLOW_55_in_expr42551)
2982
2983                        if self._state.backtracking == 0:
2984                            pass
2985                            cls = ul4c.NotContains
2986
2987
2988
2989
2990
2991
2992                    self.match(self.input, 54, self.FOLLOW_54_in_expr42564)
2993
2994                    self._state.following.append(self.FOLLOW_expr5_in_expr42571)
2995                    e2 = self.expr5()
2996
2997                    self._state.following.pop()
2998
2999                    if self._state.backtracking == 0:
3000                        pass
3001                        node = cls.make(self.location, node.start, e2.end, node, e2) 
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011                       
3012            except RecognitionException as e:
3013                raise
3014
3015        finally:
3016            pass
3017        return node
3018
3019    # $ANTLR end "expr4"
3020
3021
3022
3023    # $ANTLR start "expr3"
3024    # src/ll/UL4.g:490:1: expr3 returns [node] : (e1= expr4 |n= 'not' e2= expr3 );
3025    def expr3(self, ):
3026        node = None
3027
3028
3029        n = None
3030        e1 = None
3031
3032        e2 = None
3033
3034
3035        try:
3036            try:
3037                # src/ll/UL4.g:491:2: (e1= expr4 |n= 'not' e2= expr3 )
3038                alt42 = 2
3039                LA42_0 = self.input.LA(1)
3040
3041                if ((COLOR <= LA42_0 <= DATE) or (FALSE <= LA42_0 <= FLOAT) or (INT <= LA42_0 <= NONE) or LA42_0 == STRING or LA42_0 == TRUE or LA42_0 == 27 or LA42_0 == 35 or LA42_0 == 49 or LA42_0 == 57) :
3042                    alt42 = 1
3043                elif (LA42_0 == 55) :
3044                    alt42 = 2
3045                else:
3046                    if self._state.backtracking > 0:
3047                        raise BacktrackingFailed
3048
3049
3050                    nvae = NoViableAltException("", 42, 0, self.input)
3051
3052                    raise nvae
3053
3054
3055                if alt42 == 1:
3056                    # src/ll/UL4.g:492:3: e1= expr4
3057                    pass 
3058                    self._state.following.append(self.FOLLOW_expr4_in_expr32599)
3059                    e1 = self.expr4()
3060
3061                    self._state.following.pop()
3062
3063                    if self._state.backtracking == 0:
3064                        pass
3065                        node =  e1
3066
3067
3068
3069
3070                elif alt42 == 2:
3071                    # src/ll/UL4.g:494:3: n= 'not' e2= expr3
3072                    pass 
3073                    n = self.match(self.input, 55, self.FOLLOW_55_in_expr32610)
3074
3075                    self._state.following.append(self.FOLLOW_expr3_in_expr32614)
3076                    e2 = self.expr3()
3077
3078                    self._state.following.pop()
3079
3080                    if self._state.backtracking == 0:
3081                        pass
3082                        node = ul4c.Not.make(self.location, self.start(n), e2.end, e2) 
3083
3084
3085
3086
3087
3088                       
3089            except RecognitionException as e:
3090                raise
3091
3092        finally:
3093            pass
3094        return node
3095
3096    # $ANTLR end "expr3"
3097
3098
3099
3100    # $ANTLR start "expr2"
3101    # src/ll/UL4.g:499:1: expr2 returns [node] : e1= expr3 ( 'and' e2= expr3 )* ;
3102    def expr2(self, ):
3103        node = None
3104
3105
3106        e1 = None
3107
3108        e2 = None
3109
3110
3111        try:
3112            try:
3113                # src/ll/UL4.g:500:2: (e1= expr3 ( 'and' e2= expr3 )* )
3114                # src/ll/UL4.g:501:3: e1= expr3 ( 'and' e2= expr3 )*
3115                pass 
3116                self._state.following.append(self.FOLLOW_expr3_in_expr22638)
3117                e1 = self.expr3()
3118
3119                self._state.following.pop()
3120
3121                if self._state.backtracking == 0:
3122                    pass
3123                    node =  e1
3124
3125
3126
3127                # src/ll/UL4.g:502:3: ( 'and' e2= expr3 )*
3128                while True: #loop43
3129                    alt43 = 2
3130                    LA43_0 = self.input.LA(1)
3131
3132                    if (LA43_0 == 51) :
3133                        alt43 = 1
3134
3135
3136                    if alt43 == 1:
3137                        # src/ll/UL4.g:503:4: 'and' e2= expr3
3138                        pass 
3139                        self.match(self.input, 51, self.FOLLOW_51_in_expr22649)
3140
3141                        self._state.following.append(self.FOLLOW_expr3_in_expr22656)
3142                        e2 = self.expr3()
3143
3144                        self._state.following.pop()
3145
3146                        if self._state.backtracking == 0:
3147                            pass
3148                            node = ul4c.And(self.location, node.start, e2.end, node, e2) 
3149
3150
3151
3152
3153                    else:
3154                        break #loop43
3155
3156
3157
3158
3159
3160                       
3161            except RecognitionException as e:
3162                raise
3163
3164        finally:
3165            pass
3166        return node
3167
3168    # $ANTLR end "expr2"
3169
3170
3171
3172    # $ANTLR start "expr1"
3173    # src/ll/UL4.g:509:1: expr1 returns [node] : e1= expr2 ( 'or' e2= expr2 )* ;
3174    def expr1(self, ):
3175        node = None
3176
3177
3178        e1 = None
3179
3180        e2 = None
3181
3182
3183        try:
3184            try:
3185                # src/ll/UL4.g:510:2: (e1= expr2 ( 'or' e2= expr2 )* )
3186                # src/ll/UL4.g:511:3: e1= expr2 ( 'or' e2= expr2 )*
3187                pass 
3188                self._state.following.append(self.FOLLOW_expr2_in_expr12684)
3189                e1 = self.expr2()
3190
3191                self._state.following.pop()
3192
3193                if self._state.backtracking == 0:
3194                    pass
3195                    node =  e1
3196
3197
3198
3199                # src/ll/UL4.g:512:3: ( 'or' e2= expr2 )*
3200                while True: #loop44
3201                    alt44 = 2
3202                    LA44_0 = self.input.LA(1)
3203
3204                    if (LA44_0 == 56) :
3205                        alt44 = 1
3206
3207
3208                    if alt44 == 1:
3209                        # src/ll/UL4.g:513:4: 'or' e2= expr2
3210                        pass 
3211                        self.match(self.input, 56, self.FOLLOW_56_in_expr12695)
3212
3213                        self._state.following.append(self.FOLLOW_expr2_in_expr12702)
3214                        e2 = self.expr2()
3215
3216                        self._state.following.pop()
3217
3218                        if self._state.backtracking == 0:
3219                            pass
3220                            node = ul4c.Or(self.location, node.start, e2.end, node, e2) 
3221
3222
3223
3224
3225                    else:
3226                        break #loop44
3227
3228
3229
3230
3231
3232                       
3233            except RecognitionException as e:
3234                raise
3235
3236        finally:
3237            pass
3238        return node
3239
3240    # $ANTLR end "expr1"
3241
3242
3243
3244    # $ANTLR start "exprarg"
3245    # src/ll/UL4.g:518:1: exprarg returns [node] : (ege= generatorexpression |e1= expr1 );
3246    def exprarg(self, ):
3247        node = None
3248
3249
3250        ege = None
3251
3252        e1 = None
3253
3254
3255        try:
3256            try:
3257                # src/ll/UL4.g:519:2: (ege= generatorexpression |e1= expr1 )
3258                alt45 = 2
3259                LA45 = self.input.LA(1)
3260                if LA45 == NONE:
3261                    LA45_1 = self.input.LA(2)
3262
3263                    if (self.synpred69_UL4()) :
3264                        alt45 = 1
3265                    elif (True) :
3266                        alt45 = 2
3267                    else:
3268                        if self._state.backtracking > 0:
3269                            raise BacktrackingFailed
3270
3271
3272                        nvae = NoViableAltException("", 45, 1, self.input)
3273
3274                        raise nvae
3275
3276
3277                elif LA45 == FALSE:
3278                    LA45_2 = self.input.LA(2)
3279
3280                    if (self.synpred69_UL4()) :
3281                        alt45 = 1
3282                    elif (True) :
3283                        alt45 = 2
3284                    else:
3285                        if self._state.backtracking > 0:
3286                            raise BacktrackingFailed
3287
3288
3289                        nvae = NoViableAltException("", 45, 2, self.input)
3290
3291                        raise nvae
3292
3293
3294                elif LA45 == TRUE:
3295                    LA45_3 = self.input.LA(2)
3296
3297                    if (self.synpred69_UL4()) :
3298                        alt45 = 1
3299                    elif (True) :
3300                        alt45 = 2
3301                    else:
3302                        if self._state.backtracking > 0:
3303                            raise BacktrackingFailed
3304
3305
3306                        nvae = NoViableAltException("", 45, 3, self.input)
3307
3308                        raise nvae
3309
3310
3311                elif LA45 == INT:
3312                    LA45_4 = self.input.LA(2)
3313
3314                    if (self.synpred69_UL4()) :
3315                        alt45 = 1
3316                    elif (True) :
3317                        alt45 = 2
3318                    else:
3319                        if self._state.backtracking > 0:
3320                            raise BacktrackingFailed
3321
3322
3323                        nvae = NoViableAltException("", 45, 4, self.input)
3324
3325                        raise nvae
3326
3327
3328                elif LA45 == FLOAT:
3329                    LA45_5 = self.input.LA(2)
3330
3331                    if (self.synpred69_UL4()) :
3332                        alt45 = 1
3333                    elif (True) :
3334                        alt45 = 2
3335                    else:
3336                        if self._state.backtracking > 0:
3337                            raise BacktrackingFailed
3338
3339
3340                        nvae = NoViableAltException("", 45, 5, self.input)
3341
3342                        raise nvae
3343
3344
3345                elif LA45 == STRING:
3346                    LA45_6 = self.input.LA(2)
3347
3348                    if (self.synpred69_UL4()) :
3349                        alt45 = 1
3350                    elif (True) :
3351                        alt45 = 2
3352                    else:
3353                        if self._state.backtracking > 0:
3354                            raise BacktrackingFailed
3355
3356
3357                        nvae = NoViableAltException("", 45, 6, self.input)
3358
3359                        raise nvae
3360
3361
3362                elif LA45 == DATE:
3363                    LA45_7 = self.input.LA(2)
3364
3365                    if (self.synpred69_UL4()) :
3366                        alt45 = 1
3367                    elif (True) :
3368                        alt45 = 2
3369                    else:
3370                        if self._state.backtracking > 0:
3371                            raise BacktrackingFailed
3372
3373
3374                        nvae = NoViableAltException("", 45, 7, self.input)
3375
3376                        raise nvae
3377
3378
3379                elif LA45 == COLOR:
3380                    LA45_8 = self.input.LA(2)
3381
3382                    if (self.synpred69_UL4()) :
3383                        alt45 = 1
3384                    elif (True) :
3385                        alt45 = 2
3386                    else:
3387                        if self._state.backtracking > 0:
3388                            raise BacktrackingFailed
3389
3390
3391                        nvae = NoViableAltException("", 45, 8, self.input)
3392
3393                        raise nvae
3394
3395
3396                elif LA45 == NAME:
3397                    LA45_9 = self.input.LA(2)
3398
3399                    if (self.synpred69_UL4()) :
3400                        alt45 = 1
3401                    elif (True) :
3402                        alt45 = 2
3403                    else:
3404                        if self._state.backtracking > 0:
3405                            raise BacktrackingFailed
3406
3407
3408                        nvae = NoViableAltException("", 45, 9, self.input)
3409
3410                        raise nvae
3411
3412
3413                elif LA45 == 49:
3414                    LA45_10 = self.input.LA(2)
3415
3416                    if (self.synpred69_UL4()) :
3417                        alt45 = 1
3418                    elif (True) :
3419                        alt45 = 2
3420                    else:
3421                        if self._state.backtracking > 0:
3422                            raise BacktrackingFailed
3423
3424
3425                        nvae = NoViableAltException("", 45, 10, self.input)
3426
3427                        raise nvae
3428
3429
3430                elif LA45 == 57:
3431                    LA45_11 = self.input.LA(2)
3432
3433                    if (self.synpred69_UL4()) :
3434                        alt45 = 1
3435                    elif (True) :
3436                        alt45 = 2
3437                    else:
3438                        if self._state.backtracking > 0:
3439                            raise BacktrackingFailed
3440
3441
3442                        nvae = NoViableAltException("", 45, 11, self.input)
3443
3444                        raise nvae
3445
3446
3447                elif LA45 == 27:
3448                    LA45_12 = self.input.LA(2)
3449
3450                    if (self.synpred69_UL4()) :
3451                        alt45 = 1
3452                    elif (True) :
3453                        alt45 = 2
3454                    else:
3455                        if self._state.backtracking > 0:
3456                            raise BacktrackingFailed
3457
3458
3459                        nvae = NoViableAltException("", 45, 12, self.input)
3460
3461                        raise nvae
3462
3463
3464                elif LA45 == 35:
3465                    LA45_13 = self.input.LA(2)
3466
3467                    if (self.synpred69_UL4()) :
3468                        alt45 = 1
3469                    elif (True) :
3470                        alt45 = 2
3471                    else:
3472                        if self._state.backtracking > 0:
3473                            raise BacktrackingFailed
3474
3475
3476                        nvae = NoViableAltException("", 45, 13, self.input)
3477
3478                        raise nvae
3479
3480
3481                elif LA45 == 55:
3482                    LA45_14 = self.input.LA(2)
3483
3484                    if (self.synpred69_UL4()) :
3485                        alt45 = 1
3486                    elif (True) :
3487                        alt45 = 2
3488                    else:
3489                        if self._state.backtracking > 0:
3490                            raise BacktrackingFailed
3491
3492
3493                        nvae = NoViableAltException("", 45, 14, self.input)
3494
3495                        raise nvae
3496
3497
3498                else:
3499                    if self._state.backtracking > 0:
3500                        raise BacktrackingFailed
3501
3502
3503                    nvae = NoViableAltException("", 45, 0, self.input)
3504
3505                    raise nvae
3506
3507
3508                if alt45 == 1:
3509                    # src/ll/UL4.g:519:4: ege= generatorexpression
3510                    pass 
3511                    self._state.following.append(self.FOLLOW_generatorexpression_in_exprarg2726)
3512                    ege = self.generatorexpression()
3513
3514                    self._state.following.pop()
3515
3516                    if self._state.backtracking == 0:
3517                        pass
3518                        node =  ege
3519
3520
3521
3522
3523                elif alt45 == 2:
3524                    # src/ll/UL4.g:520:4: e1= expr1
3525                    pass 
3526                    self._state.following.append(self.FOLLOW_expr1_in_exprarg2735)
3527                    e1 = self.expr1()
3528
3529                    self._state.following.pop()
3530
3531                    if self._state.backtracking == 0:
3532                        pass
3533                        node =  e1
3534
3535
3536
3537
3538
3539                       
3540            except RecognitionException as e:
3541                raise
3542
3543        finally:
3544            pass
3545        return node
3546
3547    # $ANTLR end "exprarg"
3548
3549
3550
3551    # $ANTLR start "expression"
3552    # src/ll/UL4.g:523:1: expression returns [node] : (ege= generatorexpression EOF |e= expr1 EOF );
3553    def expression(self, ):
3554        node = None
3555
3556
3557        ege = None
3558
3559        e = None
3560
3561
3562        try:
3563            try:
3564                # src/ll/UL4.g:524:2: (ege= generatorexpression EOF |e= expr1 EOF )
3565                alt46 = 2
3566                LA46 = self.input.LA(1)
3567                if LA46 == NONE:
3568                    LA46_1 = self.input.LA(2)
3569
3570                    if (self.synpred70_UL4()) :
3571                        alt46 = 1
3572                    elif (True) :
3573                        alt46 = 2
3574                    else:
3575                        if self._state.backtracking > 0:
3576                            raise BacktrackingFailed
3577
3578
3579                        nvae = NoViableAltException("", 46, 1, self.input)
3580
3581                        raise nvae
3582
3583
3584                elif LA46 == FALSE:
3585                    LA46_2 = self.input.LA(2)
3586
3587                    if (self.synpred70_UL4()) :
3588                        alt46 = 1
3589                    elif (True) :
3590                        alt46 = 2
3591                    else:
3592                        if self._state.backtracking > 0:
3593                            raise BacktrackingFailed
3594
3595
3596                        nvae = NoViableAltException("", 46, 2, self.input)
3597
3598                        raise nvae
3599
3600
3601                elif LA46 == TRUE:
3602                    LA46_3 = self.input.LA(2)
3603
3604                    if (self.synpred70_UL4()) :
3605                        alt46 = 1
3606                    elif (True) :
3607                        alt46 = 2
3608                    else:
3609                        if self._state.backtracking > 0:
3610                            raise BacktrackingFailed
3611
3612
3613                        nvae = NoViableAltException("", 46, 3, self.input)
3614
3615                        raise nvae
3616
3617
3618                elif LA46 == INT:
3619                    LA46_4 = self.input.LA(2)
3620
3621                    if (self.synpred70_UL4()) :
3622                        alt46 = 1
3623                    elif (True) :
3624                        alt46 = 2
3625                    else:
3626                        if self._state.backtracking > 0:
3627                            raise BacktrackingFailed
3628
3629
3630                        nvae = NoViableAltException("", 46, 4, self.input)
3631
3632                        raise nvae
3633
3634
3635                elif LA46 == FLOAT:
3636                    LA46_5 = self.input.LA(2)
3637
3638                    if (self.synpred70_UL4()) :
3639                        alt46 = 1
3640                    elif (True) :
3641                        alt46 = 2
3642                    else:
3643                        if self._state.backtracking > 0:
3644                            raise BacktrackingFailed
3645
3646
3647                        nvae = NoViableAltException("", 46, 5, self.input)
3648
3649                        raise nvae
3650
3651
3652                elif LA46 == STRING:
3653                    LA46_6 = self.input.LA(2)
3654
3655                    if (self.synpred70_UL4()) :
3656                        alt46 = 1
3657                    elif (True) :
3658                        alt46 = 2
3659                    else:
3660                        if self._state.backtracking > 0:
3661                            raise BacktrackingFailed
3662
3663
3664                        nvae = NoViableAltException("", 46, 6, self.input)
3665
3666                        raise nvae
3667
3668
3669                elif LA46 == DATE:
3670                    LA46_7 = self.input.LA(2)
3671
3672                    if (self.synpred70_UL4()) :
3673                        alt46 = 1
3674                    elif (True) :
3675                        alt46 = 2
3676                    else:
3677                        if self._state.backtracking > 0:
3678                            raise BacktrackingFailed
3679
3680
3681                        nvae = NoViableAltException("", 46, 7, self.input)
3682
3683                        raise nvae
3684
3685
3686                elif LA46 == COLOR:
3687                    LA46_8 = self.input.LA(2)
3688
3689                    if (self.synpred70_UL4()) :
3690                        alt46 = 1
3691                    elif (True) :
3692                        alt46 = 2
3693                    else:
3694                        if self._state.backtracking > 0:
3695                            raise BacktrackingFailed
3696
3697
3698                        nvae = NoViableAltException("", 46, 8, self.input)
3699
3700                        raise nvae
3701
3702
3703                elif LA46 == NAME:
3704                    LA46_9 = self.input.LA(2)
3705
3706                    if (self.synpred70_UL4()) :
3707                        alt46 = 1
3708                    elif (True) :
3709                        alt46 = 2
3710                    else:
3711                        if self._state.backtracking > 0:
3712                            raise BacktrackingFailed
3713
3714
3715                        nvae = NoViableAltException("", 46, 9, self.input)
3716
3717                        raise nvae
3718
3719
3720                elif LA46 == 49:
3721                    LA46_10 = self.input.LA(2)
3722
3723                    if (self.synpred70_UL4()) :
3724                        alt46 = 1
3725                    elif (True) :
3726                        alt46 = 2
3727                    else:
3728                        if self._state.backtracking > 0:
3729                            raise BacktrackingFailed
3730
3731
3732                        nvae = NoViableAltException("", 46, 10, self.input)
3733
3734                        raise nvae
3735
3736
3737                elif LA46 == 57:
3738                    LA46_11 = self.input.LA(2)
3739
3740                    if (self.synpred70_UL4()) :
3741                        alt46 = 1
3742                    elif (True) :
3743                        alt46 = 2
3744                    else:
3745                        if self._state.backtracking > 0:
3746                            raise BacktrackingFailed
3747
3748
3749                        nvae = NoViableAltException("", 46, 11, self.input)
3750
3751                        raise nvae
3752
3753
3754                elif LA46 == 27:
3755                    LA46_12 = self.input.LA(2)
3756
3757                    if (self.synpred70_UL4()) :
3758                        alt46 = 1
3759                    elif (True) :
3760                        alt46 = 2
3761                    else:
3762                        if self._state.backtracking > 0:
3763                            raise BacktrackingFailed
3764
3765
3766                        nvae = NoViableAltException("", 46, 12, self.input)
3767
3768                        raise nvae
3769
3770
3771                elif LA46 == 35:
3772                    LA46_13 = self.input.LA(2)
3773
3774                    if (self.synpred70_UL4()) :
3775                        alt46 = 1
3776                    elif (True) :
3777                        alt46 = 2
3778                    else:
3779                        if self._state.backtracking > 0:
3780                            raise BacktrackingFailed
3781
3782
3783                        nvae = NoViableAltException("", 46, 13, self.input)
3784
3785                        raise nvae
3786
3787
3788                elif LA46 == 55:
3789                    LA46_14 = self.input.LA(2)
3790
3791                    if (self.synpred70_UL4()) :
3792                        alt46 = 1
3793                    elif (True) :
3794                        alt46 = 2
3795                    else:
3796                        if self._state.backtracking > 0:
3797                            raise BacktrackingFailed
3798
3799
3800                        nvae = NoViableAltException("", 46, 14, self.input)
3801
3802                        raise nvae
3803
3804
3805                else:
3806                    if self._state.backtracking > 0:
3807                        raise BacktrackingFailed
3808
3809
3810                    nvae = NoViableAltException("", 46, 0, self.input)
3811
3812                    raise nvae
3813
3814
3815                if alt46 == 1:
3816                    # src/ll/UL4.g:524:4: ege= generatorexpression EOF
3817                    pass 
3818                    self._state.following.append(self.FOLLOW_generatorexpression_in_expression2754)
3819                    ege = self.generatorexpression()
3820
3821                    self._state.following.pop()
3822
3823                    self.match(self.input, EOF, self.FOLLOW_EOF_in_expression2756)
3824
3825                    if self._state.backtracking == 0:
3826                        pass
3827                        node =  ege
3828
3829
3830
3831
3832                elif alt46 == 2:
3833                    # src/ll/UL4.g:525:4: e= expr1 EOF
3834                    pass 
3835                    self._state.following.append(self.FOLLOW_expr1_in_expression2765)
3836                    e = self.expr1()
3837
3838                    self._state.following.pop()
3839
3840                    self.match(self.input, EOF, self.FOLLOW_EOF_in_expression2767)
3841
3842                    if self._state.backtracking == 0:
3843                        pass
3844                        node =  e
3845
3846
3847
3848
3849
3850                       
3851            except RecognitionException as e:
3852                raise
3853
3854        finally:
3855            pass
3856        return node
3857
3858    # $ANTLR end "expression"
3859
3860
3861
3862    # $ANTLR start "for_"
3863    # src/ll/UL4.g:531:1: for_ returns [node] : n= nestedname 'in' e= expr1 EOF ;
3864    def for_(self, ):
3865        node = None
3866
3867
3868        n = None
3869
3870        e = None
3871
3872
3873        try:
3874            try:
3875                # src/ll/UL4.g:532:2: (n= nestedname 'in' e= expr1 EOF )
3876                # src/ll/UL4.g:533:3: n= nestedname 'in' e= expr1 EOF
3877                pass 
3878                self._state.following.append(self.FOLLOW_nestedname_in_for_2792)
3879                n = self.nestedname()
3880
3881                self._state.following.pop()
3882
3883                self.match(self.input, 54, self.FOLLOW_54_in_for_2796)
3884
3885                self._state.following.append(self.FOLLOW_expr1_in_for_2802)
3886                e = self.expr1()
3887
3888                self._state.following.pop()
3889
3890                if self._state.backtracking == 0:
3891                    pass
3892                    node = ul4c.For(self.location, self.start(n.start), e.end, ((n is not None) and [n.varname] or [None])[0], e) 
3893
3894
3895
3896                self.match(self.input, EOF, self.FOLLOW_EOF_in_for_2808)
3897
3898
3899
3900
3901                       
3902            except RecognitionException as e:
3903                raise
3904
3905        finally:
3906            pass
3907        return node
3908
3909    # $ANTLR end "for_"
3910
3911
3912
3913    # $ANTLR start "statement"
3914    # src/ll/UL4.g:542:1: statement returns [node] : (nn= nestedname '=' e= expr1 EOF |n= name '+=' e= expr1 EOF |n= name '-=' e= expr1 EOF |n= name '*=' e= expr1 EOF |n= name '/=' e= expr1 EOF |n= name '//=' e= expr1 EOF |n= name '%=' e= expr1 EOF |e= expression EOF );
3915    def statement(self, ):
3916        node = None
3917
3918
3919        nn = None
3920
3921        e = None
3922
3923        n = None
3924
3925
3926        try:
3927            try:
3928                # src/ll/UL4.g:543:2: (nn= nestedname '=' e= expr1 EOF |n= name '+=' e= expr1 EOF |n= name '-=' e= expr1 EOF |n= name '*=' e= expr1 EOF |n= name '/=' e= expr1 EOF |n= name '//=' e= expr1 EOF |n= name '%=' e= expr1 EOF |e= expression EOF )
3929                alt47 = 8
3930                LA47 = self.input.LA(1)
3931                if LA47 == NAME:
3932                    LA47_1 = self.input.LA(2)
3933
3934                    if (self.synpred71_UL4()) :
3935                        alt47 = 1
3936                    elif (self.synpred72_UL4()) :
3937                        alt47 = 2
3938                    elif (self.synpred73_UL4()) :
3939                        alt47 = 3
3940                    elif (self.synpred74_UL4()) :
3941                        alt47 = 4
3942                    elif (self.synpred75_UL4()) :
3943                        alt47 = 5
3944                    elif (self.synpred76_UL4()) :
3945                        alt47 = 6
3946                    elif (self.synpred77_UL4()) :
3947                        alt47 = 7
3948                    elif (True) :
3949                        alt47 = 8
3950                    else:
3951                        if self._state.backtracking > 0:
3952                            raise BacktrackingFailed
3953
3954
3955                        nvae = NoViableAltException("", 47, 1, self.input)
3956
3957                        raise nvae
3958
3959
3960                elif LA47 == 27:
3961                    LA47_2 = self.input.LA(2)
3962
3963                    if (self.synpred71_UL4()) :
3964                        alt47 = 1
3965                    elif (True) :
3966                        alt47 = 8
3967                    else:
3968                        if self._state.backtracking > 0:
3969                            raise BacktrackingFailed
3970
3971
3972                        nvae = NoViableAltException("", 47, 2, self.input)
3973
3974                        raise nvae
3975
3976
3977                elif LA47 == COLOR or LA47 == DATE or LA47 == FALSE or LA47 == FLOAT or LA47 == INT or LA47 == NONE or LA47 == STRING or LA47 == TRUE or LA47 == 35 or LA47 == 49 or LA47 == 55 or LA47 == 57:
3978                    alt47 = 8
3979                else:
3980                    if self._state.backtracking > 0:
3981                        raise BacktrackingFailed
3982
3983
3984                    nvae = NoViableAltException("", 47, 0, self.input)
3985
3986                    raise nvae
3987
3988
3989                if alt47 == 1:
3990                    # src/ll/UL4.g:543:4: nn= nestedname '=' e= expr1 EOF
3991                    pass 
3992                    self._state.following.append(self.FOLLOW_nestedname_in_statement2829)
3993                    nn = self.nestedname()
3994
3995                    self._state.following.pop()
3996
3997                    self.match(self.input, 45, self.FOLLOW_45_in_statement2831)
3998
3999                    self._state.following.append(self.FOLLOW_expr1_in_statement2835)
4000                    e = self.expr1()
4001
4002                    self._state.following.pop()
4003
4004                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2837)
4005
4006                    if self._state.backtracking == 0:
4007                        pass
4008                        node = ul4c.StoreVar(self.location, self.start(nn.start), e.end, ((nn is not None) and [nn.varname] or [None])[0], e) 
4009
4010
4011
4012
4013                elif alt47 == 2:
4014                    # src/ll/UL4.g:544:4: n= name '+=' e= expr1 EOF
4015                    pass 
4016                    self._state.following.append(self.FOLLOW_name_in_statement2846)
4017                    n = self.name()
4018
4019                    self._state.following.pop()
4020
4021                    self.match(self.input, 33, self.FOLLOW_33_in_statement2848)
4022
4023                    self._state.following.append(self.FOLLOW_expr1_in_statement2852)
4024                    e = self.expr1()
4025
4026                    self._state.following.pop()
4027
4028                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2854)
4029
4030                    if self._state.backtracking == 0:
4031                        pass
4032                        node = ul4c.AddVar(self.location, self.start(n.start), e.end, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4033
4034
4035
4036
4037                elif alt47 == 3:
4038                    # src/ll/UL4.g:545:4: n= name '-=' e= expr1 EOF
4039                    pass 
4040                    self._state.following.append(self.FOLLOW_name_in_statement2863)
4041                    n = self.name()
4042
4043                    self._state.following.pop()
4044
4045                    self.match(self.input, 36, self.FOLLOW_36_in_statement2865)
4046
4047                    self._state.following.append(self.FOLLOW_expr1_in_statement2869)
4048                    e = self.expr1()
4049
4050                    self._state.following.pop()
4051
4052                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2871)
4053
4054                    if self._state.backtracking == 0:
4055                        pass
4056                        node = ul4c.SubVar(self.location, self.start(n.start), e.end, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4057
4058
4059
4060
4061                elif alt47 == 4:
4062                    # src/ll/UL4.g:546:4: n= name '*=' e= expr1 EOF
4063                    pass 
4064                    self._state.following.append(self.FOLLOW_name_in_statement2880)
4065                    n = self.name()
4066
4067                    self._state.following.pop()
4068
4069                    self.match(self.input, 31, self.FOLLOW_31_in_statement2882)
4070
4071                    self._state.following.append(self.FOLLOW_expr1_in_statement2886)
4072                    e = self.expr1()
4073
4074                    self._state.following.pop()
4075
4076                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2888)
4077
4078                    if self._state.backtracking == 0:
4079                        pass
4080                        node = ul4c.MulVar(self.location, self.start(n.start), e.end, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4081
4082
4083
4084
4085                elif alt47 == 5:
4086                    # src/ll/UL4.g:547:4: n= name '/=' e= expr1 EOF
4087                    pass 
4088                    self._state.following.append(self.FOLLOW_name_in_statement2897)
4089                    n = self.name()
4090
4091                    self._state.following.pop()
4092
4093                    self.match(self.input, 41, self.FOLLOW_41_in_statement2899)
4094
4095                    self._state.following.append(self.FOLLOW_expr1_in_statement2903)
4096                    e = self.expr1()
4097
4098                    self._state.following.pop()
4099
4100                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2905)
4101
4102                    if self._state.backtracking == 0:
4103                        pass
4104                        node = ul4c.TrueDivVar(self.location, self.start(n.start), e.end, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4105
4106
4107
4108
4109                elif alt47 == 6:
4110                    # src/ll/UL4.g:548:4: n= name '//=' e= expr1 EOF
4111                    pass 
4112                    self._state.following.append(self.FOLLOW_name_in_statement2914)
4113                    n = self.name()
4114
4115                    self._state.following.pop()
4116
4117                    self.match(self.input, 40, self.FOLLOW_40_in_statement2916)
4118
4119                    self._state.following.append(self.FOLLOW_expr1_in_statement2920)
4120                    e = self.expr1()
4121
4122                    self._state.following.pop()
4123
4124                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2922)
4125
4126                    if self._state.backtracking == 0:
4127                        pass
4128                        node = ul4c.FloorDivVar(self.location, self.start(n.start), e.end, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4129
4130
4131
4132
4133                elif alt47 == 7:
4134                    # src/ll/UL4.g:549:4: n= name '%=' e= expr1 EOF
4135                    pass 
4136                    self._state.following.append(self.FOLLOW_name_in_statement2931)
4137                    n = self.name()
4138
4139                    self._state.following.pop()
4140
4141                    self.match(self.input, 26, self.FOLLOW_26_in_statement2933)
4142
4143                    self._state.following.append(self.FOLLOW_expr1_in_statement2937)
4144                    e = self.expr1()
4145
4146                    self._state.following.pop()
4147
4148                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2939)
4149
4150                    if self._state.backtracking == 0:
4151                        pass
4152                        node = ul4c.ModVar(self.location, self.start(n.start), e.end, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4153
4154
4155
4156
4157                elif alt47 == 8:
4158                    # src/ll/UL4.g:550:4: e= expression EOF
4159                    pass 
4160                    self._state.following.append(self.FOLLOW_expression_in_statement2948)
4161                    e = self.expression()
4162
4163                    self._state.following.pop()
4164
4165                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2950)
4166
4167                    if self._state.backtracking == 0:
4168                        pass
4169                        node = e
4170
4171
4172
4173
4174
4175                       
4176            except RecognitionException as e:
4177                raise
4178
4179        finally:
4180            pass
4181        return node
4182
4183    # $ANTLR end "statement"
4184
4185    # $ANTLR start "synpred19_UL4"
4186    def synpred19_UL4_fragment(self, ):
4187        e_list = None
4188
4189
4190        # src/ll/UL4.g:295:4: (e_list= list )
4191        # src/ll/UL4.g:295:4: e_list= list
4192        pass 
4193        self._state.following.append(self.FOLLOW_list_in_synpred19_UL41401)
4194        e_list = self.list()
4195
4196        self._state.following.pop()
4197
4198
4199
4200    # $ANTLR end "synpred19_UL4"
4201
4202
4203
4204    # $ANTLR start "synpred20_UL4"
4205    def synpred20_UL4_fragment(self, ):
4206        e_listcomp = None
4207
4208
4209        # src/ll/UL4.g:296:4: (e_listcomp= listcomprehension )
4210        # src/ll/UL4.g:296:4: e_listcomp= listcomprehension
4211        pass 
4212        self._state.following.append(self.FOLLOW_listcomprehension_in_synpred20_UL41410)
4213        e_listcomp = self.listcomprehension()
4214
4215        self._state.following.pop()
4216
4217
4218
4219    # $ANTLR end "synpred20_UL4"
4220
4221
4222
4223    # $ANTLR start "synpred21_UL4"
4224    def synpred21_UL4_fragment(self, ):
4225        e_dict = None
4226
4227
4228        # src/ll/UL4.g:297:4: (e_dict= dict )
4229        # src/ll/UL4.g:297:4: e_dict= dict
4230        pass 
4231        self._state.following.append(self.FOLLOW_dict_in_synpred21_UL41419)
4232        e_dict = self.dict()
4233
4234        self._state.following.pop()
4235
4236
4237
4238    # $ANTLR end "synpred21_UL4"
4239
4240
4241
4242    # $ANTLR start "synpred22_UL4"
4243    def synpred22_UL4_fragment(self, ):
4244        e_dictcomp = None
4245
4246
4247        # src/ll/UL4.g:298:4: (e_dictcomp= dictcomprehension )
4248        # src/ll/UL4.g:298:4: e_dictcomp= dictcomprehension
4249        pass 
4250        self._state.following.append(self.FOLLOW_dictcomprehension_in_synpred22_UL41428)
4251        e_dictcomp = self.dictcomprehension()
4252
4253        self._state.following.pop()
4254
4255
4256
4257    # $ANTLR end "synpred22_UL4"
4258
4259
4260
4261    # $ANTLR start "synpred23_UL4"
4262    def synpred23_UL4_fragment(self, ):
4263        e_genexpr = None
4264
4265
4266        # src/ll/UL4.g:299:4: ( '(' e_genexpr= generatorexpression ')' )
4267        # src/ll/UL4.g:299:4: '(' e_genexpr= generatorexpression ')'
4268        pass 
4269        self.match(self.input, 27, self.FOLLOW_27_in_synpred23_UL41435)
4270
4271        self._state.following.append(self.FOLLOW_generatorexpression_in_synpred23_UL41439)
4272        e_genexpr = self.generatorexpression()
4273
4274        self._state.following.pop()
4275
4276        self.match(self.input, 28, self.FOLLOW_28_in_synpred23_UL41441)
4277
4278
4279
4280    # $ANTLR end "synpred23_UL4"
4281
4282
4283
4284    # $ANTLR start "synpred25_UL4"
4285    def synpred25_UL4_fragment(self, ):
4286        n0 = None
4287
4288
4289        # src/ll/UL4.g:308:3: ( '(' n0= nestedname ',' ')' )
4290        # src/ll/UL4.g:308:3: '(' n0= nestedname ',' ')'
4291        pass 
4292        self.match(self.input, 27, self.FOLLOW_27_in_synpred25_UL41486)
4293
4294        self._state.following.append(self.FOLLOW_nestedname_in_synpred25_UL41490)
4295        n0 = self.nestedname()
4296
4297        self._state.following.pop()
4298
4299        self.match(self.input, 34, self.FOLLOW_34_in_synpred25_UL41492)
4300
4301        self.match(self.input, 28, self.FOLLOW_28_in_synpred25_UL41494)
4302
4303
4304
4305    # $ANTLR end "synpred25_UL4"
4306
4307
4308
4309    # $ANTLR start "synpred69_UL4"
4310    def synpred69_UL4_fragment(self, ):
4311        ege = None
4312
4313
4314        # src/ll/UL4.g:519:4: (ege= generatorexpression )
4315        # src/ll/UL4.g:519:4: ege= generatorexpression
4316        pass 
4317        self._state.following.append(self.FOLLOW_generatorexpression_in_synpred69_UL42726)
4318        ege = self.generatorexpression()
4319
4320        self._state.following.pop()
4321
4322
4323
4324    # $ANTLR end "synpred69_UL4"
4325
4326
4327
4328    # $ANTLR start "synpred70_UL4"
4329    def synpred70_UL4_fragment(self, ):
4330        ege = None
4331
4332
4333        # src/ll/UL4.g:524:4: (ege= generatorexpression EOF )
4334        # src/ll/UL4.g:524:4: ege= generatorexpression EOF
4335        pass 
4336        self._state.following.append(self.FOLLOW_generatorexpression_in_synpred70_UL42754)
4337        ege = self.generatorexpression()
4338
4339        self._state.following.pop()
4340
4341        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred70_UL42756)
4342
4343
4344
4345    # $ANTLR end "synpred70_UL4"
4346
4347
4348
4349    # $ANTLR start "synpred71_UL4"
4350    def synpred71_UL4_fragment(self, ):
4351        nn = None
4352
4353        e = None
4354
4355
4356        # src/ll/UL4.g:543:4: (nn= nestedname '=' e= expr1 EOF )
4357        # src/ll/UL4.g:543:4: nn= nestedname '=' e= expr1 EOF
4358        pass 
4359        self._state.following.append(self.FOLLOW_nestedname_in_synpred71_UL42829)
4360        nn = self.nestedname()
4361
4362        self._state.following.pop()
4363
4364        self.match(self.input, 45, self.FOLLOW_45_in_synpred71_UL42831)
4365
4366        self._state.following.append(self.FOLLOW_expr1_in_synpred71_UL42835)
4367        e = self.expr1()
4368
4369        self._state.following.pop()
4370
4371        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred71_UL42837)
4372
4373
4374
4375    # $ANTLR end "synpred71_UL4"
4376
4377
4378
4379    # $ANTLR start "synpred72_UL4"
4380    def synpred72_UL4_fragment(self, ):
4381        n = None
4382
4383        e = None
4384
4385
4386        # src/ll/UL4.g:544:4: (n= name '+=' e= expr1 EOF )
4387        # src/ll/UL4.g:544:4: n= name '+=' e= expr1 EOF
4388        pass 
4389        self._state.following.append(self.FOLLOW_name_in_synpred72_UL42846)
4390        n = self.name()
4391
4392        self._state.following.pop()
4393
4394        self.match(self.input, 33, self.FOLLOW_33_in_synpred72_UL42848)
4395
4396        self._state.following.append(self.FOLLOW_expr1_in_synpred72_UL42852)
4397        e = self.expr1()
4398
4399        self._state.following.pop()
4400
4401        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred72_UL42854)
4402
4403
4404
4405    # $ANTLR end "synpred72_UL4"
4406
4407
4408
4409    # $ANTLR start "synpred73_UL4"
4410    def synpred73_UL4_fragment(self, ):
4411        n = None
4412
4413        e = None
4414
4415
4416        # src/ll/UL4.g:545:4: (n= name '-=' e= expr1 EOF )
4417        # src/ll/UL4.g:545:4: n= name '-=' e= expr1 EOF
4418        pass 
4419        self._state.following.append(self.FOLLOW_name_in_synpred73_UL42863)
4420        n = self.name()
4421
4422        self._state.following.pop()
4423
4424        self.match(self.input, 36, self.FOLLOW_36_in_synpred73_UL42865)
4425
4426        self._state.following.append(self.FOLLOW_expr1_in_synpred73_UL42869)
4427        e = self.expr1()
4428
4429        self._state.following.pop()
4430
4431        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred73_UL42871)
4432
4433
4434
4435    # $ANTLR end "synpred73_UL4"
4436
4437
4438
4439    # $ANTLR start "synpred74_UL4"
4440    def synpred74_UL4_fragment(self, ):
4441        n = None
4442
4443        e = None
4444
4445
4446        # src/ll/UL4.g:546:4: (n= name '*=' e= expr1 EOF )
4447        # src/ll/UL4.g:546:4: n= name '*=' e= expr1 EOF
4448        pass 
4449        self._state.following.append(self.FOLLOW_name_in_synpred74_UL42880)
4450        n = self.name()
4451
4452        self._state.following.pop()
4453
4454        self.match(self.input, 31, self.FOLLOW_31_in_synpred74_UL42882)
4455
4456        self._state.following.append(self.FOLLOW_expr1_in_synpred74_UL42886)
4457        e = self.expr1()
4458
4459        self._state.following.pop()
4460
4461        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred74_UL42888)
4462
4463
4464
4465    # $ANTLR end "synpred74_UL4"
4466
4467
4468
4469    # $ANTLR start "synpred75_UL4"
4470    def synpred75_UL4_fragment(self, ):
4471        n = None
4472
4473        e = None
4474
4475
4476        # src/ll/UL4.g:547:4: (n= name '/=' e= expr1 EOF )
4477        # src/ll/UL4.g:547:4: n= name '/=' e= expr1 EOF
4478        pass 
4479        self._state.following.append(self.FOLLOW_name_in_synpred75_UL42897)
4480        n = self.name()
4481
4482        self._state.following.pop()
4483
4484        self.match(self.input, 41, self.FOLLOW_41_in_synpred75_UL42899)
4485
4486        self._state.following.append(self.FOLLOW_expr1_in_synpred75_UL42903)
4487        e = self.expr1()
4488
4489        self._state.following.pop()
4490
4491        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred75_UL42905)
4492
4493
4494
4495    # $ANTLR end "synpred75_UL4"
4496
4497
4498
4499    # $ANTLR start "synpred76_UL4"
4500    def synpred76_UL4_fragment(self, ):
4501        n = None
4502
4503        e = None
4504
4505
4506        # src/ll/UL4.g:548:4: (n= name '//=' e= expr1 EOF )
4507        # src/ll/UL4.g:548:4: n= name '//=' e= expr1 EOF
4508        pass 
4509        self._state.following.append(self.FOLLOW_name_in_synpred76_UL42914)
4510        n = self.name()
4511
4512        self._state.following.pop()
4513
4514        self.match(self.input, 40, self.FOLLOW_40_in_synpred76_UL42916)
4515
4516        self._state.following.append(self.FOLLOW_expr1_in_synpred76_UL42920)
4517        e = self.expr1()
4518
4519        self._state.following.pop()
4520
4521        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred76_UL42922)
4522
4523
4524
4525    # $ANTLR end "synpred76_UL4"
4526
4527
4528
4529    # $ANTLR start "synpred77_UL4"
4530    def synpred77_UL4_fragment(self, ):
4531        n = None
4532
4533        e = None
4534
4535
4536        # src/ll/UL4.g:549:4: (n= name '%=' e= expr1 EOF )
4537        # src/ll/UL4.g:549:4: n= name '%=' e= expr1 EOF
4538        pass 
4539        self._state.following.append(self.FOLLOW_name_in_synpred77_UL42931)
4540        n = self.name()
4541
4542        self._state.following.pop()
4543
4544        self.match(self.input, 26, self.FOLLOW_26_in_synpred77_UL42933)
4545
4546        self._state.following.append(self.FOLLOW_expr1_in_synpred77_UL42937)
4547        e = self.expr1()
4548
4549        self._state.following.pop()
4550
4551        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred77_UL42939)
4552
4553
4554
4555    # $ANTLR end "synpred77_UL4"
4556
4557
4558
4559
4560    def synpred76_UL4(self):
4561        self._state.backtracking += 1
4562        start = self.input.mark()
4563        try:
4564            self.synpred76_UL4_fragment()
4565        except BacktrackingFailed:
4566            success = False
4567        else:
4568            success = True
4569        self.input.rewind(start)
4570        self._state.backtracking -= 1
4571        return success
4572
4573    def synpred22_UL4(self):
4574        self._state.backtracking += 1
4575        start = self.input.mark()
4576        try:
4577            self.synpred22_UL4_fragment()
4578        except BacktrackingFailed:
4579            success = False
4580        else:
4581            success = True
4582        self.input.rewind(start)
4583        self._state.backtracking -= 1
4584        return success
4585
4586    def synpred77_UL4(self):
4587        self._state.backtracking += 1
4588        start = self.input.mark()
4589        try:
4590            self.synpred77_UL4_fragment()
4591        except BacktrackingFailed:
4592            success = False
4593        else:
4594            success = True
4595        self.input.rewind(start)
4596        self._state.backtracking -= 1
4597        return success
4598
4599    def synpred70_UL4(self):
4600        self._state.backtracking += 1
4601        start = self.input.mark()
4602        try:
4603            self.synpred70_UL4_fragment()
4604        except BacktrackingFailed:
4605            success = False
4606        else:
4607            success = True
4608        self.input.rewind(start)
4609        self._state.backtracking -= 1
4610        return success
4611
4612    def synpred75_UL4(self):
4613        self._state.backtracking += 1
4614        start = self.input.mark()
4615        try:
4616            self.synpred75_UL4_fragment()
4617        except BacktrackingFailed:
4618            success = False
4619        else:
4620            success = True
4621        self.input.rewind(start)
4622        self._state.backtracking -= 1
4623        return success
4624
4625    def synpred20_UL4(self):
4626        self._state.backtracking += 1
4627        start = self.input.mark()
4628        try:
4629            self.synpred20_UL4_fragment()
4630        except BacktrackingFailed:
4631            success = False
4632        else:
4633            success = True
4634        self.input.rewind(start)
4635        self._state.backtracking -= 1
4636        return success
4637
4638    def synpred23_UL4(self):
4639        self._state.backtracking += 1
4640        start = self.input.mark()
4641        try:
4642            self.synpred23_UL4_fragment()
4643        except BacktrackingFailed:
4644            success = False
4645        else:
4646            success = True
4647        self.input.rewind(start)
4648        self._state.backtracking -= 1
4649        return success
4650
4651    def synpred72_UL4(self):
4652        self._state.backtracking += 1
4653        start = self.input.mark()
4654        try:
4655            self.synpred72_UL4_fragment()
4656        except BacktrackingFailed:
4657            success = False
4658        else:
4659            success = True
4660        self.input.rewind(start)
4661        self._state.backtracking -= 1
4662        return success
4663
4664    def synpred69_UL4(self):
4665        self._state.backtracking += 1
4666        start = self.input.mark()
4667        try:
4668            self.synpred69_UL4_fragment()
4669        except BacktrackingFailed:
4670            success = False
4671        else:
4672            success = True
4673        self.input.rewind(start)
4674        self._state.backtracking -= 1
4675        return success
4676
4677    def synpred19_UL4(self):
4678        self._state.backtracking += 1
4679        start = self.input.mark()
4680        try:
4681            self.synpred19_UL4_fragment()
4682        except BacktrackingFailed:
4683            success = False
4684        else:
4685            success = True
4686        self.input.rewind(start)
4687        self._state.backtracking -= 1
4688        return success
4689
4690    def synpred71_UL4(self):
4691        self._state.backtracking += 1
4692        start = self.input.mark()
4693        try:
4694            self.synpred71_UL4_fragment()
4695        except BacktrackingFailed:
4696            success = False
4697        else:
4698            success = True
4699        self.input.rewind(start)
4700        self._state.backtracking -= 1
4701        return success
4702
4703    def synpred21_UL4(self):
4704        self._state.backtracking += 1
4705        start = self.input.mark()
4706        try:
4707            self.synpred21_UL4_fragment()
4708        except BacktrackingFailed:
4709            success = False
4710        else:
4711            success = True
4712        self.input.rewind(start)
4713        self._state.backtracking -= 1
4714        return success
4715
4716    def synpred73_UL4(self):
4717        self._state.backtracking += 1
4718        start = self.input.mark()
4719        try:
4720            self.synpred73_UL4_fragment()
4721        except BacktrackingFailed:
4722            success = False
4723        else:
4724            success = True
4725        self.input.rewind(start)
4726        self._state.backtracking -= 1
4727        return success
4728
4729    def synpred25_UL4(self):
4730        self._state.backtracking += 1
4731        start = self.input.mark()
4732        try:
4733            self.synpred25_UL4_fragment()
4734        except BacktrackingFailed:
4735            success = False
4736        else:
4737            success = True
4738        self.input.rewind(start)
4739        self._state.backtracking -= 1
4740        return success
4741
4742    def synpred74_UL4(self):
4743        self._state.backtracking += 1
4744        start = self.input.mark()
4745        try:
4746            self.synpred74_UL4_fragment()
4747        except BacktrackingFailed:
4748            success = False
4749        else:
4750            success = True
4751        self.input.rewind(start)
4752        self._state.backtracking -= 1
4753        return success
4754
4755
4756
4757 
4758
4759    FOLLOW_NONE_in_none694 = frozenset([1])
4760    FOLLOW_TRUE_in_true_711 = frozenset([1])
4761    FOLLOW_FALSE_in_false_728 = frozenset([1])
4762    FOLLOW_INT_in_int_745 = frozenset([1])
4763    FOLLOW_FLOAT_in_float_762 = frozenset([1])
4764    FOLLOW_STRING_in_string779 = frozenset([1])
4765    FOLLOW_DATE_in_date796 = frozenset([1])
4766    FOLLOW_COLOR_in_color813 = frozenset([1])
4767    FOLLOW_NAME_in_name830 = frozenset([1])
4768    FOLLOW_none_in_literal849 = frozenset([1])
4769    FOLLOW_false__in_literal858 = frozenset([1])
4770    FOLLOW_true__in_literal867 = frozenset([1])
4771    FOLLOW_int__in_literal876 = frozenset([1])
4772    FOLLOW_float__in_literal885 = frozenset([1])
4773    FOLLOW_string_in_literal894 = frozenset([1])
4774    FOLLOW_date_in_literal903 = frozenset([1])
4775    FOLLOW_color_in_literal912 = frozenset([1])
4776    FOLLOW_name_in_literal921 = frozenset([1])
4777    FOLLOW_49_in_list944 = frozenset([50])
4778    FOLLOW_50_in_list950 = frozenset([1])
4779    FOLLOW_49_in_list961 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4780    FOLLOW_expr1_in_list969 = frozenset([34, 50])
4781    FOLLOW_34_in_list980 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4782    FOLLOW_expr1_in_list987 = frozenset([34, 50])
4783    FOLLOW_34_in_list998 = frozenset([50])
4784    FOLLOW_50_in_list1005 = frozenset([1])
4785    FOLLOW_49_in_listcomprehension1033 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4786    FOLLOW_expr1_in_listcomprehension1039 = frozenset([52])
4787    FOLLOW_52_in_listcomprehension1043 = frozenset([14, 27])
4788    FOLLOW_nestedname_in_listcomprehension1049 = frozenset([54])
4789    FOLLOW_54_in_listcomprehension1053 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4790    FOLLOW_expr1_in_listcomprehension1059 = frozenset([50, 53])
4791    FOLLOW_53_in_listcomprehension1068 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4792    FOLLOW_expr1_in_listcomprehension1075 = frozenset([50])
4793    FOLLOW_50_in_listcomprehension1088 = frozenset([1])
4794    FOLLOW_expr1_in_dictitem1113 = frozenset([42])
4795    FOLLOW_42_in_dictitem1117 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4796    FOLLOW_expr1_in_dictitem1123 = frozenset([1])
4797    FOLLOW_57_in_dict1144 = frozenset([58])
4798    FOLLOW_58_in_dict1150 = frozenset([1])
4799    FOLLOW_57_in_dict1161 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4800    FOLLOW_dictitem_in_dict1169 = frozenset([34, 58])
4801    FOLLOW_34_in_dict1180 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4802    FOLLOW_dictitem_in_dict1187 = frozenset([34, 58])
4803    FOLLOW_34_in_dict1198 = frozenset([58])
4804    FOLLOW_58_in_dict1205 = frozenset([1])
4805    FOLLOW_57_in_dictcomprehension1233 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4806    FOLLOW_expr1_in_dictcomprehension1239 = frozenset([42])
4807    FOLLOW_42_in_dictcomprehension1243 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4808    FOLLOW_expr1_in_dictcomprehension1249 = frozenset([52])
4809    FOLLOW_52_in_dictcomprehension1253 = frozenset([14, 27])
4810    FOLLOW_nestedname_in_dictcomprehension1259 = frozenset([54])
4811    FOLLOW_54_in_dictcomprehension1263 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4812    FOLLOW_expr1_in_dictcomprehension1269 = frozenset([53, 58])
4813    FOLLOW_53_in_dictcomprehension1278 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4814    FOLLOW_expr1_in_dictcomprehension1285 = frozenset([58])
4815    FOLLOW_58_in_dictcomprehension1298 = frozenset([1])
4816    FOLLOW_expr1_in_generatorexpression1326 = frozenset([52])
4817    FOLLOW_52_in_generatorexpression1332 = frozenset([14, 27])
4818    FOLLOW_nestedname_in_generatorexpression1338 = frozenset([54])
4819    FOLLOW_54_in_generatorexpression1342 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4820    FOLLOW_expr1_in_generatorexpression1348 = frozenset([1, 53])
4821    FOLLOW_53_in_generatorexpression1359 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4822    FOLLOW_expr1_in_generatorexpression1366 = frozenset([1])
4823    FOLLOW_literal_in_atom1392 = frozenset([1])
4824    FOLLOW_list_in_atom1401 = frozenset([1])
4825    FOLLOW_listcomprehension_in_atom1410 = frozenset([1])
4826    FOLLOW_dict_in_atom1419 = frozenset([1])
4827    FOLLOW_dictcomprehension_in_atom1428 = frozenset([1])
4828    FOLLOW_27_in_atom1435 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4829    FOLLOW_generatorexpression_in_atom1439 = frozenset([28])
4830    FOLLOW_28_in_atom1441 = frozenset([1])
4831    FOLLOW_27_in_atom1448 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4832    FOLLOW_expr1_in_atom1452 = frozenset([28])
4833    FOLLOW_28_in_atom1454 = frozenset([1])
4834    FOLLOW_name_in_nestedname1477 = frozenset([1])
4835    FOLLOW_27_in_nestedname1486 = frozenset([14, 27])
4836    FOLLOW_nestedname_in_nestedname1490 = frozenset([34])
4837    FOLLOW_34_in_nestedname1492 = frozenset([28])
4838    FOLLOW_28_in_nestedname1494 = frozenset([1])
4839    FOLLOW_27_in_nestedname1503 = frozenset([14, 27])
4840    FOLLOW_nestedname_in_nestedname1509 = frozenset([34])
4841    FOLLOW_34_in_nestedname1513 = frozenset([14, 27])
4842    FOLLOW_nestedname_in_nestedname1519 = frozenset([28, 34])
4843    FOLLOW_34_in_nestedname1530 = frozenset([14, 27])
4844    FOLLOW_nestedname_in_nestedname1537 = frozenset([28, 34])
4845    FOLLOW_34_in_nestedname1548 = frozenset([28])
4846    FOLLOW_28_in_nestedname1553 = frozenset([1])
4847    FOLLOW_atom_in_expr91582 = frozenset([1, 27, 37, 49])
4848    FOLLOW_37_in_expr91598 = frozenset([14])
4849    FOLLOW_name_in_expr91605 = frozenset([1, 27, 37, 49])
4850    FOLLOW_27_in_expr91621 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 28, 29, 30, 35, 49, 55, 57])
4851    FOLLOW_30_in_expr91651 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4852    FOLLOW_exprarg_in_expr91655 = frozenset([28, 34])
4853    FOLLOW_34_in_expr91663 = frozenset([28])
4854    FOLLOW_29_in_expr91681 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4855    FOLLOW_exprarg_in_expr91685 = frozenset([28, 34])
4856    FOLLOW_34_in_expr91700 = frozenset([30])
4857    FOLLOW_30_in_expr91707 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4858    FOLLOW_exprarg_in_expr91711 = frozenset([28, 34])
4859    FOLLOW_34_in_expr91726 = frozenset([28])
4860    FOLLOW_exprarg_in_expr91746 = frozenset([28, 34])
4861    FOLLOW_34_in_expr91761 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4862    FOLLOW_exprarg_in_expr91770 = frozenset([28, 34])
4863    FOLLOW_34_in_expr91792 = frozenset([14])
4864    FOLLOW_name_in_expr91801 = frozenset([45])
4865    FOLLOW_45_in_expr91803 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4866    FOLLOW_exprarg_in_expr91807 = frozenset([28, 34])
4867    FOLLOW_34_in_expr91829 = frozenset([29])
4868    FOLLOW_29_in_expr91836 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4869    FOLLOW_exprarg_in_expr91840 = frozenset([28, 34])
4870    FOLLOW_34_in_expr91862 = frozenset([30])
4871    FOLLOW_30_in_expr91869 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4872    FOLLOW_exprarg_in_expr91873 = frozenset([28, 34])
4873    FOLLOW_34_in_expr91888 = frozenset([28])
4874    FOLLOW_name_in_expr91908 = frozenset([45])
4875    FOLLOW_45_in_expr91910 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4876    FOLLOW_exprarg_in_expr91914 = frozenset([28, 34])
4877    FOLLOW_34_in_expr91929 = frozenset([14])
4878    FOLLOW_name_in_expr91938 = frozenset([45])
4879    FOLLOW_45_in_expr91940 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4880    FOLLOW_exprarg_in_expr91944 = frozenset([28, 34])
4881    FOLLOW_34_in_expr91966 = frozenset([29])
4882    FOLLOW_29_in_expr91973 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4883    FOLLOW_exprarg_in_expr91977 = frozenset([28, 34])
4884    FOLLOW_34_in_expr91999 = frozenset([30])
4885    FOLLOW_30_in_expr92006 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4886    FOLLOW_exprarg_in_expr92010 = frozenset([28, 34])
4887    FOLLOW_34_in_expr92025 = frozenset([28])
4888    FOLLOW_28_in_expr92038 = frozenset([1, 27, 37, 49])
4889    FOLLOW_49_in_expr92054 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 42, 49, 55, 57])
4890    FOLLOW_42_in_expr92065 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 50, 55, 57])
4891    FOLLOW_expr1_in_expr92080 = frozenset([50])
4892    FOLLOW_expr1_in_expr92104 = frozenset([42, 50])
4893    FOLLOW_42_in_expr92119 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 50, 55, 57])
4894    FOLLOW_expr1_in_expr92138 = frozenset([50])
4895    FOLLOW_50_in_expr92169 = frozenset([1, 27, 37, 49])
4896    FOLLOW_expr9_in_expr82197 = frozenset([1])
4897    FOLLOW_35_in_expr82208 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4898    FOLLOW_expr8_in_expr82212 = frozenset([1])
4899    FOLLOW_expr8_in_expr72235 = frozenset([1, 25, 29, 38, 39])
4900    FOLLOW_29_in_expr72252 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4901    FOLLOW_38_in_expr72265 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4902    FOLLOW_39_in_expr72278 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4903    FOLLOW_25_in_expr72291 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4904    FOLLOW_expr8_in_expr72305 = frozenset([1, 25, 29, 38, 39])
4905    FOLLOW_expr7_in_expr62333 = frozenset([1, 32, 35])
4906    FOLLOW_32_in_expr62350 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4907    FOLLOW_35_in_expr62363 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4908    FOLLOW_expr7_in_expr62377 = frozenset([1, 32, 35])
4909    FOLLOW_expr6_in_expr52405 = frozenset([1, 24, 43, 44, 46, 47, 48])
4910    FOLLOW_46_in_expr52422 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4911    FOLLOW_24_in_expr52435 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4912    FOLLOW_43_in_expr52448 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4913    FOLLOW_44_in_expr52461 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4914    FOLLOW_47_in_expr52474 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4915    FOLLOW_48_in_expr52487 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4916    FOLLOW_expr6_in_expr52501 = frozenset([1, 24, 43, 44, 46, 47, 48])
4917    FOLLOW_expr5_in_expr42529 = frozenset([1, 54, 55])
4918    FOLLOW_55_in_expr42551 = frozenset([54])
4919    FOLLOW_54_in_expr42564 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4920    FOLLOW_expr5_in_expr42571 = frozenset([1])
4921    FOLLOW_expr4_in_expr32599 = frozenset([1])
4922    FOLLOW_55_in_expr32610 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4923    FOLLOW_expr3_in_expr32614 = frozenset([1])
4924    FOLLOW_expr3_in_expr22638 = frozenset([1, 51])
4925    FOLLOW_51_in_expr22649 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4926    FOLLOW_expr3_in_expr22656 = frozenset([1, 51])
4927    FOLLOW_expr2_in_expr12684 = frozenset([1, 56])
4928    FOLLOW_56_in_expr12695 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4929    FOLLOW_expr2_in_expr12702 = frozenset([1, 56])
4930    FOLLOW_generatorexpression_in_exprarg2726 = frozenset([1])
4931    FOLLOW_expr1_in_exprarg2735 = frozenset([1])
4932    FOLLOW_generatorexpression_in_expression2754 = frozenset([])
4933    FOLLOW_EOF_in_expression2756 = frozenset([1])
4934    FOLLOW_expr1_in_expression2765 = frozenset([])
4935    FOLLOW_EOF_in_expression2767 = frozenset([1])
4936    FOLLOW_nestedname_in_for_2792 = frozenset([54])
4937    FOLLOW_54_in_for_2796 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4938    FOLLOW_expr1_in_for_2802 = frozenset([])
4939    FOLLOW_EOF_in_for_2808 = frozenset([1])
4940    FOLLOW_nestedname_in_statement2829 = frozenset([45])
4941    FOLLOW_45_in_statement2831 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4942    FOLLOW_expr1_in_statement2835 = frozenset([])
4943    FOLLOW_EOF_in_statement2837 = frozenset([1])
4944    FOLLOW_name_in_statement2846 = frozenset([33])
4945    FOLLOW_33_in_statement2848 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4946    FOLLOW_expr1_in_statement2852 = frozenset([])
4947    FOLLOW_EOF_in_statement2854 = frozenset([1])
4948    FOLLOW_name_in_statement2863 = frozenset([36])
4949    FOLLOW_36_in_statement2865 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4950    FOLLOW_expr1_in_statement2869 = frozenset([])
4951    FOLLOW_EOF_in_statement2871 = frozenset([1])
4952    FOLLOW_name_in_statement2880 = frozenset([31])
4953    FOLLOW_31_in_statement2882 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4954    FOLLOW_expr1_in_statement2886 = frozenset([])
4955    FOLLOW_EOF_in_statement2888 = frozenset([1])
4956    FOLLOW_name_in_statement2897 = frozenset([41])
4957    FOLLOW_41_in_statement2899 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4958    FOLLOW_expr1_in_statement2903 = frozenset([])
4959    FOLLOW_EOF_in_statement2905 = frozenset([1])
4960    FOLLOW_name_in_statement2914 = frozenset([40])
4961    FOLLOW_40_in_statement2916 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4962    FOLLOW_expr1_in_statement2920 = frozenset([])
4963    FOLLOW_EOF_in_statement2922 = frozenset([1])
4964    FOLLOW_name_in_statement2931 = frozenset([26])
4965    FOLLOW_26_in_statement2933 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4966    FOLLOW_expr1_in_statement2937 = frozenset([])
4967    FOLLOW_EOF_in_statement2939 = frozenset([1])
4968    FOLLOW_expression_in_statement2948 = frozenset([])
4969    FOLLOW_EOF_in_statement2950 = frozenset([1])
4970    FOLLOW_list_in_synpred19_UL41401 = frozenset([1])
4971    FOLLOW_listcomprehension_in_synpred20_UL41410 = frozenset([1])
4972    FOLLOW_dict_in_synpred21_UL41419 = frozenset([1])
4973    FOLLOW_dictcomprehension_in_synpred22_UL41428 = frozenset([1])
4974    FOLLOW_27_in_synpred23_UL41435 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4975    FOLLOW_generatorexpression_in_synpred23_UL41439 = frozenset([28])
4976    FOLLOW_28_in_synpred23_UL41441 = frozenset([1])
4977    FOLLOW_27_in_synpred25_UL41486 = frozenset([14, 27])
4978    FOLLOW_nestedname_in_synpred25_UL41490 = frozenset([34])
4979    FOLLOW_34_in_synpred25_UL41492 = frozenset([28])
4980    FOLLOW_28_in_synpred25_UL41494 = frozenset([1])
4981    FOLLOW_generatorexpression_in_synpred69_UL42726 = frozenset([1])
4982    FOLLOW_generatorexpression_in_synpred70_UL42754 = frozenset([])
4983    FOLLOW_EOF_in_synpred70_UL42756 = frozenset([1])
4984    FOLLOW_nestedname_in_synpred71_UL42829 = frozenset([45])
4985    FOLLOW_45_in_synpred71_UL42831 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4986    FOLLOW_expr1_in_synpred71_UL42835 = frozenset([])
4987    FOLLOW_EOF_in_synpred71_UL42837 = frozenset([1])
4988    FOLLOW_name_in_synpred72_UL42846 = frozenset([33])
4989    FOLLOW_33_in_synpred72_UL42848 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4990    FOLLOW_expr1_in_synpred72_UL42852 = frozenset([])
4991    FOLLOW_EOF_in_synpred72_UL42854 = frozenset([1])
4992    FOLLOW_name_in_synpred73_UL42863 = frozenset([36])
4993    FOLLOW_36_in_synpred73_UL42865 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4994    FOLLOW_expr1_in_synpred73_UL42869 = frozenset([])
4995    FOLLOW_EOF_in_synpred73_UL42871 = frozenset([1])
4996    FOLLOW_name_in_synpred74_UL42880 = frozenset([31])
4997    FOLLOW_31_in_synpred74_UL42882 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4998    FOLLOW_expr1_in_synpred74_UL42886 = frozenset([])
4999    FOLLOW_EOF_in_synpred74_UL42888 = frozenset([1])
5000    FOLLOW_name_in_synpred75_UL42897 = frozenset([41])
5001    FOLLOW_41_in_synpred75_UL42899 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
5002    FOLLOW_expr1_in_synpred75_UL42903 = frozenset([])
5003    FOLLOW_EOF_in_synpred75_UL42905 = frozenset([1])
5004    FOLLOW_name_in_synpred76_UL42914 = frozenset([40])
5005    FOLLOW_40_in_synpred76_UL42916 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
5006    FOLLOW_expr1_in_synpred76_UL42920 = frozenset([])
5007    FOLLOW_EOF_in_synpred76_UL42922 = frozenset([1])
5008    FOLLOW_name_in_synpred77_UL42931 = frozenset([26])
5009    FOLLOW_26_in_synpred77_UL42933 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
5010    FOLLOW_expr1_in_synpred77_UL42937 = frozenset([])
5011    FOLLOW_EOF_in_synpred77_UL42939 = frozenset([1])
5012
5013
5014
5015def main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
5016    from antlr3.main import ParserMain
5017    main = ParserMain("UL4Lexer", UL4Parser)
5018
5019    main.stdin = stdin
5020    main.stdout = stdout
5021    main.stderr = stderr
5022    main.execute(argv)
5023
5024
5025
5026if __name__ == '__main__':
5027    main(sys.argv)
Note: See TracBrowser for help on using the browser.