-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathyatgFW.cpp
11090 lines (9789 loc) · 386 KB
/
yatgFW.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/** \file
* This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23
*
* - From the grammar source file : C:\\Zlang\\src\\Zzparser\\Grammar\\yatgFW.g
* - On : 2010-07-07 17:24:44
* - for the tree parser : yatgFWTreeParser *
* Editing it, at least manually, is not wise.
*
* C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
*
*
*/
// [The "BSD licence"]
// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
// http://www.temporal-wave.com
// http://www.linkedin.com/in/jimidle
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/* -----------------------------------------
* Include the ANTLR3 generated header file.
*/
#include "yatgFW.h"
#include "ZInterp.h"
/* ----------------------------------------- */
/* MACROS that hide the C interface implementations from the
* generated code, which makes it a little more understandable to the human eye.
* I am very much against using C pre-processor macros for function calls and bits
* of code as you cannot see what is happening when single stepping in debuggers
* and so on. The exception (in my book at least) is for generated code, where you are
* not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
* hides some indirect calls, but is always referring to the input stream. This is
* probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
* the runtime interfaces without changing the generated code too often, without
* confusing the reader of the generated output, who may not wish to know the gory
* details of the interface inheritance.
*/
#define CTX ctx
/* Aids in accessing scopes for grammar programmers
*/
#undef SCOPE_TYPE
#undef SCOPE_STACK
#undef SCOPE_TOP
#define SCOPE_TYPE(scope) pyatgFW_##scope##_SCOPE
#define SCOPE_STACK(scope) pyatgFW_##scope##Stack
#define SCOPE_TOP(scope) ctx->pyatgFW_##scope##Top
#define SCOPE_SIZE(scope) ctx->pyatgFW_##scope##Stack_limit
#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
/* Macros for accessing things in the parser
*/
#undef PARSER
#undef RECOGNIZER
#undef HAVEPARSEDRULE
#undef INPUT
#undef STRSTREAM
#undef HASEXCEPTION
#undef EXCEPTION
#undef MATCHT
#undef MATCHANYT
#undef FOLLOWSTACK
#undef FOLLOWPUSH
#undef FOLLOWPOP
#undef PRECOVER
#undef PREPORTERROR
#undef LA
#undef LT
#undef CONSTRUCTEX
#undef CONSUME
#undef MARK
#undef REWIND
#undef REWINDLAST
#undef PERRORRECOVERY
#undef HASFAILED
#undef FAILEDFLAG
#undef RECOVERFROMMISMATCHEDSET
#undef RECOVERFROMMISMATCHEDELEMENT
#undef BACKTRACKING
#undef ADAPTOR
#undef RULEMEMO
#undef SEEK
#undef INDEX
#undef DBG
#define PARSER ctx->pTreeParser
#define RECOGNIZER PARSER->rec
#define PSRSTATE RECOGNIZER->state
#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
#define INPUT PARSER->ctnstream
#define ISTREAM INPUT->tnstream->istream
#define STRSTREAM INPUT->tnstream
#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
#define EXCEPTION PSRSTATE->exception
#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
#define FOLLOWSTACK PSRSTATE->following
#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
#define LA(n) ISTREAM->_LA(ISTREAM, n)
#define LT(n) INPUT->tnstream->_LT(INPUT->tnstream, n)
#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
#define CONSUME() ISTREAM->consume(ISTREAM)
#define MARK() ISTREAM->mark(ISTREAM)
#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
#define PERRORRECOVERY PSRSTATE->errorRecovery
#define FAILEDFLAG PSRSTATE->failed
#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
#define BACKTRACKING PSRSTATE->backtracking
#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
#define ADAPTOR INPUT->adaptor
#define RULEMEMO PSRSTATE->ruleMemo
#define SEEK(n) ISTREAM->seek(ISTREAM, n)
#define INDEX() ISTREAM->index(ISTREAM)
#define DBG RECOGNIZER->debugger
#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
/* The 4 tokens defined below may well clash with your own #defines or token types. If so
* then for the present you must use different names for your defines as these are hard coded
* in the code generator. It would be better not to use such names internally, and maybe
* we can change this in a forthcoming release. I deliberately do not #undef these
* here as this will at least give you a redefined error somewhere if they clash.
*/
#define UP ANTLR3_TOKEN_UP
#define DOWN ANTLR3_TOKEN_DOWN
#define EOR ANTLR3_TOKEN_EOR
#define INVALID ANTLR3_TOKEN_INVALID
/* =============================================================================
* Functions to create and destroy scopes. First come the rule scopes, followed
* by the global declared scopes.
*/
/* ============================================================================= */
/* =============================================================================
* Start of recognizer
*/
/** \brief Table of all token names in symbolic order, mainly used for
* error reporting.
*/
pANTLR3_UINT8 yatgFWTokenNames[167+4]
= {
(pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
(pANTLR3_UINT8) "<EOR>",
(pANTLR3_UINT8) "<DOWN>",
(pANTLR3_UINT8) "<UP>",
(pANTLR3_UINT8) "VDECL",
(pANTLR3_UINT8) "VDEF",
(pANTLR3_UINT8) "VVAL",
(pANTLR3_UINT8) "ESEQ",
(pANTLR3_UINT8) "EIF",
(pANTLR3_UINT8) "EIF_COND",
(pANTLR3_UINT8) "EIF_THEN",
(pANTLR3_UINT8) "EIF_ELSE",
(pANTLR3_UINT8) "EIF_END",
(pANTLR3_UINT8) "EWHILE",
(pANTLR3_UINT8) "EWHILE_CON",
(pANTLR3_UINT8) "EWHILE_EXP",
(pANTLR3_UINT8) "EWHILE_END",
(pANTLR3_UINT8) "EDO",
(pANTLR3_UINT8) "EDO_CON",
(pANTLR3_UINT8) "EDO_EXP",
(pANTLR3_UINT8) "EDO_END",
(pANTLR3_UINT8) "EFOR",
(pANTLR3_UINT8) "EFOR_SRC",
(pANTLR3_UINT8) "EFOR_EXP",
(pANTLR3_UINT8) "EFOR_END",
(pANTLR3_UINT8) "ESRC_START",
(pANTLR3_UINT8) "ESRC_TO",
(pANTLR3_UINT8) "ESRC_BY",
(pANTLR3_UINT8) "ESRC_WHERE",
(pANTLR3_UINT8) "P_BOX2",
(pANTLR3_UINT8) "P_P2",
(pANTLR3_UINT8) "P_P3",
(pANTLR3_UINT8) "ARR_A",
(pANTLR3_UINT8) "ARR_BIT",
(pANTLR3_UINT8) "ARR_BIT_RANGE",
(pANTLR3_UINT8) "ARR_IND",
(pANTLR3_UINT8) "LP_EXIT",
(pANTLR3_UINT8) "LP_EXIT_WITH",
(pANTLR3_UINT8) "LP_CONT",
(pANTLR3_UINT8) "CASE",
(pANTLR3_UINT8) "CASE_Exp",
(pANTLR3_UINT8) "CASE_Item",
(pANTLR3_UINT8) "DEFAULT",
(pANTLR3_UINT8) "ECASE_END",
(pANTLR3_UINT8) "STRUCT",
(pANTLR3_UINT8) "MEMBER",
(pANTLR3_UINT8) "ETRY",
(pANTLR3_UINT8) "ETRY_EXP",
(pANTLR3_UINT8) "ECATCH_EXP",
(pANTLR3_UINT8) "RETURN",
(pANTLR3_UINT8) "FUN_DEF",
(pANTLR3_UINT8) "FUN_NAME",
(pANTLR3_UINT8) "BODY",
(pANTLR3_UINT8) "FUN",
(pANTLR3_UINT8) "MAPPED",
(pANTLR3_UINT8) "FUN_DEF_END",
(pANTLR3_UINT8) "STRING",
(pANTLR3_UINT8) "CONTEXT",
(pANTLR3_UINT8) "COORDSYS",
(pANTLR3_UINT8) "SELECTION",
(pANTLR3_UINT8) "PIVOT",
(pANTLR3_UINT8) "ABOUT",
(pANTLR3_UINT8) "LOCAL",
(pANTLR3_UINT8) "WORLD",
(pANTLR3_UINT8) "PARENT",
(pANTLR3_UINT8) "LEVEL",
(pANTLR3_UINT8) "ANIMATE",
(pANTLR3_UINT8) "TIME",
(pANTLR3_UINT8) "WITH",
(pANTLR3_UINT8) "UNDO",
(pANTLR3_UINT8) "EIN",
(pANTLR3_UINT8) "AT",
(pANTLR3_UINT8) "OPERAND",
(pANTLR3_UINT8) "DOT",
(pANTLR3_UINT8) "ARG_EXPR_L",
(pANTLR3_UINT8) "ID_MORE",
(pANTLR3_UINT8) "SET",
(pANTLR3_UINT8) "PRIM_EXP",
(pANTLR3_UINT8) "NUMBER",
(pANTLR3_UINT8) "MATRIX",
(pANTLR3_UINT8) "ROW",
(pANTLR3_UINT8) "SS_COMMA",
(pANTLR3_UINT8) "KW_LOCAL",
(pANTLR3_UINT8) "KW_GLOBAL",
(pANTLR3_UINT8) "IDENTIFIER",
(pANTLR3_UINT8) "SS_EQUAL",
(pANTLR3_UINT8) "KW_IF",
(pANTLR3_UINT8) "KW_THEN",
(pANTLR3_UINT8) "KW_DO",
(pANTLR3_UINT8) "KW_ELSE",
(pANTLR3_UINT8) "KW_WHILE",
(pANTLR3_UINT8) "KW_FOR",
(pANTLR3_UINT8) "KW_IN",
(pANTLR3_UINT8) "KW_COLLECT",
(pANTLR3_UINT8) "KW_TO",
(pANTLR3_UINT8) "KW_BY",
(pANTLR3_UINT8) "KW_WHERE",
(pANTLR3_UINT8) "KW_EXIT",
(pANTLR3_UINT8) "KW_WITH",
(pANTLR3_UINT8) "KW_CONTINUE",
(pANTLR3_UINT8) "KW_CASE",
(pANTLR3_UINT8) "KW_OF",
(pANTLR3_UINT8) "SS_OPAREN",
(pANTLR3_UINT8) "SS_CPAREN",
(pANTLR3_UINT8) "SS_COLON",
(pANTLR3_UINT8) "KW_DEFAULT",
(pANTLR3_UINT8) "KW_STRUCT",
(pANTLR3_UINT8) "KW_TRY",
(pANTLR3_UINT8) "KW_CATCH",
(pANTLR3_UINT8) "KW_MAPPED",
(pANTLR3_UINT8) "KW_FUNCTION",
(pANTLR3_UINT8) "KW_FN",
(pANTLR3_UINT8) "KW_RETURN",
(pANTLR3_UINT8) "KW_ANIMATE",
(pANTLR3_UINT8) "KW_AT",
(pANTLR3_UINT8) "KW_LEVEL",
(pANTLR3_UINT8) "KW_TIME",
(pANTLR3_UINT8) "KW_COORDSYS",
(pANTLR3_UINT8) "KW_WORLD",
(pANTLR3_UINT8) "KW_PARENT",
(pANTLR3_UINT8) "KW_ABOUT",
(pANTLR3_UINT8) "KW_PIVOT",
(pANTLR3_UINT8) "KW_SELECTION",
(pANTLR3_UINT8) "KW_UNDO",
(pANTLR3_UINT8) "KW_SET",
(pANTLR3_UINT8) "SS_PLUS",
(pANTLR3_UINT8) "SS_MINUS",
(pANTLR3_UINT8) "SS_STAR",
(pANTLR3_UINT8) "SS_FSLASH",
(pANTLR3_UINT8) "SS_PERCENT",
(pANTLR3_UINT8) "SS_DOT",
(pANTLR3_UINT8) "SS_OBRACKET",
(pANTLR3_UINT8) "SS_CBRACKET",
(pANTLR3_UINT8) "HEX_LITERAL",
(pANTLR3_UINT8) "STRING_LITERIAL",
(pANTLR3_UINT8) "SS_HASH",
(pANTLR3_UINT8) "KW_TRUE",
(pANTLR3_UINT8) "KW_FALSE",
(pANTLR3_UINT8) "KW_ON",
(pANTLR3_UINT8) "KW_OFF",
(pANTLR3_UINT8) "KW_OK",
(pANTLR3_UINT8) "KW_UNDEFINED",
(pANTLR3_UINT8) "KW_UNSUPPLIED",
(pANTLR3_UINT8) "DIGIT",
(pANTLR3_UINT8) "DIGIT1",
(pANTLR3_UINT8) "SS_STAR_EQUAL",
(pANTLR3_UINT8) "SS_FSLASH_EQUAL",
(pANTLR3_UINT8) "SS_PERCENT_EQUAL",
(pANTLR3_UINT8) "SS_PLUS_EQUAL",
(pANTLR3_UINT8) "SS_MINUS_EQUAL",
(pANTLR3_UINT8) "SS_D_BAR",
(pANTLR3_UINT8) "SS_D_AMP",
(pANTLR3_UINT8) "SS_D_EQUAL",
(pANTLR3_UINT8) "SS_EXC_EQUAL",
(pANTLR3_UINT8) "SS_LT",
(pANTLR3_UINT8) "SS_GT",
(pANTLR3_UINT8) "SS_LT_EQUAL",
(pANTLR3_UINT8) "SS_GT_EQUAL",
(pANTLR3_UINT8) "SS_OCBRACKET",
(pANTLR3_UINT8) "SS_CCBRACKET",
(pANTLR3_UINT8) "SS_D_DOT",
(pANTLR3_UINT8) "EscapeSequence",
(pANTLR3_UINT8) "SS_DQUOTE",
(pANTLR3_UINT8) "ESQ_FSLASH_SQUOTE",
(pANTLR3_UINT8) "LETTER",
(pANTLR3_UINT8) "HexDigit",
(pANTLR3_UINT8) "WS",
(pANTLR3_UINT8) "EOL",
(pANTLR3_UINT8) "COMMENT",
(pANTLR3_UINT8) "LINE_COMMENT",
(pANTLR3_UINT8) "REF_OP"
};
// Forward declare the locally static matching functions we have generated.
//
static void program (pyatgFW ctx);
static yatgFW_expr_return expr (pyatgFW ctx);
static void variable_decls (pyatgFW ctx);
static void type_decl (pyatgFW ctx);
static void decl (pyatgFW ctx);
static void if_expr (pyatgFW ctx);
static void while_loop (pyatgFW ctx);
static void do_loop (pyatgFW ctx);
static void for_loop (pyatgFW ctx);
static yatgFW_source_return source (pyatgFW ctx);
static void loop_exit (pyatgFW ctx);
static void loop_continue (pyatgFW ctx);
static void case_expr (pyatgFW ctx);
static void case_item (pyatgFW ctx);
static void struct_def (pyatgFW ctx);
static void member (pyatgFW ctx);
static void try_expr (pyatgFW ctx);
static void function_def (pyatgFW ctx);
static void fun (pyatgFW ctx);
static void function_return (pyatgFW ctx);
static void context_expr (pyatgFW ctx);
static void context (pyatgFW ctx);
static void set_context (pyatgFW ctx);
static void argT (pyatgFW ctx);
static void argument_expression_list (pyatgFW ctx);
static void unary_expression (pyatgFW ctx);
static void operand (pyatgFW ctx);
static void operand_op (pyatgFW ctx);
static void constant (pyatgFW ctx);
static void number (pyatgFW ctx);
static void assignment_expression (pyatgFW ctx);
static yatgFW_cexprx_return cexprx (pyatgFW ctx);
static yatgFW_lvalue_return lvalue (pyatgFW ctx);
static yatgFW_assignment_operator_return assignment_operator (pyatgFW ctx);
static void expr_seq (pyatgFW ctx);
static yatgFW_expr_g_return expr_g (pyatgFW ctx);
static void box2 (pyatgFW ctx);
static void point3 (pyatgFW ctx);
static void point2 (pyatgFW ctx);
static void array (pyatgFW ctx);
static void bitarray (pyatgFW ctx);
static void arrrange (pyatgFW ctx);
static void matrix (pyatgFW ctx);
static ANTLR3_BOOLEAN synpred2_yatgFW (pyatgFW ctx);
static ANTLR3_BOOLEAN synpred43_yatgFW (pyatgFW ctx);
static ANTLR3_BOOLEAN synpred94_yatgFW (pyatgFW ctx);
static void yatgFWFree(pyatgFW ctx);
/* For use in tree output where we are accumulating rule labels via label += ruleRef
* we need a function that knows how to free a return scope when the list is destroyed.
* We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
*/
static void ANTLR3_CDECL freeScope(void * scope)
{
ANTLR3_FREE(scope);
}
/** \brief Name of the grammar file that generated this code
*/
static const char fileName[] = "C:\\Zlang\\src\\Zzparser\\Grammar\\yatgFW.g";
/** \brief Return the name of the grammar file that generated this code.
*/
static const char * getGrammarFileName()
{
return fileName;
}
/** \brief Create a new yatgFW parser and return a context for it.
*
* \param[in] instream Pointer to an input stream interface.
*
* \return Pointer to new parser context upon success.
*/
ANTLR3_API pyatgFW
yatgFWNew (pANTLR3_COMMON_TREE_NODE_STREAM instream)
{
// See if we can create a new parser with the standard constructor
//
return yatgFWNewSSD(instream, NULL);
}
/** \brief Create a new yatgFW parser and return a context for it.
*
* \param[in] instream Pointer to an input stream interface.
*
* \return Pointer to new parser context upon success.
*/
ANTLR3_API pyatgFW
yatgFWNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
{
pyatgFW ctx; /* Context structure we will build and return */
ctx = (pyatgFW) ANTLR3_CALLOC(1, sizeof(yatgFW));
if (ctx == NULL)
{
// Failed to allocate memory for parser context
//
return NULL;
}
/* -------------------------------------------------------------------
* Memory for basic structure is allocated, now to fill in
* the base ANTLR3 structures. We initialize the function pointers
* for the standard ANTLR3 parser function set, but upon return
* from here, the programmer may set the pointers to provide custom
* implementations of each function.
*
* We don't use the macros defined in yatgFW.h here, in order that you can get a sense
* of what goes where.
*/
/* Create a base Tree parser/recognizer, using the supplied tree node stream
*/
ctx->pTreeParser = antlr3TreeParserNewStream(ANTLR3_SIZE_HINT, instream, state);
/* Install the implementation of our yatgFW interface
*/
ctx->program = program;
ctx->expr = expr;
ctx->variable_decls = variable_decls;
ctx->type_decl = type_decl;
ctx->decl = decl;
ctx->if_expr = if_expr;
ctx->while_loop = while_loop;
ctx->do_loop = do_loop;
ctx->for_loop = for_loop;
ctx->source = source;
ctx->loop_exit = loop_exit;
ctx->loop_continue = loop_continue;
ctx->case_expr = case_expr;
ctx->case_item = case_item;
ctx->struct_def = struct_def;
ctx->member = member;
ctx->try_expr = try_expr;
ctx->function_def = function_def;
ctx->fun = fun;
ctx->function_return = function_return;
ctx->context_expr = context_expr;
ctx->context = context;
ctx->set_context = set_context;
ctx->argT = argT;
ctx->argument_expression_list = argument_expression_list;
ctx->unary_expression = unary_expression;
ctx->operand = operand;
ctx->operand_op = operand_op;
ctx->constant = constant;
ctx->number = number;
ctx->assignment_expression = assignment_expression;
ctx->cexprx = cexprx;
ctx->lvalue = lvalue;
ctx->assignment_operator = assignment_operator;
ctx->expr_seq = expr_seq;
ctx->expr_g = expr_g;
ctx->box2 = box2;
ctx->point3 = point3;
ctx->point2 = point2;
ctx->array = array;
ctx->bitarray = bitarray;
ctx->arrrange = arrrange;
ctx->matrix = matrix;
ctx->synpred2_yatgFW = synpred2_yatgFW;
ctx->synpred43_yatgFW = synpred43_yatgFW;
ctx->synpred94_yatgFW = synpred94_yatgFW;
ctx->free = yatgFWFree;
ctx->getGrammarFileName = getGrammarFileName;
/* Install the scope pushing methods.
*/
/* Install the token table
*/
PSRSTATE->tokenNames = yatgFWTokenNames;
/* Return the newly built parser to the caller
*/
return ctx;
}
/** Free the parser resources
*/
static void
yatgFWFree(pyatgFW ctx)
{
/* Free any scope memory
*/
// Free this parser
//
ctx->pTreeParser->free(ctx->pTreeParser);
ANTLR3_FREE(ctx);
/* Everything is released, so we can return
*/
return;
}
/** Return token names used by this tree parser
*
* The returned pointer is used as an index into the token names table (using the token
* number as the index).
*
* \return Pointer to first char * in the table.
*/
static pANTLR3_UINT8 *getTokenNames()
{
return yatgFWTokenNames;
}
/* Declare the bitsets
*/
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_program94 */
static ANTLR3_BITWORD FOLLOW_expr_in_program94_bits[] = { ANTLR3_UINT64_LIT(0x020650D3E0222192), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_expr_in_program94 = { FOLLOW_expr_in_program94_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_assignment_expression_in_expr108 */
static ANTLR3_BITWORD FOLLOW_assignment_expression_in_expr108_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_assignment_expression_in_expr108 = { FOLLOW_assignment_expression_in_expr108_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_variable_decls_in_expr113 */
static ANTLR3_BITWORD FOLLOW_variable_decls_in_expr113_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_variable_decls_in_expr113 = { FOLLOW_variable_decls_in_expr113_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_if_expr_in_expr122 */
static ANTLR3_BITWORD FOLLOW_if_expr_in_expr122_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_if_expr_in_expr122 = { FOLLOW_if_expr_in_expr122_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_while_loop_in_expr131 */
static ANTLR3_BITWORD FOLLOW_while_loop_in_expr131_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_while_loop_in_expr131 = { FOLLOW_while_loop_in_expr131_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_do_loop_in_expr140 */
static ANTLR3_BITWORD FOLLOW_do_loop_in_expr140_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_do_loop_in_expr140 = { FOLLOW_do_loop_in_expr140_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_for_loop_in_expr149 */
static ANTLR3_BITWORD FOLLOW_for_loop_in_expr149_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_for_loop_in_expr149 = { FOLLOW_for_loop_in_expr149_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_loop_exit_in_expr158 */
static ANTLR3_BITWORD FOLLOW_loop_exit_in_expr158_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_loop_exit_in_expr158 = { FOLLOW_loop_exit_in_expr158_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_loop_continue_in_expr167 */
static ANTLR3_BITWORD FOLLOW_loop_continue_in_expr167_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_loop_continue_in_expr167 = { FOLLOW_loop_continue_in_expr167_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_case_expr_in_expr176 */
static ANTLR3_BITWORD FOLLOW_case_expr_in_expr176_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_case_expr_in_expr176 = { FOLLOW_case_expr_in_expr176_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_struct_def_in_expr185 */
static ANTLR3_BITWORD FOLLOW_struct_def_in_expr185_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_struct_def_in_expr185 = { FOLLOW_struct_def_in_expr185_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_try_expr_in_expr194 */
static ANTLR3_BITWORD FOLLOW_try_expr_in_expr194_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_try_expr_in_expr194 = { FOLLOW_try_expr_in_expr194_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_function_def_in_expr203 */
static ANTLR3_BITWORD FOLLOW_function_def_in_expr203_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_function_def_in_expr203 = { FOLLOW_function_def_in_expr203_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_function_return_in_expr212 */
static ANTLR3_BITWORD FOLLOW_function_return_in_expr212_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_function_return_in_expr212 = { FOLLOW_function_return_in_expr212_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_context_expr_in_expr221 */
static ANTLR3_BITWORD FOLLOW_context_expr_in_expr221_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_context_expr_in_expr221 = { FOLLOW_context_expr_in_expr221_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_seq_in_expr230 */
static ANTLR3_BITWORD FOLLOW_expr_seq_in_expr230_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_expr_seq_in_expr230 = { FOLLOW_expr_seq_in_expr230_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_VDECL_in_variable_decls257 */
static ANTLR3_BITWORD FOLLOW_VDECL_in_variable_decls257_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_VDECL_in_variable_decls257 = { FOLLOW_VDECL_in_variable_decls257_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_type_decl_in_variable_decls259 */
static ANTLR3_BITWORD FOLLOW_type_decl_in_variable_decls259_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000020) };
static ANTLR3_BITSET_LIST FOLLOW_type_decl_in_variable_decls259 = { FOLLOW_type_decl_in_variable_decls259_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_decl_in_variable_decls261 */
static ANTLR3_BITWORD FOLLOW_decl_in_variable_decls261_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000028) };
static ANTLR3_BITSET_LIST FOLLOW_decl_in_variable_decls261 = { FOLLOW_decl_in_variable_decls261_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_type_decl0 */
static ANTLR3_BITWORD FOLLOW_set_in_type_decl0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_set_in_type_decl0 = { FOLLOW_set_in_type_decl0_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_VDEF_in_decl297 */
static ANTLR3_BITWORD FOLLOW_VDEF_in_decl297_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_VDEF_in_decl297 = { FOLLOW_VDEF_in_decl297_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_IDENTIFIER_in_decl301 */
static ANTLR3_BITWORD FOLLOW_IDENTIFIER_in_decl301_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000040) };
static ANTLR3_BITSET_LIST FOLLOW_IDENTIFIER_in_decl301 = { FOLLOW_IDENTIFIER_in_decl301_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_VVAL_in_decl305 */
static ANTLR3_BITWORD FOLLOW_VVAL_in_decl305_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_VVAL_in_decl305 = { FOLLOW_VVAL_in_decl305_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_decl309 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_decl309_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_decl309 = { FOLLOW_expr_g_in_decl309_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_VDEF_in_decl321 */
static ANTLR3_BITWORD FOLLOW_VDEF_in_decl321_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_VDEF_in_decl321 = { FOLLOW_VDEF_in_decl321_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_IDENTIFIER_in_decl323 */
static ANTLR3_BITWORD FOLLOW_IDENTIFIER_in_decl323_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_IDENTIFIER_in_decl323 = { FOLLOW_IDENTIFIER_in_decl323_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EIF_in_if_expr343 */
static ANTLR3_BITWORD FOLLOW_EIF_in_if_expr343_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_EIF_in_if_expr343 = { FOLLOW_EIF_in_if_expr343_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EIF_COND_in_if_expr346 */
static ANTLR3_BITWORD FOLLOW_EIF_COND_in_if_expr346_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_EIF_COND_in_if_expr346 = { FOLLOW_EIF_COND_in_if_expr346_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_if_expr351 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_if_expr351_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_if_expr351 = { FOLLOW_expr_g_in_if_expr351_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EWHILE_in_while_loop382 */
static ANTLR3_BITWORD FOLLOW_EWHILE_in_while_loop382_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_EWHILE_in_while_loop382 = { FOLLOW_EWHILE_in_while_loop382_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EWHILE_CON_in_while_loop385 */
static ANTLR3_BITWORD FOLLOW_EWHILE_CON_in_while_loop385_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_EWHILE_CON_in_while_loop385 = { FOLLOW_EWHILE_CON_in_while_loop385_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_while_loop390 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_while_loop390_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_while_loop390 = { FOLLOW_expr_g_in_while_loop390_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EDO_in_do_loop414 */
static ANTLR3_BITWORD FOLLOW_EDO_in_do_loop414_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_EDO_in_do_loop414 = { FOLLOW_EDO_in_do_loop414_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EDO_CON_in_do_loop417 */
static ANTLR3_BITWORD FOLLOW_EDO_CON_in_do_loop417_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_EDO_CON_in_do_loop417 = { FOLLOW_EDO_CON_in_do_loop417_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_do_loop423 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_do_loop423_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_do_loop423 = { FOLLOW_expr_g_in_do_loop423_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EFOR_in_for_loop448 */
static ANTLR3_BITWORD FOLLOW_EFOR_in_for_loop448_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_EFOR_in_for_loop448 = { FOLLOW_EFOR_in_for_loop448_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_IDENTIFIER_in_for_loop450 */
static ANTLR3_BITWORD FOLLOW_IDENTIFIER_in_for_loop450_bits[] = { ANTLR3_UINT64_LIT(0x0000000000400000) };
static ANTLR3_BITSET_LIST FOLLOW_IDENTIFIER_in_for_loop450 = { FOLLOW_IDENTIFIER_in_for_loop450_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EFOR_SRC_in_for_loop453 */
static ANTLR3_BITWORD FOLLOW_EFOR_SRC_in_for_loop453_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_EFOR_SRC_in_for_loop453 = { FOLLOW_EFOR_SRC_in_for_loop453_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_source_in_for_loop458 */
static ANTLR3_BITWORD FOLLOW_source_in_for_loop458_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_source_in_for_loop458 = { FOLLOW_source_in_for_loop458_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ESRC_START_in_source481 */
static ANTLR3_BITWORD FOLLOW_ESRC_START_in_source481_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ESRC_START_in_source481 = { FOLLOW_ESRC_START_in_source481_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_source483 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_source483_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_source483 = { FOLLOW_expr_g_in_source483_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ESRC_TO_in_source488 */
static ANTLR3_BITWORD FOLLOW_ESRC_TO_in_source488_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ESRC_TO_in_source488 = { FOLLOW_ESRC_TO_in_source488_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_source490 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_source490_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_source490 = { FOLLOW_expr_g_in_source490_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ESRC_BY_in_source497 */
static ANTLR3_BITWORD FOLLOW_ESRC_BY_in_source497_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ESRC_BY_in_source497 = { FOLLOW_ESRC_BY_in_source497_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_source499 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_source499_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_source499 = { FOLLOW_expr_g_in_source499_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ESRC_WHERE_in_source506 */
static ANTLR3_BITWORD FOLLOW_ESRC_WHERE_in_source506_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ESRC_WHERE_in_source506 = { FOLLOW_ESRC_WHERE_in_source506_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_source508 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_source508_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_source508 = { FOLLOW_expr_g_in_source508_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LP_EXIT_in_loop_exit533 */
static ANTLR3_BITWORD FOLLOW_LP_EXIT_in_loop_exit533_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_LP_EXIT_in_loop_exit533 = { FOLLOW_LP_EXIT_in_loop_exit533_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LP_CONT_in_loop_continue556 */
static ANTLR3_BITWORD FOLLOW_LP_CONT_in_loop_continue556_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_LP_CONT_in_loop_continue556 = { FOLLOW_LP_CONT_in_loop_continue556_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CASE_in_case_expr578 */
static ANTLR3_BITWORD FOLLOW_CASE_in_case_expr578_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CASE_in_case_expr578 = { FOLLOW_CASE_in_case_expr578_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CASE_Exp_in_case_expr582 */
static ANTLR3_BITWORD FOLLOW_CASE_Exp_in_case_expr582_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CASE_Exp_in_case_expr582 = { FOLLOW_CASE_Exp_in_case_expr582_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_case_expr584 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_case_expr584_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_case_expr584 = { FOLLOW_expr_g_in_case_expr584_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CASE_Item_in_case_item605 */
static ANTLR3_BITWORD FOLLOW_CASE_Item_in_case_item605_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CASE_Item_in_case_item605 = { FOLLOW_CASE_Item_in_case_item605_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_constant_in_case_item608 */
static ANTLR3_BITWORD FOLLOW_constant_in_case_item608_bits[] = { ANTLR3_UINT64_LIT(0x020650D3E0222190), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_constant_in_case_item608 = { FOLLOW_constant_in_case_item608_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_case_item610 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_case_item610_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_case_item610 = { FOLLOW_expr_g_in_case_item610_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CASE_Item_in_case_item619 */
static ANTLR3_BITWORD FOLLOW_CASE_Item_in_case_item619_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CASE_Item_in_case_item619 = { FOLLOW_CASE_Item_in_case_item619_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DEFAULT_in_case_item623 */
static ANTLR3_BITWORD FOLLOW_DEFAULT_in_case_item623_bits[] = { ANTLR3_UINT64_LIT(0x020650D3E0222190), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_DEFAULT_in_case_item623 = { FOLLOW_DEFAULT_in_case_item623_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_case_item625 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_case_item625_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_case_item625 = { FOLLOW_expr_g_in_case_item625_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_STRUCT_in_struct_def643 */
static ANTLR3_BITWORD FOLLOW_STRUCT_in_struct_def643_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_STRUCT_in_struct_def643 = { FOLLOW_STRUCT_in_struct_def643_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_member_in_struct_def645 */
static ANTLR3_BITWORD FOLLOW_member_in_struct_def645_bits[] = { ANTLR3_UINT64_LIT(0x0004200000000008) };
static ANTLR3_BITSET_LIST FOLLOW_member_in_struct_def645 = { FOLLOW_member_in_struct_def645_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_MEMBER_in_member667 */
static ANTLR3_BITWORD FOLLOW_MEMBER_in_member667_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_MEMBER_in_member667 = { FOLLOW_MEMBER_in_member667_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_IDENTIFIER_in_member669 */
static ANTLR3_BITWORD FOLLOW_IDENTIFIER_in_member669_bits[] = { ANTLR3_UINT64_LIT(0x020650D3E0222190), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_IDENTIFIER_in_member669 = { FOLLOW_IDENTIFIER_in_member669_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_member671 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_member671_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_member671 = { FOLLOW_expr_g_in_member671_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_function_def_in_member681 */
static ANTLR3_BITWORD FOLLOW_function_def_in_member681_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_function_def_in_member681 = { FOLLOW_function_def_in_member681_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ETRY_in_try_expr699 */
static ANTLR3_BITWORD FOLLOW_ETRY_in_try_expr699_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ETRY_in_try_expr699 = { FOLLOW_ETRY_in_try_expr699_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ETRY_EXP_in_try_expr703 */
static ANTLR3_BITWORD FOLLOW_ETRY_EXP_in_try_expr703_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ETRY_EXP_in_try_expr703 = { FOLLOW_ETRY_EXP_in_try_expr703_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_try_expr705 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_try_expr705_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_try_expr705 = { FOLLOW_expr_g_in_try_expr705_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ECATCH_EXP_in_try_expr710 */
static ANTLR3_BITWORD FOLLOW_ECATCH_EXP_in_try_expr710_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ECATCH_EXP_in_try_expr710 = { FOLLOW_ECATCH_EXP_in_try_expr710_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_try_expr713 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_try_expr713_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_try_expr713 = { FOLLOW_expr_g_in_try_expr713_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_FUN_DEF_in_function_def735 */
static ANTLR3_BITWORD FOLLOW_FUN_DEF_in_function_def735_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_FUN_DEF_in_function_def735 = { FOLLOW_FUN_DEF_in_function_def735_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_FUN_NAME_in_function_def738 */
static ANTLR3_BITWORD FOLLOW_FUN_NAME_in_function_def738_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_FUN_NAME_in_function_def738 = { FOLLOW_FUN_NAME_in_function_def738_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_IDENTIFIER_in_function_def740 */
static ANTLR3_BITWORD FOLLOW_IDENTIFIER_in_function_def740_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_IDENTIFIER_in_function_def740 = { FOLLOW_IDENTIFIER_in_function_def740_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ARG_EXPR_L_in_function_def744 */
static ANTLR3_BITWORD FOLLOW_ARG_EXPR_L_in_function_def744_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ARG_EXPR_L_in_function_def744 = { FOLLOW_ARG_EXPR_L_in_function_def744_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_argument_expression_list_in_function_def748 */
static ANTLR3_BITWORD FOLLOW_argument_expression_list_in_function_def748_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008), ANTLR3_UINT64_LIT(0x0000000000100000) };
static ANTLR3_BITSET_LIST FOLLOW_argument_expression_list_in_function_def748 = { FOLLOW_argument_expression_list_in_function_def748_bits, 2 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_fun0 */
static ANTLR3_BITWORD FOLLOW_set_in_fun0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_set_in_fun0 = { FOLLOW_set_in_fun0_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_RETURN_in_function_return791 */
static ANTLR3_BITWORD FOLLOW_RETURN_in_function_return791_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_RETURN_in_function_return791 = { FOLLOW_RETURN_in_function_return791_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_function_return793 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_function_return793_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_function_return793 = { FOLLOW_expr_g_in_function_return793_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context_expr810 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context_expr810_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context_expr810 = { FOLLOW_CONTEXT_in_context_expr810_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_context_in_context_expr812 */
static ANTLR3_BITWORD FOLLOW_context_in_context_expr812_bits[] = { ANTLR3_UINT64_LIT(0x020650D3E0222190), ANTLR3_UINT64_LIT(0xE12000001020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_context_in_context_expr812 = { FOLLOW_context_in_context_expr812_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_context_expr815 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_context_expr815_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_context_expr815 = { FOLLOW_expr_g_in_context_expr815_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context830 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context830_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context830 = { FOLLOW_CONTEXT_in_context830_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ANIMATE_in_context833 */
static ANTLR3_BITWORD FOLLOW_ANIMATE_in_context833_bits[] = { ANTLR3_UINT64_LIT(0x00000003E0000080), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_ANIMATE_in_context833 = { FOLLOW_ANIMATE_in_context833_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_cexprx_in_context835 */
static ANTLR3_BITWORD FOLLOW_cexprx_in_context835_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_cexprx_in_context835 = { FOLLOW_cexprx_in_context835_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context846 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context846_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context846 = { FOLLOW_CONTEXT_in_context846_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_AT_in_context848 */
static ANTLR3_BITWORD FOLLOW_AT_in_context848_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000), ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_AT_in_context848 = { FOLLOW_AT_in_context848_bits, 2 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LEVEL_in_context850 */
static ANTLR3_BITWORD FOLLOW_LEVEL_in_context850_bits[] = { ANTLR3_UINT64_LIT(0x00000003E0000080), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_LEVEL_in_context850 = { FOLLOW_LEVEL_in_context850_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_operand_in_context852 */
static ANTLR3_BITWORD FOLLOW_operand_in_context852_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_operand_in_context852 = { FOLLOW_operand_in_context852_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context863 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context863_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context863 = { FOLLOW_CONTEXT_in_context863_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_AT_in_context865 */
static ANTLR3_BITWORD FOLLOW_AT_in_context865_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000), ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_AT_in_context865 = { FOLLOW_AT_in_context865_bits, 2 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_TIME_in_context867 */
static ANTLR3_BITWORD FOLLOW_TIME_in_context867_bits[] = { ANTLR3_UINT64_LIT(0x00000003E0000080), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_TIME_in_context867 = { FOLLOW_TIME_in_context867_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_operand_in_context870 */
static ANTLR3_BITWORD FOLLOW_operand_in_context870_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_operand_in_context870 = { FOLLOW_operand_in_context870_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context881 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context881_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context881 = { FOLLOW_CONTEXT_in_context881_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EIN_in_context883 */
static ANTLR3_BITWORD FOLLOW_EIN_in_context883_bits[] = { ANTLR3_UINT64_LIT(0x00000003E0000080), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_EIN_in_context883 = { FOLLOW_EIN_in_context883_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_operand_in_context885 */
static ANTLR3_BITWORD FOLLOW_operand_in_context885_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_operand_in_context885 = { FOLLOW_operand_in_context885_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_KW_IN_in_context892 */
static ANTLR3_BITWORD FOLLOW_KW_IN_in_context892_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000), ANTLR3_UINT64_LIT(0x0020000000000000) };
static ANTLR3_BITSET_LIST FOLLOW_KW_IN_in_context892 = { FOLLOW_KW_IN_in_context892_bits, 2 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_KW_COORDSYS_in_context896 */
static ANTLR3_BITWORD FOLLOW_KW_COORDSYS_in_context896_bits[] = { ANTLR3_UINT64_LIT(0x0200000000000000) };
static ANTLR3_BITSET_LIST FOLLOW_KW_COORDSYS_in_context896 = { FOLLOW_KW_COORDSYS_in_context896_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context910 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context910_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context910 = { FOLLOW_CONTEXT_in_context910_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COORDSYS_in_context913 */
static ANTLR3_BITWORD FOLLOW_COORDSYS_in_context913_bits[] = { ANTLR3_UINT64_LIT(0x4000000000000000) };
static ANTLR3_BITSET_LIST FOLLOW_COORDSYS_in_context913 = { FOLLOW_COORDSYS_in_context913_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LOCAL_in_context915 */
static ANTLR3_BITWORD FOLLOW_LOCAL_in_context915_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_LOCAL_in_context915 = { FOLLOW_LOCAL_in_context915_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context925 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context925_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context925 = { FOLLOW_CONTEXT_in_context925_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COORDSYS_in_context928 */
static ANTLR3_BITWORD FOLLOW_COORDSYS_in_context928_bits[] = { ANTLR3_UINT64_LIT(0x8000000000000000) };
static ANTLR3_BITSET_LIST FOLLOW_COORDSYS_in_context928 = { FOLLOW_COORDSYS_in_context928_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_WORLD_in_context930 */
static ANTLR3_BITWORD FOLLOW_WORLD_in_context930_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_WORLD_in_context930 = { FOLLOW_WORLD_in_context930_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context940 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context940_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context940 = { FOLLOW_CONTEXT_in_context940_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COORDSYS_in_context942 */
static ANTLR3_BITWORD FOLLOW_COORDSYS_in_context942_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000), ANTLR3_UINT64_LIT(0x0000000000000001) };
static ANTLR3_BITSET_LIST FOLLOW_COORDSYS_in_context942 = { FOLLOW_COORDSYS_in_context942_bits, 2 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_PARENT_in_context944 */
static ANTLR3_BITWORD FOLLOW_PARENT_in_context944_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_PARENT_in_context944 = { FOLLOW_PARENT_in_context944_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context954 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context954_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context954 = { FOLLOW_CONTEXT_in_context954_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COORDSYS_in_context956 */
static ANTLR3_BITWORD FOLLOW_COORDSYS_in_context956_bits[] = { ANTLR3_UINT64_LIT(0x00000003E0000080), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_COORDSYS_in_context956 = { FOLLOW_COORDSYS_in_context956_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_operand_in_context958 */
static ANTLR3_BITWORD FOLLOW_operand_in_context958_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_operand_in_context958 = { FOLLOW_operand_in_context958_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_KW_ABOUT_in_context970 */
static ANTLR3_BITWORD FOLLOW_KW_ABOUT_in_context970_bits[] = { ANTLR3_UINT64_LIT(0x0200000000000000) };
static ANTLR3_BITSET_LIST FOLLOW_KW_ABOUT_in_context970 = { FOLLOW_KW_ABOUT_in_context970_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context979 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context979_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context979 = { FOLLOW_CONTEXT_in_context979_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ABOUT_in_context981 */
static ANTLR3_BITWORD FOLLOW_ABOUT_in_context981_bits[] = { ANTLR3_UINT64_LIT(0x1000000000000000) };
static ANTLR3_BITSET_LIST FOLLOW_ABOUT_in_context981 = { FOLLOW_ABOUT_in_context981_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_PIVOT_in_context983 */
static ANTLR3_BITWORD FOLLOW_PIVOT_in_context983_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_PIVOT_in_context983 = { FOLLOW_PIVOT_in_context983_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context995 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context995_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context995 = { FOLLOW_CONTEXT_in_context995_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ABOUT_in_context997 */
static ANTLR3_BITWORD FOLLOW_ABOUT_in_context997_bits[] = { ANTLR3_UINT64_LIT(0x0800000000000000) };
static ANTLR3_BITSET_LIST FOLLOW_ABOUT_in_context997 = { FOLLOW_ABOUT_in_context997_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SELECTION_in_context999 */
static ANTLR3_BITWORD FOLLOW_SELECTION_in_context999_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_SELECTION_in_context999 = { FOLLOW_SELECTION_in_context999_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context1009 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context1009_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context1009 = { FOLLOW_CONTEXT_in_context1009_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ABOUT_in_context1011 */
static ANTLR3_BITWORD FOLLOW_ABOUT_in_context1011_bits[] = { ANTLR3_UINT64_LIT(0x0400000000000000) };
static ANTLR3_BITSET_LIST FOLLOW_ABOUT_in_context1011 = { FOLLOW_ABOUT_in_context1011_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COORDSYS_in_context1013 */
static ANTLR3_BITWORD FOLLOW_COORDSYS_in_context1013_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_COORDSYS_in_context1013 = { FOLLOW_COORDSYS_in_context1013_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context1022 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context1022_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context1022 = { FOLLOW_CONTEXT_in_context1022_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ABOUT_in_context1024 */
static ANTLR3_BITWORD FOLLOW_ABOUT_in_context1024_bits[] = { ANTLR3_UINT64_LIT(0x00000003E0000080), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_ABOUT_in_context1024 = { FOLLOW_ABOUT_in_context1024_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_operand_in_context1026 */
static ANTLR3_BITWORD FOLLOW_operand_in_context1026_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_operand_in_context1026 = { FOLLOW_operand_in_context1026_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_CONTEXT_in_context1038 */
static ANTLR3_BITWORD FOLLOW_CONTEXT_in_context1038_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_CONTEXT_in_context1038 = { FOLLOW_CONTEXT_in_context1038_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_UNDO_in_context1041 */
static ANTLR3_BITWORD FOLLOW_UNDO_in_context1041_bits[] = { ANTLR3_UINT64_LIT(0x00000003E0000080), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_UNDO_in_context1041 = { FOLLOW_UNDO_in_context1041_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_cexprx_in_context1044 */
static ANTLR3_BITWORD FOLLOW_cexprx_in_context1044_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_cexprx_in_context1044 = { FOLLOW_cexprx_in_context1044_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SET_in_set_context1063 */
static ANTLR3_BITWORD FOLLOW_SET_in_set_context1063_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_SET_in_set_context1063 = { FOLLOW_SET_in_set_context1063_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_context_in_set_context1065 */
static ANTLR3_BITWORD FOLLOW_context_in_set_context1065_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_context_in_set_context1065 = { FOLLOW_context_in_set_context1065_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_IDENTIFIER_in_argT1085 */
static ANTLR3_BITWORD FOLLOW_IDENTIFIER_in_argT1085_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_IDENTIFIER_in_argT1085 = { FOLLOW_IDENTIFIER_in_argT1085_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_operand_in_argT1088 */
static ANTLR3_BITWORD FOLLOW_operand_in_argT1088_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_operand_in_argT1088 = { FOLLOW_operand_in_argT1088_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_argT_in_argument_expression_list1107 */
static ANTLR3_BITWORD FOLLOW_argT_in_argument_expression_list1107_bits[] = { ANTLR3_UINT64_LIT(0x000000000000000A), ANTLR3_UINT64_LIT(0x0000000000100000) };
static ANTLR3_BITSET_LIST FOLLOW_argT_in_argument_expression_list1107 = { FOLLOW_argT_in_argument_expression_list1107_bits, 2 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_operand_in_unary_expression1119 */
static ANTLR3_BITWORD FOLLOW_operand_in_unary_expression1119_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_operand_in_unary_expression1119 = { FOLLOW_operand_in_unary_expression1119_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_OPERAND_in_operand1139 */
static ANTLR3_BITWORD FOLLOW_OPERAND_in_operand1139_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_OPERAND_in_operand1139 = { FOLLOW_OPERAND_in_operand1139_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_IDENTIFIER_in_operand1141 */
static ANTLR3_BITWORD FOLLOW_IDENTIFIER_in_operand1141_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000), ANTLR3_UINT64_LIT(0x0000000000000E00) };
static ANTLR3_BITSET_LIST FOLLOW_IDENTIFIER_in_operand1141 = { FOLLOW_IDENTIFIER_in_operand1141_bits, 2 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DOT_in_operand1158 */
static ANTLR3_BITWORD FOLLOW_DOT_in_operand1158_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_DOT_in_operand1158 = { FOLLOW_DOT_in_operand1158_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_IDENTIFIER_in_operand1160 */
static ANTLR3_BITWORD FOLLOW_IDENTIFIER_in_operand1160_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_IDENTIFIER_in_operand1160 = { FOLLOW_IDENTIFIER_in_operand1160_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ARR_IND_in_operand1181 */
static ANTLR3_BITWORD FOLLOW_ARR_IND_in_operand1181_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ARR_IND_in_operand1181 = { FOLLOW_ARR_IND_in_operand1181_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_operand1183 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_operand1183_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_operand1183 = { FOLLOW_expr_g_in_operand1183_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ARG_EXPR_L_in_operand1203 */
static ANTLR3_BITWORD FOLLOW_ARG_EXPR_L_in_operand1203_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
static ANTLR3_BITSET_LIST FOLLOW_ARG_EXPR_L_in_operand1203 = { FOLLOW_ARG_EXPR_L_in_operand1203_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_g_in_operand1205 */
static ANTLR3_BITWORD FOLLOW_expr_g_in_operand1205_bits[] = { ANTLR3_UINT64_LIT(0x020650D3E0222198), ANTLR3_UINT64_LIT(0xE00000000020C100), ANTLR3_UINT64_LIT(0x000000003FFE7FE3) };
static ANTLR3_BITSET_LIST FOLLOW_expr_g_in_operand1205 = { FOLLOW_expr_g_in_operand1205_bits, 3 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_MORE_in_operand1216 */
static ANTLR3_BITWORD FOLLOW_ID_MORE_in_operand1216_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
static ANTLR3_BITSET_LIST FOLLOW_ID_MORE_in_operand1216 = { FOLLOW_ID_MORE_in_operand1216_bits, 1 };
/** Bitset defining follow set for error recovery in rule state: FOLLOW_constant_in_operand1231 */
static ANTLR3_BITWORD FOLLOW_constant_in_operand1231_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
static ANTLR3_BITSET_LIST FOLLOW_constant_in_operand1231 = { FOLLOW_constant_in_operand1231_bits, 1 };