root/livinglogic.python.xist/src/ll/UL4Parser.py @ 5331:8564b72915cf

Revision 5331:8564b72915cf, 145.7 KB (checked in by Walter Doerwald <walter@…>, 7 years ago)

Remove ** syntax from UL4 dict literals.

Line 
1# $ANTLR 3.4 src/ll/UL4.g 2013-02-09 21:15:36
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 ;
893    def dictitem(self, ):
894        node = None
895
896
897        k = None
898
899        v = None
900
901
902        try:
903            try:
904                # src/ll/UL4.g:228:2: (k= expr1 ':' v= expr1 )
905                # src/ll/UL4.g:229:3: k= expr1 ':' v= expr1
906                pass 
907                self._state.following.append(self.FOLLOW_expr1_in_dictitem1100)
908                k = self.expr1()
909
910                self._state.following.pop()
911
912                self.match(self.input, 42, self.FOLLOW_42_in_dictitem1104)
913
914                self._state.following.append(self.FOLLOW_expr1_in_dictitem1110)
915                v = self.expr1()
916
917                self._state.following.pop()
918
919                if self._state.backtracking == 0:
920                    pass
921                    node = (k, v) 
922
923
924
925
926
927
928                       
929            except RecognitionException as e:
930                raise
931
932        finally:
933            pass
934        return node
935
936    # $ANTLR end "dictitem"
937
938
939
940    # $ANTLR start "dict"
941    # src/ll/UL4.g:234:1: dict returns [node] : ( '{' '}' | '{' i1= dictitem ( ',' i2= dictitem )* ( ',' )? '}' );
942    def dict(self, ):
943        node = None
944
945
946        i1 = None
947
948        i2 = None
949
950
951        try:
952            try:
953                # src/ll/UL4.g:235:2: ( '{' '}' | '{' i1= dictitem ( ',' i2= dictitem )* ( ',' )? '}' )
954                alt8 = 2
955                LA8_0 = self.input.LA(1)
956
957                if (LA8_0 == 57) :
958                    LA8_1 = self.input.LA(2)
959
960                    if (LA8_1 == 58) :
961                        alt8 = 1
962                    elif ((COLOR <= LA8_1 <= DATE) or (FALSE <= LA8_1 <= FLOAT) or (INT <= LA8_1 <= NONE) or LA8_1 == STRING or LA8_1 == TRUE or LA8_1 == 27 or LA8_1 == 35 or LA8_1 == 49 or LA8_1 == 55 or LA8_1 == 57) :
963                        alt8 = 2
964                    else:
965                        if self._state.backtracking > 0:
966                            raise BacktrackingFailed
967
968
969                        nvae = NoViableAltException("", 8, 1, self.input)
970
971                        raise nvae
972
973
974                else:
975                    if self._state.backtracking > 0:
976                        raise BacktrackingFailed
977
978
979                    nvae = NoViableAltException("", 8, 0, self.input)
980
981                    raise nvae
982
983
984                if alt8 == 1:
985                    # src/ll/UL4.g:236:3: '{' '}'
986                    pass 
987                    self.match(self.input, 57, self.FOLLOW_57_in_dict1129)
988
989                    self.match(self.input, 58, self.FOLLOW_58_in_dict1133)
990
991                    if self._state.backtracking == 0:
992                        pass
993                        node = ul4c.Dict() 
994
995
996
997
998                elif alt8 == 2:
999                    # src/ll/UL4.g:239:3: '{' i1= dictitem ( ',' i2= dictitem )* ( ',' )? '}'
1000                    pass 
1001                    self.match(self.input, 57, self.FOLLOW_57_in_dict1142)
1002
1003                    if self._state.backtracking == 0:
1004                        pass
1005                        node = ul4c.Dict() 
1006
1007
1008
1009                    self._state.following.append(self.FOLLOW_dictitem_in_dict1150)
1010                    i1 = self.dictitem()
1011
1012                    self._state.following.pop()
1013
1014                    if self._state.backtracking == 0:
1015                        pass
1016                        node.items.append(i1) 
1017
1018
1019
1020                    # src/ll/UL4.g:241:3: ( ',' i2= dictitem )*
1021                    while True: #loop6
1022                        alt6 = 2
1023                        LA6_0 = self.input.LA(1)
1024
1025                        if (LA6_0 == 34) :
1026                            LA6_1 = self.input.LA(2)
1027
1028                            if ((COLOR <= LA6_1 <= DATE) or (FALSE <= LA6_1 <= FLOAT) or (INT <= LA6_1 <= NONE) or LA6_1 == STRING or LA6_1 == TRUE or LA6_1 == 27 or LA6_1 == 35 or LA6_1 == 49 or LA6_1 == 55 or LA6_1 == 57) :
1029                                alt6 = 1
1030
1031
1032
1033
1034                        if alt6 == 1:
1035                            # src/ll/UL4.g:242:4: ',' i2= dictitem
1036                            pass 
1037                            self.match(self.input, 34, self.FOLLOW_34_in_dict1161)
1038
1039                            self._state.following.append(self.FOLLOW_dictitem_in_dict1168)
1040                            i2 = self.dictitem()
1041
1042                            self._state.following.pop()
1043
1044                            if self._state.backtracking == 0:
1045                                pass
1046                                node.items.append(i2) 
1047
1048
1049
1050
1051                        else:
1052                            break #loop6
1053
1054
1055                    # src/ll/UL4.g:245:3: ( ',' )?
1056                    alt7 = 2
1057                    LA7_0 = self.input.LA(1)
1058
1059                    if (LA7_0 == 34) :
1060                        alt7 = 1
1061                    if alt7 == 1:
1062                        # src/ll/UL4.g:245:3: ','
1063                        pass 
1064                        self.match(self.input, 34, self.FOLLOW_34_in_dict1179)
1065
1066
1067
1068
1069                    self.match(self.input, 58, self.FOLLOW_58_in_dict1184)
1070
1071
1072
1073                       
1074            except RecognitionException as e:
1075                raise
1076
1077        finally:
1078            pass
1079        return node
1080
1081    # $ANTLR end "dict"
1082
1083
1084
1085    # $ANTLR start "dictcomprehension"
1086    # src/ll/UL4.g:249:1: dictcomprehension returns [node] : '{' key= expr1 ':' value= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? '}' ;
1087    def dictcomprehension(self, ):
1088        node = None
1089
1090
1091        key = None
1092
1093        value = None
1094
1095        n = None
1096
1097        container = None
1098
1099        condition = None
1100
1101
1102         
1103        _condition = None;
1104           
1105        try:
1106            try:
1107                # src/ll/UL4.g:254:2: ( '{' key= expr1 ':' value= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? '}' )
1108                # src/ll/UL4.g:255:3: '{' key= expr1 ':' value= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? '}'
1109                pass 
1110                self.match(self.input, 57, self.FOLLOW_57_in_dictcomprehension1208)
1111
1112                self._state.following.append(self.FOLLOW_expr1_in_dictcomprehension1214)
1113                key = self.expr1()
1114
1115                self._state.following.pop()
1116
1117                self.match(self.input, 42, self.FOLLOW_42_in_dictcomprehension1218)
1118
1119                self._state.following.append(self.FOLLOW_expr1_in_dictcomprehension1224)
1120                value = self.expr1()
1121
1122                self._state.following.pop()
1123
1124                self.match(self.input, 52, self.FOLLOW_52_in_dictcomprehension1228)
1125
1126                self._state.following.append(self.FOLLOW_nestedname_in_dictcomprehension1234)
1127                n = self.nestedname()
1128
1129                self._state.following.pop()
1130
1131                self.match(self.input, 54, self.FOLLOW_54_in_dictcomprehension1238)
1132
1133                self._state.following.append(self.FOLLOW_expr1_in_dictcomprehension1244)
1134                container = self.expr1()
1135
1136                self._state.following.pop()
1137
1138                # src/ll/UL4.g:263:3: ( 'if' condition= expr1 )?
1139                alt9 = 2
1140                LA9_0 = self.input.LA(1)
1141
1142                if (LA9_0 == 53) :
1143                    alt9 = 1
1144                if alt9 == 1:
1145                    # src/ll/UL4.g:264:4: 'if' condition= expr1
1146                    pass 
1147                    self.match(self.input, 53, self.FOLLOW_53_in_dictcomprehension1253)
1148
1149                    self._state.following.append(self.FOLLOW_expr1_in_dictcomprehension1260)
1150                    condition = self.expr1()
1151
1152                    self._state.following.pop()
1153
1154                    if self._state.backtracking == 0:
1155                        pass
1156                        _condition = condition; 
1157
1158
1159
1160
1161
1162
1163                self.match(self.input, 58, self.FOLLOW_58_in_dictcomprehension1271)
1164
1165                if self._state.backtracking == 0:
1166                    pass
1167                    node = ul4c.DictComp(key, value, n, container, _condition) 
1168
1169
1170
1171
1172
1173
1174                       
1175            except RecognitionException as e:
1176                raise
1177
1178        finally:
1179            pass
1180        return node
1181
1182    # $ANTLR end "dictcomprehension"
1183
1184
1185
1186    # $ANTLR start "generatorexpression"
1187    # src/ll/UL4.g:270:1: generatorexpression returns [node] : item= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? ;
1188    def generatorexpression(self, ):
1189        node = None
1190
1191
1192        item = None
1193
1194        n = None
1195
1196        container = None
1197
1198        condition = None
1199
1200
1201         
1202        _condition = None;
1203           
1204        try:
1205            try:
1206                # src/ll/UL4.g:275:2: (item= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )? )
1207                # src/ll/UL4.g:276:3: item= expr1 'for' n= nestedname 'in' container= expr1 ( 'if' condition= expr1 )?
1208                pass 
1209                self._state.following.append(self.FOLLOW_expr1_in_generatorexpression1299)
1210                item = self.expr1()
1211
1212                self._state.following.pop()
1213
1214                self.match(self.input, 52, self.FOLLOW_52_in_generatorexpression1303)
1215
1216                self._state.following.append(self.FOLLOW_nestedname_in_generatorexpression1309)
1217                n = self.nestedname()
1218
1219                self._state.following.pop()
1220
1221                self.match(self.input, 54, self.FOLLOW_54_in_generatorexpression1313)
1222
1223                self._state.following.append(self.FOLLOW_expr1_in_generatorexpression1319)
1224                container = self.expr1()
1225
1226                self._state.following.pop()
1227
1228                # src/ll/UL4.g:281:3: ( 'if' condition= expr1 )?
1229                alt10 = 2
1230                LA10_0 = self.input.LA(1)
1231
1232                if (LA10_0 == 53) :
1233                    alt10 = 1
1234                if alt10 == 1:
1235                    # src/ll/UL4.g:282:4: 'if' condition= expr1
1236                    pass 
1237                    self.match(self.input, 53, self.FOLLOW_53_in_generatorexpression1328)
1238
1239                    self._state.following.append(self.FOLLOW_expr1_in_generatorexpression1335)
1240                    condition = self.expr1()
1241
1242                    self._state.following.pop()
1243
1244                    if self._state.backtracking == 0:
1245                        pass
1246                        _condition = condition; 
1247
1248
1249
1250
1251
1252
1253                if self._state.backtracking == 0:
1254                    pass
1255                    node = ul4c.GenExpr(item, n, container, _condition) 
1256
1257
1258
1259
1260
1261
1262                       
1263            except RecognitionException as e:
1264                raise
1265
1266        finally:
1267            pass
1268        return node
1269
1270    # $ANTLR end "generatorexpression"
1271
1272
1273
1274    # $ANTLR start "atom"
1275    # src/ll/UL4.g:287: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 ')' );
1276    def atom(self, ):
1277        node = None
1278
1279
1280        e_literal = None
1281
1282        e_list = None
1283
1284        e_listcomp = None
1285
1286        e_dict = None
1287
1288        e_dictcomp = None
1289
1290        e_genexpr = None
1291
1292        e_bracket = None
1293
1294
1295        try:
1296            try:
1297                # src/ll/UL4.g:288:2: (e_literal= literal |e_list= list |e_listcomp= listcomprehension |e_dict= dict |e_dictcomp= dictcomprehension | '(' e_genexpr= generatorexpression ')' | '(' e_bracket= expr1 ')' )
1298                alt11 = 7
1299                LA11 = self.input.LA(1)
1300                if LA11 == COLOR or LA11 == DATE or LA11 == FALSE or LA11 == FLOAT or LA11 == INT or LA11 == NAME or LA11 == NONE or LA11 == STRING or LA11 == TRUE:
1301                    alt11 = 1
1302                elif LA11 == 49:
1303                    LA11_10 = self.input.LA(2)
1304
1305                    if (self.synpred19_UL4()) :
1306                        alt11 = 2
1307                    elif (self.synpred20_UL4()) :
1308                        alt11 = 3
1309                    else:
1310                        if self._state.backtracking > 0:
1311                            raise BacktrackingFailed
1312
1313
1314                        nvae = NoViableAltException("", 11, 10, self.input)
1315
1316                        raise nvae
1317
1318
1319                elif LA11 == 57:
1320                    LA11_11 = self.input.LA(2)
1321
1322                    if (self.synpred21_UL4()) :
1323                        alt11 = 4
1324                    elif (self.synpred22_UL4()) :
1325                        alt11 = 5
1326                    else:
1327                        if self._state.backtracking > 0:
1328                            raise BacktrackingFailed
1329
1330
1331                        nvae = NoViableAltException("", 11, 11, self.input)
1332
1333                        raise nvae
1334
1335
1336                elif LA11 == 27:
1337                    LA11_12 = self.input.LA(2)
1338
1339                    if (self.synpred23_UL4()) :
1340                        alt11 = 6
1341                    elif (True) :
1342                        alt11 = 7
1343                    else:
1344                        if self._state.backtracking > 0:
1345                            raise BacktrackingFailed
1346
1347
1348                        nvae = NoViableAltException("", 11, 12, self.input)
1349
1350                        raise nvae
1351
1352
1353                else:
1354                    if self._state.backtracking > 0:
1355                        raise BacktrackingFailed
1356
1357
1358                    nvae = NoViableAltException("", 11, 0, self.input)
1359
1360                    raise nvae
1361
1362
1363                if alt11 == 1:
1364                    # src/ll/UL4.g:288:4: e_literal= literal
1365                    pass 
1366                    self._state.following.append(self.FOLLOW_literal_in_atom1361)
1367                    e_literal = self.literal()
1368
1369                    self._state.following.pop()
1370
1371                    if self._state.backtracking == 0:
1372                        pass
1373                        node =  e_literal
1374
1375
1376
1377
1378                elif alt11 == 2:
1379                    # src/ll/UL4.g:289:4: e_list= list
1380                    pass 
1381                    self._state.following.append(self.FOLLOW_list_in_atom1370)
1382                    e_list = self.list()
1383
1384                    self._state.following.pop()
1385
1386                    if self._state.backtracking == 0:
1387                        pass
1388                        node =  e_list
1389
1390
1391
1392
1393                elif alt11 == 3:
1394                    # src/ll/UL4.g:290:4: e_listcomp= listcomprehension
1395                    pass 
1396                    self._state.following.append(self.FOLLOW_listcomprehension_in_atom1379)
1397                    e_listcomp = self.listcomprehension()
1398
1399                    self._state.following.pop()
1400
1401                    if self._state.backtracking == 0:
1402                        pass
1403                        node =  e_listcomp
1404
1405
1406
1407
1408                elif alt11 == 4:
1409                    # src/ll/UL4.g:291:4: e_dict= dict
1410                    pass 
1411                    self._state.following.append(self.FOLLOW_dict_in_atom1388)
1412                    e_dict = self.dict()
1413
1414                    self._state.following.pop()
1415
1416                    if self._state.backtracking == 0:
1417                        pass
1418                        node =  e_dict
1419
1420
1421
1422
1423                elif alt11 == 5:
1424                    # src/ll/UL4.g:292:4: e_dictcomp= dictcomprehension
1425                    pass 
1426                    self._state.following.append(self.FOLLOW_dictcomprehension_in_atom1397)
1427                    e_dictcomp = self.dictcomprehension()
1428
1429                    self._state.following.pop()
1430
1431                    if self._state.backtracking == 0:
1432                        pass
1433                        node =  e_dictcomp
1434
1435
1436
1437
1438                elif alt11 == 6:
1439                    # src/ll/UL4.g:293:4: '(' e_genexpr= generatorexpression ')'
1440                    pass 
1441                    self.match(self.input, 27, self.FOLLOW_27_in_atom1404)
1442
1443                    self._state.following.append(self.FOLLOW_generatorexpression_in_atom1408)
1444                    e_genexpr = self.generatorexpression()
1445
1446                    self._state.following.pop()
1447
1448                    self.match(self.input, 28, self.FOLLOW_28_in_atom1410)
1449
1450                    if self._state.backtracking == 0:
1451                        pass
1452                        node =  e_genexpr
1453
1454
1455
1456
1457                elif alt11 == 7:
1458                    # src/ll/UL4.g:294:4: '(' e_bracket= expr1 ')'
1459                    pass 
1460                    self.match(self.input, 27, self.FOLLOW_27_in_atom1417)
1461
1462                    self._state.following.append(self.FOLLOW_expr1_in_atom1421)
1463                    e_bracket = self.expr1()
1464
1465                    self._state.following.pop()
1466
1467                    self.match(self.input, 28, self.FOLLOW_28_in_atom1423)
1468
1469                    if self._state.backtracking == 0:
1470                        pass
1471                        node =  e_bracket
1472
1473
1474
1475
1476
1477                       
1478            except RecognitionException as e:
1479                raise
1480
1481        finally:
1482            pass
1483        return node
1484
1485    # $ANTLR end "atom"
1486
1487
1488
1489    # $ANTLR start "nestedname"
1490    # src/ll/UL4.g:298:1: nestedname returns [varname] : (n= name | '(' n0= nestedname ',' ')' | '(' n1= nestedname ',' n2= nestedname ( ',' n3= nestedname )* ( ',' )? ')' );
1491    def nestedname(self, ):
1492        varname = None
1493
1494
1495        n = None
1496
1497        n0 = None
1498
1499        n1 = None
1500
1501        n2 = None
1502
1503        n3 = None
1504
1505
1506        try:
1507            try:
1508                # src/ll/UL4.g:299:2: (n= name | '(' n0= nestedname ',' ')' | '(' n1= nestedname ',' n2= nestedname ( ',' n3= nestedname )* ( ',' )? ')' )
1509                alt14 = 3
1510                LA14_0 = self.input.LA(1)
1511
1512                if (LA14_0 == NAME) :
1513                    alt14 = 1
1514                elif (LA14_0 == 27) :
1515                    LA14_2 = self.input.LA(2)
1516
1517                    if (self.synpred25_UL4()) :
1518                        alt14 = 2
1519                    elif (True) :
1520                        alt14 = 3
1521                    else:
1522                        if self._state.backtracking > 0:
1523                            raise BacktrackingFailed
1524
1525
1526                        nvae = NoViableAltException("", 14, 2, self.input)
1527
1528                        raise nvae
1529
1530
1531                else:
1532                    if self._state.backtracking > 0:
1533                        raise BacktrackingFailed
1534
1535
1536                    nvae = NoViableAltException("", 14, 0, self.input)
1537
1538                    raise nvae
1539
1540
1541                if alt14 == 1:
1542                    # src/ll/UL4.g:300:3: n= name
1543                    pass 
1544                    self._state.following.append(self.FOLLOW_name_in_nestedname1446)
1545                    n = self.name()
1546
1547                    self._state.following.pop()
1548
1549                    if self._state.backtracking == 0:
1550                        pass
1551                        varname =  ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0] 
1552
1553
1554
1555
1556                elif alt14 == 2:
1557                    # src/ll/UL4.g:302:3: '(' n0= nestedname ',' ')'
1558                    pass 
1559                    self.match(self.input, 27, self.FOLLOW_27_in_nestedname1455)
1560
1561                    self._state.following.append(self.FOLLOW_nestedname_in_nestedname1459)
1562                    n0 = self.nestedname()
1563
1564                    self._state.following.pop()
1565
1566                    self.match(self.input, 34, self.FOLLOW_34_in_nestedname1461)
1567
1568                    self.match(self.input, 28, self.FOLLOW_28_in_nestedname1463)
1569
1570                    if self._state.backtracking == 0:
1571                        pass
1572                        varname = (n0,) 
1573
1574
1575
1576
1577                elif alt14 == 3:
1578                    # src/ll/UL4.g:304:3: '(' n1= nestedname ',' n2= nestedname ( ',' n3= nestedname )* ( ',' )? ')'
1579                    pass 
1580                    self.match(self.input, 27, self.FOLLOW_27_in_nestedname1472)
1581
1582                    self._state.following.append(self.FOLLOW_nestedname_in_nestedname1478)
1583                    n1 = self.nestedname()
1584
1585                    self._state.following.pop()
1586
1587                    self.match(self.input, 34, self.FOLLOW_34_in_nestedname1482)
1588
1589                    self._state.following.append(self.FOLLOW_nestedname_in_nestedname1488)
1590                    n2 = self.nestedname()
1591
1592                    self._state.following.pop()
1593
1594                    if self._state.backtracking == 0:
1595                        pass
1596                        varname = (n1, n2) 
1597
1598
1599
1600                    # src/ll/UL4.g:308:3: ( ',' n3= nestedname )*
1601                    while True: #loop12
1602                        alt12 = 2
1603                        LA12_0 = self.input.LA(1)
1604
1605                        if (LA12_0 == 34) :
1606                            LA12_1 = self.input.LA(2)
1607
1608                            if (LA12_1 == NAME or LA12_1 == 27) :
1609                                alt12 = 1
1610
1611
1612
1613
1614                        if alt12 == 1:
1615                            # src/ll/UL4.g:309:4: ',' n3= nestedname
1616                            pass 
1617                            self.match(self.input, 34, self.FOLLOW_34_in_nestedname1499)
1618
1619                            self._state.following.append(self.FOLLOW_nestedname_in_nestedname1506)
1620                            n3 = self.nestedname()
1621
1622                            self._state.following.pop()
1623
1624                            if self._state.backtracking == 0:
1625                                pass
1626                                varname += (n3,) 
1627
1628
1629
1630
1631                        else:
1632                            break #loop12
1633
1634
1635                    # src/ll/UL4.g:312:3: ( ',' )?
1636                    alt13 = 2
1637                    LA13_0 = self.input.LA(1)
1638
1639                    if (LA13_0 == 34) :
1640                        alt13 = 1
1641                    if alt13 == 1:
1642                        # src/ll/UL4.g:312:3: ','
1643                        pass 
1644                        self.match(self.input, 34, self.FOLLOW_34_in_nestedname1517)
1645
1646
1647
1648
1649                    self.match(self.input, 28, self.FOLLOW_28_in_nestedname1522)
1650
1651
1652
1653                       
1654            except RecognitionException as e:
1655                raise
1656
1657        finally:
1658            pass
1659        return varname
1660
1661    # $ANTLR end "nestedname"
1662
1663
1664
1665    # $ANTLR start "expr9"
1666    # src/ll/UL4.g:317: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 )? )? ) ']' )* ;
1667    def expr9(self, ):
1668        node = None
1669
1670
1671        e1 = None
1672
1673        n = None
1674
1675        rkwargs = None
1676
1677        rargs = None
1678
1679        a1 = None
1680
1681        a2 = None
1682
1683        an3 = None
1684
1685        av3 = None
1686
1687        an1 = None
1688
1689        av1 = None
1690
1691        an2 = None
1692
1693        av2 = None
1694
1695        e2 = None
1696
1697        e3 = None
1698
1699
1700         
1701        callmeth = False
1702        index1 = None
1703        index2 = None
1704        slice = False
1705           
1706        try:
1707            try:
1708                # src/ll/UL4.g:325: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 )? )? ) ']' )* )
1709                # src/ll/UL4.g:326: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 )? )? ) ']' )*
1710                pass 
1711                self._state.following.append(self.FOLLOW_atom_in_expr91551)
1712                e1 = self.atom()
1713
1714                self._state.following.pop()
1715
1716                if self._state.backtracking == 0:
1717                    pass
1718                    node =  e1
1719
1720
1721
1722                # src/ll/UL4.g:327: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 )? )? ) ']' )*
1723                while True: #loop32
1724                    alt32 = 4
1725                    LA32 = self.input.LA(1)
1726                    if LA32 == 37:
1727                        alt32 = 1
1728                    elif LA32 == 27:
1729                        alt32 = 2
1730                    elif LA32 == 49:
1731                        alt32 = 3
1732
1733                    if alt32 == 1:
1734                        # src/ll/UL4.g:329:4: '.' n= name
1735                        pass 
1736                        self.match(self.input, 37, self.FOLLOW_37_in_expr91567)
1737
1738                        self._state.following.append(self.FOLLOW_name_in_expr91574)
1739                        n = self.name()
1740
1741                        self._state.following.pop()
1742
1743                        if self._state.backtracking == 0:
1744                            pass
1745                            node = ul4c.GetAttr(node, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0]) 
1746
1747
1748
1749
1750                    elif alt32 == 2:
1751                        # src/ll/UL4.g:333: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 )? ( ',' )? ) ')'
1752                        pass 
1753                        self.match(self.input, 27, self.FOLLOW_27_in_expr91590)
1754
1755                        if self._state.backtracking == 0:
1756                            pass
1757                            node = ul4c.CallMeth(node.obj, node.attrname) if isinstance(node, ul4c.GetAttr) else ul4c.CallFunc(node) 
1758
1759
1760
1761                        # src/ll/UL4.g:334: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 )? ( ',' )? )
1762                        alt27 = 5
1763                        LA27 = self.input.LA(1)
1764                        if LA27 == 28:
1765                            alt27 = 1
1766                        elif LA27 == 30:
1767                            alt27 = 2
1768                        elif LA27 == 29:
1769                            alt27 = 3
1770                        elif LA27 == COLOR or LA27 == DATE or LA27 == FALSE or LA27 == FLOAT or LA27 == INT or LA27 == NONE or LA27 == STRING or LA27 == TRUE or LA27 == 27 or LA27 == 35 or LA27 == 49 or LA27 == 55 or LA27 == 57:
1771                            alt27 = 4
1772                        elif LA27 == NAME:
1773                            LA27_5 = self.input.LA(2)
1774
1775                            if ((24 <= LA27_5 <= 25) or (27 <= LA27_5 <= 29) or LA27_5 == 32 or (34 <= LA27_5 <= 35) or (37 <= LA27_5 <= 39) or (43 <= LA27_5 <= 44) or (46 <= LA27_5 <= 49) or (51 <= LA27_5 <= 52) or (54 <= LA27_5 <= 56)) :
1776                                alt27 = 4
1777                            elif (LA27_5 == 45) :
1778                                alt27 = 5
1779                            else:
1780                                if self._state.backtracking > 0:
1781                                    raise BacktrackingFailed
1782
1783
1784                                nvae = NoViableAltException("", 27, 5, self.input)
1785
1786                                raise nvae
1787
1788
1789                        else:
1790                            if self._state.backtracking > 0:
1791                                raise BacktrackingFailed
1792
1793
1794                            nvae = NoViableAltException("", 27, 0, self.input)
1795
1796                            raise nvae
1797
1798
1799                        if alt27 == 1:
1800                            # src/ll/UL4.g:336:4:
1801                            pass 
1802
1803                        elif alt27 == 2:
1804                            # src/ll/UL4.g:338:5: '**' rkwargs= exprarg ( ',' )?
1805                            pass 
1806                            self.match(self.input, 30, self.FOLLOW_30_in_expr91620)
1807
1808                            self._state.following.append(self.FOLLOW_exprarg_in_expr91624)
1809                            rkwargs = self.exprarg()
1810
1811                            self._state.following.pop()
1812
1813                            if self._state.backtracking == 0:
1814                                pass
1815                                node.remkwargs = rkwargs; 
1816
1817
1818
1819                            # src/ll/UL4.g:339:5: ( ',' )?
1820                            alt15 = 2
1821                            LA15_0 = self.input.LA(1)
1822
1823                            if (LA15_0 == 34) :
1824                                alt15 = 1
1825                            if alt15 == 1:
1826                                # src/ll/UL4.g:339:5: ','
1827                                pass 
1828                                self.match(self.input, 34, self.FOLLOW_34_in_expr91632)
1829
1830
1831
1832
1833
1834                        elif alt27 == 3:
1835                            # src/ll/UL4.g:342:5: '*' rargs= exprarg ( ',' '**' rkwargs= exprarg )? ( ',' )?
1836                            pass 
1837                            self.match(self.input, 29, self.FOLLOW_29_in_expr91650)
1838
1839                            self._state.following.append(self.FOLLOW_exprarg_in_expr91654)
1840                            rargs = self.exprarg()
1841
1842                            self._state.following.pop()
1843
1844                            if self._state.backtracking == 0:
1845                                pass
1846                                node.remargs = rargs; 
1847
1848
1849
1850                            # src/ll/UL4.g:343:5: ( ',' '**' rkwargs= exprarg )?
1851                            alt16 = 2
1852                            LA16_0 = self.input.LA(1)
1853
1854                            if (LA16_0 == 34) :
1855                                LA16_1 = self.input.LA(2)
1856
1857                                if (LA16_1 == 30) :
1858                                    alt16 = 1
1859                            if alt16 == 1:
1860                                # src/ll/UL4.g:344:6: ',' '**' rkwargs= exprarg
1861                                pass 
1862                                self.match(self.input, 34, self.FOLLOW_34_in_expr91669)
1863
1864                                self.match(self.input, 30, self.FOLLOW_30_in_expr91676)
1865
1866                                self._state.following.append(self.FOLLOW_exprarg_in_expr91680)
1867                                rkwargs = self.exprarg()
1868
1869                                self._state.following.pop()
1870
1871                                if self._state.backtracking == 0:
1872                                    pass
1873                                    node.remkwargs = rkwargs; 
1874
1875
1876
1877
1878
1879
1880                            # src/ll/UL4.g:347:5: ( ',' )?
1881                            alt17 = 2
1882                            LA17_0 = self.input.LA(1)
1883
1884                            if (LA17_0 == 34) :
1885                                alt17 = 1
1886                            if alt17 == 1:
1887                                # src/ll/UL4.g:347:5: ','
1888                                pass 
1889                                self.match(self.input, 34, self.FOLLOW_34_in_expr91695)
1890
1891
1892
1893
1894
1895                        elif alt27 == 4:
1896                            # src/ll/UL4.g:350:5: a1= exprarg ( ',' a2= exprarg )* ( ',' an3= name '=' av3= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )?
1897                            pass 
1898                            self._state.following.append(self.FOLLOW_exprarg_in_expr91715)
1899                            a1 = self.exprarg()
1900
1901                            self._state.following.pop()
1902
1903                            if self._state.backtracking == 0:
1904                                pass
1905                                node.args.append(a1) 
1906
1907
1908
1909                            # src/ll/UL4.g:351:5: ( ',' a2= exprarg )*
1910                            while True: #loop18
1911                                alt18 = 2
1912                                LA18_0 = self.input.LA(1)
1913
1914                                if (LA18_0 == 34) :
1915                                    LA18_1 = self.input.LA(2)
1916
1917                                    if (LA18_1 == NAME) :
1918                                        LA18_3 = self.input.LA(3)
1919
1920                                        if ((24 <= LA18_3 <= 25) or (27 <= LA18_3 <= 29) or LA18_3 == 32 or (34 <= LA18_3 <= 35) or (37 <= LA18_3 <= 39) or (43 <= LA18_3 <= 44) or (46 <= LA18_3 <= 49) or (51 <= LA18_3 <= 52) or (54 <= LA18_3 <= 56)) :
1921                                            alt18 = 1
1922
1923
1924                                    elif ((COLOR <= LA18_1 <= DATE) or (FALSE <= LA18_1 <= FLOAT) or LA18_1 == INT or LA18_1 == NONE or LA18_1 == STRING or LA18_1 == TRUE or LA18_1 == 27 or LA18_1 == 35 or LA18_1 == 49 or LA18_1 == 55 or LA18_1 == 57) :
1925                                        alt18 = 1
1926
1927
1928
1929
1930                                if alt18 == 1:
1931                                    # src/ll/UL4.g:352:6: ',' a2= exprarg
1932                                    pass 
1933                                    self.match(self.input, 34, self.FOLLOW_34_in_expr91730)
1934
1935                                    self._state.following.append(self.FOLLOW_exprarg_in_expr91739)
1936                                    a2 = self.exprarg()
1937
1938                                    self._state.following.pop()
1939
1940                                    if self._state.backtracking == 0:
1941                                        pass
1942                                        node.args.append(a2) 
1943
1944
1945
1946
1947                                else:
1948                                    break #loop18
1949
1950
1951                            # src/ll/UL4.g:355:5: ( ',' an3= name '=' av3= exprarg )*
1952                            while True: #loop19
1953                                alt19 = 2
1954                                LA19_0 = self.input.LA(1)
1955
1956                                if (LA19_0 == 34) :
1957                                    LA19_1 = self.input.LA(2)
1958
1959                                    if (LA19_1 == NAME) :
1960                                        alt19 = 1
1961
1962
1963
1964
1965                                if alt19 == 1:
1966                                    # src/ll/UL4.g:356:6: ',' an3= name '=' av3= exprarg
1967                                    pass 
1968                                    self.match(self.input, 34, self.FOLLOW_34_in_expr91761)
1969
1970                                    self._state.following.append(self.FOLLOW_name_in_expr91770)
1971                                    an3 = self.name()
1972
1973                                    self._state.following.pop()
1974
1975                                    self.match(self.input, 45, self.FOLLOW_45_in_expr91772)
1976
1977                                    self._state.following.append(self.FOLLOW_exprarg_in_expr91776)
1978                                    av3 = self.exprarg()
1979
1980                                    self._state.following.pop()
1981
1982                                    if self._state.backtracking == 0:
1983                                        pass
1984                                        node.kwargs.append((((an3 is not None) and [self.input.toString(an3.start,an3.stop)] or [None])[0], av3)) 
1985
1986
1987
1988
1989                                else:
1990                                    break #loop19
1991
1992
1993                            # src/ll/UL4.g:359:5: ( ',' '*' rargs= exprarg )?
1994                            alt20 = 2
1995                            LA20_0 = self.input.LA(1)
1996
1997                            if (LA20_0 == 34) :
1998                                LA20_1 = self.input.LA(2)
1999
2000                                if (LA20_1 == 29) :
2001                                    alt20 = 1
2002                            if alt20 == 1:
2003                                # src/ll/UL4.g:360:6: ',' '*' rargs= exprarg
2004                                pass 
2005                                self.match(self.input, 34, self.FOLLOW_34_in_expr91798)
2006
2007                                self.match(self.input, 29, self.FOLLOW_29_in_expr91805)
2008
2009                                self._state.following.append(self.FOLLOW_exprarg_in_expr91809)
2010                                rargs = self.exprarg()
2011
2012                                self._state.following.pop()
2013
2014                                if self._state.backtracking == 0:
2015                                    pass
2016                                    node.remargs = rargs; 
2017
2018
2019
2020
2021
2022
2023                            # src/ll/UL4.g:363:5: ( ',' '**' rkwargs= exprarg )?
2024                            alt21 = 2
2025                            LA21_0 = self.input.LA(1)
2026
2027                            if (LA21_0 == 34) :
2028                                LA21_1 = self.input.LA(2)
2029
2030                                if (LA21_1 == 30) :
2031                                    alt21 = 1
2032                            if alt21 == 1:
2033                                # src/ll/UL4.g:364:6: ',' '**' rkwargs= exprarg
2034                                pass 
2035                                self.match(self.input, 34, self.FOLLOW_34_in_expr91831)
2036
2037                                self.match(self.input, 30, self.FOLLOW_30_in_expr91838)
2038
2039                                self._state.following.append(self.FOLLOW_exprarg_in_expr91842)
2040                                rkwargs = self.exprarg()
2041
2042                                self._state.following.pop()
2043
2044                                if self._state.backtracking == 0:
2045                                    pass
2046                                    node.remkwargs = rkwargs; 
2047
2048
2049
2050
2051
2052
2053                            # src/ll/UL4.g:367:5: ( ',' )?
2054                            alt22 = 2
2055                            LA22_0 = self.input.LA(1)
2056
2057                            if (LA22_0 == 34) :
2058                                alt22 = 1
2059                            if alt22 == 1:
2060                                # src/ll/UL4.g:367:5: ','
2061                                pass 
2062                                self.match(self.input, 34, self.FOLLOW_34_in_expr91857)
2063
2064
2065
2066
2067
2068                        elif alt27 == 5:
2069                            # src/ll/UL4.g:370:5: an1= name '=' av1= exprarg ( ',' an2= name '=' av2= exprarg )* ( ',' '*' rargs= exprarg )? ( ',' '**' rkwargs= exprarg )? ( ',' )?
2070                            pass 
2071                            self._state.following.append(self.FOLLOW_name_in_expr91877)
2072                            an1 = self.name()
2073
2074                            self._state.following.pop()
2075
2076                            self.match(self.input, 45, self.FOLLOW_45_in_expr91879)
2077
2078                            self._state.following.append(self.FOLLOW_exprarg_in_expr91883)
2079                            av1 = self.exprarg()
2080
2081                            self._state.following.pop()
2082
2083                            if self._state.backtracking == 0:
2084                                pass
2085                                node.kwargs.append((((an1 is not None) and [self.input.toString(an1.start,an1.stop)] or [None])[0], av1)) 
2086
2087
2088
2089                            # src/ll/UL4.g:371:5: ( ',' an2= name '=' av2= exprarg )*
2090                            while True: #loop23
2091                                alt23 = 2
2092                                LA23_0 = self.input.LA(1)
2093
2094                                if (LA23_0 == 34) :
2095                                    LA23_1 = self.input.LA(2)
2096
2097                                    if (LA23_1 == NAME) :
2098                                        alt23 = 1
2099
2100
2101
2102
2103                                if alt23 == 1:
2104                                    # src/ll/UL4.g:372:6: ',' an2= name '=' av2= exprarg
2105                                    pass 
2106                                    self.match(self.input, 34, self.FOLLOW_34_in_expr91898)
2107
2108                                    self._state.following.append(self.FOLLOW_name_in_expr91907)
2109                                    an2 = self.name()
2110
2111                                    self._state.following.pop()
2112
2113                                    self.match(self.input, 45, self.FOLLOW_45_in_expr91909)
2114
2115                                    self._state.following.append(self.FOLLOW_exprarg_in_expr91913)
2116                                    av2 = self.exprarg()
2117
2118                                    self._state.following.pop()
2119
2120                                    if self._state.backtracking == 0:
2121                                        pass
2122                                        node.kwargs.append((((an2 is not None) and [self.input.toString(an2.start,an2.stop)] or [None])[0], av2)) 
2123
2124
2125
2126
2127                                else:
2128                                    break #loop23
2129
2130
2131                            # src/ll/UL4.g:375:5: ( ',' '*' rargs= exprarg )?
2132                            alt24 = 2
2133                            LA24_0 = self.input.LA(1)
2134
2135                            if (LA24_0 == 34) :
2136                                LA24_1 = self.input.LA(2)
2137
2138                                if (LA24_1 == 29) :
2139                                    alt24 = 1
2140                            if alt24 == 1:
2141                                # src/ll/UL4.g:376:6: ',' '*' rargs= exprarg
2142                                pass 
2143                                self.match(self.input, 34, self.FOLLOW_34_in_expr91935)
2144
2145                                self.match(self.input, 29, self.FOLLOW_29_in_expr91942)
2146
2147                                self._state.following.append(self.FOLLOW_exprarg_in_expr91946)
2148                                rargs = self.exprarg()
2149
2150                                self._state.following.pop()
2151
2152                                if self._state.backtracking == 0:
2153                                    pass
2154                                    node.remargs = rargs; 
2155
2156
2157
2158
2159
2160
2161                            # src/ll/UL4.g:379:5: ( ',' '**' rkwargs= exprarg )?
2162                            alt25 = 2
2163                            LA25_0 = self.input.LA(1)
2164
2165                            if (LA25_0 == 34) :
2166                                LA25_1 = self.input.LA(2)
2167
2168                                if (LA25_1 == 30) :
2169                                    alt25 = 1
2170                            if alt25 == 1:
2171                                # src/ll/UL4.g:380:6: ',' '**' rkwargs= exprarg
2172                                pass 
2173                                self.match(self.input, 34, self.FOLLOW_34_in_expr91968)
2174
2175                                self.match(self.input, 30, self.FOLLOW_30_in_expr91975)
2176
2177                                self._state.following.append(self.FOLLOW_exprarg_in_expr91979)
2178                                rkwargs = self.exprarg()
2179
2180                                self._state.following.pop()
2181
2182                                if self._state.backtracking == 0:
2183                                    pass
2184                                    node.remkwargs = rkwargs; 
2185
2186
2187
2188
2189
2190
2191                            # src/ll/UL4.g:383:5: ( ',' )?
2192                            alt26 = 2
2193                            LA26_0 = self.input.LA(1)
2194
2195                            if (LA26_0 == 34) :
2196                                alt26 = 1
2197                            if alt26 == 1:
2198                                # src/ll/UL4.g:383:5: ','
2199                                pass 
2200                                self.match(self.input, 34, self.FOLLOW_34_in_expr91994)
2201
2202
2203
2204
2205
2206
2207
2208                        self.match(self.input, 28, self.FOLLOW_28_in_expr92005)
2209
2210
2211                    elif alt32 == 3:
2212                        # src/ll/UL4.g:388:4: '[' ( ':' (e2= expr1 )? |e2= expr1 ( ':' (e3= expr1 )? )? ) ']'
2213                        pass 
2214                        self.match(self.input, 49, self.FOLLOW_49_in_expr92019)
2215
2216                        # src/ll/UL4.g:389:4: ( ':' (e2= expr1 )? |e2= expr1 ( ':' (e3= expr1 )? )? )
2217                        alt31 = 2
2218                        LA31_0 = self.input.LA(1)
2219
2220                        if (LA31_0 == 42) :
2221                            alt31 = 1
2222                        elif ((COLOR <= LA31_0 <= DATE) or (FALSE <= LA31_0 <= FLOAT) or (INT <= LA31_0 <= NONE) or LA31_0 == STRING or LA31_0 == TRUE or LA31_0 == 27 or LA31_0 == 35 or LA31_0 == 49 or LA31_0 == 55 or LA31_0 == 57) :
2223                            alt31 = 2
2224                        else:
2225                            if self._state.backtracking > 0:
2226                                raise BacktrackingFailed
2227
2228
2229                            nvae = NoViableAltException("", 31, 0, self.input)
2230
2231                            raise nvae
2232
2233
2234                        if alt31 == 1:
2235                            # src/ll/UL4.g:390:5: ':' (e2= expr1 )?
2236                            pass 
2237                            self.match(self.input, 42, self.FOLLOW_42_in_expr92030)
2238
2239                            # src/ll/UL4.g:391:5: (e2= expr1 )?
2240                            alt28 = 2
2241                            LA28_0 = self.input.LA(1)
2242
2243                            if ((COLOR <= LA28_0 <= DATE) or (FALSE <= LA28_0 <= FLOAT) or (INT <= LA28_0 <= NONE) or LA28_0 == STRING or LA28_0 == TRUE or LA28_0 == 27 or LA28_0 == 35 or LA28_0 == 49 or LA28_0 == 55 or LA28_0 == 57) :
2244                                alt28 = 1
2245                            if alt28 == 1:
2246                                # src/ll/UL4.g:392:6: e2= expr1
2247                                pass 
2248                                self._state.following.append(self.FOLLOW_expr1_in_expr92045)
2249                                e2 = self.expr1()
2250
2251                                self._state.following.pop()
2252
2253                                if self._state.backtracking == 0:
2254                                    pass
2255                                    index2 = e2; 
2256
2257
2258
2259
2260
2261
2262                            if self._state.backtracking == 0:
2263                                pass
2264                                node = ul4c.GetSlice(node, None, index2) 
2265
2266
2267
2268
2269                        elif alt31 == 2:
2270                            # src/ll/UL4.g:395:5: e2= expr1 ( ':' (e3= expr1 )? )?
2271                            pass 
2272                            self._state.following.append(self.FOLLOW_expr1_in_expr92069)
2273                            e2 = self.expr1()
2274
2275                            self._state.following.pop()
2276
2277                            if self._state.backtracking == 0:
2278                                pass
2279                                index1 = e2; 
2280
2281
2282
2283                            # src/ll/UL4.g:396:5: ( ':' (e3= expr1 )? )?
2284                            alt30 = 2
2285                            LA30_0 = self.input.LA(1)
2286
2287                            if (LA30_0 == 42) :
2288                                alt30 = 1
2289                            if alt30 == 1:
2290                                # src/ll/UL4.g:397:6: ':' (e3= expr1 )?
2291                                pass 
2292                                self.match(self.input, 42, self.FOLLOW_42_in_expr92084)
2293
2294                                if self._state.backtracking == 0:
2295                                    pass
2296                                    slice = True; 
2297
2298
2299
2300                                # src/ll/UL4.g:398:6: (e3= expr1 )?
2301                                alt29 = 2
2302                                LA29_0 = self.input.LA(1)
2303
2304                                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) :
2305                                    alt29 = 1
2306                                if alt29 == 1:
2307                                    # src/ll/UL4.g:399:7: e3= expr1
2308                                    pass 
2309                                    self._state.following.append(self.FOLLOW_expr1_in_expr92103)
2310                                    e3 = self.expr1()
2311
2312                                    self._state.following.pop()
2313
2314                                    if self._state.backtracking == 0:
2315                                        pass
2316                                        index2 = e3; 
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326                            if self._state.backtracking == 0:
2327                                pass
2328                                node = ul4c.GetSlice(node, index1, index2) if slice else ul4c.GetItem(node, index1) 
2329
2330
2331
2332
2333
2334
2335                        self.match(self.input, 50, self.FOLLOW_50_in_expr92132)
2336
2337
2338                    else:
2339                        break #loop32
2340
2341
2342
2343
2344
2345                       
2346            except RecognitionException as e:
2347                raise
2348
2349        finally:
2350            pass
2351        return node
2352
2353    # $ANTLR end "expr9"
2354
2355
2356
2357    # $ANTLR start "expr8"
2358    # src/ll/UL4.g:408:1: expr8 returns [node] : ( '-' )* e= expr9 ;
2359    def expr8(self, ):
2360        node = None
2361
2362
2363        e = None
2364
2365
2366         
2367        count = 0;
2368           
2369        try:
2370            try:
2371                # src/ll/UL4.g:413:2: ( ( '-' )* e= expr9 )
2372                # src/ll/UL4.g:414:3: ( '-' )* e= expr9
2373                pass 
2374                # src/ll/UL4.g:414:3: ( '-' )*
2375                while True: #loop33
2376                    alt33 = 2
2377                    LA33_0 = self.input.LA(1)
2378
2379                    if (LA33_0 == 35) :
2380                        alt33 = 1
2381
2382
2383                    if alt33 == 1:
2384                        # src/ll/UL4.g:415:4: '-'
2385                        pass 
2386                        self.match(self.input, 35, self.FOLLOW_35_in_expr82168)
2387
2388                        if self._state.backtracking == 0:
2389                            pass
2390                            count += 1; 
2391
2392
2393
2394
2395                    else:
2396                        break #loop33
2397
2398
2399                self._state.following.append(self.FOLLOW_expr9_in_expr82181)
2400                e = self.expr9()
2401
2402                self._state.following.pop()
2403
2404                if self._state.backtracking == 0:
2405                    pass
2406                             
2407                    node =  e
2408                    for i in range(count):
2409                        node =  ul4c.Neg.make(node)
2410                           
2411
2412
2413
2414
2415
2416
2417                       
2418            except RecognitionException as e:
2419                raise
2420
2421        finally:
2422            pass
2423        return node
2424
2425    # $ANTLR end "expr8"
2426
2427
2428
2429    # $ANTLR start "expr7"
2430    # src/ll/UL4.g:425:1: expr7 returns [node] : e1= expr8 ( ( '*' | '/' | '//' | '%' ) e2= expr8 )* ;
2431    def expr7(self, ):
2432        node = None
2433
2434
2435        e1 = None
2436
2437        e2 = None
2438
2439
2440        try:
2441            try:
2442                # src/ll/UL4.g:426:2: (e1= expr8 ( ( '*' | '/' | '//' | '%' ) e2= expr8 )* )
2443                # src/ll/UL4.g:427:3: e1= expr8 ( ( '*' | '/' | '//' | '%' ) e2= expr8 )*
2444                pass 
2445                self._state.following.append(self.FOLLOW_expr8_in_expr72204)
2446                e1 = self.expr8()
2447
2448                self._state.following.pop()
2449
2450                if self._state.backtracking == 0:
2451                    pass
2452                    node =  e1
2453
2454
2455
2456                # src/ll/UL4.g:428:3: ( ( '*' | '/' | '//' | '%' ) e2= expr8 )*
2457                while True: #loop35
2458                    alt35 = 2
2459                    LA35_0 = self.input.LA(1)
2460
2461                    if (LA35_0 == 25 or LA35_0 == 29 or (38 <= LA35_0 <= 39)) :
2462                        alt35 = 1
2463
2464
2465                    if alt35 == 1:
2466                        # src/ll/UL4.g:429:4: ( '*' | '/' | '//' | '%' ) e2= expr8
2467                        pass 
2468                        # src/ll/UL4.g:429:4: ( '*' | '/' | '//' | '%' )
2469                        alt34 = 4
2470                        LA34 = self.input.LA(1)
2471                        if LA34 == 29:
2472                            alt34 = 1
2473                        elif LA34 == 38:
2474                            alt34 = 2
2475                        elif LA34 == 39:
2476                            alt34 = 3
2477                        elif LA34 == 25:
2478                            alt34 = 4
2479                        else:
2480                            if self._state.backtracking > 0:
2481                                raise BacktrackingFailed
2482
2483
2484                            nvae = NoViableAltException("", 34, 0, self.input)
2485
2486                            raise nvae
2487
2488
2489                        if alt34 == 1:
2490                            # src/ll/UL4.g:430:5: '*'
2491                            pass 
2492                            self.match(self.input, 29, self.FOLLOW_29_in_expr72221)
2493
2494                            if self._state.backtracking == 0:
2495                                pass
2496                                cls = ul4c.Mul; 
2497
2498
2499
2500
2501                        elif alt34 == 2:
2502                            # src/ll/UL4.g:432:5: '/'
2503                            pass 
2504                            self.match(self.input, 38, self.FOLLOW_38_in_expr72234)
2505
2506                            if self._state.backtracking == 0:
2507                                pass
2508                                cls = ul4c.TrueDiv; 
2509
2510
2511
2512
2513                        elif alt34 == 3:
2514                            # src/ll/UL4.g:434:5: '//'
2515                            pass 
2516                            self.match(self.input, 39, self.FOLLOW_39_in_expr72247)
2517
2518                            if self._state.backtracking == 0:
2519                                pass
2520                                cls = ul4c.FloorDiv; 
2521
2522
2523
2524
2525                        elif alt34 == 4:
2526                            # src/ll/UL4.g:436:5: '%'
2527                            pass 
2528                            self.match(self.input, 25, self.FOLLOW_25_in_expr72260)
2529
2530                            if self._state.backtracking == 0:
2531                                pass
2532                                cls = ul4c.Mod; 
2533
2534
2535
2536
2537
2538
2539                        self._state.following.append(self.FOLLOW_expr8_in_expr72274)
2540                        e2 = self.expr8()
2541
2542                        self._state.following.pop()
2543
2544                        if self._state.backtracking == 0:
2545                            pass
2546                            node = cls.make(node, e2) 
2547
2548
2549
2550
2551                    else:
2552                        break #loop35
2553
2554
2555
2556
2557
2558                       
2559            except RecognitionException as e:
2560                raise
2561
2562        finally:
2563            pass
2564        return node
2565
2566    # $ANTLR end "expr7"
2567
2568
2569
2570    # $ANTLR start "expr6"
2571    # src/ll/UL4.g:443:1: expr6 returns [node] : e1= expr7 ( ( '+' | '-' ) e2= expr7 )* ;
2572    def expr6(self, ):
2573        node = None
2574
2575
2576        e1 = None
2577
2578        e2 = None
2579
2580
2581        try:
2582            try:
2583                # src/ll/UL4.g:444:2: (e1= expr7 ( ( '+' | '-' ) e2= expr7 )* )
2584                # src/ll/UL4.g:445:3: e1= expr7 ( ( '+' | '-' ) e2= expr7 )*
2585                pass 
2586                self._state.following.append(self.FOLLOW_expr7_in_expr62302)
2587                e1 = self.expr7()
2588
2589                self._state.following.pop()
2590
2591                if self._state.backtracking == 0:
2592                    pass
2593                    node =  e1
2594
2595
2596
2597                # src/ll/UL4.g:446:3: ( ( '+' | '-' ) e2= expr7 )*
2598                while True: #loop37
2599                    alt37 = 2
2600                    LA37_0 = self.input.LA(1)
2601
2602                    if (LA37_0 == 32 or LA37_0 == 35) :
2603                        alt37 = 1
2604
2605
2606                    if alt37 == 1:
2607                        # src/ll/UL4.g:447:4: ( '+' | '-' ) e2= expr7
2608                        pass 
2609                        # src/ll/UL4.g:447:4: ( '+' | '-' )
2610                        alt36 = 2
2611                        LA36_0 = self.input.LA(1)
2612
2613                        if (LA36_0 == 32) :
2614                            alt36 = 1
2615                        elif (LA36_0 == 35) :
2616                            alt36 = 2
2617                        else:
2618                            if self._state.backtracking > 0:
2619                                raise BacktrackingFailed
2620
2621
2622                            nvae = NoViableAltException("", 36, 0, self.input)
2623
2624                            raise nvae
2625
2626
2627                        if alt36 == 1:
2628                            # src/ll/UL4.g:448:5: '+'
2629                            pass 
2630                            self.match(self.input, 32, self.FOLLOW_32_in_expr62319)
2631
2632                            if self._state.backtracking == 0:
2633                                pass
2634                                cls = ul4c.Add; 
2635
2636
2637
2638
2639                        elif alt36 == 2:
2640                            # src/ll/UL4.g:450:5: '-'
2641                            pass 
2642                            self.match(self.input, 35, self.FOLLOW_35_in_expr62332)
2643
2644                            if self._state.backtracking == 0:
2645                                pass
2646                                cls = ul4c.Sub; 
2647
2648
2649
2650
2651
2652
2653                        self._state.following.append(self.FOLLOW_expr7_in_expr62346)
2654                        e2 = self.expr7()
2655
2656                        self._state.following.pop()
2657
2658                        if self._state.backtracking == 0:
2659                            pass
2660                            node = cls.make(node, e2) 
2661
2662
2663
2664
2665                    else:
2666                        break #loop37
2667
2668
2669
2670
2671
2672                       
2673            except RecognitionException as e:
2674                raise
2675
2676        finally:
2677            pass
2678        return node
2679
2680    # $ANTLR end "expr6"
2681
2682
2683
2684    # $ANTLR start "expr5"
2685    # src/ll/UL4.g:457:1: expr5 returns [node] : e1= expr6 ( ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6 )* ;
2686    def expr5(self, ):
2687        node = None
2688
2689
2690        e1 = None
2691
2692        e2 = None
2693
2694
2695        try:
2696            try:
2697                # src/ll/UL4.g:458:2: (e1= expr6 ( ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6 )* )
2698                # src/ll/UL4.g:459:3: e1= expr6 ( ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6 )*
2699                pass 
2700                self._state.following.append(self.FOLLOW_expr6_in_expr52374)
2701                e1 = self.expr6()
2702
2703                self._state.following.pop()
2704
2705                if self._state.backtracking == 0:
2706                    pass
2707                    node =  e1
2708
2709
2710
2711                # src/ll/UL4.g:460:3: ( ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6 )*
2712                while True: #loop39
2713                    alt39 = 2
2714                    LA39_0 = self.input.LA(1)
2715
2716                    if (LA39_0 == 24 or (43 <= LA39_0 <= 44) or (46 <= LA39_0 <= 48)) :
2717                        alt39 = 1
2718
2719
2720                    if alt39 == 1:
2721                        # src/ll/UL4.g:461:4: ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) e2= expr6
2722                        pass 
2723                        # src/ll/UL4.g:461:4: ( '==' | '!=' | '<' | '<=' | '>' | '>=' )
2724                        alt38 = 6
2725                        LA38 = self.input.LA(1)
2726                        if LA38 == 46:
2727                            alt38 = 1
2728                        elif LA38 == 24:
2729                            alt38 = 2
2730                        elif LA38 == 43:
2731                            alt38 = 3
2732                        elif LA38 == 44:
2733                            alt38 = 4
2734                        elif LA38 == 47:
2735                            alt38 = 5
2736                        elif LA38 == 48:
2737                            alt38 = 6
2738                        else:
2739                            if self._state.backtracking > 0:
2740                                raise BacktrackingFailed
2741
2742
2743                            nvae = NoViableAltException("", 38, 0, self.input)
2744
2745                            raise nvae
2746
2747
2748                        if alt38 == 1:
2749                            # src/ll/UL4.g:462:5: '=='
2750                            pass 
2751                            self.match(self.input, 46, self.FOLLOW_46_in_expr52391)
2752
2753                            if self._state.backtracking == 0:
2754                                pass
2755                                cls = ul4c.EQ; 
2756
2757
2758
2759
2760                        elif alt38 == 2:
2761                            # src/ll/UL4.g:464:5: '!='
2762                            pass 
2763                            self.match(self.input, 24, self.FOLLOW_24_in_expr52404)
2764
2765                            if self._state.backtracking == 0:
2766                                pass
2767                                cls = ul4c.NE; 
2768
2769
2770
2771
2772                        elif alt38 == 3:
2773                            # src/ll/UL4.g:466:5: '<'
2774                            pass 
2775                            self.match(self.input, 43, self.FOLLOW_43_in_expr52417)
2776
2777                            if self._state.backtracking == 0:
2778                                pass
2779                                cls = ul4c.LT; 
2780
2781
2782
2783
2784                        elif alt38 == 4:
2785                            # src/ll/UL4.g:468:5: '<='
2786                            pass 
2787                            self.match(self.input, 44, self.FOLLOW_44_in_expr52430)
2788
2789                            if self._state.backtracking == 0:
2790                                pass
2791                                cls = ul4c.LE; 
2792
2793
2794
2795
2796                        elif alt38 == 5:
2797                            # src/ll/UL4.g:470:5: '>'
2798                            pass 
2799                            self.match(self.input, 47, self.FOLLOW_47_in_expr52443)
2800
2801                            if self._state.backtracking == 0:
2802                                pass
2803                                cls = ul4c.GT; 
2804
2805
2806
2807
2808                        elif alt38 == 6:
2809                            # src/ll/UL4.g:472:5: '>='
2810                            pass 
2811                            self.match(self.input, 48, self.FOLLOW_48_in_expr52456)
2812
2813                            if self._state.backtracking == 0:
2814                                pass
2815                                cls = ul4c.GE; 
2816
2817
2818
2819
2820
2821
2822                        self._state.following.append(self.FOLLOW_expr6_in_expr52470)
2823                        e2 = self.expr6()
2824
2825                        self._state.following.pop()
2826
2827                        if self._state.backtracking == 0:
2828                            pass
2829                            node = cls.make(node, e2) 
2830
2831
2832
2833
2834                    else:
2835                        break #loop39
2836
2837
2838
2839
2840
2841                       
2842            except RecognitionException as e:
2843                raise
2844
2845        finally:
2846            pass
2847        return node
2848
2849    # $ANTLR end "expr5"
2850
2851
2852
2853    # $ANTLR start "expr4"
2854    # src/ll/UL4.g:479:1: expr4 returns [node] : e1= expr5 ( ( 'not' )? 'in' e2= expr5 )? ;
2855    def expr4(self, ):
2856        node = None
2857
2858
2859        e1 = None
2860
2861        e2 = None
2862
2863
2864        try:
2865            try:
2866                # src/ll/UL4.g:480:2: (e1= expr5 ( ( 'not' )? 'in' e2= expr5 )? )
2867                # src/ll/UL4.g:481:3: e1= expr5 ( ( 'not' )? 'in' e2= expr5 )?
2868                pass 
2869                self._state.following.append(self.FOLLOW_expr5_in_expr42498)
2870                e1 = self.expr5()
2871
2872                self._state.following.pop()
2873
2874                if self._state.backtracking == 0:
2875                    pass
2876                    node =  e1
2877
2878
2879
2880                # src/ll/UL4.g:482:3: ( ( 'not' )? 'in' e2= expr5 )?
2881                alt41 = 2
2882                LA41_0 = self.input.LA(1)
2883
2884                if ((54 <= LA41_0 <= 55)) :
2885                    alt41 = 1
2886                if alt41 == 1:
2887                    # src/ll/UL4.g:483:4: ( 'not' )? 'in' e2= expr5
2888                    pass 
2889                    if self._state.backtracking == 0:
2890                        pass
2891                        cls = ul4c.Contains; 
2892
2893
2894
2895                    # src/ll/UL4.g:484:4: ( 'not' )?
2896                    alt40 = 2
2897                    LA40_0 = self.input.LA(1)
2898
2899                    if (LA40_0 == 55) :
2900                        alt40 = 1
2901                    if alt40 == 1:
2902                        # src/ll/UL4.g:485:5: 'not'
2903                        pass 
2904                        self.match(self.input, 55, self.FOLLOW_55_in_expr42520)
2905
2906                        if self._state.backtracking == 0:
2907                            pass
2908                            cls = ul4c.NotContains; 
2909
2910
2911
2912
2913
2914
2915                    self.match(self.input, 54, self.FOLLOW_54_in_expr42533)
2916
2917                    self._state.following.append(self.FOLLOW_expr5_in_expr42540)
2918                    e2 = self.expr5()
2919
2920                    self._state.following.pop()
2921
2922                    if self._state.backtracking == 0:
2923                        pass
2924                        node = cls.make(node, e2) 
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934                       
2935            except RecognitionException as e:
2936                raise
2937
2938        finally:
2939            pass
2940        return node
2941
2942    # $ANTLR end "expr4"
2943
2944
2945
2946    # $ANTLR start "expr3"
2947    # src/ll/UL4.g:493:1: expr3 returns [node] : ( 'not' e= expr4 |e= expr4 );
2948    def expr3(self, ):
2949        node = None
2950
2951
2952        e = None
2953
2954
2955        try:
2956            try:
2957                # src/ll/UL4.g:494:2: ( 'not' e= expr4 |e= expr4 )
2958                alt42 = 2
2959                LA42_0 = self.input.LA(1)
2960
2961                if (LA42_0 == 55) :
2962                    alt42 = 1
2963                elif ((COLOR <= LA42_0 <= DATE) or (FALSE <= LA42_0 <= FLOAT) or (INT <= LA42_0 <= NONE) or LA42_0 == STRING or LA42_0 == TRUE or LA42_0 == 27 or LA42_0 == 35 or LA42_0 == 49 or LA42_0 == 57) :
2964                    alt42 = 2
2965                else:
2966                    if self._state.backtracking > 0:
2967                        raise BacktrackingFailed
2968
2969
2970                    nvae = NoViableAltException("", 42, 0, self.input)
2971
2972                    raise nvae
2973
2974
2975                if alt42 == 1:
2976                    # src/ll/UL4.g:495:3: 'not' e= expr4
2977                    pass 
2978                    self.match(self.input, 55, self.FOLLOW_55_in_expr32566)
2979
2980                    self._state.following.append(self.FOLLOW_expr4_in_expr32572)
2981                    e = self.expr4()
2982
2983                    self._state.following.pop()
2984
2985                    if self._state.backtracking == 0:
2986                        pass
2987                        node = ul4c.Not.make(e) 
2988
2989
2990
2991
2992                elif alt42 == 2:
2993                    # src/ll/UL4.g:498:3: e= expr4
2994                    pass 
2995                    self._state.following.append(self.FOLLOW_expr4_in_expr32583)
2996                    e = self.expr4()
2997
2998                    self._state.following.pop()
2999
3000                    if self._state.backtracking == 0:
3001                        pass
3002                        node =  e
3003
3004
3005
3006
3007
3008                       
3009            except RecognitionException as e:
3010                raise
3011
3012        finally:
3013            pass
3014        return node
3015
3016    # $ANTLR end "expr3"
3017
3018
3019
3020    # $ANTLR start "expr2"
3021    # src/ll/UL4.g:503:1: expr2 returns [node] : e1= expr3 ( 'and' e2= expr3 )* ;
3022    def expr2(self, ):
3023        node = None
3024
3025
3026        e1 = None
3027
3028        e2 = None
3029
3030
3031        try:
3032            try:
3033                # src/ll/UL4.g:504:2: (e1= expr3 ( 'and' e2= expr3 )* )
3034                # src/ll/UL4.g:505:3: e1= expr3 ( 'and' e2= expr3 )*
3035                pass 
3036                self._state.following.append(self.FOLLOW_expr3_in_expr22607)
3037                e1 = self.expr3()
3038
3039                self._state.following.pop()
3040
3041                if self._state.backtracking == 0:
3042                    pass
3043                    node =  e1
3044
3045
3046
3047                # src/ll/UL4.g:506:3: ( 'and' e2= expr3 )*
3048                while True: #loop43
3049                    alt43 = 2
3050                    LA43_0 = self.input.LA(1)
3051
3052                    if (LA43_0 == 51) :
3053                        alt43 = 1
3054
3055
3056                    if alt43 == 1:
3057                        # src/ll/UL4.g:507:4: 'and' e2= expr3
3058                        pass 
3059                        self.match(self.input, 51, self.FOLLOW_51_in_expr22618)
3060
3061                        self._state.following.append(self.FOLLOW_expr3_in_expr22625)
3062                        e2 = self.expr3()
3063
3064                        self._state.following.pop()
3065
3066                        if self._state.backtracking == 0:
3067                            pass
3068                            node = ul4c.And(node, e2) 
3069
3070
3071
3072
3073                    else:
3074                        break #loop43
3075
3076
3077
3078
3079
3080                       
3081            except RecognitionException as e:
3082                raise
3083
3084        finally:
3085            pass
3086        return node
3087
3088    # $ANTLR end "expr2"
3089
3090
3091
3092    # $ANTLR start "expr1"
3093    # src/ll/UL4.g:513:1: expr1 returns [node] : e1= expr2 ( 'or' e2= expr2 )* ;
3094    def expr1(self, ):
3095        node = None
3096
3097
3098        e1 = None
3099
3100        e2 = None
3101
3102
3103        try:
3104            try:
3105                # src/ll/UL4.g:514:2: (e1= expr2 ( 'or' e2= expr2 )* )
3106                # src/ll/UL4.g:515:3: e1= expr2 ( 'or' e2= expr2 )*
3107                pass 
3108                self._state.following.append(self.FOLLOW_expr2_in_expr12653)
3109                e1 = self.expr2()
3110
3111                self._state.following.pop()
3112
3113                if self._state.backtracking == 0:
3114                    pass
3115                    node =  e1
3116
3117
3118
3119                # src/ll/UL4.g:516:3: ( 'or' e2= expr2 )*
3120                while True: #loop44
3121                    alt44 = 2
3122                    LA44_0 = self.input.LA(1)
3123
3124                    if (LA44_0 == 56) :
3125                        alt44 = 1
3126
3127
3128                    if alt44 == 1:
3129                        # src/ll/UL4.g:517:4: 'or' e2= expr2
3130                        pass 
3131                        self.match(self.input, 56, self.FOLLOW_56_in_expr12664)
3132
3133                        self._state.following.append(self.FOLLOW_expr2_in_expr12671)
3134                        e2 = self.expr2()
3135
3136                        self._state.following.pop()
3137
3138                        if self._state.backtracking == 0:
3139                            pass
3140                            node = ul4c.Or(node, e2) 
3141
3142
3143
3144
3145                    else:
3146                        break #loop44
3147
3148
3149
3150
3151
3152                       
3153            except RecognitionException as e:
3154                raise
3155
3156        finally:
3157            pass
3158        return node
3159
3160    # $ANTLR end "expr1"
3161
3162
3163
3164    # $ANTLR start "exprarg"
3165    # src/ll/UL4.g:522:1: exprarg returns [node] : (ege= generatorexpression |e1= expr1 );
3166    def exprarg(self, ):
3167        node = None
3168
3169
3170        ege = None
3171
3172        e1 = None
3173
3174
3175        try:
3176            try:
3177                # src/ll/UL4.g:523:2: (ege= generatorexpression |e1= expr1 )
3178                alt45 = 2
3179                LA45 = self.input.LA(1)
3180                if LA45 == 55:
3181                    LA45_1 = self.input.LA(2)
3182
3183                    if (self.synpred69_UL4()) :
3184                        alt45 = 1
3185                    elif (True) :
3186                        alt45 = 2
3187                    else:
3188                        if self._state.backtracking > 0:
3189                            raise BacktrackingFailed
3190
3191
3192                        nvae = NoViableAltException("", 45, 1, self.input)
3193
3194                        raise nvae
3195
3196
3197                elif LA45 == 35:
3198                    LA45_2 = self.input.LA(2)
3199
3200                    if (self.synpred69_UL4()) :
3201                        alt45 = 1
3202                    elif (True) :
3203                        alt45 = 2
3204                    else:
3205                        if self._state.backtracking > 0:
3206                            raise BacktrackingFailed
3207
3208
3209                        nvae = NoViableAltException("", 45, 2, self.input)
3210
3211                        raise nvae
3212
3213
3214                elif LA45 == NONE:
3215                    LA45_3 = self.input.LA(2)
3216
3217                    if (self.synpred69_UL4()) :
3218                        alt45 = 1
3219                    elif (True) :
3220                        alt45 = 2
3221                    else:
3222                        if self._state.backtracking > 0:
3223                            raise BacktrackingFailed
3224
3225
3226                        nvae = NoViableAltException("", 45, 3, self.input)
3227
3228                        raise nvae
3229
3230
3231                elif LA45 == FALSE:
3232                    LA45_4 = self.input.LA(2)
3233
3234                    if (self.synpred69_UL4()) :
3235                        alt45 = 1
3236                    elif (True) :
3237                        alt45 = 2
3238                    else:
3239                        if self._state.backtracking > 0:
3240                            raise BacktrackingFailed
3241
3242
3243                        nvae = NoViableAltException("", 45, 4, self.input)
3244
3245                        raise nvae
3246
3247
3248                elif LA45 == TRUE:
3249                    LA45_5 = self.input.LA(2)
3250
3251                    if (self.synpred69_UL4()) :
3252                        alt45 = 1
3253                    elif (True) :
3254                        alt45 = 2
3255                    else:
3256                        if self._state.backtracking > 0:
3257                            raise BacktrackingFailed
3258
3259
3260                        nvae = NoViableAltException("", 45, 5, self.input)
3261
3262                        raise nvae
3263
3264
3265                elif LA45 == INT:
3266                    LA45_6 = self.input.LA(2)
3267
3268                    if (self.synpred69_UL4()) :
3269                        alt45 = 1
3270                    elif (True) :
3271                        alt45 = 2
3272                    else:
3273                        if self._state.backtracking > 0:
3274                            raise BacktrackingFailed
3275
3276
3277                        nvae = NoViableAltException("", 45, 6, self.input)
3278
3279                        raise nvae
3280
3281
3282                elif LA45 == FLOAT:
3283                    LA45_7 = self.input.LA(2)
3284
3285                    if (self.synpred69_UL4()) :
3286                        alt45 = 1
3287                    elif (True) :
3288                        alt45 = 2
3289                    else:
3290                        if self._state.backtracking > 0:
3291                            raise BacktrackingFailed
3292
3293
3294                        nvae = NoViableAltException("", 45, 7, self.input)
3295
3296                        raise nvae
3297
3298
3299                elif LA45 == STRING:
3300                    LA45_8 = self.input.LA(2)
3301
3302                    if (self.synpred69_UL4()) :
3303                        alt45 = 1
3304                    elif (True) :
3305                        alt45 = 2
3306                    else:
3307                        if self._state.backtracking > 0:
3308                            raise BacktrackingFailed
3309
3310
3311                        nvae = NoViableAltException("", 45, 8, self.input)
3312
3313                        raise nvae
3314
3315
3316                elif LA45 == DATE:
3317                    LA45_9 = self.input.LA(2)
3318
3319                    if (self.synpred69_UL4()) :
3320                        alt45 = 1
3321                    elif (True) :
3322                        alt45 = 2
3323                    else:
3324                        if self._state.backtracking > 0:
3325                            raise BacktrackingFailed
3326
3327
3328                        nvae = NoViableAltException("", 45, 9, self.input)
3329
3330                        raise nvae
3331
3332
3333                elif LA45 == COLOR:
3334                    LA45_10 = self.input.LA(2)
3335
3336                    if (self.synpred69_UL4()) :
3337                        alt45 = 1
3338                    elif (True) :
3339                        alt45 = 2
3340                    else:
3341                        if self._state.backtracking > 0:
3342                            raise BacktrackingFailed
3343
3344
3345                        nvae = NoViableAltException("", 45, 10, self.input)
3346
3347                        raise nvae
3348
3349
3350                elif LA45 == NAME:
3351                    LA45_11 = self.input.LA(2)
3352
3353                    if (self.synpred69_UL4()) :
3354                        alt45 = 1
3355                    elif (True) :
3356                        alt45 = 2
3357                    else:
3358                        if self._state.backtracking > 0:
3359                            raise BacktrackingFailed
3360
3361
3362                        nvae = NoViableAltException("", 45, 11, self.input)
3363
3364                        raise nvae
3365
3366
3367                elif LA45 == 49:
3368                    LA45_12 = self.input.LA(2)
3369
3370                    if (self.synpred69_UL4()) :
3371                        alt45 = 1
3372                    elif (True) :
3373                        alt45 = 2
3374                    else:
3375                        if self._state.backtracking > 0:
3376                            raise BacktrackingFailed
3377
3378
3379                        nvae = NoViableAltException("", 45, 12, self.input)
3380
3381                        raise nvae
3382
3383
3384                elif LA45 == 57:
3385                    LA45_13 = self.input.LA(2)
3386
3387                    if (self.synpred69_UL4()) :
3388                        alt45 = 1
3389                    elif (True) :
3390                        alt45 = 2
3391                    else:
3392                        if self._state.backtracking > 0:
3393                            raise BacktrackingFailed
3394
3395
3396                        nvae = NoViableAltException("", 45, 13, self.input)
3397
3398                        raise nvae
3399
3400
3401                elif LA45 == 27:
3402                    LA45_14 = self.input.LA(2)
3403
3404                    if (self.synpred69_UL4()) :
3405                        alt45 = 1
3406                    elif (True) :
3407                        alt45 = 2
3408                    else:
3409                        if self._state.backtracking > 0:
3410                            raise BacktrackingFailed
3411
3412
3413                        nvae = NoViableAltException("", 45, 14, self.input)
3414
3415                        raise nvae
3416
3417
3418                else:
3419                    if self._state.backtracking > 0:
3420                        raise BacktrackingFailed
3421
3422
3423                    nvae = NoViableAltException("", 45, 0, self.input)
3424
3425                    raise nvae
3426
3427
3428                if alt45 == 1:
3429                    # src/ll/UL4.g:523:4: ege= generatorexpression
3430                    pass 
3431                    self._state.following.append(self.FOLLOW_generatorexpression_in_exprarg2695)
3432                    ege = self.generatorexpression()
3433
3434                    self._state.following.pop()
3435
3436                    if self._state.backtracking == 0:
3437                        pass
3438                        node =  ege
3439
3440
3441
3442
3443                elif alt45 == 2:
3444                    # src/ll/UL4.g:524:4: e1= expr1
3445                    pass 
3446                    self._state.following.append(self.FOLLOW_expr1_in_exprarg2704)
3447                    e1 = self.expr1()
3448
3449                    self._state.following.pop()
3450
3451                    if self._state.backtracking == 0:
3452                        pass
3453                        node =  e1
3454
3455
3456
3457
3458
3459                       
3460            except RecognitionException as e:
3461                raise
3462
3463        finally:
3464            pass
3465        return node
3466
3467    # $ANTLR end "exprarg"
3468
3469
3470
3471    # $ANTLR start "expression"
3472    # src/ll/UL4.g:527:1: expression returns [node] : (ege= generatorexpression EOF |e= expr1 EOF );
3473    def expression(self, ):
3474        node = None
3475
3476
3477        ege = None
3478
3479        e = None
3480
3481
3482        try:
3483            try:
3484                # src/ll/UL4.g:528:2: (ege= generatorexpression EOF |e= expr1 EOF )
3485                alt46 = 2
3486                LA46 = self.input.LA(1)
3487                if LA46 == 55:
3488                    LA46_1 = self.input.LA(2)
3489
3490                    if (self.synpred70_UL4()) :
3491                        alt46 = 1
3492                    elif (True) :
3493                        alt46 = 2
3494                    else:
3495                        if self._state.backtracking > 0:
3496                            raise BacktrackingFailed
3497
3498
3499                        nvae = NoViableAltException("", 46, 1, self.input)
3500
3501                        raise nvae
3502
3503
3504                elif LA46 == 35:
3505                    LA46_2 = self.input.LA(2)
3506
3507                    if (self.synpred70_UL4()) :
3508                        alt46 = 1
3509                    elif (True) :
3510                        alt46 = 2
3511                    else:
3512                        if self._state.backtracking > 0:
3513                            raise BacktrackingFailed
3514
3515
3516                        nvae = NoViableAltException("", 46, 2, self.input)
3517
3518                        raise nvae
3519
3520
3521                elif LA46 == NONE:
3522                    LA46_3 = self.input.LA(2)
3523
3524                    if (self.synpred70_UL4()) :
3525                        alt46 = 1
3526                    elif (True) :
3527                        alt46 = 2
3528                    else:
3529                        if self._state.backtracking > 0:
3530                            raise BacktrackingFailed
3531
3532
3533                        nvae = NoViableAltException("", 46, 3, self.input)
3534
3535                        raise nvae
3536
3537
3538                elif LA46 == FALSE:
3539                    LA46_4 = self.input.LA(2)
3540
3541                    if (self.synpred70_UL4()) :
3542                        alt46 = 1
3543                    elif (True) :
3544                        alt46 = 2
3545                    else:
3546                        if self._state.backtracking > 0:
3547                            raise BacktrackingFailed
3548
3549
3550                        nvae = NoViableAltException("", 46, 4, self.input)
3551
3552                        raise nvae
3553
3554
3555                elif LA46 == TRUE:
3556                    LA46_5 = self.input.LA(2)
3557
3558                    if (self.synpred70_UL4()) :
3559                        alt46 = 1
3560                    elif (True) :
3561                        alt46 = 2
3562                    else:
3563                        if self._state.backtracking > 0:
3564                            raise BacktrackingFailed
3565
3566
3567                        nvae = NoViableAltException("", 46, 5, self.input)
3568
3569                        raise nvae
3570
3571
3572                elif LA46 == INT:
3573                    LA46_6 = self.input.LA(2)
3574
3575                    if (self.synpred70_UL4()) :
3576                        alt46 = 1
3577                    elif (True) :
3578                        alt46 = 2
3579                    else:
3580                        if self._state.backtracking > 0:
3581                            raise BacktrackingFailed
3582
3583
3584                        nvae = NoViableAltException("", 46, 6, self.input)
3585
3586                        raise nvae
3587
3588
3589                elif LA46 == FLOAT:
3590                    LA46_7 = self.input.LA(2)
3591
3592                    if (self.synpred70_UL4()) :
3593                        alt46 = 1
3594                    elif (True) :
3595                        alt46 = 2
3596                    else:
3597                        if self._state.backtracking > 0:
3598                            raise BacktrackingFailed
3599
3600
3601                        nvae = NoViableAltException("", 46, 7, self.input)
3602
3603                        raise nvae
3604
3605
3606                elif LA46 == STRING:
3607                    LA46_8 = self.input.LA(2)
3608
3609                    if (self.synpred70_UL4()) :
3610                        alt46 = 1
3611                    elif (True) :
3612                        alt46 = 2
3613                    else:
3614                        if self._state.backtracking > 0:
3615                            raise BacktrackingFailed
3616
3617
3618                        nvae = NoViableAltException("", 46, 8, self.input)
3619
3620                        raise nvae
3621
3622
3623                elif LA46 == DATE:
3624                    LA46_9 = self.input.LA(2)
3625
3626                    if (self.synpred70_UL4()) :
3627                        alt46 = 1
3628                    elif (True) :
3629                        alt46 = 2
3630                    else:
3631                        if self._state.backtracking > 0:
3632                            raise BacktrackingFailed
3633
3634
3635                        nvae = NoViableAltException("", 46, 9, self.input)
3636
3637                        raise nvae
3638
3639
3640                elif LA46 == COLOR:
3641                    LA46_10 = self.input.LA(2)
3642
3643                    if (self.synpred70_UL4()) :
3644                        alt46 = 1
3645                    elif (True) :
3646                        alt46 = 2
3647                    else:
3648                        if self._state.backtracking > 0:
3649                            raise BacktrackingFailed
3650
3651
3652                        nvae = NoViableAltException("", 46, 10, self.input)
3653
3654                        raise nvae
3655
3656
3657                elif LA46 == NAME:
3658                    LA46_11 = self.input.LA(2)
3659
3660                    if (self.synpred70_UL4()) :
3661                        alt46 = 1
3662                    elif (True) :
3663                        alt46 = 2
3664                    else:
3665                        if self._state.backtracking > 0:
3666                            raise BacktrackingFailed
3667
3668
3669                        nvae = NoViableAltException("", 46, 11, self.input)
3670
3671                        raise nvae
3672
3673
3674                elif LA46 == 49:
3675                    LA46_12 = self.input.LA(2)
3676
3677                    if (self.synpred70_UL4()) :
3678                        alt46 = 1
3679                    elif (True) :
3680                        alt46 = 2
3681                    else:
3682                        if self._state.backtracking > 0:
3683                            raise BacktrackingFailed
3684
3685
3686                        nvae = NoViableAltException("", 46, 12, self.input)
3687
3688                        raise nvae
3689
3690
3691                elif LA46 == 57:
3692                    LA46_13 = self.input.LA(2)
3693
3694                    if (self.synpred70_UL4()) :
3695                        alt46 = 1
3696                    elif (True) :
3697                        alt46 = 2
3698                    else:
3699                        if self._state.backtracking > 0:
3700                            raise BacktrackingFailed
3701
3702
3703                        nvae = NoViableAltException("", 46, 13, self.input)
3704
3705                        raise nvae
3706
3707
3708                elif LA46 == 27:
3709                    LA46_14 = self.input.LA(2)
3710
3711                    if (self.synpred70_UL4()) :
3712                        alt46 = 1
3713                    elif (True) :
3714                        alt46 = 2
3715                    else:
3716                        if self._state.backtracking > 0:
3717                            raise BacktrackingFailed
3718
3719
3720                        nvae = NoViableAltException("", 46, 14, self.input)
3721
3722                        raise nvae
3723
3724
3725                else:
3726                    if self._state.backtracking > 0:
3727                        raise BacktrackingFailed
3728
3729
3730                    nvae = NoViableAltException("", 46, 0, self.input)
3731
3732                    raise nvae
3733
3734
3735                if alt46 == 1:
3736                    # src/ll/UL4.g:528:4: ege= generatorexpression EOF
3737                    pass 
3738                    self._state.following.append(self.FOLLOW_generatorexpression_in_expression2723)
3739                    ege = self.generatorexpression()
3740
3741                    self._state.following.pop()
3742
3743                    self.match(self.input, EOF, self.FOLLOW_EOF_in_expression2725)
3744
3745                    if self._state.backtracking == 0:
3746                        pass
3747                        node =  ege
3748
3749
3750
3751
3752                elif alt46 == 2:
3753                    # src/ll/UL4.g:529:4: e= expr1 EOF
3754                    pass 
3755                    self._state.following.append(self.FOLLOW_expr1_in_expression2734)
3756                    e = self.expr1()
3757
3758                    self._state.following.pop()
3759
3760                    self.match(self.input, EOF, self.FOLLOW_EOF_in_expression2736)
3761
3762                    if self._state.backtracking == 0:
3763                        pass
3764                        node =  e
3765
3766
3767
3768
3769
3770                       
3771            except RecognitionException as e:
3772                raise
3773
3774        finally:
3775            pass
3776        return node
3777
3778    # $ANTLR end "expression"
3779
3780
3781
3782    # $ANTLR start "for_"
3783    # src/ll/UL4.g:535:1: for_ returns [node] : n= nestedname 'in' e= expr1 EOF ;
3784    def for_(self, ):
3785        node = None
3786
3787
3788        n = None
3789
3790        e = None
3791
3792
3793        try:
3794            try:
3795                # src/ll/UL4.g:536:2: (n= nestedname 'in' e= expr1 EOF )
3796                # src/ll/UL4.g:537:3: n= nestedname 'in' e= expr1 EOF
3797                pass 
3798                self._state.following.append(self.FOLLOW_nestedname_in_for_2761)
3799                n = self.nestedname()
3800
3801                self._state.following.pop()
3802
3803                self.match(self.input, 54, self.FOLLOW_54_in_for_2765)
3804
3805                self._state.following.append(self.FOLLOW_expr1_in_for_2771)
3806                e = self.expr1()
3807
3808                self._state.following.pop()
3809
3810                if self._state.backtracking == 0:
3811                    pass
3812                    node = ul4c.For(self.location, n, e) 
3813
3814
3815
3816                self.match(self.input, EOF, self.FOLLOW_EOF_in_for_2777)
3817
3818
3819
3820
3821                       
3822            except RecognitionException as e:
3823                raise
3824
3825        finally:
3826            pass
3827        return node
3828
3829    # $ANTLR end "for_"
3830
3831
3832
3833    # $ANTLR start "statement"
3834    # src/ll/UL4.g:546:1: statement returns [node] : (nn= nestedname '=' e= expr1 EOF |n= name '+=' e= expr1 EOF |n= name '-=' e= expr1 EOF |n= name '*=' e= expr1 EOF |n= name '/=' e= expr1 EOF |n= name '//=' e= expr1 EOF |n= name '%=' e= expr1 EOF |e= expression EOF );
3835    def statement(self, ):
3836        node = None
3837
3838
3839        nn = None
3840
3841        e = None
3842
3843        n = None
3844
3845
3846        try:
3847            try:
3848                # src/ll/UL4.g:547:2: (nn= nestedname '=' e= expr1 EOF |n= name '+=' e= expr1 EOF |n= name '-=' e= expr1 EOF |n= name '*=' e= expr1 EOF |n= name '/=' e= expr1 EOF |n= name '//=' e= expr1 EOF |n= name '%=' e= expr1 EOF |e= expression EOF )
3849                alt47 = 8
3850                LA47 = self.input.LA(1)
3851                if LA47 == NAME:
3852                    LA47_1 = self.input.LA(2)
3853
3854                    if (self.synpred71_UL4()) :
3855                        alt47 = 1
3856                    elif (self.synpred72_UL4()) :
3857                        alt47 = 2
3858                    elif (self.synpred73_UL4()) :
3859                        alt47 = 3
3860                    elif (self.synpred74_UL4()) :
3861                        alt47 = 4
3862                    elif (self.synpred75_UL4()) :
3863                        alt47 = 5
3864                    elif (self.synpred76_UL4()) :
3865                        alt47 = 6
3866                    elif (self.synpred77_UL4()) :
3867                        alt47 = 7
3868                    elif (True) :
3869                        alt47 = 8
3870                    else:
3871                        if self._state.backtracking > 0:
3872                            raise BacktrackingFailed
3873
3874
3875                        nvae = NoViableAltException("", 47, 1, self.input)
3876
3877                        raise nvae
3878
3879
3880                elif LA47 == 27:
3881                    LA47_2 = self.input.LA(2)
3882
3883                    if (self.synpred71_UL4()) :
3884                        alt47 = 1
3885                    elif (True) :
3886                        alt47 = 8
3887                    else:
3888                        if self._state.backtracking > 0:
3889                            raise BacktrackingFailed
3890
3891
3892                        nvae = NoViableAltException("", 47, 2, self.input)
3893
3894                        raise nvae
3895
3896
3897                elif LA47 == COLOR or LA47 == DATE or LA47 == FALSE or LA47 == FLOAT or LA47 == INT or LA47 == NONE or LA47 == STRING or LA47 == TRUE or LA47 == 35 or LA47 == 49 or LA47 == 55 or LA47 == 57:
3898                    alt47 = 8
3899                else:
3900                    if self._state.backtracking > 0:
3901                        raise BacktrackingFailed
3902
3903
3904                    nvae = NoViableAltException("", 47, 0, self.input)
3905
3906                    raise nvae
3907
3908
3909                if alt47 == 1:
3910                    # src/ll/UL4.g:547:4: nn= nestedname '=' e= expr1 EOF
3911                    pass 
3912                    self._state.following.append(self.FOLLOW_nestedname_in_statement2798)
3913                    nn = self.nestedname()
3914
3915                    self._state.following.pop()
3916
3917                    self.match(self.input, 45, self.FOLLOW_45_in_statement2800)
3918
3919                    self._state.following.append(self.FOLLOW_expr1_in_statement2804)
3920                    e = self.expr1()
3921
3922                    self._state.following.pop()
3923
3924                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2806)
3925
3926                    if self._state.backtracking == 0:
3927                        pass
3928                        node = ul4c.StoreVar(self.location, nn, e) 
3929
3930
3931
3932
3933                elif alt47 == 2:
3934                    # src/ll/UL4.g:548:4: n= name '+=' e= expr1 EOF
3935                    pass 
3936                    self._state.following.append(self.FOLLOW_name_in_statement2815)
3937                    n = self.name()
3938
3939                    self._state.following.pop()
3940
3941                    self.match(self.input, 33, self.FOLLOW_33_in_statement2817)
3942
3943                    self._state.following.append(self.FOLLOW_expr1_in_statement2821)
3944                    e = self.expr1()
3945
3946                    self._state.following.pop()
3947
3948                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2823)
3949
3950                    if self._state.backtracking == 0:
3951                        pass
3952                        node = ul4c.AddVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
3953
3954
3955
3956
3957                elif alt47 == 3:
3958                    # src/ll/UL4.g:549:4: n= name '-=' e= expr1 EOF
3959                    pass 
3960                    self._state.following.append(self.FOLLOW_name_in_statement2832)
3961                    n = self.name()
3962
3963                    self._state.following.pop()
3964
3965                    self.match(self.input, 36, self.FOLLOW_36_in_statement2834)
3966
3967                    self._state.following.append(self.FOLLOW_expr1_in_statement2838)
3968                    e = self.expr1()
3969
3970                    self._state.following.pop()
3971
3972                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2840)
3973
3974                    if self._state.backtracking == 0:
3975                        pass
3976                        node = ul4c.SubVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
3977
3978
3979
3980
3981                elif alt47 == 4:
3982                    # src/ll/UL4.g:550:4: n= name '*=' e= expr1 EOF
3983                    pass 
3984                    self._state.following.append(self.FOLLOW_name_in_statement2849)
3985                    n = self.name()
3986
3987                    self._state.following.pop()
3988
3989                    self.match(self.input, 31, self.FOLLOW_31_in_statement2851)
3990
3991                    self._state.following.append(self.FOLLOW_expr1_in_statement2855)
3992                    e = self.expr1()
3993
3994                    self._state.following.pop()
3995
3996                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2857)
3997
3998                    if self._state.backtracking == 0:
3999                        pass
4000                        node = ul4c.MulVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4001
4002
4003
4004
4005                elif alt47 == 5:
4006                    # src/ll/UL4.g:551:4: n= name '/=' e= expr1 EOF
4007                    pass 
4008                    self._state.following.append(self.FOLLOW_name_in_statement2866)
4009                    n = self.name()
4010
4011                    self._state.following.pop()
4012
4013                    self.match(self.input, 41, self.FOLLOW_41_in_statement2868)
4014
4015                    self._state.following.append(self.FOLLOW_expr1_in_statement2872)
4016                    e = self.expr1()
4017
4018                    self._state.following.pop()
4019
4020                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2874)
4021
4022                    if self._state.backtracking == 0:
4023                        pass
4024                        node = ul4c.TrueDivVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4025
4026
4027
4028
4029                elif alt47 == 6:
4030                    # src/ll/UL4.g:552:4: n= name '//=' e= expr1 EOF
4031                    pass 
4032                    self._state.following.append(self.FOLLOW_name_in_statement2883)
4033                    n = self.name()
4034
4035                    self._state.following.pop()
4036
4037                    self.match(self.input, 40, self.FOLLOW_40_in_statement2885)
4038
4039                    self._state.following.append(self.FOLLOW_expr1_in_statement2889)
4040                    e = self.expr1()
4041
4042                    self._state.following.pop()
4043
4044                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2891)
4045
4046                    if self._state.backtracking == 0:
4047                        pass
4048                        node = ul4c.FloorDivVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4049
4050
4051
4052
4053                elif alt47 == 7:
4054                    # src/ll/UL4.g:553:4: n= name '%=' e= expr1 EOF
4055                    pass 
4056                    self._state.following.append(self.FOLLOW_name_in_statement2900)
4057                    n = self.name()
4058
4059                    self._state.following.pop()
4060
4061                    self.match(self.input, 26, self.FOLLOW_26_in_statement2902)
4062
4063                    self._state.following.append(self.FOLLOW_expr1_in_statement2906)
4064                    e = self.expr1()
4065
4066                    self._state.following.pop()
4067
4068                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2908)
4069
4070                    if self._state.backtracking == 0:
4071                        pass
4072                        node = ul4c.ModVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e) 
4073
4074
4075
4076
4077                elif alt47 == 8:
4078                    # src/ll/UL4.g:554:4: e= expression EOF
4079                    pass 
4080                    self._state.following.append(self.FOLLOW_expression_in_statement2917)
4081                    e = self.expression()
4082
4083                    self._state.following.pop()
4084
4085                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2919)
4086
4087                    if self._state.backtracking == 0:
4088                        pass
4089                        node = 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 "synpred19_UL4"
4106    def synpred19_UL4_fragment(self, ):
4107        e_list = None
4108
4109
4110        # src/ll/UL4.g:289:4: (e_list= list )
4111        # src/ll/UL4.g:289:4: e_list= list
4112        pass 
4113        self._state.following.append(self.FOLLOW_list_in_synpred19_UL41370)
4114        e_list = self.list()
4115
4116        self._state.following.pop()
4117
4118
4119
4120    # $ANTLR end "synpred19_UL4"
4121
4122
4123
4124    # $ANTLR start "synpred20_UL4"
4125    def synpred20_UL4_fragment(self, ):
4126        e_listcomp = None
4127
4128
4129        # src/ll/UL4.g:290:4: (e_listcomp= listcomprehension )
4130        # src/ll/UL4.g:290:4: e_listcomp= listcomprehension
4131        pass 
4132        self._state.following.append(self.FOLLOW_listcomprehension_in_synpred20_UL41379)
4133        e_listcomp = self.listcomprehension()
4134
4135        self._state.following.pop()
4136
4137
4138
4139    # $ANTLR end "synpred20_UL4"
4140
4141
4142
4143    # $ANTLR start "synpred21_UL4"
4144    def synpred21_UL4_fragment(self, ):
4145        e_dict = None
4146
4147
4148        # src/ll/UL4.g:291:4: (e_dict= dict )
4149        # src/ll/UL4.g:291:4: e_dict= dict
4150        pass 
4151        self._state.following.append(self.FOLLOW_dict_in_synpred21_UL41388)
4152        e_dict = self.dict()
4153
4154        self._state.following.pop()
4155
4156
4157
4158    # $ANTLR end "synpred21_UL4"
4159
4160
4161
4162    # $ANTLR start "synpred22_UL4"
4163    def synpred22_UL4_fragment(self, ):
4164        e_dictcomp = None
4165
4166
4167        # src/ll/UL4.g:292:4: (e_dictcomp= dictcomprehension )
4168        # src/ll/UL4.g:292:4: e_dictcomp= dictcomprehension
4169        pass 
4170        self._state.following.append(self.FOLLOW_dictcomprehension_in_synpred22_UL41397)
4171        e_dictcomp = self.dictcomprehension()
4172
4173        self._state.following.pop()
4174
4175
4176
4177    # $ANTLR end "synpred22_UL4"
4178
4179
4180
4181    # $ANTLR start "synpred23_UL4"
4182    def synpred23_UL4_fragment(self, ):
4183        e_genexpr = None
4184
4185
4186        # src/ll/UL4.g:293:4: ( '(' e_genexpr= generatorexpression ')' )
4187        # src/ll/UL4.g:293:4: '(' e_genexpr= generatorexpression ')'
4188        pass 
4189        self.match(self.input, 27, self.FOLLOW_27_in_synpred23_UL41404)
4190
4191        self._state.following.append(self.FOLLOW_generatorexpression_in_synpred23_UL41408)
4192        e_genexpr = self.generatorexpression()
4193
4194        self._state.following.pop()
4195
4196        self.match(self.input, 28, self.FOLLOW_28_in_synpred23_UL41410)
4197
4198
4199
4200    # $ANTLR end "synpred23_UL4"
4201
4202
4203
4204    # $ANTLR start "synpred25_UL4"
4205    def synpred25_UL4_fragment(self, ):
4206        n0 = None
4207
4208
4209        # src/ll/UL4.g:302:3: ( '(' n0= nestedname ',' ')' )
4210        # src/ll/UL4.g:302:3: '(' n0= nestedname ',' ')'
4211        pass 
4212        self.match(self.input, 27, self.FOLLOW_27_in_synpred25_UL41455)
4213
4214        self._state.following.append(self.FOLLOW_nestedname_in_synpred25_UL41459)
4215        n0 = self.nestedname()
4216
4217        self._state.following.pop()
4218
4219        self.match(self.input, 34, self.FOLLOW_34_in_synpred25_UL41461)
4220
4221        self.match(self.input, 28, self.FOLLOW_28_in_synpred25_UL41463)
4222
4223
4224
4225    # $ANTLR end "synpred25_UL4"
4226
4227
4228
4229    # $ANTLR start "synpred69_UL4"
4230    def synpred69_UL4_fragment(self, ):
4231        ege = None
4232
4233
4234        # src/ll/UL4.g:523:4: (ege= generatorexpression )
4235        # src/ll/UL4.g:523:4: ege= generatorexpression
4236        pass 
4237        self._state.following.append(self.FOLLOW_generatorexpression_in_synpred69_UL42695)
4238        ege = self.generatorexpression()
4239
4240        self._state.following.pop()
4241
4242
4243
4244    # $ANTLR end "synpred69_UL4"
4245
4246
4247
4248    # $ANTLR start "synpred70_UL4"
4249    def synpred70_UL4_fragment(self, ):
4250        ege = None
4251
4252
4253        # src/ll/UL4.g:528:4: (ege= generatorexpression EOF )
4254        # src/ll/UL4.g:528:4: ege= generatorexpression EOF
4255        pass 
4256        self._state.following.append(self.FOLLOW_generatorexpression_in_synpred70_UL42723)
4257        ege = self.generatorexpression()
4258
4259        self._state.following.pop()
4260
4261        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred70_UL42725)
4262
4263
4264
4265    # $ANTLR end "synpred70_UL4"
4266
4267
4268
4269    # $ANTLR start "synpred71_UL4"
4270    def synpred71_UL4_fragment(self, ):
4271        nn = None
4272
4273        e = None
4274
4275
4276        # src/ll/UL4.g:547:4: (nn= nestedname '=' e= expr1 EOF )
4277        # src/ll/UL4.g:547:4: nn= nestedname '=' e= expr1 EOF
4278        pass 
4279        self._state.following.append(self.FOLLOW_nestedname_in_synpred71_UL42798)
4280        nn = self.nestedname()
4281
4282        self._state.following.pop()
4283
4284        self.match(self.input, 45, self.FOLLOW_45_in_synpred71_UL42800)
4285
4286        self._state.following.append(self.FOLLOW_expr1_in_synpred71_UL42804)
4287        e = self.expr1()
4288
4289        self._state.following.pop()
4290
4291        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred71_UL42806)
4292
4293
4294
4295    # $ANTLR end "synpred71_UL4"
4296
4297
4298
4299    # $ANTLR start "synpred72_UL4"
4300    def synpred72_UL4_fragment(self, ):
4301        n = None
4302
4303        e = None
4304
4305
4306        # src/ll/UL4.g:548:4: (n= name '+=' e= expr1 EOF )
4307        # src/ll/UL4.g:548:4: n= name '+=' e= expr1 EOF
4308        pass 
4309        self._state.following.append(self.FOLLOW_name_in_synpred72_UL42815)
4310        n = self.name()
4311
4312        self._state.following.pop()
4313
4314        self.match(self.input, 33, self.FOLLOW_33_in_synpred72_UL42817)
4315
4316        self._state.following.append(self.FOLLOW_expr1_in_synpred72_UL42821)
4317        e = self.expr1()
4318
4319        self._state.following.pop()
4320
4321        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred72_UL42823)
4322
4323
4324
4325    # $ANTLR end "synpred72_UL4"
4326
4327
4328
4329    # $ANTLR start "synpred73_UL4"
4330    def synpred73_UL4_fragment(self, ):
4331        n = None
4332
4333        e = None
4334
4335
4336        # src/ll/UL4.g:549:4: (n= name '-=' e= expr1 EOF )
4337        # src/ll/UL4.g:549:4: n= name '-=' e= expr1 EOF
4338        pass 
4339        self._state.following.append(self.FOLLOW_name_in_synpred73_UL42832)
4340        n = self.name()
4341
4342        self._state.following.pop()
4343
4344        self.match(self.input, 36, self.FOLLOW_36_in_synpred73_UL42834)
4345
4346        self._state.following.append(self.FOLLOW_expr1_in_synpred73_UL42838)
4347        e = self.expr1()
4348
4349        self._state.following.pop()
4350
4351        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred73_UL42840)
4352
4353
4354
4355    # $ANTLR end "synpred73_UL4"
4356
4357
4358
4359    # $ANTLR start "synpred74_UL4"
4360    def synpred74_UL4_fragment(self, ):
4361        n = None
4362
4363        e = None
4364
4365
4366        # src/ll/UL4.g:550:4: (n= name '*=' e= expr1 EOF )
4367        # src/ll/UL4.g:550:4: n= name '*=' e= expr1 EOF
4368        pass 
4369        self._state.following.append(self.FOLLOW_name_in_synpred74_UL42849)
4370        n = self.name()
4371
4372        self._state.following.pop()
4373
4374        self.match(self.input, 31, self.FOLLOW_31_in_synpred74_UL42851)
4375
4376        self._state.following.append(self.FOLLOW_expr1_in_synpred74_UL42855)
4377        e = self.expr1()
4378
4379        self._state.following.pop()
4380
4381        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred74_UL42857)
4382
4383
4384
4385    # $ANTLR end "synpred74_UL4"
4386
4387
4388
4389    # $ANTLR start "synpred75_UL4"
4390    def synpred75_UL4_fragment(self, ):
4391        n = None
4392
4393        e = None
4394
4395
4396        # src/ll/UL4.g:551:4: (n= name '/=' e= expr1 EOF )
4397        # src/ll/UL4.g:551:4: n= name '/=' e= expr1 EOF
4398        pass 
4399        self._state.following.append(self.FOLLOW_name_in_synpred75_UL42866)
4400        n = self.name()
4401
4402        self._state.following.pop()
4403
4404        self.match(self.input, 41, self.FOLLOW_41_in_synpred75_UL42868)
4405
4406        self._state.following.append(self.FOLLOW_expr1_in_synpred75_UL42872)
4407        e = self.expr1()
4408
4409        self._state.following.pop()
4410
4411        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred75_UL42874)
4412
4413
4414
4415    # $ANTLR end "synpred75_UL4"
4416
4417
4418
4419    # $ANTLR start "synpred76_UL4"
4420    def synpred76_UL4_fragment(self, ):
4421        n = None
4422
4423        e = None
4424
4425
4426        # src/ll/UL4.g:552:4: (n= name '//=' e= expr1 EOF )
4427        # src/ll/UL4.g:552:4: n= name '//=' e= expr1 EOF
4428        pass 
4429        self._state.following.append(self.FOLLOW_name_in_synpred76_UL42883)
4430        n = self.name()
4431
4432        self._state.following.pop()
4433
4434        self.match(self.input, 40, self.FOLLOW_40_in_synpred76_UL42885)
4435
4436        self._state.following.append(self.FOLLOW_expr1_in_synpred76_UL42889)
4437        e = self.expr1()
4438
4439        self._state.following.pop()
4440
4441        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred76_UL42891)
4442
4443
4444
4445    # $ANTLR end "synpred76_UL4"
4446
4447
4448
4449    # $ANTLR start "synpred77_UL4"
4450    def synpred77_UL4_fragment(self, ):
4451        n = None
4452
4453        e = None
4454
4455
4456        # src/ll/UL4.g:553:4: (n= name '%=' e= expr1 EOF )
4457        # src/ll/UL4.g:553:4: n= name '%=' e= expr1 EOF
4458        pass 
4459        self._state.following.append(self.FOLLOW_name_in_synpred77_UL42900)
4460        n = self.name()
4461
4462        self._state.following.pop()
4463
4464        self.match(self.input, 26, self.FOLLOW_26_in_synpred77_UL42902)
4465
4466        self._state.following.append(self.FOLLOW_expr1_in_synpred77_UL42906)
4467        e = self.expr1()
4468
4469        self._state.following.pop()
4470
4471        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred77_UL42908)
4472
4473
4474
4475    # $ANTLR end "synpred77_UL4"
4476
4477
4478
4479
4480    def synpred76_UL4(self):
4481        self._state.backtracking += 1
4482        start = self.input.mark()
4483        try:
4484            self.synpred76_UL4_fragment()
4485        except BacktrackingFailed:
4486            success = False
4487        else:
4488            success = True
4489        self.input.rewind(start)
4490        self._state.backtracking -= 1
4491        return success
4492
4493    def synpred22_UL4(self):
4494        self._state.backtracking += 1
4495        start = self.input.mark()
4496        try:
4497            self.synpred22_UL4_fragment()
4498        except BacktrackingFailed:
4499            success = False
4500        else:
4501            success = True
4502        self.input.rewind(start)
4503        self._state.backtracking -= 1
4504        return success
4505
4506    def synpred77_UL4(self):
4507        self._state.backtracking += 1
4508        start = self.input.mark()
4509        try:
4510            self.synpred77_UL4_fragment()
4511        except BacktrackingFailed:
4512            success = False
4513        else:
4514            success = True
4515        self.input.rewind(start)
4516        self._state.backtracking -= 1
4517        return success
4518
4519    def synpred70_UL4(self):
4520        self._state.backtracking += 1
4521        start = self.input.mark()
4522        try:
4523            self.synpred70_UL4_fragment()
4524        except BacktrackingFailed:
4525            success = False
4526        else:
4527            success = True
4528        self.input.rewind(start)
4529        self._state.backtracking -= 1
4530        return success
4531
4532    def synpred75_UL4(self):
4533        self._state.backtracking += 1
4534        start = self.input.mark()
4535        try:
4536            self.synpred75_UL4_fragment()
4537        except BacktrackingFailed:
4538            success = False
4539        else:
4540            success = True
4541        self.input.rewind(start)
4542        self._state.backtracking -= 1
4543        return success
4544
4545    def synpred20_UL4(self):
4546        self._state.backtracking += 1
4547        start = self.input.mark()
4548        try:
4549            self.synpred20_UL4_fragment()
4550        except BacktrackingFailed:
4551            success = False
4552        else:
4553            success = True
4554        self.input.rewind(start)
4555        self._state.backtracking -= 1
4556        return success
4557
4558    def synpred23_UL4(self):
4559        self._state.backtracking += 1
4560        start = self.input.mark()
4561        try:
4562            self.synpred23_UL4_fragment()
4563        except BacktrackingFailed:
4564            success = False
4565        else:
4566            success = True
4567        self.input.rewind(start)
4568        self._state.backtracking -= 1
4569        return success
4570
4571    def synpred72_UL4(self):
4572        self._state.backtracking += 1
4573        start = self.input.mark()
4574        try:
4575            self.synpred72_UL4_fragment()
4576        except BacktrackingFailed:
4577            success = False
4578        else:
4579            success = True
4580        self.input.rewind(start)
4581        self._state.backtracking -= 1
4582        return success
4583
4584    def synpred69_UL4(self):
4585        self._state.backtracking += 1
4586        start = self.input.mark()
4587        try:
4588            self.synpred69_UL4_fragment()
4589        except BacktrackingFailed:
4590            success = False
4591        else:
4592            success = True
4593        self.input.rewind(start)
4594        self._state.backtracking -= 1
4595        return success
4596
4597    def synpred19_UL4(self):
4598        self._state.backtracking += 1
4599        start = self.input.mark()
4600        try:
4601            self.synpred19_UL4_fragment()
4602        except BacktrackingFailed:
4603            success = False
4604        else:
4605            success = True
4606        self.input.rewind(start)
4607        self._state.backtracking -= 1
4608        return success
4609
4610    def synpred71_UL4(self):
4611        self._state.backtracking += 1
4612        start = self.input.mark()
4613        try:
4614            self.synpred71_UL4_fragment()
4615        except BacktrackingFailed:
4616            success = False
4617        else:
4618            success = True
4619        self.input.rewind(start)
4620        self._state.backtracking -= 1
4621        return success
4622
4623    def synpred21_UL4(self):
4624        self._state.backtracking += 1
4625        start = self.input.mark()
4626        try:
4627            self.synpred21_UL4_fragment()
4628        except BacktrackingFailed:
4629            success = False
4630        else:
4631            success = True
4632        self.input.rewind(start)
4633        self._state.backtracking -= 1
4634        return success
4635
4636    def synpred73_UL4(self):
4637        self._state.backtracking += 1
4638        start = self.input.mark()
4639        try:
4640            self.synpred73_UL4_fragment()
4641        except BacktrackingFailed:
4642            success = False
4643        else:
4644            success = True
4645        self.input.rewind(start)
4646        self._state.backtracking -= 1
4647        return success
4648
4649    def synpred25_UL4(self):
4650        self._state.backtracking += 1
4651        start = self.input.mark()
4652        try:
4653            self.synpred25_UL4_fragment()
4654        except BacktrackingFailed:
4655            success = False
4656        else:
4657            success = True
4658        self.input.rewind(start)
4659        self._state.backtracking -= 1
4660        return success
4661
4662    def synpred74_UL4(self):
4663        self._state.backtracking += 1
4664        start = self.input.mark()
4665        try:
4666            self.synpred74_UL4_fragment()
4667        except BacktrackingFailed:
4668            success = False
4669        else:
4670            success = True
4671        self.input.rewind(start)
4672        self._state.backtracking -= 1
4673        return success
4674
4675
4676
4677 
4678
4679    FOLLOW_NONE_in_none695 = frozenset([1])
4680    FOLLOW_TRUE_in_true_712 = frozenset([1])
4681    FOLLOW_FALSE_in_false_729 = frozenset([1])
4682    FOLLOW_INT_in_int_746 = frozenset([1])
4683    FOLLOW_FLOAT_in_float_763 = frozenset([1])
4684    FOLLOW_STRING_in_string780 = frozenset([1])
4685    FOLLOW_DATE_in_date797 = frozenset([1])
4686    FOLLOW_COLOR_in_color814 = frozenset([1])
4687    FOLLOW_NAME_in_name831 = frozenset([1])
4688    FOLLOW_none_in_literal850 = frozenset([1])
4689    FOLLOW_false__in_literal859 = frozenset([1])
4690    FOLLOW_true__in_literal868 = frozenset([1])
4691    FOLLOW_int__in_literal877 = frozenset([1])
4692    FOLLOW_float__in_literal886 = frozenset([1])
4693    FOLLOW_string_in_literal895 = frozenset([1])
4694    FOLLOW_date_in_literal904 = frozenset([1])
4695    FOLLOW_color_in_literal913 = frozenset([1])
4696    FOLLOW_name_in_literal922 = frozenset([1])
4697    FOLLOW_49_in_list943 = frozenset([50])
4698    FOLLOW_50_in_list947 = frozenset([1])
4699    FOLLOW_49_in_list956 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4700    FOLLOW_expr1_in_list964 = frozenset([34, 50])
4701    FOLLOW_34_in_list975 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4702    FOLLOW_expr1_in_list982 = frozenset([34, 50])
4703    FOLLOW_34_in_list993 = frozenset([50])
4704    FOLLOW_50_in_list998 = frozenset([1])
4705    FOLLOW_49_in_listcomprehension1022 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4706    FOLLOW_expr1_in_listcomprehension1028 = frozenset([52])
4707    FOLLOW_52_in_listcomprehension1032 = frozenset([14, 27])
4708    FOLLOW_nestedname_in_listcomprehension1038 = frozenset([54])
4709    FOLLOW_54_in_listcomprehension1042 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4710    FOLLOW_expr1_in_listcomprehension1048 = frozenset([50, 53])
4711    FOLLOW_53_in_listcomprehension1057 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4712    FOLLOW_expr1_in_listcomprehension1064 = frozenset([50])
4713    FOLLOW_50_in_listcomprehension1075 = frozenset([1])
4714    FOLLOW_expr1_in_dictitem1100 = frozenset([42])
4715    FOLLOW_42_in_dictitem1104 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4716    FOLLOW_expr1_in_dictitem1110 = frozenset([1])
4717    FOLLOW_57_in_dict1129 = frozenset([58])
4718    FOLLOW_58_in_dict1133 = frozenset([1])
4719    FOLLOW_57_in_dict1142 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4720    FOLLOW_dictitem_in_dict1150 = frozenset([34, 58])
4721    FOLLOW_34_in_dict1161 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4722    FOLLOW_dictitem_in_dict1168 = frozenset([34, 58])
4723    FOLLOW_34_in_dict1179 = frozenset([58])
4724    FOLLOW_58_in_dict1184 = frozenset([1])
4725    FOLLOW_57_in_dictcomprehension1208 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4726    FOLLOW_expr1_in_dictcomprehension1214 = frozenset([42])
4727    FOLLOW_42_in_dictcomprehension1218 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4728    FOLLOW_expr1_in_dictcomprehension1224 = frozenset([52])
4729    FOLLOW_52_in_dictcomprehension1228 = frozenset([14, 27])
4730    FOLLOW_nestedname_in_dictcomprehension1234 = frozenset([54])
4731    FOLLOW_54_in_dictcomprehension1238 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4732    FOLLOW_expr1_in_dictcomprehension1244 = frozenset([53, 58])
4733    FOLLOW_53_in_dictcomprehension1253 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4734    FOLLOW_expr1_in_dictcomprehension1260 = frozenset([58])
4735    FOLLOW_58_in_dictcomprehension1271 = frozenset([1])
4736    FOLLOW_expr1_in_generatorexpression1299 = frozenset([52])
4737    FOLLOW_52_in_generatorexpression1303 = frozenset([14, 27])
4738    FOLLOW_nestedname_in_generatorexpression1309 = frozenset([54])
4739    FOLLOW_54_in_generatorexpression1313 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4740    FOLLOW_expr1_in_generatorexpression1319 = frozenset([1, 53])
4741    FOLLOW_53_in_generatorexpression1328 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4742    FOLLOW_expr1_in_generatorexpression1335 = frozenset([1])
4743    FOLLOW_literal_in_atom1361 = frozenset([1])
4744    FOLLOW_list_in_atom1370 = frozenset([1])
4745    FOLLOW_listcomprehension_in_atom1379 = frozenset([1])
4746    FOLLOW_dict_in_atom1388 = frozenset([1])
4747    FOLLOW_dictcomprehension_in_atom1397 = frozenset([1])
4748    FOLLOW_27_in_atom1404 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4749    FOLLOW_generatorexpression_in_atom1408 = frozenset([28])
4750    FOLLOW_28_in_atom1410 = frozenset([1])
4751    FOLLOW_27_in_atom1417 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4752    FOLLOW_expr1_in_atom1421 = frozenset([28])
4753    FOLLOW_28_in_atom1423 = frozenset([1])
4754    FOLLOW_name_in_nestedname1446 = frozenset([1])
4755    FOLLOW_27_in_nestedname1455 = frozenset([14, 27])
4756    FOLLOW_nestedname_in_nestedname1459 = frozenset([34])
4757    FOLLOW_34_in_nestedname1461 = frozenset([28])
4758    FOLLOW_28_in_nestedname1463 = frozenset([1])
4759    FOLLOW_27_in_nestedname1472 = frozenset([14, 27])
4760    FOLLOW_nestedname_in_nestedname1478 = frozenset([34])
4761    FOLLOW_34_in_nestedname1482 = frozenset([14, 27])
4762    FOLLOW_nestedname_in_nestedname1488 = frozenset([28, 34])
4763    FOLLOW_34_in_nestedname1499 = frozenset([14, 27])
4764    FOLLOW_nestedname_in_nestedname1506 = frozenset([28, 34])
4765    FOLLOW_34_in_nestedname1517 = frozenset([28])
4766    FOLLOW_28_in_nestedname1522 = frozenset([1])
4767    FOLLOW_atom_in_expr91551 = frozenset([1, 27, 37, 49])
4768    FOLLOW_37_in_expr91567 = frozenset([14])
4769    FOLLOW_name_in_expr91574 = frozenset([1, 27, 37, 49])
4770    FOLLOW_27_in_expr91590 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 28, 29, 30, 35, 49, 55, 57])
4771    FOLLOW_30_in_expr91620 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4772    FOLLOW_exprarg_in_expr91624 = frozenset([28, 34])
4773    FOLLOW_34_in_expr91632 = frozenset([28])
4774    FOLLOW_29_in_expr91650 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4775    FOLLOW_exprarg_in_expr91654 = frozenset([28, 34])
4776    FOLLOW_34_in_expr91669 = frozenset([30])
4777    FOLLOW_30_in_expr91676 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4778    FOLLOW_exprarg_in_expr91680 = frozenset([28, 34])
4779    FOLLOW_34_in_expr91695 = frozenset([28])
4780    FOLLOW_exprarg_in_expr91715 = frozenset([28, 34])
4781    FOLLOW_34_in_expr91730 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4782    FOLLOW_exprarg_in_expr91739 = frozenset([28, 34])
4783    FOLLOW_34_in_expr91761 = frozenset([14])
4784    FOLLOW_name_in_expr91770 = frozenset([45])
4785    FOLLOW_45_in_expr91772 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4786    FOLLOW_exprarg_in_expr91776 = frozenset([28, 34])
4787    FOLLOW_34_in_expr91798 = frozenset([29])
4788    FOLLOW_29_in_expr91805 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4789    FOLLOW_exprarg_in_expr91809 = frozenset([28, 34])
4790    FOLLOW_34_in_expr91831 = frozenset([30])
4791    FOLLOW_30_in_expr91838 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4792    FOLLOW_exprarg_in_expr91842 = frozenset([28, 34])
4793    FOLLOW_34_in_expr91857 = frozenset([28])
4794    FOLLOW_name_in_expr91877 = frozenset([45])
4795    FOLLOW_45_in_expr91879 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4796    FOLLOW_exprarg_in_expr91883 = frozenset([28, 34])
4797    FOLLOW_34_in_expr91898 = frozenset([14])
4798    FOLLOW_name_in_expr91907 = frozenset([45])
4799    FOLLOW_45_in_expr91909 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4800    FOLLOW_exprarg_in_expr91913 = frozenset([28, 34])
4801    FOLLOW_34_in_expr91935 = frozenset([29])
4802    FOLLOW_29_in_expr91942 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4803    FOLLOW_exprarg_in_expr91946 = frozenset([28, 34])
4804    FOLLOW_34_in_expr91968 = frozenset([30])
4805    FOLLOW_30_in_expr91975 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4806    FOLLOW_exprarg_in_expr91979 = frozenset([28, 34])
4807    FOLLOW_34_in_expr91994 = frozenset([28])
4808    FOLLOW_28_in_expr92005 = frozenset([1, 27, 37, 49])
4809    FOLLOW_49_in_expr92019 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 42, 49, 55, 57])
4810    FOLLOW_42_in_expr92030 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 50, 55, 57])
4811    FOLLOW_expr1_in_expr92045 = frozenset([50])
4812    FOLLOW_expr1_in_expr92069 = frozenset([42, 50])
4813    FOLLOW_42_in_expr92084 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 50, 55, 57])
4814    FOLLOW_expr1_in_expr92103 = frozenset([50])
4815    FOLLOW_50_in_expr92132 = frozenset([1, 27, 37, 49])
4816    FOLLOW_35_in_expr82168 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4817    FOLLOW_expr9_in_expr82181 = frozenset([1])
4818    FOLLOW_expr8_in_expr72204 = frozenset([1, 25, 29, 38, 39])
4819    FOLLOW_29_in_expr72221 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4820    FOLLOW_38_in_expr72234 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4821    FOLLOW_39_in_expr72247 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4822    FOLLOW_25_in_expr72260 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4823    FOLLOW_expr8_in_expr72274 = frozenset([1, 25, 29, 38, 39])
4824    FOLLOW_expr7_in_expr62302 = frozenset([1, 32, 35])
4825    FOLLOW_32_in_expr62319 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4826    FOLLOW_35_in_expr62332 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4827    FOLLOW_expr7_in_expr62346 = frozenset([1, 32, 35])
4828    FOLLOW_expr6_in_expr52374 = frozenset([1, 24, 43, 44, 46, 47, 48])
4829    FOLLOW_46_in_expr52391 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4830    FOLLOW_24_in_expr52404 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4831    FOLLOW_43_in_expr52417 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4832    FOLLOW_44_in_expr52430 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4833    FOLLOW_47_in_expr52443 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4834    FOLLOW_48_in_expr52456 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4835    FOLLOW_expr6_in_expr52470 = frozenset([1, 24, 43, 44, 46, 47, 48])
4836    FOLLOW_expr5_in_expr42498 = frozenset([1, 54, 55])
4837    FOLLOW_55_in_expr42520 = frozenset([54])
4838    FOLLOW_54_in_expr42533 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4839    FOLLOW_expr5_in_expr42540 = frozenset([1])
4840    FOLLOW_55_in_expr32566 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 57])
4841    FOLLOW_expr4_in_expr32572 = frozenset([1])
4842    FOLLOW_expr4_in_expr32583 = frozenset([1])
4843    FOLLOW_expr3_in_expr22607 = frozenset([1, 51])
4844    FOLLOW_51_in_expr22618 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4845    FOLLOW_expr3_in_expr22625 = frozenset([1, 51])
4846    FOLLOW_expr2_in_expr12653 = frozenset([1, 56])
4847    FOLLOW_56_in_expr12664 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4848    FOLLOW_expr2_in_expr12671 = frozenset([1, 56])
4849    FOLLOW_generatorexpression_in_exprarg2695 = frozenset([1])
4850    FOLLOW_expr1_in_exprarg2704 = frozenset([1])
4851    FOLLOW_generatorexpression_in_expression2723 = frozenset([])
4852    FOLLOW_EOF_in_expression2725 = frozenset([1])
4853    FOLLOW_expr1_in_expression2734 = frozenset([])
4854    FOLLOW_EOF_in_expression2736 = frozenset([1])
4855    FOLLOW_nestedname_in_for_2761 = frozenset([54])
4856    FOLLOW_54_in_for_2765 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4857    FOLLOW_expr1_in_for_2771 = frozenset([])
4858    FOLLOW_EOF_in_for_2777 = frozenset([1])
4859    FOLLOW_nestedname_in_statement2798 = frozenset([45])
4860    FOLLOW_45_in_statement2800 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4861    FOLLOW_expr1_in_statement2804 = frozenset([])
4862    FOLLOW_EOF_in_statement2806 = frozenset([1])
4863    FOLLOW_name_in_statement2815 = frozenset([33])
4864    FOLLOW_33_in_statement2817 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4865    FOLLOW_expr1_in_statement2821 = frozenset([])
4866    FOLLOW_EOF_in_statement2823 = frozenset([1])
4867    FOLLOW_name_in_statement2832 = frozenset([36])
4868    FOLLOW_36_in_statement2834 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4869    FOLLOW_expr1_in_statement2838 = frozenset([])
4870    FOLLOW_EOF_in_statement2840 = frozenset([1])
4871    FOLLOW_name_in_statement2849 = frozenset([31])
4872    FOLLOW_31_in_statement2851 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4873    FOLLOW_expr1_in_statement2855 = frozenset([])
4874    FOLLOW_EOF_in_statement2857 = frozenset([1])
4875    FOLLOW_name_in_statement2866 = frozenset([41])
4876    FOLLOW_41_in_statement2868 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4877    FOLLOW_expr1_in_statement2872 = frozenset([])
4878    FOLLOW_EOF_in_statement2874 = frozenset([1])
4879    FOLLOW_name_in_statement2883 = frozenset([40])
4880    FOLLOW_40_in_statement2885 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4881    FOLLOW_expr1_in_statement2889 = frozenset([])
4882    FOLLOW_EOF_in_statement2891 = frozenset([1])
4883    FOLLOW_name_in_statement2900 = frozenset([26])
4884    FOLLOW_26_in_statement2902 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4885    FOLLOW_expr1_in_statement2906 = frozenset([])
4886    FOLLOW_EOF_in_statement2908 = frozenset([1])
4887    FOLLOW_expression_in_statement2917 = frozenset([])
4888    FOLLOW_EOF_in_statement2919 = frozenset([1])
4889    FOLLOW_list_in_synpred19_UL41370 = frozenset([1])
4890    FOLLOW_listcomprehension_in_synpred20_UL41379 = frozenset([1])
4891    FOLLOW_dict_in_synpred21_UL41388 = frozenset([1])
4892    FOLLOW_dictcomprehension_in_synpred22_UL41397 = frozenset([1])
4893    FOLLOW_27_in_synpred23_UL41404 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4894    FOLLOW_generatorexpression_in_synpred23_UL41408 = frozenset([28])
4895    FOLLOW_28_in_synpred23_UL41410 = frozenset([1])
4896    FOLLOW_27_in_synpred25_UL41455 = frozenset([14, 27])
4897    FOLLOW_nestedname_in_synpred25_UL41459 = frozenset([34])
4898    FOLLOW_34_in_synpred25_UL41461 = frozenset([28])
4899    FOLLOW_28_in_synpred25_UL41463 = frozenset([1])
4900    FOLLOW_generatorexpression_in_synpred69_UL42695 = frozenset([1])
4901    FOLLOW_generatorexpression_in_synpred70_UL42723 = frozenset([])
4902    FOLLOW_EOF_in_synpred70_UL42725 = frozenset([1])
4903    FOLLOW_nestedname_in_synpred71_UL42798 = frozenset([45])
4904    FOLLOW_45_in_synpred71_UL42800 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4905    FOLLOW_expr1_in_synpred71_UL42804 = frozenset([])
4906    FOLLOW_EOF_in_synpred71_UL42806 = frozenset([1])
4907    FOLLOW_name_in_synpred72_UL42815 = frozenset([33])
4908    FOLLOW_33_in_synpred72_UL42817 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4909    FOLLOW_expr1_in_synpred72_UL42821 = frozenset([])
4910    FOLLOW_EOF_in_synpred72_UL42823 = frozenset([1])
4911    FOLLOW_name_in_synpred73_UL42832 = frozenset([36])
4912    FOLLOW_36_in_synpred73_UL42834 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4913    FOLLOW_expr1_in_synpred73_UL42838 = frozenset([])
4914    FOLLOW_EOF_in_synpred73_UL42840 = frozenset([1])
4915    FOLLOW_name_in_synpred74_UL42849 = frozenset([31])
4916    FOLLOW_31_in_synpred74_UL42851 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4917    FOLLOW_expr1_in_synpred74_UL42855 = frozenset([])
4918    FOLLOW_EOF_in_synpred74_UL42857 = frozenset([1])
4919    FOLLOW_name_in_synpred75_UL42866 = frozenset([41])
4920    FOLLOW_41_in_synpred75_UL42868 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4921    FOLLOW_expr1_in_synpred75_UL42872 = frozenset([])
4922    FOLLOW_EOF_in_synpred75_UL42874 = frozenset([1])
4923    FOLLOW_name_in_synpred76_UL42883 = frozenset([40])
4924    FOLLOW_40_in_synpred76_UL42885 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4925    FOLLOW_expr1_in_synpred76_UL42889 = frozenset([])
4926    FOLLOW_EOF_in_synpred76_UL42891 = frozenset([1])
4927    FOLLOW_name_in_synpred77_UL42900 = frozenset([26])
4928    FOLLOW_26_in_synpred77_UL42902 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57])
4929    FOLLOW_expr1_in_synpred77_UL42906 = frozenset([])
4930    FOLLOW_EOF_in_synpred77_UL42908 = frozenset([1])
4931
4932
4933
4934def main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
4935    from antlr3.main import ParserMain
4936    main = ParserMain("UL4Lexer", UL4Parser)
4937
4938    main.stdin = stdin
4939    main.stdout = stdout
4940    main.stderr = stderr
4941    main.execute(argv)
4942
4943
4944
4945if __name__ == '__main__':
4946    main(sys.argv)
Note: See TracBrowser for help on using the browser.