root/livinglogic.python.xist/src/ll/UL4Parser.py @ 5312:9a98178e4483

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

Merge UL4 templates and functions again.

Templates call be called as functions. All ouput will be ignored in this case.

Executing templates is now done by interpreting the AST directly (via the eval()
method), instead of generating Python source code from it first.

AST nodes can both produce output and return results via enhanced generators.

Constant folding has been removed.

Line 
1# $ANTLR 3.4 src/ll/UL4.g 2013-02-06 15:18:22
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(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(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(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(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(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(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(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(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.