root/livinglogic.python.xist/src/ll/UL4Parser.py @ 5284:b6f2162b594d

Revision 5284:b6f2162b594d, 136.6 KB (checked in by Walter Doerwald <walter@…>, 7 years ago)

Make UL4 functions (and methods) real objects.

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