1 # Generated from C.g4 by ANTLR 4.7.1
4 from io
import StringIO
5 from typing
.io
import TextIO
10 # The file defines the parser for C source files.
12 # THIS FILE IS AUTO-GENENERATED. PLEASE DON NOT MODIFY THIS FILE.
13 # This file is generated by running:
14 # java org.antlr.Tool C.g
16 # Copyright (c) 2009 - 2010, Intel Corporation All rights reserved.
18 # SPDX-License-Identifier: BSD-2-Clause-Patent
22 import Ecc
.CodeFragment
as CodeFragment
23 import Ecc
.FileProfile
as FileProfile
26 with
StringIO() as buf
:
27 buf
.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3k")
28 buf
.write("\u0380\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
29 buf
.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
30 buf
.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
31 buf
.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
32 buf
.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
33 buf
.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
34 buf
.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
35 buf
.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
36 buf
.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
37 buf
.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
38 buf
.write("D\4E\tE\4F\tF\4G\tG\4H\tH\3\2\7\2\u0092\n\2\f\2\16\2\u0095")
39 buf
.write("\13\2\3\3\5\3\u0098\n\3\3\3\3\3\7\3\u009c\n\3\f\3\16\3")
40 buf
.write("\u009f\13\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00a7\n\3\5\3")
41 buf
.write("\u00a9\n\3\3\4\5\4\u00ac\n\4\3\4\3\4\6\4\u00b0\n\4\r\4")
42 buf
.write("\16\4\u00b1\3\4\3\4\3\4\5\4\u00b7\n\4\3\4\3\4\3\5\3\5")
43 buf
.write("\3\5\6\5\u00be\n\5\r\5\16\5\u00bf\3\6\3\6\5\6\u00c4\n")
44 buf
.write("\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00cc\n\6\3\6\3\6\3\6\5")
45 buf
.write("\6\u00d1\n\6\3\7\3\7\3\7\7\7\u00d6\n\7\f\7\16\7\u00d9")
46 buf
.write("\13\7\3\b\3\b\3\b\5\b\u00de\n\b\3\t\3\t\3\n\3\n\3\n\3")
47 buf
.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
48 buf
.write("\7\n\u00f3\n\n\f\n\16\n\u00f6\13\n\3\n\3\n\5\n\u00fa\n")
49 buf
.write("\n\3\13\3\13\3\f\3\f\5\f\u0100\n\f\3\f\3\f\3\f\3\f\3\f")
50 buf
.write("\3\f\3\f\5\f\u0109\n\f\3\r\3\r\3\16\6\16\u010e\n\16\r")
51 buf
.write("\16\16\16\u010f\3\17\3\17\3\17\3\17\3\20\3\20\6\20\u0118")
52 buf
.write("\n\20\r\20\16\20\u0119\3\21\3\21\3\21\7\21\u011f\n\21")
53 buf
.write("\f\21\16\21\u0122\13\21\3\22\3\22\3\22\5\22\u0127\n\22")
54 buf
.write("\3\22\3\22\5\22\u012b\n\22\3\23\3\23\3\23\3\23\5\23\u0131")
55 buf
.write("\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u013a\n")
56 buf
.write("\23\3\23\3\23\3\23\3\23\5\23\u0140\n\23\3\24\3\24\3\24")
57 buf
.write("\7\24\u0145\n\24\f\24\16\24\u0148\13\24\3\25\3\25\3\25")
58 buf
.write("\5\25\u014d\n\25\3\26\3\26\3\27\5\27\u0152\n\27\3\27\5")
59 buf
.write("\27\u0155\n\27\3\27\5\27\u0158\n\27\3\27\5\27\u015b\n")
60 buf
.write("\27\3\27\3\27\5\27\u015f\n\27\3\30\3\30\7\30\u0163\n\30")
61 buf
.write("\f\30\16\30\u0166\13\30\3\30\3\30\5\30\u016a\n\30\3\30")
62 buf
.write("\3\30\3\30\6\30\u016f\n\30\r\30\16\30\u0170\5\30\u0173")
63 buf
.write("\n\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
64 buf
.write("\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0185\n\31\3\32\3")
65 buf
.write("\32\6\32\u0189\n\32\r\32\16\32\u018a\3\32\5\32\u018e\n")
66 buf
.write("\32\3\32\3\32\3\32\5\32\u0193\n\32\3\33\3\33\3\33\5\33")
67 buf
.write("\u0198\n\33\3\33\5\33\u019b\n\33\3\34\3\34\3\34\5\34\u01a0")
68 buf
.write("\n\34\3\34\7\34\u01a3\n\34\f\34\16\34\u01a6\13\34\3\35")
69 buf
.write("\3\35\3\35\7\35\u01ab\n\35\f\35\16\35\u01ae\13\35\3\35")
70 buf
.write("\5\35\u01b1\n\35\3\35\7\35\u01b4\n\35\f\35\16\35\u01b7")
71 buf
.write("\13\35\3\35\5\35\u01ba\n\35\3\36\3\36\3\36\7\36\u01bf")
72 buf
.write("\n\36\f\36\16\36\u01c2\13\36\3\37\3\37\5\37\u01c6\n\37")
73 buf
.write("\3\37\5\37\u01c9\n\37\3 \3 \5 \u01cd\n \3 \5 \u01d0\n")
74 buf
.write(" \3!\3!\3!\3!\3!\5!\u01d7\n!\3!\7!\u01da\n!\f!\16!\u01dd")
75 buf
.write("\13!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5")
76 buf
.write("\"\u01eb\n\"\3#\3#\3#\3#\5#\u01f1\n#\3#\3#\5#\u01f5\n")
77 buf
.write("#\3$\3$\3$\7$\u01fa\n$\f$\16$\u01fd\13$\3%\3%\5%\u0201")
78 buf
.write("\n%\3%\3%\3%\5%\u0206\n%\7%\u0208\n%\f%\16%\u020b\13%")
79 buf
.write("\3&\3&\3&\3&\3&\7&\u0212\n&\f&\16&\u0215\13&\3\'\3\'\3")
80 buf
.write("\'\3\'\3\'\3\'\3\'\7\'\u021e\n\'\f\'\16\'\u0221\13\'\3")
81 buf
.write("(\3(\3(\3(\3(\3(\5(\u0229\n(\3)\3)\3)\3)\3)\3)\3)\3)\3")
82 buf
.write(")\3)\3)\3)\3)\3)\3)\5)\u023a\n)\3*\3*\3*\3*\3*\3*\3*\3")
83 buf
.write("*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3")
84 buf
.write("*\3*\3*\3*\7*\u0259\n*\f*\16*\u025c\13*\3+\3+\3+\7+\u0261")
85 buf
.write("\n+\f+\16+\u0264\13+\3,\3,\3-\3-\3-\3-\3-\3-\5-\u026e")
86 buf
.write("\n-\3.\3.\3.\3.\3.\7.\u0275\n.\f.\16.\u0278\13.\3.\6.")
87 buf
.write("\u027b\n.\r.\16.\u027c\6.\u027f\n.\r.\16.\u0280\3.\7.")
88 buf
.write("\u0284\n.\f.\16.\u0287\13.\3.\5.\u028a\n.\3/\3/\3/\7/")
89 buf
.write("\u028f\n/\f/\16/\u0292\13/\3\60\3\60\3\61\3\61\3\61\3")
90 buf
.write("\61\3\61\5\61\u029b\n\61\3\62\3\62\3\63\3\63\3\64\3\64")
91 buf
.write("\3\64\3\64\3\64\3\64\3\64\5\64\u02a8\n\64\3\65\3\65\3")
92 buf
.write("\65\7\65\u02ad\n\65\f\65\16\65\u02b0\13\65\3\66\3\66\3")
93 buf
.write("\66\7\66\u02b5\n\66\f\66\16\66\u02b8\13\66\3\67\3\67\3")
94 buf
.write("\67\7\67\u02bd\n\67\f\67\16\67\u02c0\13\67\38\38\38\7")
95 buf
.write("8\u02c5\n8\f8\168\u02c8\138\39\39\39\79\u02cd\n9\f9\16")
96 buf
.write("9\u02d0\139\3:\3:\3:\7:\u02d5\n:\f:\16:\u02d8\13:\3;\3")
97 buf
.write(";\3;\7;\u02dd\n;\f;\16;\u02e0\13;\3<\3<\3<\7<\u02e5\n")
98 buf
.write("<\f<\16<\u02e8\13<\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\5")
99 buf
.write("=\u02f5\n=\3>\5>\u02f8\n>\3>\3>\3>\7>\u02fd\n>\f>\16>")
100 buf
.write("\u0300\13>\3>\3>\3>\3?\3?\3?\7?\u0308\n?\f?\16?\u030b")
101 buf
.write("\13?\3?\3?\3@\3@\3@\7@\u0312\n@\f@\16@\u0315\13@\3@\3")
102 buf
.write("@\3A\3A\3A\7A\u031c\nA\fA\16A\u031f\13A\3A\5A\u0322\n")
103 buf
.write("A\3A\5A\u0325\nA\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3")
104 buf
.write("B\5B\u0334\nB\3C\3C\7C\u0338\nC\fC\16C\u033b\13C\3C\5")
105 buf
.write("C\u033e\nC\3C\3C\3D\6D\u0343\nD\rD\16D\u0344\3E\3E\3E")
106 buf
.write("\3E\5E\u034b\nE\3F\3F\3F\3F\3F\3F\3F\3F\5F\u0355\nF\3")
107 buf
.write("F\3F\3F\3F\3F\3F\5F\u035d\nF\3G\3G\3G\3G\3G\3G\3G\3G\3")
108 buf
.write("G\3G\3G\3G\3G\3G\3G\3G\5G\u036f\nG\3H\3H\3H\3H\3H\3H\3")
109 buf
.write("H\3H\3H\3H\3H\3H\3H\5H\u037e\nH\3H\2\2I\2\4\6\b\n\f\16")
110 buf
.write("\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDF")
111 buf
.write("HJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086")
112 buf
.write("\u0088\u008a\u008c\u008e\2\f\3\2\b\f\3\2\27\30\3\2\33")
113 buf
.write("\'\5\2,,./\679\4\2\7\7:C\3\2IJ\3\2KN\3\2OP\3\2\4\4\3\2")
114 buf
.write("\26\26\2\u03d8\2\u0093\3\2\2\2\4\u00a8\3\2\2\2\6\u00ab")
115 buf
.write("\3\2\2\2\b\u00bd\3\2\2\2\n\u00d0\3\2\2\2\f\u00d2\3\2\2")
116 buf
.write("\2\16\u00da\3\2\2\2\20\u00df\3\2\2\2\22\u00f9\3\2\2\2")
117 buf
.write("\24\u00fb\3\2\2\2\26\u0108\3\2\2\2\30\u010a\3\2\2\2\32")
118 buf
.write("\u010d\3\2\2\2\34\u0111\3\2\2\2\36\u0117\3\2\2\2 \u011b")
119 buf
.write("\3\2\2\2\"\u012a\3\2\2\2$\u013f\3\2\2\2&\u0141\3\2\2\2")
120 buf
.write("(\u0149\3\2\2\2*\u014e\3\2\2\2,\u015e\3\2\2\2.\u0172\3")
121 buf
.write("\2\2\2\60\u0184\3\2\2\2\62\u0192\3\2\2\2\64\u0194\3\2")
122 buf
.write("\2\2\66\u019c\3\2\2\28\u01b9\3\2\2\2:\u01bb\3\2\2\2<\u01c8")
123 buf
.write("\3\2\2\2>\u01cf\3\2\2\2@\u01d6\3\2\2\2B\u01ea\3\2\2\2")
124 buf
.write("D\u01f4\3\2\2\2F\u01f6\3\2\2\2H\u01fe\3\2\2\2J\u020c\3")
125 buf
.write("\2\2\2L\u0216\3\2\2\2N\u0228\3\2\2\2P\u0239\3\2\2\2R\u023b")
126 buf
.write("\3\2\2\2T\u025d\3\2\2\2V\u0265\3\2\2\2X\u026d\3\2\2\2")
127 buf
.write("Z\u0289\3\2\2\2\\\u028b\3\2\2\2^\u0293\3\2\2\2`\u029a")
128 buf
.write("\3\2\2\2b\u029c\3\2\2\2d\u029e\3\2\2\2f\u02a0\3\2\2\2")
129 buf
.write("h\u02a9\3\2\2\2j\u02b1\3\2\2\2l\u02b9\3\2\2\2n\u02c1\3")
130 buf
.write("\2\2\2p\u02c9\3\2\2\2r\u02d1\3\2\2\2t\u02d9\3\2\2\2v\u02e1")
131 buf
.write("\3\2\2\2x\u02f4\3\2\2\2z\u02f7\3\2\2\2|\u0304\3\2\2\2")
132 buf
.write("~\u030e\3\2\2\2\u0080\u0318\3\2\2\2\u0082\u0333\3\2\2")
133 buf
.write("\2\u0084\u0335\3\2\2\2\u0086\u0342\3\2\2\2\u0088\u034a")
134 buf
.write("\3\2\2\2\u008a\u035c\3\2\2\2\u008c\u036e\3\2\2\2\u008e")
135 buf
.write("\u037d\3\2\2\2\u0090\u0092\5\4\3\2\u0091\u0090\3\2\2\2")
136 buf
.write("\u0092\u0095\3\2\2\2\u0093\u0091\3\2\2\2\u0093\u0094\3")
137 buf
.write("\2\2\2\u0094\3\3\2\2\2\u0095\u0093\3\2\2\2\u0096\u0098")
138 buf
.write("\5\b\5\2\u0097\u0096\3\2\2\2\u0097\u0098\3\2\2\2\u0098")
139 buf
.write("\u0099\3\2\2\2\u0099\u009d\5,\27\2\u009a\u009c\5\n\6\2")
140 buf
.write("\u009b\u009a\3\2\2\2\u009c\u009f\3\2\2\2\u009d\u009b\3")
141 buf
.write("\2\2\2\u009d\u009e\3\2\2\2\u009e\u00a0\3\2\2\2\u009f\u009d")
142 buf
.write("\3\2\2\2\u00a0\u00a1\7\3\2\2\u00a1\u00a9\3\2\2\2\u00a2")
143 buf
.write("\u00a9\5\6\4\2\u00a3\u00a9\5\n\6\2\u00a4\u00a6\5\u0080")
144 buf
.write("A\2\u00a5\u00a7\7\4\2\2\u00a6\u00a5\3\2\2\2\u00a6\u00a7")
145 buf
.write("\3\2\2\2\u00a7\u00a9\3\2\2\2\u00a8\u0097\3\2\2\2\u00a8")
146 buf
.write("\u00a2\3\2\2\2\u00a8\u00a3\3\2\2\2\u00a8\u00a4\3\2\2\2")
147 buf
.write("\u00a9\5\3\2\2\2\u00aa\u00ac\5\b\5\2\u00ab\u00aa\3\2\2")
148 buf
.write("\2\u00ab\u00ac\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00b6")
149 buf
.write("\5,\27\2\u00ae\u00b0\5\n\6\2\u00af\u00ae\3\2\2\2\u00b0")
150 buf
.write("\u00b1\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2\2\2")
151 buf
.write("\u00b2\u00b3\3\2\2\2\u00b3\u00b4\5\u0084C\2\u00b4\u00b7")
152 buf
.write("\3\2\2\2\u00b5\u00b7\5\u0084C\2\u00b6\u00af\3\2\2\2\u00b6")
153 buf
.write("\u00b5\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\b\4\1\2")
154 buf
.write("\u00b9\7\3\2\2\2\u00ba\u00be\5\20\t\2\u00bb\u00be\5\22")
155 buf
.write("\n\2\u00bc\u00be\5*\26\2\u00bd\u00ba\3\2\2\2\u00bd\u00bb")
156 buf
.write("\3\2\2\2\u00bd\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf")
157 buf
.write("\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\t\3\2\2\2\u00c1")
158 buf
.write("\u00c3\7\5\2\2\u00c2\u00c4\5\b\5\2\u00c3\u00c2\3\2\2\2")
159 buf
.write("\u00c3\u00c4\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c6\5")
160 buf
.write("\f\7\2\u00c6\u00c7\7\4\2\2\u00c7\u00c8\b\6\1\2\u00c8\u00d1")
161 buf
.write("\3\2\2\2\u00c9\u00cb\5\b\5\2\u00ca\u00cc\5\f\7\2\u00cb")
162 buf
.write("\u00ca\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2")
163 buf
.write("\u00cd\u00ce\7\4\2\2\u00ce\u00cf\b\6\1\2\u00cf\u00d1\3")
164 buf
.write("\2\2\2\u00d0\u00c1\3\2\2\2\u00d0\u00c9\3\2\2\2\u00d1\13")
165 buf
.write("\3\2\2\2\u00d2\u00d7\5\16\b\2\u00d3\u00d4\7\6\2\2\u00d4")
166 buf
.write("\u00d6\5\16\b\2\u00d5\u00d3\3\2\2\2\u00d6\u00d9\3\2\2")
167 buf
.write("\2\u00d7\u00d5\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\r\3\2")
168 buf
.write("\2\2\u00d9\u00d7\3\2\2\2\u00da\u00dd\5,\27\2\u00db\u00dc")
169 buf
.write("\7\7\2\2\u00dc\u00de\5D#\2\u00dd\u00db\3\2\2\2\u00dd\u00de")
170 buf
.write("\3\2\2\2\u00de\17\3\2\2\2\u00df\u00e0\t\2\2\2\u00e0\21")
171 buf
.write("\3\2\2\2\u00e1\u00fa\7\r\2\2\u00e2\u00fa\7\16\2\2\u00e3")
172 buf
.write("\u00fa\7\17\2\2\u00e4\u00fa\7\20\2\2\u00e5\u00fa\7\21")
173 buf
.write("\2\2\u00e6\u00fa\7\22\2\2\u00e7\u00fa\7\23\2\2\u00e8\u00fa")
174 buf
.write("\7\24\2\2\u00e9\u00fa\7\25\2\2\u00ea\u00eb\5\26\f\2\u00eb")
175 buf
.write("\u00ec\b\n\1\2\u00ec\u00fa\3\2\2\2\u00ed\u00ee\5$\23\2")
176 buf
.write("\u00ee\u00ef\b\n\1\2\u00ef\u00fa\3\2\2\2\u00f0\u00f4\7")
177 buf
.write("_\2\2\u00f1\u00f3\5*\26\2\u00f2\u00f1\3\2\2\2\u00f3\u00f6")
178 buf
.write("\3\2\2\2\u00f4\u00f2\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5")
179 buf
.write("\u00f7\3\2\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00fa\5,\27\2")
180 buf
.write("\u00f8\u00fa\5\24\13\2\u00f9\u00e1\3\2\2\2\u00f9\u00e2")
181 buf
.write("\3\2\2\2\u00f9\u00e3\3\2\2\2\u00f9\u00e4\3\2\2\2\u00f9")
182 buf
.write("\u00e5\3\2\2\2\u00f9\u00e6\3\2\2\2\u00f9\u00e7\3\2\2\2")
183 buf
.write("\u00f9\u00e8\3\2\2\2\u00f9\u00e9\3\2\2\2\u00f9\u00ea\3")
184 buf
.write("\2\2\2\u00f9\u00ed\3\2\2\2\u00f9\u00f0\3\2\2\2\u00f9\u00f8")
185 buf
.write("\3\2\2\2\u00fa\23\3\2\2\2\u00fb\u00fc\7_\2\2\u00fc\25")
186 buf
.write("\3\2\2\2\u00fd\u00ff\5\30\r\2\u00fe\u0100\7_\2\2\u00ff")
187 buf
.write("\u00fe\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101\3\2\2\2")
188 buf
.write("\u0101\u0102\7\3\2\2\u0102\u0103\5\32\16\2\u0103\u0104")
189 buf
.write("\7\26\2\2\u0104\u0109\3\2\2\2\u0105\u0106\5\30\r\2\u0106")
190 buf
.write("\u0107\7_\2\2\u0107\u0109\3\2\2\2\u0108\u00fd\3\2\2\2")
191 buf
.write("\u0108\u0105\3\2\2\2\u0109\27\3\2\2\2\u010a\u010b\t\3")
192 buf
.write("\2\2\u010b\31\3\2\2\2\u010c\u010e\5\34\17\2\u010d\u010c")
193 buf
.write("\3\2\2\2\u010e\u010f\3\2\2\2\u010f\u010d\3\2\2\2\u010f")
194 buf
.write("\u0110\3\2\2\2\u0110\33\3\2\2\2\u0111\u0112\5\36\20\2")
195 buf
.write("\u0112\u0113\5 \21\2\u0113\u0114\7\4\2\2\u0114\35\3\2")
196 buf
.write("\2\2\u0115\u0118\5*\26\2\u0116\u0118\5\22\n\2\u0117\u0115")
197 buf
.write("\3\2\2\2\u0117\u0116\3\2\2\2\u0118\u0119\3\2\2\2\u0119")
198 buf
.write("\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a\37\3\2\2\2\u011b")
199 buf
.write("\u0120\5\"\22\2\u011c\u011d\7\6\2\2\u011d\u011f\5\"\22")
200 buf
.write("\2\u011e\u011c\3\2\2\2\u011f\u0122\3\2\2\2\u0120\u011e")
201 buf
.write("\3\2\2\2\u0120\u0121\3\2\2\2\u0121!\3\2\2\2\u0122\u0120")
202 buf
.write("\3\2\2\2\u0123\u0126\5,\27\2\u0124\u0125\7\31\2\2\u0125")
203 buf
.write("\u0127\5^\60\2\u0126\u0124\3\2\2\2\u0126\u0127\3\2\2\2")
204 buf
.write("\u0127\u012b\3\2\2\2\u0128\u0129\7\31\2\2\u0129\u012b")
205 buf
.write("\5^\60\2\u012a\u0123\3\2\2\2\u012a\u0128\3\2\2\2\u012b")
206 buf
.write("#\3\2\2\2\u012c\u012d\7\32\2\2\u012d\u012e\7\3\2\2\u012e")
207 buf
.write("\u0130\5&\24\2\u012f\u0131\7\6\2\2\u0130\u012f\3\2\2\2")
208 buf
.write("\u0130\u0131\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0133\7")
209 buf
.write("\26\2\2\u0133\u0140\3\2\2\2\u0134\u0135\7\32\2\2\u0135")
210 buf
.write("\u0136\7_\2\2\u0136\u0137\7\3\2\2\u0137\u0139\5&\24\2")
211 buf
.write("\u0138\u013a\7\6\2\2\u0139\u0138\3\2\2\2\u0139\u013a\3")
212 buf
.write("\2\2\2\u013a\u013b\3\2\2\2\u013b\u013c\7\26\2\2\u013c")
213 buf
.write("\u0140\3\2\2\2\u013d\u013e\7\32\2\2\u013e\u0140\7_\2\2")
214 buf
.write("\u013f\u012c\3\2\2\2\u013f\u0134\3\2\2\2\u013f\u013d\3")
215 buf
.write("\2\2\2\u0140%\3\2\2\2\u0141\u0146\5(\25\2\u0142\u0143")
216 buf
.write("\7\6\2\2\u0143\u0145\5(\25\2\u0144\u0142\3\2\2\2\u0145")
217 buf
.write("\u0148\3\2\2\2\u0146\u0144\3\2\2\2\u0146\u0147\3\2\2\2")
218 buf
.write("\u0147\'\3\2\2\2\u0148\u0146\3\2\2\2\u0149\u014c\7_\2")
219 buf
.write("\2\u014a\u014b\7\7\2\2\u014b\u014d\5^\60\2\u014c\u014a")
220 buf
.write("\3\2\2\2\u014c\u014d\3\2\2\2\u014d)\3\2\2\2\u014e\u014f")
221 buf
.write("\t\4\2\2\u014f+\3\2\2\2\u0150\u0152\5\62\32\2\u0151\u0150")
222 buf
.write("\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0154\3\2\2\2\u0153")
223 buf
.write("\u0155\7$\2\2\u0154\u0153\3\2\2\2\u0154\u0155\3\2\2\2")
224 buf
.write("\u0155\u0157\3\2\2\2\u0156\u0158\7%\2\2\u0157\u0156\3")
225 buf
.write("\2\2\2\u0157\u0158\3\2\2\2\u0158\u015a\3\2\2\2\u0159\u015b")
226 buf
.write("\7&\2\2\u015a\u0159\3\2\2\2\u015a\u015b\3\2\2\2\u015b")
227 buf
.write("\u015c\3\2\2\2\u015c\u015f\5.\30\2\u015d\u015f\5\62\32")
228 buf
.write("\2\u015e\u0151\3\2\2\2\u015e\u015d\3\2\2\2\u015f-\3\2")
229 buf
.write("\2\2\u0160\u0164\7_\2\2\u0161\u0163\5\60\31\2\u0162\u0161")
230 buf
.write("\3\2\2\2\u0163\u0166\3\2\2\2\u0164\u0162\3\2\2\2\u0164")
231 buf
.write("\u0165\3\2\2\2\u0165\u0173\3\2\2\2\u0166\u0164\3\2\2\2")
232 buf
.write("\u0167\u0169\7(\2\2\u0168\u016a\7$\2\2\u0169\u0168\3\2")
233 buf
.write("\2\2\u0169\u016a\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u016c")
234 buf
.write("\5,\27\2\u016c\u016e\7)\2\2\u016d\u016f\5\60\31\2\u016e")
235 buf
.write("\u016d\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u016e\3\2\2\2")
236 buf
.write("\u0170\u0171\3\2\2\2\u0171\u0173\3\2\2\2\u0172\u0160\3")
237 buf
.write("\2\2\2\u0172\u0167\3\2\2\2\u0173/\3\2\2\2\u0174\u0175")
238 buf
.write("\7*\2\2\u0175\u0176\5^\60\2\u0176\u0177\7+\2\2\u0177\u0185")
239 buf
.write("\3\2\2\2\u0178\u0179\7*\2\2\u0179\u0185\7+\2\2\u017a\u017b")
240 buf
.write("\7(\2\2\u017b\u017c\5\64\33\2\u017c\u017d\7)\2\2\u017d")
241 buf
.write("\u0185\3\2\2\2\u017e\u017f\7(\2\2\u017f\u0180\5:\36\2")
242 buf
.write("\u0180\u0181\7)\2\2\u0181\u0185\3\2\2\2\u0182\u0183\7")
243 buf
.write("(\2\2\u0183\u0185\7)\2\2\u0184\u0174\3\2\2\2\u0184\u0178")
244 buf
.write("\3\2\2\2\u0184\u017a\3\2\2\2\u0184\u017e\3\2\2\2\u0184")
245 buf
.write("\u0182\3\2\2\2\u0185\61\3\2\2\2\u0186\u0188\7,\2\2\u0187")
246 buf
.write("\u0189\5*\26\2\u0188\u0187\3\2\2\2\u0189\u018a\3\2\2\2")
247 buf
.write("\u018a\u0188\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018d\3")
248 buf
.write("\2\2\2\u018c\u018e\5\62\32\2\u018d\u018c\3\2\2\2\u018d")
249 buf
.write("\u018e\3\2\2\2\u018e\u0193\3\2\2\2\u018f\u0190\7,\2\2")
250 buf
.write("\u0190\u0193\5\62\32\2\u0191\u0193\7,\2\2\u0192\u0186")
251 buf
.write("\3\2\2\2\u0192\u018f\3\2\2\2\u0192\u0191\3\2\2\2\u0193")
252 buf
.write("\63\3\2\2\2\u0194\u019a\5\66\34\2\u0195\u0197\7\6\2\2")
253 buf
.write("\u0196\u0198\7\37\2\2\u0197\u0196\3\2\2\2\u0197\u0198")
254 buf
.write("\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019b\7-\2\2\u019a")
255 buf
.write("\u0195\3\2\2\2\u019a\u019b\3\2\2\2\u019b\65\3\2\2\2\u019c")
256 buf
.write("\u01a4\58\35\2\u019d\u019f\7\6\2\2\u019e\u01a0\7\37\2")
257 buf
.write("\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1")
258 buf
.write("\3\2\2\2\u01a1\u01a3\58\35\2\u01a2\u019d\3\2\2\2\u01a3")
259 buf
.write("\u01a6\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2")
260 buf
.write("\u01a5\67\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a7\u01ac\5\b")
261 buf
.write("\5\2\u01a8\u01ab\5,\27\2\u01a9\u01ab\5> \2\u01aa\u01a8")
262 buf
.write("\3\2\2\2\u01aa\u01a9\3\2\2\2\u01ab\u01ae\3\2\2\2\u01ac")
263 buf
.write("\u01aa\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\u01b0\3\2\2\2")
264 buf
.write("\u01ae\u01ac\3\2\2\2\u01af\u01b1\7\37\2\2\u01b0\u01af")
265 buf
.write("\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01ba\3\2\2\2\u01b2")
266 buf
.write("\u01b4\5\62\32\2\u01b3\u01b2\3\2\2\2\u01b4\u01b7\3\2\2")
267 buf
.write("\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b8")
268 buf
.write("\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01ba\7_\2\2\u01b9")
269 buf
.write("\u01a7\3\2\2\2\u01b9\u01b5\3\2\2\2\u01ba9\3\2\2\2\u01bb")
270 buf
.write("\u01c0\7_\2\2\u01bc\u01bd\7\6\2\2\u01bd\u01bf\7_\2\2\u01be")
271 buf
.write("\u01bc\3\2\2\2\u01bf\u01c2\3\2\2\2\u01c0\u01be\3\2\2\2")
272 buf
.write("\u01c0\u01c1\3\2\2\2\u01c1;\3\2\2\2\u01c2\u01c0\3\2\2")
273 buf
.write("\2\u01c3\u01c5\5\36\20\2\u01c4\u01c6\5> \2\u01c5\u01c4")
274 buf
.write("\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6\u01c9\3\2\2\2\u01c7")
275 buf
.write("\u01c9\5\24\13\2\u01c8\u01c3\3\2\2\2\u01c8\u01c7\3\2\2")
276 buf
.write("\2\u01c9=\3\2\2\2\u01ca\u01cc\5\62\32\2\u01cb\u01cd\5")
277 buf
.write("@!\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01d0")
278 buf
.write("\3\2\2\2\u01ce\u01d0\5@!\2\u01cf\u01ca\3\2\2\2\u01cf\u01ce")
279 buf
.write("\3\2\2\2\u01d0?\3\2\2\2\u01d1\u01d2\7(\2\2\u01d2\u01d3")
280 buf
.write("\5> \2\u01d3\u01d4\7)\2\2\u01d4\u01d7\3\2\2\2\u01d5\u01d7")
281 buf
.write("\5B\"\2\u01d6\u01d1\3\2\2\2\u01d6\u01d5\3\2\2\2\u01d7")
282 buf
.write("\u01db\3\2\2\2\u01d8\u01da\5B\"\2\u01d9\u01d8\3\2\2\2")
283 buf
.write("\u01da\u01dd\3\2\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3")
284 buf
.write("\2\2\2\u01dcA\3\2\2\2\u01dd\u01db\3\2\2\2\u01de\u01df")
285 buf
.write("\7*\2\2\u01df\u01eb\7+\2\2\u01e0\u01e1\7*\2\2\u01e1\u01e2")
286 buf
.write("\5^\60\2\u01e2\u01e3\7+\2\2\u01e3\u01eb\3\2\2\2\u01e4")
287 buf
.write("\u01e5\7(\2\2\u01e5\u01eb\7)\2\2\u01e6\u01e7\7(\2\2\u01e7")
288 buf
.write("\u01e8\5\64\33\2\u01e8\u01e9\7)\2\2\u01e9\u01eb\3\2\2")
289 buf
.write("\2\u01ea\u01de\3\2\2\2\u01ea\u01e0\3\2\2\2\u01ea\u01e4")
290 buf
.write("\3\2\2\2\u01ea\u01e6\3\2\2\2\u01ebC\3\2\2\2\u01ec\u01f5")
291 buf
.write("\5`\61\2\u01ed\u01ee\7\3\2\2\u01ee\u01f0\5F$\2\u01ef\u01f1")
292 buf
.write("\7\6\2\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1")
293 buf
.write("\u01f2\3\2\2\2\u01f2\u01f3\7\26\2\2\u01f3\u01f5\3\2\2")
294 buf
.write("\2\u01f4\u01ec\3\2\2\2\u01f4\u01ed\3\2\2\2\u01f5E\3\2")
295 buf
.write("\2\2\u01f6\u01fb\5D#\2\u01f7\u01f8\7\6\2\2\u01f8\u01fa")
296 buf
.write("\5D#\2\u01f9\u01f7\3\2\2\2\u01fa\u01fd\3\2\2\2\u01fb\u01f9")
297 buf
.write("\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fcG\3\2\2\2\u01fd\u01fb")
298 buf
.write("\3\2\2\2\u01fe\u0200\5`\61\2\u01ff\u0201\7\37\2\2\u0200")
299 buf
.write("\u01ff\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0209\3\2\2\2")
300 buf
.write("\u0202\u0203\7\6\2\2\u0203\u0205\5`\61\2\u0204\u0206\7")
301 buf
.write("\37\2\2\u0205\u0204\3\2\2\2\u0205\u0206\3\2\2\2\u0206")
302 buf
.write("\u0208\3\2\2\2\u0207\u0202\3\2\2\2\u0208\u020b\3\2\2\2")
303 buf
.write("\u0209\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020aI\3\2\2")
304 buf
.write("\2\u020b\u0209\3\2\2\2\u020c\u0213\5L\'\2\u020d\u020e")
305 buf
.write("\7.\2\2\u020e\u0212\5L\'\2\u020f\u0210\7/\2\2\u0210\u0212")
306 buf
.write("\5L\'\2\u0211\u020d\3\2\2\2\u0211\u020f\3\2\2\2\u0212")
307 buf
.write("\u0215\3\2\2\2\u0213\u0211\3\2\2\2\u0213\u0214\3\2\2\2")
308 buf
.write("\u0214K\3\2\2\2\u0215\u0213\3\2\2\2\u0216\u021f\5N(\2")
309 buf
.write("\u0217\u0218\7,\2\2\u0218\u021e\5N(\2\u0219\u021a\7\60")
310 buf
.write("\2\2\u021a\u021e\5N(\2\u021b\u021c\7\61\2\2\u021c\u021e")
311 buf
.write("\5N(\2\u021d\u0217\3\2\2\2\u021d\u0219\3\2\2\2\u021d\u021b")
312 buf
.write("\3\2\2\2\u021e\u0221\3\2\2\2\u021f\u021d\3\2\2\2\u021f")
313 buf
.write("\u0220\3\2\2\2\u0220M\3\2\2\2\u0221\u021f\3\2\2\2\u0222")
314 buf
.write("\u0223\7(\2\2\u0223\u0224\5<\37\2\u0224\u0225\7)\2\2\u0225")
315 buf
.write("\u0226\5N(\2\u0226\u0229\3\2\2\2\u0227\u0229\5P)\2\u0228")
316 buf
.write("\u0222\3\2\2\2\u0228\u0227\3\2\2\2\u0229O\3\2\2\2\u022a")
317 buf
.write("\u023a\5R*\2\u022b\u022c\7\62\2\2\u022c\u023a\5P)\2\u022d")
318 buf
.write("\u022e\7\63\2\2\u022e\u023a\5P)\2\u022f\u0230\5V,\2\u0230")
319 buf
.write("\u0231\5N(\2\u0231\u023a\3\2\2\2\u0232\u0233\7\64\2\2")
320 buf
.write("\u0233\u023a\5P)\2\u0234\u0235\7\64\2\2\u0235\u0236\7")
321 buf
.write("(\2\2\u0236\u0237\5<\37\2\u0237\u0238\7)\2\2\u0238\u023a")
322 buf
.write("\3\2\2\2\u0239\u022a\3\2\2\2\u0239\u022b\3\2\2\2\u0239")
323 buf
.write("\u022d\3\2\2\2\u0239\u022f\3\2\2\2\u0239\u0232\3\2\2\2")
324 buf
.write("\u0239\u0234\3\2\2\2\u023aQ\3\2\2\2\u023b\u023c\5X-\2")
325 buf
.write("\u023c\u025a\b*\1\2\u023d\u023e\7*\2\2\u023e\u023f\5\\")
326 buf
.write("/\2\u023f\u0240\7+\2\2\u0240\u0259\3\2\2\2\u0241\u0242")
327 buf
.write("\7(\2\2\u0242\u0243\7)\2\2\u0243\u0259\b*\1\2\u0244\u0245")
328 buf
.write("\7(\2\2\u0245\u0246\5H%\2\u0246\u0247\7)\2\2\u0247\u0248")
329 buf
.write("\b*\1\2\u0248\u0259\3\2\2\2\u0249\u024a\7(\2\2\u024a\u024b")
330 buf
.write("\5T+\2\u024b\u024c\7)\2\2\u024c\u0259\3\2\2\2\u024d\u024e")
331 buf
.write("\7\65\2\2\u024e\u024f\7_\2\2\u024f\u0259\b*\1\2\u0250")
332 buf
.write("\u0251\7,\2\2\u0251\u0252\7_\2\2\u0252\u0259\b*\1\2\u0253")
333 buf
.write("\u0254\7\66\2\2\u0254\u0255\7_\2\2\u0255\u0259\b*\1\2")
334 buf
.write("\u0256\u0259\7\62\2\2\u0257\u0259\7\63\2\2\u0258\u023d")
335 buf
.write("\3\2\2\2\u0258\u0241\3\2\2\2\u0258\u0244\3\2\2\2\u0258")
336 buf
.write("\u0249\3\2\2\2\u0258\u024d\3\2\2\2\u0258\u0250\3\2\2\2")
337 buf
.write("\u0258\u0253\3\2\2\2\u0258\u0256\3\2\2\2\u0258\u0257\3")
338 buf
.write("\2\2\2\u0259\u025c\3\2\2\2\u025a\u0258\3\2\2\2\u025a\u025b")
339 buf
.write("\3\2\2\2\u025bS\3\2\2\2\u025c\u025a\3\2\2\2\u025d\u0262")
340 buf
.write("\58\35\2\u025e\u025f\7\6\2\2\u025f\u0261\58\35\2\u0260")
341 buf
.write("\u025e\3\2\2\2\u0261\u0264\3\2\2\2\u0262\u0260\3\2\2\2")
342 buf
.write("\u0262\u0263\3\2\2\2\u0263U\3\2\2\2\u0264\u0262\3\2\2")
343 buf
.write("\2\u0265\u0266\t\5\2\2\u0266W\3\2\2\2\u0267\u026e\7_\2")
344 buf
.write("\2\u0268\u026e\5Z.\2\u0269\u026a\7(\2\2\u026a\u026b\5")
345 buf
.write("\\/\2\u026b\u026c\7)\2\2\u026c\u026e\3\2\2\2\u026d\u0267")
346 buf
.write("\3\2\2\2\u026d\u0268\3\2\2\2\u026d\u0269\3\2\2\2\u026e")
347 buf
.write("Y\3\2\2\2\u026f\u028a\7b\2\2\u0270\u028a\7d\2\2\u0271")
348 buf
.write("\u028a\7c\2\2\u0272\u028a\7`\2\2\u0273\u0275\7_\2\2\u0274")
349 buf
.write("\u0273\3\2\2\2\u0275\u0278\3\2\2\2\u0276\u0274\3\2\2\2")
350 buf
.write("\u0276\u0277\3\2\2\2\u0277\u027a\3\2\2\2\u0278\u0276\3")
351 buf
.write("\2\2\2\u0279\u027b\7a\2\2\u027a\u0279\3\2\2\2\u027b\u027c")
352 buf
.write("\3\2\2\2\u027c\u027a\3\2\2\2\u027c\u027d\3\2\2\2\u027d")
353 buf
.write("\u027f\3\2\2\2\u027e\u0276\3\2\2\2\u027f\u0280\3\2\2\2")
354 buf
.write("\u0280\u027e\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0285\3")
355 buf
.write("\2\2\2\u0282\u0284\7_\2\2\u0283\u0282\3\2\2\2\u0284\u0287")
356 buf
.write("\3\2\2\2\u0285\u0283\3\2\2\2\u0285\u0286\3\2\2\2\u0286")
357 buf
.write("\u028a\3\2\2\2\u0287\u0285\3\2\2\2\u0288\u028a\7e\2\2")
358 buf
.write("\u0289\u026f\3\2\2\2\u0289\u0270\3\2\2\2\u0289\u0271\3")
359 buf
.write("\2\2\2\u0289\u0272\3\2\2\2\u0289\u027e\3\2\2\2\u0289\u0288")
360 buf
.write("\3\2\2\2\u028a[\3\2\2\2\u028b\u0290\5`\61\2\u028c\u028d")
361 buf
.write("\7\6\2\2\u028d\u028f\5`\61\2\u028e\u028c\3\2\2\2\u028f")
362 buf
.write("\u0292\3\2\2\2\u0290\u028e\3\2\2\2\u0290\u0291\3\2\2\2")
363 buf
.write("\u0291]\3\2\2\2\u0292\u0290\3\2\2\2\u0293\u0294\5f\64")
364 buf
.write("\2\u0294_\3\2\2\2\u0295\u0296\5b\62\2\u0296\u0297\5d\63")
365 buf
.write("\2\u0297\u0298\5`\61\2\u0298\u029b\3\2\2\2\u0299\u029b")
366 buf
.write("\5f\64\2\u029a\u0295\3\2\2\2\u029a\u0299\3\2\2\2\u029b")
367 buf
.write("a\3\2\2\2\u029c\u029d\5P)\2\u029dc\3\2\2\2\u029e\u029f")
368 buf
.write("\t\6\2\2\u029fe\3\2\2\2\u02a0\u02a7\5h\65\2\u02a1\u02a2")
369 buf
.write("\7D\2\2\u02a2\u02a3\5\\/\2\u02a3\u02a4\7\31\2\2\u02a4")
370 buf
.write("\u02a5\5f\64\2\u02a5\u02a6\b\64\1\2\u02a6\u02a8\3\2\2")
371 buf
.write("\2\u02a7\u02a1\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8g\3\2")
372 buf
.write("\2\2\u02a9\u02ae\5j\66\2\u02aa\u02ab\7E\2\2\u02ab\u02ad")
373 buf
.write("\5j\66\2\u02ac\u02aa\3\2\2\2\u02ad\u02b0\3\2\2\2\u02ae")
374 buf
.write("\u02ac\3\2\2\2\u02ae\u02af\3\2\2\2\u02afi\3\2\2\2\u02b0")
375 buf
.write("\u02ae\3\2\2\2\u02b1\u02b6\5l\67\2\u02b2\u02b3\7F\2\2")
376 buf
.write("\u02b3\u02b5\5l\67\2\u02b4\u02b2\3\2\2\2\u02b5\u02b8\3")
377 buf
.write("\2\2\2\u02b6\u02b4\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7k")
378 buf
.write("\3\2\2\2\u02b8\u02b6\3\2\2\2\u02b9\u02be\5n8\2\u02ba\u02bb")
379 buf
.write("\7G\2\2\u02bb\u02bd\5n8\2\u02bc\u02ba\3\2\2\2\u02bd\u02c0")
380 buf
.write("\3\2\2\2\u02be\u02bc\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf")
381 buf
.write("m\3\2\2\2\u02c0\u02be\3\2\2\2\u02c1\u02c6\5p9\2\u02c2")
382 buf
.write("\u02c3\7H\2\2\u02c3\u02c5\5p9\2\u02c4\u02c2\3\2\2\2\u02c5")
383 buf
.write("\u02c8\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c6\u02c7\3\2\2\2")
384 buf
.write("\u02c7o\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c9\u02ce\5r:\2")
385 buf
.write("\u02ca\u02cb\7\67\2\2\u02cb\u02cd\5r:\2\u02cc\u02ca\3")
386 buf
.write("\2\2\2\u02cd\u02d0\3\2\2\2\u02ce\u02cc\3\2\2\2\u02ce\u02cf")
387 buf
.write("\3\2\2\2\u02cfq\3\2\2\2\u02d0\u02ce\3\2\2\2\u02d1\u02d6")
388 buf
.write("\5t;\2\u02d2\u02d3\t\7\2\2\u02d3\u02d5\5t;\2\u02d4\u02d2")
389 buf
.write("\3\2\2\2\u02d5\u02d8\3\2\2\2\u02d6\u02d4\3\2\2\2\u02d6")
390 buf
.write("\u02d7\3\2\2\2\u02d7s\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d9")
391 buf
.write("\u02de\5v<\2\u02da\u02db\t\b\2\2\u02db\u02dd\5v<\2\u02dc")
392 buf
.write("\u02da\3\2\2\2\u02dd\u02e0\3\2\2\2\u02de\u02dc\3\2\2\2")
393 buf
.write("\u02de\u02df\3\2\2\2\u02dfu\3\2\2\2\u02e0\u02de\3\2\2")
394 buf
.write("\2\u02e1\u02e6\5J&\2\u02e2\u02e3\t\t\2\2\u02e3\u02e5\5")
395 buf
.write("J&\2\u02e4\u02e2\3\2\2\2\u02e5\u02e8\3\2\2\2\u02e6\u02e4")
396 buf
.write("\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7w\3\2\2\2\u02e8\u02e6")
397 buf
.write("\3\2\2\2\u02e9\u02f5\5\u0082B\2\u02ea\u02f5\5\u0084C\2")
398 buf
.write("\u02eb\u02f5\5\u0088E\2\u02ec\u02f5\5\u008aF\2\u02ed\u02f5")
399 buf
.write("\5\u008cG\2\u02ee\u02f5\5\u008eH\2\u02ef\u02f5\5\u0080")
400 buf
.write("A\2\u02f0\u02f5\5z>\2\u02f1\u02f5\5|?\2\u02f2\u02f5\5")
401 buf
.write("~@\2\u02f3\u02f5\5\n\6\2\u02f4\u02e9\3\2\2\2\u02f4\u02ea")
402 buf
.write("\3\2\2\2\u02f4\u02eb\3\2\2\2\u02f4\u02ec\3\2\2\2\u02f4")
403 buf
.write("\u02ed\3\2\2\2\u02f4\u02ee\3\2\2\2\u02f4\u02ef\3\2\2\2")
404 buf
.write("\u02f4\u02f0\3\2\2\2\u02f4\u02f1\3\2\2\2\u02f4\u02f2\3")
405 buf
.write("\2\2\2\u02f4\u02f3\3\2\2\2\u02f5y\3\2\2\2\u02f6\u02f8")
406 buf
.write("\7Q\2\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8")
407 buf
.write("\u02f9\3\2\2\2\u02f9\u02fa\7_\2\2\u02fa\u02fe\7(\2\2\u02fb")
408 buf
.write("\u02fd\n\n\2\2\u02fc\u02fb\3\2\2\2\u02fd\u0300\3\2\2\2")
409 buf
.write("\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0301\3")
410 buf
.write("\2\2\2\u0300\u02fe\3\2\2\2\u0301\u0302\7)\2\2\u0302\u0303")
411 buf
.write("\7\4\2\2\u0303{\3\2\2\2\u0304\u0305\7R\2\2\u0305\u0309")
412 buf
.write("\7\3\2\2\u0306\u0308\n\13\2\2\u0307\u0306\3\2\2\2\u0308")
413 buf
.write("\u030b\3\2\2\2\u0309\u0307\3\2\2\2\u0309\u030a\3\2\2\2")
414 buf
.write("\u030a\u030c\3\2\2\2\u030b\u0309\3\2\2\2\u030c\u030d\7")
415 buf
.write("\26\2\2\u030d}\3\2\2\2\u030e\u030f\7S\2\2\u030f\u0313")
416 buf
.write("\7\3\2\2\u0310\u0312\n\13\2\2\u0311\u0310\3\2\2\2\u0312")
417 buf
.write("\u0315\3\2\2\2\u0313\u0311\3\2\2\2\u0313\u0314\3\2\2\2")
418 buf
.write("\u0314\u0316\3\2\2\2\u0315\u0313\3\2\2\2\u0316\u0317\7")
419 buf
.write("\26\2\2\u0317\177\3\2\2\2\u0318\u0319\7_\2\2\u0319\u031d")
420 buf
.write("\7(\2\2\u031a\u031c\5\n\6\2\u031b\u031a\3\2\2\2\u031c")
421 buf
.write("\u031f\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031e\3\2\2\2")
422 buf
.write("\u031e\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u0320\u0322\5")
423 buf
.write("\u0086D\2\u0321\u0320\3\2\2\2\u0321\u0322\3\2\2\2\u0322")
424 buf
.write("\u0324\3\2\2\2\u0323\u0325\5\\/\2\u0324\u0323\3\2\2\2")
425 buf
.write("\u0324\u0325\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u0327\7")
426 buf
.write(")\2\2\u0327\u0081\3\2\2\2\u0328\u0329\7_\2\2\u0329\u032a")
427 buf
.write("\7\31\2\2\u032a\u0334\5x=\2\u032b\u032c\7T\2\2\u032c\u032d")
428 buf
.write("\5^\60\2\u032d\u032e\7\31\2\2\u032e\u032f\5x=\2\u032f")
429 buf
.write("\u0334\3\2\2\2\u0330\u0331\7U\2\2\u0331\u0332\7\31\2\2")
430 buf
.write("\u0332\u0334\5x=\2\u0333\u0328\3\2\2\2\u0333\u032b\3\2")
431 buf
.write("\2\2\u0333\u0330\3\2\2\2\u0334\u0083\3\2\2\2\u0335\u0339")
432 buf
.write("\7\3\2\2\u0336\u0338\5\n\6\2\u0337\u0336\3\2\2\2\u0338")
433 buf
.write("\u033b\3\2\2\2\u0339\u0337\3\2\2\2\u0339\u033a\3\2\2\2")
434 buf
.write("\u033a\u033d\3\2\2\2\u033b\u0339\3\2\2\2\u033c\u033e\5")
435 buf
.write("\u0086D\2\u033d\u033c\3\2\2\2\u033d\u033e\3\2\2\2\u033e")
436 buf
.write("\u033f\3\2\2\2\u033f\u0340\7\26\2\2\u0340\u0085\3\2\2")
437 buf
.write("\2\u0341\u0343\5x=\2\u0342\u0341\3\2\2\2\u0343\u0344\3")
438 buf
.write("\2\2\2\u0344\u0342\3\2\2\2\u0344\u0345\3\2\2\2\u0345\u0087")
439 buf
.write("\3\2\2\2\u0346\u034b\7\4\2\2\u0347\u0348\5\\/\2\u0348")
440 buf
.write("\u0349\7\4\2\2\u0349\u034b\3\2\2\2\u034a\u0346\3\2\2\2")
441 buf
.write("\u034a\u0347\3\2\2\2\u034b\u0089\3\2\2\2\u034c\u034d\7")
442 buf
.write("V\2\2\u034d\u034e\7(\2\2\u034e\u034f\5\\/\2\u034f\u0350")
443 buf
.write("\7)\2\2\u0350\u0351\bF\1\2\u0351\u0354\5x=\2\u0352\u0353")
444 buf
.write("\7W\2\2\u0353\u0355\5x=\2\u0354\u0352\3\2\2\2\u0354\u0355")
445 buf
.write("\3\2\2\2\u0355\u035d\3\2\2\2\u0356\u0357\7X\2\2\u0357")
446 buf
.write("\u0358\7(\2\2\u0358\u0359\5\\/\2\u0359\u035a\7)\2\2\u035a")
447 buf
.write("\u035b\5x=\2\u035b\u035d\3\2\2\2\u035c\u034c\3\2\2\2\u035c")
448 buf
.write("\u0356\3\2\2\2\u035d\u008b\3\2\2\2\u035e\u035f\7Y\2\2")
449 buf
.write("\u035f\u0360\7(\2\2\u0360\u0361\5\\/\2\u0361\u0362\7)")
450 buf
.write("\2\2\u0362\u0363\5x=\2\u0363\u0364\bG\1\2\u0364\u036f")
451 buf
.write("\3\2\2\2\u0365\u0366\7Z\2\2\u0366\u0367\5x=\2\u0367\u0368")
452 buf
.write("\7Y\2\2\u0368\u0369\7(\2\2\u0369\u036a\5\\/\2\u036a\u036b")
453 buf
.write("\7)\2\2\u036b\u036c\7\4\2\2\u036c\u036d\bG\1\2\u036d\u036f")
454 buf
.write("\3\2\2\2\u036e\u035e\3\2\2\2\u036e\u0365\3\2\2\2\u036f")
455 buf
.write("\u008d\3\2\2\2\u0370\u0371\7[\2\2\u0371\u0372\7_\2\2\u0372")
456 buf
.write("\u037e\7\4\2\2\u0373\u0374\7\\\2\2\u0374\u037e\7\4\2\2")
457 buf
.write("\u0375\u0376\7]\2\2\u0376\u037e\7\4\2\2\u0377\u0378\7")
458 buf
.write("^\2\2\u0378\u037e\7\4\2\2\u0379\u037a\7^\2\2\u037a\u037b")
459 buf
.write("\5\\/\2\u037b\u037c\7\4\2\2\u037c\u037e\3\2\2\2\u037d")
460 buf
.write("\u0370\3\2\2\2\u037d\u0373\3\2\2\2\u037d\u0375\3\2\2\2")
461 buf
.write("\u037d\u0377\3\2\2\2\u037d\u0379\3\2\2\2\u037e\u008f\3")
462 buf
.write("\2\2\2o\u0093\u0097\u009d\u00a6\u00a8\u00ab\u00b1\u00b6")
463 buf
.write("\u00bd\u00bf\u00c3\u00cb\u00d0\u00d7\u00dd\u00f4\u00f9")
464 buf
.write("\u00ff\u0108\u010f\u0117\u0119\u0120\u0126\u012a\u0130")
465 buf
.write("\u0139\u013f\u0146\u014c\u0151\u0154\u0157\u015a\u015e")
466 buf
.write("\u0164\u0169\u0170\u0172\u0184\u018a\u018d\u0192\u0197")
467 buf
.write("\u019a\u019f\u01a4\u01aa\u01ac\u01b0\u01b5\u01b9\u01c0")
468 buf
.write("\u01c5\u01c8\u01cc\u01cf\u01d6\u01db\u01ea\u01f0\u01f4")
469 buf
.write("\u01fb\u0200\u0205\u0209\u0211\u0213\u021d\u021f\u0228")
470 buf
.write("\u0239\u0258\u025a\u0262\u026d\u0276\u027c\u0280\u0285")
471 buf
.write("\u0289\u0290\u029a\u02a7\u02ae\u02b6\u02be\u02c6\u02ce")
472 buf
.write("\u02d6\u02de\u02e6\u02f4\u02f7\u02fe\u0309\u0313\u031d")
473 buf
.write("\u0321\u0324\u0333\u0339\u033d\u0344\u034a\u0354\u035c")
474 buf
.write("\u036e\u037d")
475 return buf
.getvalue()
478 class CParser ( Parser
):
480 grammarFileName
= "C.g4"
482 atn
= ATNDeserializer().deserialize(serializedATN())
484 decisionsToDFA
= [ DFA(ds
, i
) for i
, ds
in enumerate(atn
.decisionToState
) ]
486 sharedContextCache
= PredictionContextCache()
488 literalNames
= [ "<INVALID>", "'{'", "';'", "'typedef'", "','", "'='",
489 "'extern'", "'static'", "'auto'", "'register'", "'STATIC'",
490 "'void'", "'char'", "'short'", "'int'", "'long'", "'float'",
491 "'double'", "'signed'", "'unsigned'", "'}'", "'struct'",
492 "'union'", "':'", "'enum'", "'const'", "'volatile'",
493 "'IN'", "'OUT'", "'OPTIONAL'", "'CONST'", "'UNALIGNED'",
494 "'VOLATILE'", "'GLOBAL_REMOVE_IF_UNREFERENCED'", "'EFIAPI'",
495 "'EFI_BOOTSERVICE'", "'EFI_RUNTIMESERVICE'", "'PACKED'",
496 "'('", "')'", "'['", "']'", "'*'", "'...'", "'+'",
497 "'-'", "'/'", "'%'", "'++'", "'--'", "'sizeof'", "'.'",
498 "'->'", "'&'", "'~'", "'!'", "'*='", "'/='", "'%='",
499 "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", "'|='",
500 "'?'", "'||'", "'&&'", "'|'", "'^'", "'=='", "'!='",
501 "'<'", "'>'", "'<='", "'>='", "'<<'", "'>>'", "'__asm__'",
502 "'_asm'", "'__asm'", "'case'", "'default'", "'if'",
503 "'else'", "'switch'", "'while'", "'do'", "'goto'",
504 "'continue'", "'break'", "'return'" ]
506 symbolicNames
= [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
507 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
508 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
509 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
510 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
511 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
512 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
513 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
514 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
515 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
516 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
517 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
518 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
519 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
520 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
521 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
522 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
523 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
524 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
525 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
526 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
527 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
528 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
529 "<INVALID>", "IDENTIFIER", "CHARACTER_LITERAL", "STRING_LITERAL",
530 "HEX_LITERAL", "DECIMAL_LITERAL", "OCTAL_LITERAL",
531 "FLOATING_POINT_LITERAL", "WS", "BS", "UnicodeVocabulary",
532 "COMMENT", "LINE_COMMENT", "LINE_COMMAND" ]
534 RULE_translation_unit
= 0
535 RULE_external_declaration
= 1
536 RULE_function_definition
= 2
537 RULE_declaration_specifiers
= 3
539 RULE_init_declarator_list
= 5
540 RULE_init_declarator
= 6
541 RULE_storage_class_specifier
= 7
542 RULE_type_specifier
= 8
544 RULE_struct_or_union_specifier
= 10
545 RULE_struct_or_union
= 11
546 RULE_struct_declaration_list
= 12
547 RULE_struct_declaration
= 13
548 RULE_specifier_qualifier_list
= 14
549 RULE_struct_declarator_list
= 15
550 RULE_struct_declarator
= 16
551 RULE_enum_specifier
= 17
552 RULE_enumerator_list
= 18
554 RULE_type_qualifier
= 20
556 RULE_direct_declarator
= 22
557 RULE_declarator_suffix
= 23
559 RULE_parameter_type_list
= 25
560 RULE_parameter_list
= 26
561 RULE_parameter_declaration
= 27
562 RULE_identifier_list
= 28
564 RULE_abstract_declarator
= 30
565 RULE_direct_abstract_declarator
= 31
566 RULE_abstract_declarator_suffix
= 32
567 RULE_initializer
= 33
568 RULE_initializer_list
= 34
569 RULE_argument_expression_list
= 35
570 RULE_additive_expression
= 36
571 RULE_multiplicative_expression
= 37
572 RULE_cast_expression
= 38
573 RULE_unary_expression
= 39
574 RULE_postfix_expression
= 40
575 RULE_macro_parameter_list
= 41
576 RULE_unary_operator
= 42
577 RULE_primary_expression
= 43
580 RULE_constant_expression
= 46
581 RULE_assignment_expression
= 47
583 RULE_assignment_operator
= 49
584 RULE_conditional_expression
= 50
585 RULE_logical_or_expression
= 51
586 RULE_logical_and_expression
= 52
587 RULE_inclusive_or_expression
= 53
588 RULE_exclusive_or_expression
= 54
589 RULE_and_expression
= 55
590 RULE_equality_expression
= 56
591 RULE_relational_expression
= 57
592 RULE_shift_expression
= 58
594 RULE_asm2_statement
= 60
595 RULE_asm1_statement
= 61
596 RULE_asm_statement
= 62
597 RULE_macro_statement
= 63
598 RULE_labeled_statement
= 64
599 RULE_compound_statement
= 65
600 RULE_statement_list
= 66
601 RULE_expression_statement
= 67
602 RULE_selection_statement
= 68
603 RULE_iteration_statement
= 69
604 RULE_jump_statement
= 70
606 ruleNames
= [ "translation_unit", "external_declaration", "function_definition",
607 "declaration_specifiers", "declaration", "init_declarator_list",
608 "init_declarator", "storage_class_specifier", "type_specifier",
609 "type_id", "struct_or_union_specifier", "struct_or_union",
610 "struct_declaration_list", "struct_declaration", "specifier_qualifier_list",
611 "struct_declarator_list", "struct_declarator", "enum_specifier",
612 "enumerator_list", "enumerator", "type_qualifier", "declarator",
613 "direct_declarator", "declarator_suffix", "pointer",
614 "parameter_type_list", "parameter_list", "parameter_declaration",
615 "identifier_list", "type_name", "abstract_declarator",
616 "direct_abstract_declarator", "abstract_declarator_suffix",
617 "initializer", "initializer_list", "argument_expression_list",
618 "additive_expression", "multiplicative_expression", "cast_expression",
619 "unary_expression", "postfix_expression", "macro_parameter_list",
620 "unary_operator", "primary_expression", "constant", "expression",
621 "constant_expression", "assignment_expression", "lvalue",
622 "assignment_operator", "conditional_expression", "logical_or_expression",
623 "logical_and_expression", "inclusive_or_expression",
624 "exclusive_or_expression", "and_expression", "equality_expression",
625 "relational_expression", "shift_expression", "statement",
626 "asm2_statement", "asm1_statement", "asm_statement",
627 "macro_statement", "labeled_statement", "compound_statement",
628 "statement_list", "expression_statement", "selection_statement",
629 "iteration_statement", "jump_statement" ]
730 FLOATING_POINT_LITERAL
=99
733 UnicodeVocabulary
=102
738 # @param input Type: TokenStream
739 # @param output= sys.stdout Type: TextIO
740 def __init__(self
,input,output
= sys
.stdout
):
741 super().__init
__(input, output
)
742 self
.checkVersion("4.7.1")
743 self
._interp
= ParserATNSimulator(self
, self
.atn
, self
.decisionsToDFA
, self
.sharedContextCache
)
744 self
._predicates
= None
749 def printTokenInfo(self
,line
,offset
,tokenText
):
750 print(str(line
)+ ',' + str(offset
) + ':' + str(tokenText
))
752 def StorePredicateExpression(self
,StartLine
,StartOffset
,EndLine
,EndOffset
,Text
):
753 PredExp
= CodeFragment
.PredicateExpression(Text
, (StartLine
, StartOffset
), (EndLine
, EndOffset
))
754 FileProfile
.PredicateExpressionList
.append(PredExp
)
756 def StoreEnumerationDefinition(self
,StartLine
,StartOffset
,EndLine
,EndOffset
,Text
):
757 EnumDef
= CodeFragment
.EnumerationDefinition(Text
, (StartLine
, StartOffset
), (EndLine
, EndOffset
))
758 FileProfile
.EnumerationDefinitionList
.append(EnumDef
)
760 def StoreStructUnionDefinition(self
,StartLine
,StartOffset
,EndLine
,EndOffset
,Text
):
761 SUDef
= CodeFragment
.StructUnionDefinition(Text
, (StartLine
, StartOffset
), (EndLine
, EndOffset
))
762 FileProfile
.StructUnionDefinitionList
.append(SUDef
)
764 def StoreTypedefDefinition(self
,StartLine
,StartOffset
,EndLine
,EndOffset
,FromText
,ToText
):
765 Tdef
= CodeFragment
.TypedefDefinition(FromText
, ToText
, (StartLine
, StartOffset
), (EndLine
, EndOffset
))
766 FileProfile
.TypedefDefinitionList
.append(Tdef
)
768 def StoreFunctionDefinition(self
,StartLine
,StartOffset
,EndLine
,EndOffset
,ModifierText
,DeclText
,LeftBraceLine
,LeftBraceOffset
,DeclLine
,DeclOffset
):
769 FuncDef
= CodeFragment
.FunctionDefinition(ModifierText
, DeclText
, (StartLine
, StartOffset
), (EndLine
, EndOffset
), (LeftBraceLine
, LeftBraceOffset
), (DeclLine
, DeclOffset
))
770 FileProfile
.FunctionDefinitionList
.append(FuncDef
)
772 def StoreVariableDeclaration(self
,StartLine
,StartOffset
,EndLine
,EndOffset
,ModifierText
,DeclText
):
773 VarDecl
= CodeFragment
.VariableDeclaration(ModifierText
, DeclText
, (StartLine
, StartOffset
), (EndLine
, EndOffset
))
774 FileProfile
.VariableDeclarationList
.append(VarDecl
)
776 def StoreFunctionCalling(self
,StartLine
,StartOffset
,EndLine
,EndOffset
,FuncName
,ParamList
):
777 FuncCall
= CodeFragment
.FunctionCalling(FuncName
, ParamList
, (StartLine
, StartOffset
), (EndLine
, EndOffset
))
778 FileProfile
.FunctionCallingList
.append(FuncCall
)
782 class Translation_unitContext(ParserRuleContext
):
784 # @param parent=None Type: ParserRuleContext
785 # @param invokingState=-1 Type: int
786 def __init__(self
,parser
,parent
=None,invokingState
=-1):
787 super().__init
__(parent
, invokingState
)
790 # @param i=None Type: int
791 def external_declaration(self
,i
=None):
793 return self
.getTypedRuleContexts(CParser
.External_declarationContext
)
795 return self
.getTypedRuleContext(CParser
.External_declarationContext
,i
)
798 def getRuleIndex(self
):
799 return CParser
.RULE_translation_unit
801 # @param listener Type: ParseTreeListener
802 def enterRule(self
,listener
):
803 if hasattr( listener
, "enterTranslation_unit" ):
804 listener
.enterTranslation_unit(self
)
806 # @param listener Type: ParseTreeListener
807 def exitRule(self
,listener
):
808 if hasattr( listener
, "exitTranslation_unit" ):
809 listener
.exitTranslation_unit(self
)
814 def translation_unit(self
):
816 localctx
= CParser
.Translation_unitContext(self
, self
._ctx
, self
.state
)
817 self
.enterRule(localctx
, 0, self
.RULE_translation_unit
)
818 self
._la
= 0 # Token type
820 self
.enterOuterAlt(localctx
, 1)
822 self
._errHandler
.sync(self
)
823 _la
= self
._input
.LA(1)
824 while (((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__2
) |
(1 << CParser
.T__5
) |
(1 << CParser
.T__6
) |
(1 << CParser
.T__7
) |
(1 << CParser
.T__8
) |
(1 << CParser
.T__9
) |
(1 << CParser
.T__10
) |
(1 << CParser
.T__11
) |
(1 << CParser
.T__12
) |
(1 << CParser
.T__13
) |
(1 << CParser
.T__14
) |
(1 << CParser
.T__15
) |
(1 << CParser
.T__16
) |
(1 << CParser
.T__17
) |
(1 << CParser
.T__18
) |
(1 << CParser
.T__20
) |
(1 << CParser
.T__21
) |
(1 << CParser
.T__23
) |
(1 << CParser
.T__24
) |
(1 << CParser
.T__25
) |
(1 << CParser
.T__26
) |
(1 << CParser
.T__27
) |
(1 << CParser
.T__28
) |
(1 << CParser
.T__29
) |
(1 << CParser
.T__30
) |
(1 << CParser
.T__31
) |
(1 << CParser
.T__32
) |
(1 << CParser
.T__33
) |
(1 << CParser
.T__34
) |
(1 << CParser
.T__35
) |
(1 << CParser
.T__36
) |
(1 << CParser
.T__37
) |
(1 << CParser
.T__41
))) != 0) or _la
==CParser
.IDENTIFIER
:
826 self
.external_declaration()
828 self
._errHandler
.sync(self
)
829 _la
= self
._input
.LA(1)
831 except RecognitionException
as re
:
832 localctx
.exception
= re
833 self
._errHandler
.reportError(self
, re
)
834 self
._errHandler
.recover(self
, re
)
839 class External_declarationContext(ParserRuleContext
):
841 # @param parent=None Type: ParserRuleContext
842 # @param invokingState=-1 Type: int
843 def __init__(self
,parser
,parent
=None,invokingState
=-1):
844 super().__init
__(parent
, invokingState
)
847 def declarator(self
):
848 return self
.getTypedRuleContext(CParser
.DeclaratorContext
,0)
851 def declaration_specifiers(self
):
852 return self
.getTypedRuleContext(CParser
.Declaration_specifiersContext
,0)
855 # @param i=None Type: int
856 def declaration(self
,i
=None):
858 return self
.getTypedRuleContexts(CParser
.DeclarationContext
)
860 return self
.getTypedRuleContext(CParser
.DeclarationContext
,i
)
863 def function_definition(self
):
864 return self
.getTypedRuleContext(CParser
.Function_definitionContext
,0)
867 def macro_statement(self
):
868 return self
.getTypedRuleContext(CParser
.Macro_statementContext
,0)
871 def getRuleIndex(self
):
872 return CParser
.RULE_external_declaration
874 # @param listener Type: ParseTreeListener
875 def enterRule(self
,listener
):
876 if hasattr( listener
, "enterExternal_declaration" ):
877 listener
.enterExternal_declaration(self
)
879 # @param listener Type: ParseTreeListener
880 def exitRule(self
,listener
):
881 if hasattr( listener
, "exitExternal_declaration" ):
882 listener
.exitExternal_declaration(self
)
887 def external_declaration(self
):
889 localctx
= CParser
.External_declarationContext(self
, self
._ctx
, self
.state
)
890 self
.enterRule(localctx
, 2, self
.RULE_external_declaration
)
891 self
._la
= 0 # Token type
894 self
._errHandler
.sync(self
)
895 la_
= self
._interp
.adaptivePredict(self
._input
,4,self
._ctx
)
897 self
.enterOuterAlt(localctx
, 1)
899 self
._errHandler
.sync(self
)
900 la_
= self
._interp
.adaptivePredict(self
._input
,1,self
._ctx
)
903 self
.declaration_specifiers()
909 self
._errHandler
.sync(self
)
910 _la
= self
._input
.LA(1)
911 while (((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__2
) |
(1 << CParser
.T__5
) |
(1 << CParser
.T__6
) |
(1 << CParser
.T__7
) |
(1 << CParser
.T__8
) |
(1 << CParser
.T__9
) |
(1 << CParser
.T__10
) |
(1 << CParser
.T__11
) |
(1 << CParser
.T__12
) |
(1 << CParser
.T__13
) |
(1 << CParser
.T__14
) |
(1 << CParser
.T__15
) |
(1 << CParser
.T__16
) |
(1 << CParser
.T__17
) |
(1 << CParser
.T__18
) |
(1 << CParser
.T__20
) |
(1 << CParser
.T__21
) |
(1 << CParser
.T__23
) |
(1 << CParser
.T__24
) |
(1 << CParser
.T__25
) |
(1 << CParser
.T__26
) |
(1 << CParser
.T__27
) |
(1 << CParser
.T__28
) |
(1 << CParser
.T__29
) |
(1 << CParser
.T__30
) |
(1 << CParser
.T__31
) |
(1 << CParser
.T__32
) |
(1 << CParser
.T__33
) |
(1 << CParser
.T__34
) |
(1 << CParser
.T__35
) |
(1 << CParser
.T__36
))) != 0) or _la
==CParser
.IDENTIFIER
:
915 self
._errHandler
.sync(self
)
916 _la
= self
._input
.LA(1)
919 self
.match(CParser
.T__0
)
923 self
.enterOuterAlt(localctx
, 2)
925 self
.function_definition()
929 self
.enterOuterAlt(localctx
, 3)
935 self
.enterOuterAlt(localctx
, 4)
937 self
.macro_statement()
939 self
._errHandler
.sync(self
)
940 _la
= self
._input
.LA(1)
941 if _la
==CParser
.T__1
:
943 self
.match(CParser
.T__1
)
949 except RecognitionException
as re
:
950 localctx
.exception
= re
951 self
._errHandler
.reportError(self
, re
)
952 self
._errHandler
.recover(self
, re
)
957 class Function_definitionContext(ParserRuleContext
):
959 # @param parent=None Type: ParserRuleContext
960 # @param invokingState=-1 Type: int
961 def __init__(self
,parser
,parent
=None,invokingState
=-1):
962 super().__init
__(parent
, invokingState
)
964 self
.ModifierText
= ''
970 self
.d
= None # Declaration_specifiersContext
971 self
._declaration
_specifiers
= None # Declaration_specifiersContext
972 self
._declarator
= None # DeclaratorContext
973 self
.a
= None # Compound_statementContext
974 self
.b
= None # Compound_statementContext
976 def declarator(self
):
977 return self
.getTypedRuleContext(CParser
.DeclaratorContext
,0)
980 def compound_statement(self
):
981 return self
.getTypedRuleContext(CParser
.Compound_statementContext
,0)
984 def declaration_specifiers(self
):
985 return self
.getTypedRuleContext(CParser
.Declaration_specifiersContext
,0)
988 # @param i=None Type: int
989 def declaration(self
,i
=None):
991 return self
.getTypedRuleContexts(CParser
.DeclarationContext
)
993 return self
.getTypedRuleContext(CParser
.DeclarationContext
,i
)
996 def getRuleIndex(self
):
997 return CParser
.RULE_function_definition
999 # @param listener Type: ParseTreeListener
1000 def enterRule(self
,listener
):
1001 if hasattr( listener
, "enterFunction_definition" ):
1002 listener
.enterFunction_definition(self
)
1004 # @param listener Type: ParseTreeListener
1005 def exitRule(self
,listener
):
1006 if hasattr( listener
, "exitFunction_definition" ):
1007 listener
.exitFunction_definition(self
)
1012 def function_definition(self
):
1014 localctx
= CParser
.Function_definitionContext(self
, self
._ctx
, self
.state
)
1015 self
.enterRule(localctx
, 4, self
.RULE_function_definition
)
1024 self
._la
= 0 # Token type
1026 self
.enterOuterAlt(localctx
, 1)
1028 self
._errHandler
.sync(self
)
1029 la_
= self
._interp
.adaptivePredict(self
._input
,5,self
._ctx
)
1032 localctx
.d
= localctx
._declaration
_specifiers
= self
.declaration_specifiers()
1036 localctx
._declarator
= self
.declarator()
1038 self
._errHandler
.sync(self
)
1039 token
= self
._input
.LA(1)
1040 if token
in [CParser
.T__2
, CParser
.T__5
, CParser
.T__6
, CParser
.T__7
, CParser
.T__8
, CParser
.T__9
, CParser
.T__10
, CParser
.T__11
, CParser
.T__12
, CParser
.T__13
, CParser
.T__14
, CParser
.T__15
, CParser
.T__16
, CParser
.T__17
, CParser
.T__18
, CParser
.T__20
, CParser
.T__21
, CParser
.T__23
, CParser
.T__24
, CParser
.T__25
, CParser
.T__26
, CParser
.T__27
, CParser
.T__28
, CParser
.T__29
, CParser
.T__30
, CParser
.T__31
, CParser
.T__32
, CParser
.T__33
, CParser
.T__34
, CParser
.T__35
, CParser
.T__36
, CParser
.IDENTIFIER
]:
1042 self
._errHandler
.sync(self
)
1043 _la
= self
._input
.LA(1)
1048 self
._errHandler
.sync(self
)
1049 _la
= self
._input
.LA(1)
1050 if not ((((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__2
) |
(1 << CParser
.T__5
) |
(1 << CParser
.T__6
) |
(1 << CParser
.T__7
) |
(1 << CParser
.T__8
) |
(1 << CParser
.T__9
) |
(1 << CParser
.T__10
) |
(1 << CParser
.T__11
) |
(1 << CParser
.T__12
) |
(1 << CParser
.T__13
) |
(1 << CParser
.T__14
) |
(1 << CParser
.T__15
) |
(1 << CParser
.T__16
) |
(1 << CParser
.T__17
) |
(1 << CParser
.T__18
) |
(1 << CParser
.T__20
) |
(1 << CParser
.T__21
) |
(1 << CParser
.T__23
) |
(1 << CParser
.T__24
) |
(1 << CParser
.T__25
) |
(1 << CParser
.T__26
) |
(1 << CParser
.T__27
) |
(1 << CParser
.T__28
) |
(1 << CParser
.T__29
) |
(1 << CParser
.T__30
) |
(1 << CParser
.T__31
) |
(1 << CParser
.T__32
) |
(1 << CParser
.T__33
) |
(1 << CParser
.T__34
) |
(1 << CParser
.T__35
) |
(1 << CParser
.T__36
))) != 0) or _la
==CParser
.IDENTIFIER
):
1054 localctx
.a
= self
.compound_statement()
1056 elif token
in [CParser
.T__0
]:
1058 localctx
.b
= self
.compound_statement()
1061 raise NoViableAltException(self
)
1064 if localctx
.d
!= None:
1065 ModifierText
= (None if localctx
._declaration
_specifiers
is None else self
._input
.getText((localctx
._declaration
_specifiers
.start
,localctx
._declaration
_specifiers
.stop
)))
1068 DeclText
= (None if localctx
._declarator
is None else self
._input
.getText((localctx
._declarator
.start
,localctx
._declarator
.stop
)))
1069 DeclLine
= (None if localctx
._declarator
is None else localctx
._declarator
.start
).line
1070 DeclOffset
= (None if localctx
._declarator
is None else localctx
._declarator
.start
).column
1071 if localctx
.a
!= None:
1072 LBLine
= (None if localctx
.a
is None else localctx
.a
.start
).line
1073 LBOffset
= (None if localctx
.a
is None else localctx
.a
.start
).column
1075 LBLine
= (None if localctx
.b
is None else localctx
.b
.start
).line
1076 LBOffset
= (None if localctx
.b
is None else localctx
.b
.start
).column
1078 self
._ctx
.stop
= self
._input
.LT(-1)
1080 self
.StoreFunctionDefinition(localctx
.start
.line
, localctx
.start
.column
, localctx
.stop
.line
, localctx
.stop
.column
, ModifierText
, DeclText
, LBLine
, LBOffset
, DeclLine
, DeclOffset
)
1082 except RecognitionException
as re
:
1083 localctx
.exception
= re
1084 self
._errHandler
.reportError(self
, re
)
1085 self
._errHandler
.recover(self
, re
)
1090 class Declaration_specifiersContext(ParserRuleContext
):
1092 # @param parent=None Type: ParserRuleContext
1093 # @param invokingState=-1 Type: int
1094 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1095 super().__init
__(parent
, invokingState
)
1096 self
.parser
= parser
1098 # @param i=None Type: int
1099 def storage_class_specifier(self
,i
=None):
1101 return self
.getTypedRuleContexts(CParser
.Storage_class_specifierContext
)
1103 return self
.getTypedRuleContext(CParser
.Storage_class_specifierContext
,i
)
1106 # @param i=None Type: int
1107 def type_specifier(self
,i
=None):
1109 return self
.getTypedRuleContexts(CParser
.Type_specifierContext
)
1111 return self
.getTypedRuleContext(CParser
.Type_specifierContext
,i
)
1114 # @param i=None Type: int
1115 def type_qualifier(self
,i
=None):
1117 return self
.getTypedRuleContexts(CParser
.Type_qualifierContext
)
1119 return self
.getTypedRuleContext(CParser
.Type_qualifierContext
,i
)
1122 def getRuleIndex(self
):
1123 return CParser
.RULE_declaration_specifiers
1125 # @param listener Type: ParseTreeListener
1126 def enterRule(self
,listener
):
1127 if hasattr( listener
, "enterDeclaration_specifiers" ):
1128 listener
.enterDeclaration_specifiers(self
)
1130 # @param listener Type: ParseTreeListener
1131 def exitRule(self
,listener
):
1132 if hasattr( listener
, "exitDeclaration_specifiers" ):
1133 listener
.exitDeclaration_specifiers(self
)
1138 def declaration_specifiers(self
):
1140 localctx
= CParser
.Declaration_specifiersContext(self
, self
._ctx
, self
.state
)
1141 self
.enterRule(localctx
, 6, self
.RULE_declaration_specifiers
)
1143 self
.enterOuterAlt(localctx
, 1)
1145 self
._errHandler
.sync(self
)
1147 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
1150 self
._errHandler
.sync(self
)
1151 token
= self
._input
.LA(1)
1152 if token
in [CParser
.T__5
, CParser
.T__6
, CParser
.T__7
, CParser
.T__8
, CParser
.T__9
]:
1154 self
.storage_class_specifier()
1156 elif token
in [CParser
.T__10
, CParser
.T__11
, CParser
.T__12
, CParser
.T__13
, CParser
.T__14
, CParser
.T__15
, CParser
.T__16
, CParser
.T__17
, CParser
.T__18
, CParser
.T__20
, CParser
.T__21
, CParser
.T__23
, CParser
.IDENTIFIER
]:
1158 self
.type_specifier()
1160 elif token
in [CParser
.T__24
, CParser
.T__25
, CParser
.T__26
, CParser
.T__27
, CParser
.T__28
, CParser
.T__29
, CParser
.T__30
, CParser
.T__31
, CParser
.T__32
, CParser
.T__33
, CParser
.T__34
, CParser
.T__35
, CParser
.T__36
]:
1162 self
.type_qualifier()
1165 raise NoViableAltException(self
)
1169 raise NoViableAltException(self
)
1171 self
._errHandler
.sync(self
)
1172 _alt
= self
._interp
.adaptivePredict(self
._input
,9,self
._ctx
)
1174 except RecognitionException
as re
:
1175 localctx
.exception
= re
1176 self
._errHandler
.reportError(self
, re
)
1177 self
._errHandler
.recover(self
, re
)
1182 class DeclarationContext(ParserRuleContext
):
1184 # @param parent=None Type: ParserRuleContext
1185 # @param invokingState=-1 Type: int
1186 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1187 super().__init
__(parent
, invokingState
)
1188 self
.parser
= parser
1189 self
.a
= None # Token
1190 self
.b
= None # Declaration_specifiersContext
1191 self
.c
= None # Init_declarator_listContext
1192 self
.d
= None # Token
1193 self
.s
= None # Declaration_specifiersContext
1194 self
.t
= None # Init_declarator_listContext
1195 self
.e
= None # Token
1197 def init_declarator_list(self
):
1198 return self
.getTypedRuleContext(CParser
.Init_declarator_listContext
,0)
1201 def declaration_specifiers(self
):
1202 return self
.getTypedRuleContext(CParser
.Declaration_specifiersContext
,0)
1205 def getRuleIndex(self
):
1206 return CParser
.RULE_declaration
1208 # @param listener Type: ParseTreeListener
1209 def enterRule(self
,listener
):
1210 if hasattr( listener
, "enterDeclaration" ):
1211 listener
.enterDeclaration(self
)
1213 # @param listener Type: ParseTreeListener
1214 def exitRule(self
,listener
):
1215 if hasattr( listener
, "exitDeclaration" ):
1216 listener
.exitDeclaration(self
)
1221 def declaration(self
):
1223 localctx
= CParser
.DeclarationContext(self
, self
._ctx
, self
.state
)
1224 self
.enterRule(localctx
, 8, self
.RULE_declaration
)
1225 self
._la
= 0 # Token type
1228 self
._errHandler
.sync(self
)
1229 token
= self
._input
.LA(1)
1230 if token
in [CParser
.T__2
]:
1231 self
.enterOuterAlt(localctx
, 1)
1233 localctx
.a
= self
.match(CParser
.T__2
)
1235 self
._errHandler
.sync(self
)
1236 la_
= self
._interp
.adaptivePredict(self
._input
,10,self
._ctx
)
1239 localctx
.b
= self
.declaration_specifiers()
1243 localctx
.c
= self
.init_declarator_list()
1245 localctx
.d
= self
.match(CParser
.T__1
)
1247 if localctx
.b
is not None:
1248 self
.StoreTypedefDefinition(localctx
.a
.line
, localctx
.a
.column
, (0 if localctx
.d
is None else localctx
.d
.line
), localctx
.d
.column
, (None if localctx
.b
is None else self
._input
.getText((localctx
.b
.start
,localctx
.b
.stop
))), (None if localctx
.c
is None else self
._input
.getText((localctx
.c
.start
,localctx
.c
.stop
))))
1250 self
.StoreTypedefDefinition(localctx
.a
.line
, localctx
.a
.column
, (0 if localctx
.d
is None else localctx
.d
.line
), localctx
.d
.column
, '', (None if localctx
.c
is None else self
._input
.getText((localctx
.c
.start
,localctx
.c
.stop
))))
1253 elif token
in [CParser
.T__5
, CParser
.T__6
, CParser
.T__7
, CParser
.T__8
, CParser
.T__9
, CParser
.T__10
, CParser
.T__11
, CParser
.T__12
, CParser
.T__13
, CParser
.T__14
, CParser
.T__15
, CParser
.T__16
, CParser
.T__17
, CParser
.T__18
, CParser
.T__20
, CParser
.T__21
, CParser
.T__23
, CParser
.T__24
, CParser
.T__25
, CParser
.T__26
, CParser
.T__27
, CParser
.T__28
, CParser
.T__29
, CParser
.T__30
, CParser
.T__31
, CParser
.T__32
, CParser
.T__33
, CParser
.T__34
, CParser
.T__35
, CParser
.T__36
, CParser
.IDENTIFIER
]:
1254 self
.enterOuterAlt(localctx
, 2)
1256 localctx
.s
= self
.declaration_specifiers()
1258 self
._errHandler
.sync(self
)
1259 _la
= self
._input
.LA(1)
1260 if ((((_la
- 34)) & ~
0x3f) == 0 and ((1 << (_la
- 34)) & ((1 << (CParser
.T__33
- 34)) |
(1 << (CParser
.T__34
- 34)) |
(1 << (CParser
.T__35
- 34)) |
(1 << (CParser
.T__37
- 34)) |
(1 << (CParser
.T__41
- 34)) |
(1 << (CParser
.IDENTIFIER
- 34)))) != 0):
1262 localctx
.t
= self
.init_declarator_list()
1266 localctx
.e
= self
.match(CParser
.T__1
)
1268 if localctx
.t
is not None:
1269 self
.StoreVariableDeclaration((None if localctx
.s
is None else localctx
.s
.start
).line
, (None if localctx
.s
is None else localctx
.s
.start
).column
, (None if localctx
.t
is None else localctx
.t
.start
).line
, (None if localctx
.t
is None else localctx
.t
.start
).column
, (None if localctx
.s
is None else self
._input
.getText((localctx
.s
.start
,localctx
.s
.stop
))), (None if localctx
.t
is None else self
._input
.getText((localctx
.t
.start
,localctx
.t
.stop
))))
1273 raise NoViableAltException(self
)
1275 except RecognitionException
as re
:
1276 localctx
.exception
= re
1277 self
._errHandler
.reportError(self
, re
)
1278 self
._errHandler
.recover(self
, re
)
1283 class Init_declarator_listContext(ParserRuleContext
):
1285 # @param parent=None Type: ParserRuleContext
1286 # @param invokingState=-1 Type: int
1287 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1288 super().__init
__(parent
, invokingState
)
1289 self
.parser
= parser
1291 # @param i=None Type: int
1292 def init_declarator(self
,i
=None):
1294 return self
.getTypedRuleContexts(CParser
.Init_declaratorContext
)
1296 return self
.getTypedRuleContext(CParser
.Init_declaratorContext
,i
)
1299 def getRuleIndex(self
):
1300 return CParser
.RULE_init_declarator_list
1302 # @param listener Type: ParseTreeListener
1303 def enterRule(self
,listener
):
1304 if hasattr( listener
, "enterInit_declarator_list" ):
1305 listener
.enterInit_declarator_list(self
)
1307 # @param listener Type: ParseTreeListener
1308 def exitRule(self
,listener
):
1309 if hasattr( listener
, "exitInit_declarator_list" ):
1310 listener
.exitInit_declarator_list(self
)
1315 def init_declarator_list(self
):
1317 localctx
= CParser
.Init_declarator_listContext(self
, self
._ctx
, self
.state
)
1318 self
.enterRule(localctx
, 10, self
.RULE_init_declarator_list
)
1319 self
._la
= 0 # Token type
1321 self
.enterOuterAlt(localctx
, 1)
1323 self
.init_declarator()
1325 self
._errHandler
.sync(self
)
1326 _la
= self
._input
.LA(1)
1327 while _la
==CParser
.T__3
:
1329 self
.match(CParser
.T__3
)
1331 self
.init_declarator()
1333 self
._errHandler
.sync(self
)
1334 _la
= self
._input
.LA(1)
1336 except RecognitionException
as re
:
1337 localctx
.exception
= re
1338 self
._errHandler
.reportError(self
, re
)
1339 self
._errHandler
.recover(self
, re
)
1344 class Init_declaratorContext(ParserRuleContext
):
1346 # @param parent=None Type: ParserRuleContext
1347 # @param invokingState=-1 Type: int
1348 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1349 super().__init
__(parent
, invokingState
)
1350 self
.parser
= parser
1352 def declarator(self
):
1353 return self
.getTypedRuleContext(CParser
.DeclaratorContext
,0)
1356 def initializer(self
):
1357 return self
.getTypedRuleContext(CParser
.InitializerContext
,0)
1360 def getRuleIndex(self
):
1361 return CParser
.RULE_init_declarator
1363 # @param listener Type: ParseTreeListener
1364 def enterRule(self
,listener
):
1365 if hasattr( listener
, "enterInit_declarator" ):
1366 listener
.enterInit_declarator(self
)
1368 # @param listener Type: ParseTreeListener
1369 def exitRule(self
,listener
):
1370 if hasattr( listener
, "exitInit_declarator" ):
1371 listener
.exitInit_declarator(self
)
1376 def init_declarator(self
):
1378 localctx
= CParser
.Init_declaratorContext(self
, self
._ctx
, self
.state
)
1379 self
.enterRule(localctx
, 12, self
.RULE_init_declarator
)
1380 self
._la
= 0 # Token type
1382 self
.enterOuterAlt(localctx
, 1)
1386 self
._errHandler
.sync(self
)
1387 _la
= self
._input
.LA(1)
1388 if _la
==CParser
.T__4
:
1390 self
.match(CParser
.T__4
)
1395 except RecognitionException
as re
:
1396 localctx
.exception
= re
1397 self
._errHandler
.reportError(self
, re
)
1398 self
._errHandler
.recover(self
, re
)
1403 class Storage_class_specifierContext(ParserRuleContext
):
1405 # @param parent=None Type: ParserRuleContext
1406 # @param invokingState=-1 Type: int
1407 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1408 super().__init
__(parent
, invokingState
)
1409 self
.parser
= parser
1412 def getRuleIndex(self
):
1413 return CParser
.RULE_storage_class_specifier
1415 # @param listener Type: ParseTreeListener
1416 def enterRule(self
,listener
):
1417 if hasattr( listener
, "enterStorage_class_specifier" ):
1418 listener
.enterStorage_class_specifier(self
)
1420 # @param listener Type: ParseTreeListener
1421 def exitRule(self
,listener
):
1422 if hasattr( listener
, "exitStorage_class_specifier" ):
1423 listener
.exitStorage_class_specifier(self
)
1428 def storage_class_specifier(self
):
1430 localctx
= CParser
.Storage_class_specifierContext(self
, self
._ctx
, self
.state
)
1431 self
.enterRule(localctx
, 14, self
.RULE_storage_class_specifier
)
1432 self
._la
= 0 # Token type
1434 self
.enterOuterAlt(localctx
, 1)
1436 _la
= self
._input
.LA(1)
1437 if not((((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__5
) |
(1 << CParser
.T__6
) |
(1 << CParser
.T__7
) |
(1 << CParser
.T__8
) |
(1 << CParser
.T__9
))) != 0)):
1438 self
._errHandler
.recoverInline(self
)
1440 self
._errHandler
.reportMatch(self
)
1442 except RecognitionException
as re
:
1443 localctx
.exception
= re
1444 self
._errHandler
.reportError(self
, re
)
1445 self
._errHandler
.recover(self
, re
)
1450 class Type_specifierContext(ParserRuleContext
):
1452 # @param parent=None Type: ParserRuleContext
1453 # @param invokingState=-1 Type: int
1454 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1455 super().__init
__(parent
, invokingState
)
1456 self
.parser
= parser
1457 self
.s
= None # Struct_or_union_specifierContext
1458 self
.e
= None # Enum_specifierContext
1460 def struct_or_union_specifier(self
):
1461 return self
.getTypedRuleContext(CParser
.Struct_or_union_specifierContext
,0)
1464 def enum_specifier(self
):
1465 return self
.getTypedRuleContext(CParser
.Enum_specifierContext
,0)
1468 def IDENTIFIER(self
):
1469 return self
.getToken(CParser
.IDENTIFIER
, 0)
1471 def declarator(self
):
1472 return self
.getTypedRuleContext(CParser
.DeclaratorContext
,0)
1475 # @param i=None Type: int
1476 def type_qualifier(self
,i
=None):
1478 return self
.getTypedRuleContexts(CParser
.Type_qualifierContext
)
1480 return self
.getTypedRuleContext(CParser
.Type_qualifierContext
,i
)
1484 return self
.getTypedRuleContext(CParser
.Type_idContext
,0)
1487 def getRuleIndex(self
):
1488 return CParser
.RULE_type_specifier
1490 # @param listener Type: ParseTreeListener
1491 def enterRule(self
,listener
):
1492 if hasattr( listener
, "enterType_specifier" ):
1493 listener
.enterType_specifier(self
)
1495 # @param listener Type: ParseTreeListener
1496 def exitRule(self
,listener
):
1497 if hasattr( listener
, "exitType_specifier" ):
1498 listener
.exitType_specifier(self
)
1503 def type_specifier(self
):
1505 localctx
= CParser
.Type_specifierContext(self
, self
._ctx
, self
.state
)
1506 self
.enterRule(localctx
, 16, self
.RULE_type_specifier
)
1509 self
._errHandler
.sync(self
)
1510 la_
= self
._interp
.adaptivePredict(self
._input
,16,self
._ctx
)
1512 self
.enterOuterAlt(localctx
, 1)
1514 self
.match(CParser
.T__10
)
1518 self
.enterOuterAlt(localctx
, 2)
1520 self
.match(CParser
.T__11
)
1524 self
.enterOuterAlt(localctx
, 3)
1526 self
.match(CParser
.T__12
)
1530 self
.enterOuterAlt(localctx
, 4)
1532 self
.match(CParser
.T__13
)
1536 self
.enterOuterAlt(localctx
, 5)
1538 self
.match(CParser
.T__14
)
1542 self
.enterOuterAlt(localctx
, 6)
1544 self
.match(CParser
.T__15
)
1548 self
.enterOuterAlt(localctx
, 7)
1550 self
.match(CParser
.T__16
)
1554 self
.enterOuterAlt(localctx
, 8)
1556 self
.match(CParser
.T__17
)
1560 self
.enterOuterAlt(localctx
, 9)
1562 self
.match(CParser
.T__18
)
1566 self
.enterOuterAlt(localctx
, 10)
1568 localctx
.s
= self
.struct_or_union_specifier()
1570 if localctx
.s
.stop
is not None:
1571 self
.StoreStructUnionDefinition((None if localctx
.s
is None else localctx
.s
.start
).line
, (None if localctx
.s
is None else localctx
.s
.start
).column
, (None if localctx
.s
is None else localctx
.s
.stop
).line
, (None if localctx
.s
is None else localctx
.s
.stop
).column
, (None if localctx
.s
is None else self
._input
.getText((localctx
.s
.start
,localctx
.s
.stop
))))
1576 self
.enterOuterAlt(localctx
, 11)
1578 localctx
.e
= self
.enum_specifier()
1580 if localctx
.e
.stop
is not None:
1581 self
.StoreEnumerationDefinition((None if localctx
.e
is None else localctx
.e
.start
).line
, (None if localctx
.e
is None else localctx
.e
.start
).column
, (None if localctx
.e
is None else localctx
.e
.stop
).line
, (None if localctx
.e
is None else localctx
.e
.stop
).column
, (None if localctx
.e
is None else self
._input
.getText((localctx
.e
.start
,localctx
.e
.stop
))))
1586 self
.enterOuterAlt(localctx
, 12)
1588 self
.match(CParser
.IDENTIFIER
)
1590 self
._errHandler
.sync(self
)
1591 _alt
= self
._interp
.adaptivePredict(self
._input
,15,self
._ctx
)
1592 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
1595 self
.type_qualifier()
1597 self
._errHandler
.sync(self
)
1598 _alt
= self
._interp
.adaptivePredict(self
._input
,15,self
._ctx
)
1605 self
.enterOuterAlt(localctx
, 13)
1611 except RecognitionException
as re
:
1612 localctx
.exception
= re
1613 self
._errHandler
.reportError(self
, re
)
1614 self
._errHandler
.recover(self
, re
)
1619 class Type_idContext(ParserRuleContext
):
1621 # @param parent=None Type: ParserRuleContext
1622 # @param invokingState=-1 Type: int
1623 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1624 super().__init
__(parent
, invokingState
)
1625 self
.parser
= parser
1627 def IDENTIFIER(self
):
1628 return self
.getToken(CParser
.IDENTIFIER
, 0)
1630 def getRuleIndex(self
):
1631 return CParser
.RULE_type_id
1633 # @param listener Type: ParseTreeListener
1634 def enterRule(self
,listener
):
1635 if hasattr( listener
, "enterType_id" ):
1636 listener
.enterType_id(self
)
1638 # @param listener Type: ParseTreeListener
1639 def exitRule(self
,listener
):
1640 if hasattr( listener
, "exitType_id" ):
1641 listener
.exitType_id(self
)
1648 localctx
= CParser
.Type_idContext(self
, self
._ctx
, self
.state
)
1649 self
.enterRule(localctx
, 18, self
.RULE_type_id
)
1651 self
.enterOuterAlt(localctx
, 1)
1653 self
.match(CParser
.IDENTIFIER
)
1654 except RecognitionException
as re
:
1655 localctx
.exception
= re
1656 self
._errHandler
.reportError(self
, re
)
1657 self
._errHandler
.recover(self
, re
)
1662 class Struct_or_union_specifierContext(ParserRuleContext
):
1664 # @param parent=None Type: ParserRuleContext
1665 # @param invokingState=-1 Type: int
1666 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1667 super().__init
__(parent
, invokingState
)
1668 self
.parser
= parser
1670 def struct_or_union(self
):
1671 return self
.getTypedRuleContext(CParser
.Struct_or_unionContext
,0)
1674 def struct_declaration_list(self
):
1675 return self
.getTypedRuleContext(CParser
.Struct_declaration_listContext
,0)
1678 def IDENTIFIER(self
):
1679 return self
.getToken(CParser
.IDENTIFIER
, 0)
1681 def getRuleIndex(self
):
1682 return CParser
.RULE_struct_or_union_specifier
1684 # @param listener Type: ParseTreeListener
1685 def enterRule(self
,listener
):
1686 if hasattr( listener
, "enterStruct_or_union_specifier" ):
1687 listener
.enterStruct_or_union_specifier(self
)
1689 # @param listener Type: ParseTreeListener
1690 def exitRule(self
,listener
):
1691 if hasattr( listener
, "exitStruct_or_union_specifier" ):
1692 listener
.exitStruct_or_union_specifier(self
)
1697 def struct_or_union_specifier(self
):
1699 localctx
= CParser
.Struct_or_union_specifierContext(self
, self
._ctx
, self
.state
)
1700 self
.enterRule(localctx
, 20, self
.RULE_struct_or_union_specifier
)
1701 self
._la
= 0 # Token type
1704 self
._errHandler
.sync(self
)
1705 la_
= self
._interp
.adaptivePredict(self
._input
,18,self
._ctx
)
1707 self
.enterOuterAlt(localctx
, 1)
1709 self
.struct_or_union()
1711 self
._errHandler
.sync(self
)
1712 _la
= self
._input
.LA(1)
1713 if _la
==CParser
.IDENTIFIER
:
1715 self
.match(CParser
.IDENTIFIER
)
1719 self
.match(CParser
.T__0
)
1721 self
.struct_declaration_list()
1723 self
.match(CParser
.T__19
)
1727 self
.enterOuterAlt(localctx
, 2)
1729 self
.struct_or_union()
1731 self
.match(CParser
.IDENTIFIER
)
1735 except RecognitionException
as re
:
1736 localctx
.exception
= re
1737 self
._errHandler
.reportError(self
, re
)
1738 self
._errHandler
.recover(self
, re
)
1743 class Struct_or_unionContext(ParserRuleContext
):
1745 # @param parent=None Type: ParserRuleContext
1746 # @param invokingState=-1 Type: int
1747 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1748 super().__init
__(parent
, invokingState
)
1749 self
.parser
= parser
1752 def getRuleIndex(self
):
1753 return CParser
.RULE_struct_or_union
1755 # @param listener Type: ParseTreeListener
1756 def enterRule(self
,listener
):
1757 if hasattr( listener
, "enterStruct_or_union" ):
1758 listener
.enterStruct_or_union(self
)
1760 # @param listener Type: ParseTreeListener
1761 def exitRule(self
,listener
):
1762 if hasattr( listener
, "exitStruct_or_union" ):
1763 listener
.exitStruct_or_union(self
)
1768 def struct_or_union(self
):
1770 localctx
= CParser
.Struct_or_unionContext(self
, self
._ctx
, self
.state
)
1771 self
.enterRule(localctx
, 22, self
.RULE_struct_or_union
)
1772 self
._la
= 0 # Token type
1774 self
.enterOuterAlt(localctx
, 1)
1776 _la
= self
._input
.LA(1)
1777 if not(_la
==CParser
.T__20
or _la
==CParser
.T__21
):
1778 self
._errHandler
.recoverInline(self
)
1780 self
._errHandler
.reportMatch(self
)
1782 except RecognitionException
as re
:
1783 localctx
.exception
= re
1784 self
._errHandler
.reportError(self
, re
)
1785 self
._errHandler
.recover(self
, re
)
1790 class Struct_declaration_listContext(ParserRuleContext
):
1792 # @param parent=None Type: ParserRuleContext
1793 # @param invokingState=-1 Type: int
1794 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1795 super().__init
__(parent
, invokingState
)
1796 self
.parser
= parser
1798 # @param i=None Type: int
1799 def struct_declaration(self
,i
=None):
1801 return self
.getTypedRuleContexts(CParser
.Struct_declarationContext
)
1803 return self
.getTypedRuleContext(CParser
.Struct_declarationContext
,i
)
1806 def getRuleIndex(self
):
1807 return CParser
.RULE_struct_declaration_list
1809 # @param listener Type: ParseTreeListener
1810 def enterRule(self
,listener
):
1811 if hasattr( listener
, "enterStruct_declaration_list" ):
1812 listener
.enterStruct_declaration_list(self
)
1814 # @param listener Type: ParseTreeListener
1815 def exitRule(self
,listener
):
1816 if hasattr( listener
, "exitStruct_declaration_list" ):
1817 listener
.exitStruct_declaration_list(self
)
1822 def struct_declaration_list(self
):
1824 localctx
= CParser
.Struct_declaration_listContext(self
, self
._ctx
, self
.state
)
1825 self
.enterRule(localctx
, 24, self
.RULE_struct_declaration_list
)
1826 self
._la
= 0 # Token type
1828 self
.enterOuterAlt(localctx
, 1)
1830 self
._errHandler
.sync(self
)
1831 _la
= self
._input
.LA(1)
1834 self
.struct_declaration()
1836 self
._errHandler
.sync(self
)
1837 _la
= self
._input
.LA(1)
1838 if not ((((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__10
) |
(1 << CParser
.T__11
) |
(1 << CParser
.T__12
) |
(1 << CParser
.T__13
) |
(1 << CParser
.T__14
) |
(1 << CParser
.T__15
) |
(1 << CParser
.T__16
) |
(1 << CParser
.T__17
) |
(1 << CParser
.T__18
) |
(1 << CParser
.T__20
) |
(1 << CParser
.T__21
) |
(1 << CParser
.T__23
) |
(1 << CParser
.T__24
) |
(1 << CParser
.T__25
) |
(1 << CParser
.T__26
) |
(1 << CParser
.T__27
) |
(1 << CParser
.T__28
) |
(1 << CParser
.T__29
) |
(1 << CParser
.T__30
) |
(1 << CParser
.T__31
) |
(1 << CParser
.T__32
) |
(1 << CParser
.T__33
) |
(1 << CParser
.T__34
) |
(1 << CParser
.T__35
) |
(1 << CParser
.T__36
))) != 0) or _la
==CParser
.IDENTIFIER
):
1841 except RecognitionException
as re
:
1842 localctx
.exception
= re
1843 self
._errHandler
.reportError(self
, re
)
1844 self
._errHandler
.recover(self
, re
)
1849 class Struct_declarationContext(ParserRuleContext
):
1851 # @param parent=None Type: ParserRuleContext
1852 # @param invokingState=-1 Type: int
1853 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1854 super().__init
__(parent
, invokingState
)
1855 self
.parser
= parser
1857 def specifier_qualifier_list(self
):
1858 return self
.getTypedRuleContext(CParser
.Specifier_qualifier_listContext
,0)
1861 def struct_declarator_list(self
):
1862 return self
.getTypedRuleContext(CParser
.Struct_declarator_listContext
,0)
1865 def getRuleIndex(self
):
1866 return CParser
.RULE_struct_declaration
1868 # @param listener Type: ParseTreeListener
1869 def enterRule(self
,listener
):
1870 if hasattr( listener
, "enterStruct_declaration" ):
1871 listener
.enterStruct_declaration(self
)
1873 # @param listener Type: ParseTreeListener
1874 def exitRule(self
,listener
):
1875 if hasattr( listener
, "exitStruct_declaration" ):
1876 listener
.exitStruct_declaration(self
)
1881 def struct_declaration(self
):
1883 localctx
= CParser
.Struct_declarationContext(self
, self
._ctx
, self
.state
)
1884 self
.enterRule(localctx
, 26, self
.RULE_struct_declaration
)
1886 self
.enterOuterAlt(localctx
, 1)
1888 self
.specifier_qualifier_list()
1890 self
.struct_declarator_list()
1892 self
.match(CParser
.T__1
)
1893 except RecognitionException
as re
:
1894 localctx
.exception
= re
1895 self
._errHandler
.reportError(self
, re
)
1896 self
._errHandler
.recover(self
, re
)
1901 class Specifier_qualifier_listContext(ParserRuleContext
):
1903 # @param parent=None Type: ParserRuleContext
1904 # @param invokingState=-1 Type: int
1905 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1906 super().__init
__(parent
, invokingState
)
1907 self
.parser
= parser
1909 # @param i=None Type: int
1910 def type_qualifier(self
,i
=None):
1912 return self
.getTypedRuleContexts(CParser
.Type_qualifierContext
)
1914 return self
.getTypedRuleContext(CParser
.Type_qualifierContext
,i
)
1917 # @param i=None Type: int
1918 def type_specifier(self
,i
=None):
1920 return self
.getTypedRuleContexts(CParser
.Type_specifierContext
)
1922 return self
.getTypedRuleContext(CParser
.Type_specifierContext
,i
)
1925 def getRuleIndex(self
):
1926 return CParser
.RULE_specifier_qualifier_list
1928 # @param listener Type: ParseTreeListener
1929 def enterRule(self
,listener
):
1930 if hasattr( listener
, "enterSpecifier_qualifier_list" ):
1931 listener
.enterSpecifier_qualifier_list(self
)
1933 # @param listener Type: ParseTreeListener
1934 def exitRule(self
,listener
):
1935 if hasattr( listener
, "exitSpecifier_qualifier_list" ):
1936 listener
.exitSpecifier_qualifier_list(self
)
1941 def specifier_qualifier_list(self
):
1943 localctx
= CParser
.Specifier_qualifier_listContext(self
, self
._ctx
, self
.state
)
1944 self
.enterRule(localctx
, 28, self
.RULE_specifier_qualifier_list
)
1946 self
.enterOuterAlt(localctx
, 1)
1948 self
._errHandler
.sync(self
)
1950 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
1953 self
._errHandler
.sync(self
)
1954 token
= self
._input
.LA(1)
1955 if token
in [CParser
.T__24
, CParser
.T__25
, CParser
.T__26
, CParser
.T__27
, CParser
.T__28
, CParser
.T__29
, CParser
.T__30
, CParser
.T__31
, CParser
.T__32
, CParser
.T__33
, CParser
.T__34
, CParser
.T__35
, CParser
.T__36
]:
1957 self
.type_qualifier()
1959 elif token
in [CParser
.T__10
, CParser
.T__11
, CParser
.T__12
, CParser
.T__13
, CParser
.T__14
, CParser
.T__15
, CParser
.T__16
, CParser
.T__17
, CParser
.T__18
, CParser
.T__20
, CParser
.T__21
, CParser
.T__23
, CParser
.IDENTIFIER
]:
1961 self
.type_specifier()
1964 raise NoViableAltException(self
)
1968 raise NoViableAltException(self
)
1970 self
._errHandler
.sync(self
)
1971 _alt
= self
._interp
.adaptivePredict(self
._input
,21,self
._ctx
)
1973 except RecognitionException
as re
:
1974 localctx
.exception
= re
1975 self
._errHandler
.reportError(self
, re
)
1976 self
._errHandler
.recover(self
, re
)
1981 class Struct_declarator_listContext(ParserRuleContext
):
1983 # @param parent=None Type: ParserRuleContext
1984 # @param invokingState=-1 Type: int
1985 def __init__(self
,parser
,parent
=None,invokingState
=-1):
1986 super().__init
__(parent
, invokingState
)
1987 self
.parser
= parser
1989 # @param i=None Type: int
1990 def struct_declarator(self
,i
=None):
1992 return self
.getTypedRuleContexts(CParser
.Struct_declaratorContext
)
1994 return self
.getTypedRuleContext(CParser
.Struct_declaratorContext
,i
)
1997 def getRuleIndex(self
):
1998 return CParser
.RULE_struct_declarator_list
2000 # @param listener Type: ParseTreeListener
2001 def enterRule(self
,listener
):
2002 if hasattr( listener
, "enterStruct_declarator_list" ):
2003 listener
.enterStruct_declarator_list(self
)
2005 # @param listener Type: ParseTreeListener
2006 def exitRule(self
,listener
):
2007 if hasattr( listener
, "exitStruct_declarator_list" ):
2008 listener
.exitStruct_declarator_list(self
)
2013 def struct_declarator_list(self
):
2015 localctx
= CParser
.Struct_declarator_listContext(self
, self
._ctx
, self
.state
)
2016 self
.enterRule(localctx
, 30, self
.RULE_struct_declarator_list
)
2017 self
._la
= 0 # Token type
2019 self
.enterOuterAlt(localctx
, 1)
2021 self
.struct_declarator()
2023 self
._errHandler
.sync(self
)
2024 _la
= self
._input
.LA(1)
2025 while _la
==CParser
.T__3
:
2027 self
.match(CParser
.T__3
)
2029 self
.struct_declarator()
2031 self
._errHandler
.sync(self
)
2032 _la
= self
._input
.LA(1)
2034 except RecognitionException
as re
:
2035 localctx
.exception
= re
2036 self
._errHandler
.reportError(self
, re
)
2037 self
._errHandler
.recover(self
, re
)
2042 class Struct_declaratorContext(ParserRuleContext
):
2044 # @param parent=None Type: ParserRuleContext
2045 # @param invokingState=-1 Type: int
2046 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2047 super().__init
__(parent
, invokingState
)
2048 self
.parser
= parser
2050 def declarator(self
):
2051 return self
.getTypedRuleContext(CParser
.DeclaratorContext
,0)
2054 def constant_expression(self
):
2055 return self
.getTypedRuleContext(CParser
.Constant_expressionContext
,0)
2058 def getRuleIndex(self
):
2059 return CParser
.RULE_struct_declarator
2061 # @param listener Type: ParseTreeListener
2062 def enterRule(self
,listener
):
2063 if hasattr( listener
, "enterStruct_declarator" ):
2064 listener
.enterStruct_declarator(self
)
2066 # @param listener Type: ParseTreeListener
2067 def exitRule(self
,listener
):
2068 if hasattr( listener
, "exitStruct_declarator" ):
2069 listener
.exitStruct_declarator(self
)
2074 def struct_declarator(self
):
2076 localctx
= CParser
.Struct_declaratorContext(self
, self
._ctx
, self
.state
)
2077 self
.enterRule(localctx
, 32, self
.RULE_struct_declarator
)
2078 self
._la
= 0 # Token type
2081 self
._errHandler
.sync(self
)
2082 token
= self
._input
.LA(1)
2083 if token
in [CParser
.T__33
, CParser
.T__34
, CParser
.T__35
, CParser
.T__37
, CParser
.T__41
, CParser
.IDENTIFIER
]:
2084 self
.enterOuterAlt(localctx
, 1)
2088 self
._errHandler
.sync(self
)
2089 _la
= self
._input
.LA(1)
2090 if _la
==CParser
.T__22
:
2092 self
.match(CParser
.T__22
)
2094 self
.constant_expression()
2098 elif token
in [CParser
.T__22
]:
2099 self
.enterOuterAlt(localctx
, 2)
2101 self
.match(CParser
.T__22
)
2103 self
.constant_expression()
2106 raise NoViableAltException(self
)
2108 except RecognitionException
as re
:
2109 localctx
.exception
= re
2110 self
._errHandler
.reportError(self
, re
)
2111 self
._errHandler
.recover(self
, re
)
2116 class Enum_specifierContext(ParserRuleContext
):
2118 # @param parent=None Type: ParserRuleContext
2119 # @param invokingState=-1 Type: int
2120 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2121 super().__init
__(parent
, invokingState
)
2122 self
.parser
= parser
2124 def enumerator_list(self
):
2125 return self
.getTypedRuleContext(CParser
.Enumerator_listContext
,0)
2128 def IDENTIFIER(self
):
2129 return self
.getToken(CParser
.IDENTIFIER
, 0)
2131 def getRuleIndex(self
):
2132 return CParser
.RULE_enum_specifier
2134 # @param listener Type: ParseTreeListener
2135 def enterRule(self
,listener
):
2136 if hasattr( listener
, "enterEnum_specifier" ):
2137 listener
.enterEnum_specifier(self
)
2139 # @param listener Type: ParseTreeListener
2140 def exitRule(self
,listener
):
2141 if hasattr( listener
, "exitEnum_specifier" ):
2142 listener
.exitEnum_specifier(self
)
2147 def enum_specifier(self
):
2149 localctx
= CParser
.Enum_specifierContext(self
, self
._ctx
, self
.state
)
2150 self
.enterRule(localctx
, 34, self
.RULE_enum_specifier
)
2151 self
._la
= 0 # Token type
2154 self
._errHandler
.sync(self
)
2155 la_
= self
._interp
.adaptivePredict(self
._input
,27,self
._ctx
)
2157 self
.enterOuterAlt(localctx
, 1)
2159 self
.match(CParser
.T__23
)
2161 self
.match(CParser
.T__0
)
2163 self
.enumerator_list()
2165 self
._errHandler
.sync(self
)
2166 _la
= self
._input
.LA(1)
2167 if _la
==CParser
.T__3
:
2169 self
.match(CParser
.T__3
)
2173 self
.match(CParser
.T__19
)
2177 self
.enterOuterAlt(localctx
, 2)
2179 self
.match(CParser
.T__23
)
2181 self
.match(CParser
.IDENTIFIER
)
2183 self
.match(CParser
.T__0
)
2185 self
.enumerator_list()
2187 self
._errHandler
.sync(self
)
2188 _la
= self
._input
.LA(1)
2189 if _la
==CParser
.T__3
:
2191 self
.match(CParser
.T__3
)
2195 self
.match(CParser
.T__19
)
2199 self
.enterOuterAlt(localctx
, 3)
2201 self
.match(CParser
.T__23
)
2203 self
.match(CParser
.IDENTIFIER
)
2207 except RecognitionException
as re
:
2208 localctx
.exception
= re
2209 self
._errHandler
.reportError(self
, re
)
2210 self
._errHandler
.recover(self
, re
)
2215 class Enumerator_listContext(ParserRuleContext
):
2217 # @param parent=None Type: ParserRuleContext
2218 # @param invokingState=-1 Type: int
2219 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2220 super().__init
__(parent
, invokingState
)
2221 self
.parser
= parser
2223 # @param i=None Type: int
2224 def enumerator(self
,i
=None):
2226 return self
.getTypedRuleContexts(CParser
.EnumeratorContext
)
2228 return self
.getTypedRuleContext(CParser
.EnumeratorContext
,i
)
2231 def getRuleIndex(self
):
2232 return CParser
.RULE_enumerator_list
2234 # @param listener Type: ParseTreeListener
2235 def enterRule(self
,listener
):
2236 if hasattr( listener
, "enterEnumerator_list" ):
2237 listener
.enterEnumerator_list(self
)
2239 # @param listener Type: ParseTreeListener
2240 def exitRule(self
,listener
):
2241 if hasattr( listener
, "exitEnumerator_list" ):
2242 listener
.exitEnumerator_list(self
)
2247 def enumerator_list(self
):
2249 localctx
= CParser
.Enumerator_listContext(self
, self
._ctx
, self
.state
)
2250 self
.enterRule(localctx
, 36, self
.RULE_enumerator_list
)
2252 self
.enterOuterAlt(localctx
, 1)
2256 self
._errHandler
.sync(self
)
2257 _alt
= self
._interp
.adaptivePredict(self
._input
,28,self
._ctx
)
2258 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
2261 self
.match(CParser
.T__3
)
2265 self
._errHandler
.sync(self
)
2266 _alt
= self
._interp
.adaptivePredict(self
._input
,28,self
._ctx
)
2268 except RecognitionException
as re
:
2269 localctx
.exception
= re
2270 self
._errHandler
.reportError(self
, re
)
2271 self
._errHandler
.recover(self
, re
)
2276 class EnumeratorContext(ParserRuleContext
):
2278 # @param parent=None Type: ParserRuleContext
2279 # @param invokingState=-1 Type: int
2280 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2281 super().__init
__(parent
, invokingState
)
2282 self
.parser
= parser
2284 def IDENTIFIER(self
):
2285 return self
.getToken(CParser
.IDENTIFIER
, 0)
2287 def constant_expression(self
):
2288 return self
.getTypedRuleContext(CParser
.Constant_expressionContext
,0)
2291 def getRuleIndex(self
):
2292 return CParser
.RULE_enumerator
2294 # @param listener Type: ParseTreeListener
2295 def enterRule(self
,listener
):
2296 if hasattr( listener
, "enterEnumerator" ):
2297 listener
.enterEnumerator(self
)
2299 # @param listener Type: ParseTreeListener
2300 def exitRule(self
,listener
):
2301 if hasattr( listener
, "exitEnumerator" ):
2302 listener
.exitEnumerator(self
)
2307 def enumerator(self
):
2309 localctx
= CParser
.EnumeratorContext(self
, self
._ctx
, self
.state
)
2310 self
.enterRule(localctx
, 38, self
.RULE_enumerator
)
2311 self
._la
= 0 # Token type
2313 self
.enterOuterAlt(localctx
, 1)
2315 self
.match(CParser
.IDENTIFIER
)
2317 self
._errHandler
.sync(self
)
2318 _la
= self
._input
.LA(1)
2319 if _la
==CParser
.T__4
:
2321 self
.match(CParser
.T__4
)
2323 self
.constant_expression()
2326 except RecognitionException
as re
:
2327 localctx
.exception
= re
2328 self
._errHandler
.reportError(self
, re
)
2329 self
._errHandler
.recover(self
, re
)
2334 class Type_qualifierContext(ParserRuleContext
):
2336 # @param parent=None Type: ParserRuleContext
2337 # @param invokingState=-1 Type: int
2338 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2339 super().__init
__(parent
, invokingState
)
2340 self
.parser
= parser
2343 def getRuleIndex(self
):
2344 return CParser
.RULE_type_qualifier
2346 # @param listener Type: ParseTreeListener
2347 def enterRule(self
,listener
):
2348 if hasattr( listener
, "enterType_qualifier" ):
2349 listener
.enterType_qualifier(self
)
2351 # @param listener Type: ParseTreeListener
2352 def exitRule(self
,listener
):
2353 if hasattr( listener
, "exitType_qualifier" ):
2354 listener
.exitType_qualifier(self
)
2359 def type_qualifier(self
):
2361 localctx
= CParser
.Type_qualifierContext(self
, self
._ctx
, self
.state
)
2362 self
.enterRule(localctx
, 40, self
.RULE_type_qualifier
)
2363 self
._la
= 0 # Token type
2365 self
.enterOuterAlt(localctx
, 1)
2367 _la
= self
._input
.LA(1)
2368 if not((((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__24
) |
(1 << CParser
.T__25
) |
(1 << CParser
.T__26
) |
(1 << CParser
.T__27
) |
(1 << CParser
.T__28
) |
(1 << CParser
.T__29
) |
(1 << CParser
.T__30
) |
(1 << CParser
.T__31
) |
(1 << CParser
.T__32
) |
(1 << CParser
.T__33
) |
(1 << CParser
.T__34
) |
(1 << CParser
.T__35
) |
(1 << CParser
.T__36
))) != 0)):
2369 self
._errHandler
.recoverInline(self
)
2371 self
._errHandler
.reportMatch(self
)
2373 except RecognitionException
as re
:
2374 localctx
.exception
= re
2375 self
._errHandler
.reportError(self
, re
)
2376 self
._errHandler
.recover(self
, re
)
2381 class DeclaratorContext(ParserRuleContext
):
2383 # @param parent=None Type: ParserRuleContext
2384 # @param invokingState=-1 Type: int
2385 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2386 super().__init
__(parent
, invokingState
)
2387 self
.parser
= parser
2389 def direct_declarator(self
):
2390 return self
.getTypedRuleContext(CParser
.Direct_declaratorContext
,0)
2394 return self
.getTypedRuleContext(CParser
.PointerContext
,0)
2397 def getRuleIndex(self
):
2398 return CParser
.RULE_declarator
2400 # @param listener Type: ParseTreeListener
2401 def enterRule(self
,listener
):
2402 if hasattr( listener
, "enterDeclarator" ):
2403 listener
.enterDeclarator(self
)
2405 # @param listener Type: ParseTreeListener
2406 def exitRule(self
,listener
):
2407 if hasattr( listener
, "exitDeclarator" ):
2408 listener
.exitDeclarator(self
)
2413 def declarator(self
):
2415 localctx
= CParser
.DeclaratorContext(self
, self
._ctx
, self
.state
)
2416 self
.enterRule(localctx
, 42, self
.RULE_declarator
)
2417 self
._la
= 0 # Token type
2420 self
._errHandler
.sync(self
)
2421 la_
= self
._interp
.adaptivePredict(self
._input
,34,self
._ctx
)
2423 self
.enterOuterAlt(localctx
, 1)
2425 self
._errHandler
.sync(self
)
2426 _la
= self
._input
.LA(1)
2427 if _la
==CParser
.T__41
:
2433 self
._errHandler
.sync(self
)
2434 _la
= self
._input
.LA(1)
2435 if _la
==CParser
.T__33
:
2437 self
.match(CParser
.T__33
)
2441 self
._errHandler
.sync(self
)
2442 _la
= self
._input
.LA(1)
2443 if _la
==CParser
.T__34
:
2445 self
.match(CParser
.T__34
)
2449 self
._errHandler
.sync(self
)
2450 _la
= self
._input
.LA(1)
2451 if _la
==CParser
.T__35
:
2453 self
.match(CParser
.T__35
)
2457 self
.direct_declarator()
2461 self
.enterOuterAlt(localctx
, 2)
2467 except RecognitionException
as re
:
2468 localctx
.exception
= re
2469 self
._errHandler
.reportError(self
, re
)
2470 self
._errHandler
.recover(self
, re
)
2475 class Direct_declaratorContext(ParserRuleContext
):
2477 # @param parent=None Type: ParserRuleContext
2478 # @param invokingState=-1 Type: int
2479 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2480 super().__init
__(parent
, invokingState
)
2481 self
.parser
= parser
2483 def IDENTIFIER(self
):
2484 return self
.getToken(CParser
.IDENTIFIER
, 0)
2486 # @param i=None Type: int
2487 def declarator_suffix(self
,i
=None):
2489 return self
.getTypedRuleContexts(CParser
.Declarator_suffixContext
)
2491 return self
.getTypedRuleContext(CParser
.Declarator_suffixContext
,i
)
2494 def declarator(self
):
2495 return self
.getTypedRuleContext(CParser
.DeclaratorContext
,0)
2498 def getRuleIndex(self
):
2499 return CParser
.RULE_direct_declarator
2501 # @param listener Type: ParseTreeListener
2502 def enterRule(self
,listener
):
2503 if hasattr( listener
, "enterDirect_declarator" ):
2504 listener
.enterDirect_declarator(self
)
2506 # @param listener Type: ParseTreeListener
2507 def exitRule(self
,listener
):
2508 if hasattr( listener
, "exitDirect_declarator" ):
2509 listener
.exitDirect_declarator(self
)
2514 def direct_declarator(self
):
2516 localctx
= CParser
.Direct_declaratorContext(self
, self
._ctx
, self
.state
)
2517 self
.enterRule(localctx
, 44, self
.RULE_direct_declarator
)
2520 self
._errHandler
.sync(self
)
2521 token
= self
._input
.LA(1)
2522 if token
in [CParser
.IDENTIFIER
]:
2523 self
.enterOuterAlt(localctx
, 1)
2525 self
.match(CParser
.IDENTIFIER
)
2527 self
._errHandler
.sync(self
)
2528 _alt
= self
._interp
.adaptivePredict(self
._input
,35,self
._ctx
)
2529 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
2532 self
.declarator_suffix()
2534 self
._errHandler
.sync(self
)
2535 _alt
= self
._interp
.adaptivePredict(self
._input
,35,self
._ctx
)
2538 elif token
in [CParser
.T__37
]:
2539 self
.enterOuterAlt(localctx
, 2)
2541 self
.match(CParser
.T__37
)
2543 self
._errHandler
.sync(self
)
2544 la_
= self
._interp
.adaptivePredict(self
._input
,36,self
._ctx
)
2547 self
.match(CParser
.T__33
)
2553 self
.match(CParser
.T__38
)
2555 self
._errHandler
.sync(self
)
2557 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
2560 self
.declarator_suffix()
2563 raise NoViableAltException(self
)
2565 self
._errHandler
.sync(self
)
2566 _alt
= self
._interp
.adaptivePredict(self
._input
,37,self
._ctx
)
2570 raise NoViableAltException(self
)
2572 except RecognitionException
as re
:
2573 localctx
.exception
= re
2574 self
._errHandler
.reportError(self
, re
)
2575 self
._errHandler
.recover(self
, re
)
2580 class Declarator_suffixContext(ParserRuleContext
):
2582 # @param parent=None Type: ParserRuleContext
2583 # @param invokingState=-1 Type: int
2584 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2585 super().__init
__(parent
, invokingState
)
2586 self
.parser
= parser
2588 def constant_expression(self
):
2589 return self
.getTypedRuleContext(CParser
.Constant_expressionContext
,0)
2592 def parameter_type_list(self
):
2593 return self
.getTypedRuleContext(CParser
.Parameter_type_listContext
,0)
2596 def identifier_list(self
):
2597 return self
.getTypedRuleContext(CParser
.Identifier_listContext
,0)
2600 def getRuleIndex(self
):
2601 return CParser
.RULE_declarator_suffix
2603 # @param listener Type: ParseTreeListener
2604 def enterRule(self
,listener
):
2605 if hasattr( listener
, "enterDeclarator_suffix" ):
2606 listener
.enterDeclarator_suffix(self
)
2608 # @param listener Type: ParseTreeListener
2609 def exitRule(self
,listener
):
2610 if hasattr( listener
, "exitDeclarator_suffix" ):
2611 listener
.exitDeclarator_suffix(self
)
2616 def declarator_suffix(self
):
2618 localctx
= CParser
.Declarator_suffixContext(self
, self
._ctx
, self
.state
)
2619 self
.enterRule(localctx
, 46, self
.RULE_declarator_suffix
)
2622 self
._errHandler
.sync(self
)
2623 la_
= self
._interp
.adaptivePredict(self
._input
,39,self
._ctx
)
2625 self
.enterOuterAlt(localctx
, 1)
2627 self
.match(CParser
.T__39
)
2629 self
.constant_expression()
2631 self
.match(CParser
.T__40
)
2635 self
.enterOuterAlt(localctx
, 2)
2637 self
.match(CParser
.T__39
)
2639 self
.match(CParser
.T__40
)
2643 self
.enterOuterAlt(localctx
, 3)
2645 self
.match(CParser
.T__37
)
2647 self
.parameter_type_list()
2649 self
.match(CParser
.T__38
)
2653 self
.enterOuterAlt(localctx
, 4)
2655 self
.match(CParser
.T__37
)
2657 self
.identifier_list()
2659 self
.match(CParser
.T__38
)
2663 self
.enterOuterAlt(localctx
, 5)
2665 self
.match(CParser
.T__37
)
2667 self
.match(CParser
.T__38
)
2671 except RecognitionException
as re
:
2672 localctx
.exception
= re
2673 self
._errHandler
.reportError(self
, re
)
2674 self
._errHandler
.recover(self
, re
)
2679 class PointerContext(ParserRuleContext
):
2681 # @param parent=None Type: ParserRuleContext
2682 # @param invokingState=-1 Type: int
2683 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2684 super().__init
__(parent
, invokingState
)
2685 self
.parser
= parser
2687 # @param i=None Type: int
2688 def type_qualifier(self
,i
=None):
2690 return self
.getTypedRuleContexts(CParser
.Type_qualifierContext
)
2692 return self
.getTypedRuleContext(CParser
.Type_qualifierContext
,i
)
2696 return self
.getTypedRuleContext(CParser
.PointerContext
,0)
2699 def getRuleIndex(self
):
2700 return CParser
.RULE_pointer
2702 # @param listener Type: ParseTreeListener
2703 def enterRule(self
,listener
):
2704 if hasattr( listener
, "enterPointer" ):
2705 listener
.enterPointer(self
)
2707 # @param listener Type: ParseTreeListener
2708 def exitRule(self
,listener
):
2709 if hasattr( listener
, "exitPointer" ):
2710 listener
.exitPointer(self
)
2717 localctx
= CParser
.PointerContext(self
, self
._ctx
, self
.state
)
2718 self
.enterRule(localctx
, 48, self
.RULE_pointer
)
2721 self
._errHandler
.sync(self
)
2722 la_
= self
._interp
.adaptivePredict(self
._input
,42,self
._ctx
)
2724 self
.enterOuterAlt(localctx
, 1)
2726 self
.match(CParser
.T__41
)
2728 self
._errHandler
.sync(self
)
2730 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
2733 self
.type_qualifier()
2736 raise NoViableAltException(self
)
2738 self
._errHandler
.sync(self
)
2739 _alt
= self
._interp
.adaptivePredict(self
._input
,40,self
._ctx
)
2742 self
._errHandler
.sync(self
)
2743 la_
= self
._interp
.adaptivePredict(self
._input
,41,self
._ctx
)
2752 self
.enterOuterAlt(localctx
, 2)
2754 self
.match(CParser
.T__41
)
2760 self
.enterOuterAlt(localctx
, 3)
2762 self
.match(CParser
.T__41
)
2766 except RecognitionException
as re
:
2767 localctx
.exception
= re
2768 self
._errHandler
.reportError(self
, re
)
2769 self
._errHandler
.recover(self
, re
)
2774 class Parameter_type_listContext(ParserRuleContext
):
2776 # @param parent=None Type: ParserRuleContext
2777 # @param invokingState=-1 Type: int
2778 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2779 super().__init
__(parent
, invokingState
)
2780 self
.parser
= parser
2782 def parameter_list(self
):
2783 return self
.getTypedRuleContext(CParser
.Parameter_listContext
,0)
2786 def getRuleIndex(self
):
2787 return CParser
.RULE_parameter_type_list
2789 # @param listener Type: ParseTreeListener
2790 def enterRule(self
,listener
):
2791 if hasattr( listener
, "enterParameter_type_list" ):
2792 listener
.enterParameter_type_list(self
)
2794 # @param listener Type: ParseTreeListener
2795 def exitRule(self
,listener
):
2796 if hasattr( listener
, "exitParameter_type_list" ):
2797 listener
.exitParameter_type_list(self
)
2802 def parameter_type_list(self
):
2804 localctx
= CParser
.Parameter_type_listContext(self
, self
._ctx
, self
.state
)
2805 self
.enterRule(localctx
, 50, self
.RULE_parameter_type_list
)
2806 self
._la
= 0 # Token type
2808 self
.enterOuterAlt(localctx
, 1)
2810 self
.parameter_list()
2812 self
._errHandler
.sync(self
)
2813 _la
= self
._input
.LA(1)
2814 if _la
==CParser
.T__3
:
2816 self
.match(CParser
.T__3
)
2818 self
._errHandler
.sync(self
)
2819 _la
= self
._input
.LA(1)
2820 if _la
==CParser
.T__28
:
2822 self
.match(CParser
.T__28
)
2826 self
.match(CParser
.T__42
)
2829 except RecognitionException
as re
:
2830 localctx
.exception
= re
2831 self
._errHandler
.reportError(self
, re
)
2832 self
._errHandler
.recover(self
, re
)
2837 class Parameter_listContext(ParserRuleContext
):
2839 # @param parent=None Type: ParserRuleContext
2840 # @param invokingState=-1 Type: int
2841 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2842 super().__init
__(parent
, invokingState
)
2843 self
.parser
= parser
2845 # @param i=None Type: int
2846 def parameter_declaration(self
,i
=None):
2848 return self
.getTypedRuleContexts(CParser
.Parameter_declarationContext
)
2850 return self
.getTypedRuleContext(CParser
.Parameter_declarationContext
,i
)
2853 def getRuleIndex(self
):
2854 return CParser
.RULE_parameter_list
2856 # @param listener Type: ParseTreeListener
2857 def enterRule(self
,listener
):
2858 if hasattr( listener
, "enterParameter_list" ):
2859 listener
.enterParameter_list(self
)
2861 # @param listener Type: ParseTreeListener
2862 def exitRule(self
,listener
):
2863 if hasattr( listener
, "exitParameter_list" ):
2864 listener
.exitParameter_list(self
)
2869 def parameter_list(self
):
2871 localctx
= CParser
.Parameter_listContext(self
, self
._ctx
, self
.state
)
2872 self
.enterRule(localctx
, 52, self
.RULE_parameter_list
)
2874 self
.enterOuterAlt(localctx
, 1)
2876 self
.parameter_declaration()
2878 self
._errHandler
.sync(self
)
2879 _alt
= self
._interp
.adaptivePredict(self
._input
,46,self
._ctx
)
2880 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
2883 self
.match(CParser
.T__3
)
2885 self
._errHandler
.sync(self
)
2886 la_
= self
._interp
.adaptivePredict(self
._input
,45,self
._ctx
)
2889 self
.match(CParser
.T__28
)
2893 self
.parameter_declaration()
2895 self
._errHandler
.sync(self
)
2896 _alt
= self
._interp
.adaptivePredict(self
._input
,46,self
._ctx
)
2898 except RecognitionException
as re
:
2899 localctx
.exception
= re
2900 self
._errHandler
.reportError(self
, re
)
2901 self
._errHandler
.recover(self
, re
)
2906 class Parameter_declarationContext(ParserRuleContext
):
2908 # @param parent=None Type: ParserRuleContext
2909 # @param invokingState=-1 Type: int
2910 def __init__(self
,parser
,parent
=None,invokingState
=-1):
2911 super().__init
__(parent
, invokingState
)
2912 self
.parser
= parser
2914 def declaration_specifiers(self
):
2915 return self
.getTypedRuleContext(CParser
.Declaration_specifiersContext
,0)
2918 # @param i=None Type: int
2919 def declarator(self
,i
=None):
2921 return self
.getTypedRuleContexts(CParser
.DeclaratorContext
)
2923 return self
.getTypedRuleContext(CParser
.DeclaratorContext
,i
)
2926 # @param i=None Type: int
2927 def abstract_declarator(self
,i
=None):
2929 return self
.getTypedRuleContexts(CParser
.Abstract_declaratorContext
)
2931 return self
.getTypedRuleContext(CParser
.Abstract_declaratorContext
,i
)
2934 def IDENTIFIER(self
):
2935 return self
.getToken(CParser
.IDENTIFIER
, 0)
2937 # @param i=None Type: int
2938 def pointer(self
,i
=None):
2940 return self
.getTypedRuleContexts(CParser
.PointerContext
)
2942 return self
.getTypedRuleContext(CParser
.PointerContext
,i
)
2945 def getRuleIndex(self
):
2946 return CParser
.RULE_parameter_declaration
2948 # @param listener Type: ParseTreeListener
2949 def enterRule(self
,listener
):
2950 if hasattr( listener
, "enterParameter_declaration" ):
2951 listener
.enterParameter_declaration(self
)
2953 # @param listener Type: ParseTreeListener
2954 def exitRule(self
,listener
):
2955 if hasattr( listener
, "exitParameter_declaration" ):
2956 listener
.exitParameter_declaration(self
)
2961 def parameter_declaration(self
):
2963 localctx
= CParser
.Parameter_declarationContext(self
, self
._ctx
, self
.state
)
2964 self
.enterRule(localctx
, 54, self
.RULE_parameter_declaration
)
2965 self
._la
= 0 # Token type
2968 self
._errHandler
.sync(self
)
2969 la_
= self
._interp
.adaptivePredict(self
._input
,51,self
._ctx
)
2971 self
.enterOuterAlt(localctx
, 1)
2973 self
.declaration_specifiers()
2975 self
._errHandler
.sync(self
)
2976 _la
= self
._input
.LA(1)
2977 while ((((_la
- 34)) & ~
0x3f) == 0 and ((1 << (_la
- 34)) & ((1 << (CParser
.T__33
- 34)) |
(1 << (CParser
.T__34
- 34)) |
(1 << (CParser
.T__35
- 34)) |
(1 << (CParser
.T__37
- 34)) |
(1 << (CParser
.T__39
- 34)) |
(1 << (CParser
.T__41
- 34)) |
(1 << (CParser
.IDENTIFIER
- 34)))) != 0):
2979 self
._errHandler
.sync(self
)
2980 la_
= self
._interp
.adaptivePredict(self
._input
,47,self
._ctx
)
2988 self
.abstract_declarator()
2993 self
._errHandler
.sync(self
)
2994 _la
= self
._input
.LA(1)
2997 self
._errHandler
.sync(self
)
2998 _la
= self
._input
.LA(1)
2999 if _la
==CParser
.T__28
:
3001 self
.match(CParser
.T__28
)
3007 self
.enterOuterAlt(localctx
, 2)
3009 self
._errHandler
.sync(self
)
3010 _la
= self
._input
.LA(1)
3011 while _la
==CParser
.T__41
:
3015 self
._errHandler
.sync(self
)
3016 _la
= self
._input
.LA(1)
3019 self
.match(CParser
.IDENTIFIER
)
3023 except RecognitionException
as re
:
3024 localctx
.exception
= re
3025 self
._errHandler
.reportError(self
, re
)
3026 self
._errHandler
.recover(self
, re
)
3031 class Identifier_listContext(ParserRuleContext
):
3033 # @param parent=None Type: ParserRuleContext
3034 # @param invokingState=-1 Type: int
3035 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3036 super().__init
__(parent
, invokingState
)
3037 self
.parser
= parser
3039 # @param i=None Type: int
3040 def IDENTIFIER(self
,i
=None):
3042 return self
.getTokens(CParser
.IDENTIFIER
)
3044 return self
.getToken(CParser
.IDENTIFIER
, i
)
3046 def getRuleIndex(self
):
3047 return CParser
.RULE_identifier_list
3049 # @param listener Type: ParseTreeListener
3050 def enterRule(self
,listener
):
3051 if hasattr( listener
, "enterIdentifier_list" ):
3052 listener
.enterIdentifier_list(self
)
3054 # @param listener Type: ParseTreeListener
3055 def exitRule(self
,listener
):
3056 if hasattr( listener
, "exitIdentifier_list" ):
3057 listener
.exitIdentifier_list(self
)
3062 def identifier_list(self
):
3064 localctx
= CParser
.Identifier_listContext(self
, self
._ctx
, self
.state
)
3065 self
.enterRule(localctx
, 56, self
.RULE_identifier_list
)
3066 self
._la
= 0 # Token type
3068 self
.enterOuterAlt(localctx
, 1)
3070 self
.match(CParser
.IDENTIFIER
)
3072 self
._errHandler
.sync(self
)
3073 _la
= self
._input
.LA(1)
3074 while _la
==CParser
.T__3
:
3076 self
.match(CParser
.T__3
)
3078 self
.match(CParser
.IDENTIFIER
)
3080 self
._errHandler
.sync(self
)
3081 _la
= self
._input
.LA(1)
3083 except RecognitionException
as re
:
3084 localctx
.exception
= re
3085 self
._errHandler
.reportError(self
, re
)
3086 self
._errHandler
.recover(self
, re
)
3091 class Type_nameContext(ParserRuleContext
):
3093 # @param parent=None Type: ParserRuleContext
3094 # @param invokingState=-1 Type: int
3095 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3096 super().__init
__(parent
, invokingState
)
3097 self
.parser
= parser
3099 def specifier_qualifier_list(self
):
3100 return self
.getTypedRuleContext(CParser
.Specifier_qualifier_listContext
,0)
3103 def abstract_declarator(self
):
3104 return self
.getTypedRuleContext(CParser
.Abstract_declaratorContext
,0)
3108 return self
.getTypedRuleContext(CParser
.Type_idContext
,0)
3111 def getRuleIndex(self
):
3112 return CParser
.RULE_type_name
3114 # @param listener Type: ParseTreeListener
3115 def enterRule(self
,listener
):
3116 if hasattr( listener
, "enterType_name" ):
3117 listener
.enterType_name(self
)
3119 # @param listener Type: ParseTreeListener
3120 def exitRule(self
,listener
):
3121 if hasattr( listener
, "exitType_name" ):
3122 listener
.exitType_name(self
)
3127 def type_name(self
):
3129 localctx
= CParser
.Type_nameContext(self
, self
._ctx
, self
.state
)
3130 self
.enterRule(localctx
, 58, self
.RULE_type_name
)
3131 self
._la
= 0 # Token type
3134 self
._errHandler
.sync(self
)
3135 la_
= self
._interp
.adaptivePredict(self
._input
,54,self
._ctx
)
3137 self
.enterOuterAlt(localctx
, 1)
3139 self
.specifier_qualifier_list()
3141 self
._errHandler
.sync(self
)
3142 _la
= self
._input
.LA(1)
3143 if (((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__37
) |
(1 << CParser
.T__39
) |
(1 << CParser
.T__41
))) != 0):
3145 self
.abstract_declarator()
3151 self
.enterOuterAlt(localctx
, 2)
3157 except RecognitionException
as re
:
3158 localctx
.exception
= re
3159 self
._errHandler
.reportError(self
, re
)
3160 self
._errHandler
.recover(self
, re
)
3165 class Abstract_declaratorContext(ParserRuleContext
):
3167 # @param parent=None Type: ParserRuleContext
3168 # @param invokingState=-1 Type: int
3169 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3170 super().__init
__(parent
, invokingState
)
3171 self
.parser
= parser
3174 return self
.getTypedRuleContext(CParser
.PointerContext
,0)
3177 def direct_abstract_declarator(self
):
3178 return self
.getTypedRuleContext(CParser
.Direct_abstract_declaratorContext
,0)
3181 def getRuleIndex(self
):
3182 return CParser
.RULE_abstract_declarator
3184 # @param listener Type: ParseTreeListener
3185 def enterRule(self
,listener
):
3186 if hasattr( listener
, "enterAbstract_declarator" ):
3187 listener
.enterAbstract_declarator(self
)
3189 # @param listener Type: ParseTreeListener
3190 def exitRule(self
,listener
):
3191 if hasattr( listener
, "exitAbstract_declarator" ):
3192 listener
.exitAbstract_declarator(self
)
3197 def abstract_declarator(self
):
3199 localctx
= CParser
.Abstract_declaratorContext(self
, self
._ctx
, self
.state
)
3200 self
.enterRule(localctx
, 60, self
.RULE_abstract_declarator
)
3203 self
._errHandler
.sync(self
)
3204 token
= self
._input
.LA(1)
3205 if token
in [CParser
.T__41
]:
3206 self
.enterOuterAlt(localctx
, 1)
3210 self
._errHandler
.sync(self
)
3211 la_
= self
._interp
.adaptivePredict(self
._input
,55,self
._ctx
)
3214 self
.direct_abstract_declarator()
3218 elif token
in [CParser
.T__37
, CParser
.T__39
]:
3219 self
.enterOuterAlt(localctx
, 2)
3221 self
.direct_abstract_declarator()
3224 raise NoViableAltException(self
)
3226 except RecognitionException
as re
:
3227 localctx
.exception
= re
3228 self
._errHandler
.reportError(self
, re
)
3229 self
._errHandler
.recover(self
, re
)
3234 class Direct_abstract_declaratorContext(ParserRuleContext
):
3236 # @param parent=None Type: ParserRuleContext
3237 # @param invokingState=-1 Type: int
3238 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3239 super().__init
__(parent
, invokingState
)
3240 self
.parser
= parser
3242 def abstract_declarator(self
):
3243 return self
.getTypedRuleContext(CParser
.Abstract_declaratorContext
,0)
3246 # @param i=None Type: int
3247 def abstract_declarator_suffix(self
,i
=None):
3249 return self
.getTypedRuleContexts(CParser
.Abstract_declarator_suffixContext
)
3251 return self
.getTypedRuleContext(CParser
.Abstract_declarator_suffixContext
,i
)
3254 def getRuleIndex(self
):
3255 return CParser
.RULE_direct_abstract_declarator
3257 # @param listener Type: ParseTreeListener
3258 def enterRule(self
,listener
):
3259 if hasattr( listener
, "enterDirect_abstract_declarator" ):
3260 listener
.enterDirect_abstract_declarator(self
)
3262 # @param listener Type: ParseTreeListener
3263 def exitRule(self
,listener
):
3264 if hasattr( listener
, "exitDirect_abstract_declarator" ):
3265 listener
.exitDirect_abstract_declarator(self
)
3269 def direct_abstract_declarator(self
):
3271 localctx
= CParser
.Direct_abstract_declaratorContext(self
, self
._ctx
, self
.state
)
3272 self
.enterRule(localctx
, 62, self
.RULE_direct_abstract_declarator
)
3274 self
.enterOuterAlt(localctx
, 1)
3276 self
._errHandler
.sync(self
)
3277 la_
= self
._interp
.adaptivePredict(self
._input
,57,self
._ctx
)
3280 self
.match(CParser
.T__37
)
3282 self
.abstract_declarator()
3284 self
.match(CParser
.T__38
)
3289 self
.abstract_declarator_suffix()
3294 self
._errHandler
.sync(self
)
3295 _alt
= self
._interp
.adaptivePredict(self
._input
,58,self
._ctx
)
3296 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
3299 self
.abstract_declarator_suffix()
3301 self
._errHandler
.sync(self
)
3302 _alt
= self
._interp
.adaptivePredict(self
._input
,58,self
._ctx
)
3304 except RecognitionException
as re
:
3305 localctx
.exception
= re
3306 self
._errHandler
.reportError(self
, re
)
3307 self
._errHandler
.recover(self
, re
)
3312 class Abstract_declarator_suffixContext(ParserRuleContext
):
3314 # @param parent=None Type: ParserRuleContext
3315 # @param invokingState=-1 Type: int
3316 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3317 super().__init
__(parent
, invokingState
)
3318 self
.parser
= parser
3320 def constant_expression(self
):
3321 return self
.getTypedRuleContext(CParser
.Constant_expressionContext
,0)
3324 def parameter_type_list(self
):
3325 return self
.getTypedRuleContext(CParser
.Parameter_type_listContext
,0)
3328 def getRuleIndex(self
):
3329 return CParser
.RULE_abstract_declarator_suffix
3331 # @param listener Type: ParseTreeListener
3332 def enterRule(self
,listener
):
3333 if hasattr( listener
, "enterAbstract_declarator_suffix" ):
3334 listener
.enterAbstract_declarator_suffix(self
)
3336 # @param listener Type: ParseTreeListener
3337 def exitRule(self
,listener
):
3338 if hasattr( listener
, "exitAbstract_declarator_suffix" ):
3339 listener
.exitAbstract_declarator_suffix(self
)
3344 def abstract_declarator_suffix(self
):
3346 localctx
= CParser
.Abstract_declarator_suffixContext(self
, self
._ctx
, self
.state
)
3347 self
.enterRule(localctx
, 64, self
.RULE_abstract_declarator_suffix
)
3350 self
._errHandler
.sync(self
)
3351 la_
= self
._interp
.adaptivePredict(self
._input
,59,self
._ctx
)
3353 self
.enterOuterAlt(localctx
, 1)
3355 self
.match(CParser
.T__39
)
3357 self
.match(CParser
.T__40
)
3361 self
.enterOuterAlt(localctx
, 2)
3363 self
.match(CParser
.T__39
)
3365 self
.constant_expression()
3367 self
.match(CParser
.T__40
)
3371 self
.enterOuterAlt(localctx
, 3)
3373 self
.match(CParser
.T__37
)
3375 self
.match(CParser
.T__38
)
3379 self
.enterOuterAlt(localctx
, 4)
3381 self
.match(CParser
.T__37
)
3383 self
.parameter_type_list()
3385 self
.match(CParser
.T__38
)
3389 except RecognitionException
as re
:
3390 localctx
.exception
= re
3391 self
._errHandler
.reportError(self
, re
)
3392 self
._errHandler
.recover(self
, re
)
3397 class InitializerContext(ParserRuleContext
):
3399 # @param parent=None Type: ParserRuleContext
3400 # @param invokingState=-1 Type: int
3401 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3402 super().__init
__(parent
, invokingState
)
3403 self
.parser
= parser
3405 def assignment_expression(self
):
3406 return self
.getTypedRuleContext(CParser
.Assignment_expressionContext
,0)
3409 def initializer_list(self
):
3410 return self
.getTypedRuleContext(CParser
.Initializer_listContext
,0)
3413 def getRuleIndex(self
):
3414 return CParser
.RULE_initializer
3416 # @param listener Type: ParseTreeListener
3417 def enterRule(self
,listener
):
3418 if hasattr( listener
, "enterInitializer" ):
3419 listener
.enterInitializer(self
)
3421 # @param listener Type: ParseTreeListener
3422 def exitRule(self
,listener
):
3423 if hasattr( listener
, "exitInitializer" ):
3424 listener
.exitInitializer(self
)
3429 def initializer(self
):
3431 localctx
= CParser
.InitializerContext(self
, self
._ctx
, self
.state
)
3432 self
.enterRule(localctx
, 66, self
.RULE_initializer
)
3433 self
._la
= 0 # Token type
3436 self
._errHandler
.sync(self
)
3437 token
= self
._input
.LA(1)
3438 if token
in [CParser
.T__37
, CParser
.T__41
, CParser
.T__43
, CParser
.T__44
, CParser
.T__47
, CParser
.T__48
, CParser
.T__49
, CParser
.T__52
, CParser
.T__53
, CParser
.T__54
, CParser
.IDENTIFIER
, CParser
.CHARACTER_LITERAL
, CParser
.STRING_LITERAL
, CParser
.HEX_LITERAL
, CParser
.DECIMAL_LITERAL
, CParser
.OCTAL_LITERAL
, CParser
.FLOATING_POINT_LITERAL
]:
3439 self
.enterOuterAlt(localctx
, 1)
3441 self
.assignment_expression()
3443 elif token
in [CParser
.T__0
]:
3444 self
.enterOuterAlt(localctx
, 2)
3446 self
.match(CParser
.T__0
)
3448 self
.initializer_list()
3450 self
._errHandler
.sync(self
)
3451 _la
= self
._input
.LA(1)
3452 if _la
==CParser
.T__3
:
3454 self
.match(CParser
.T__3
)
3458 self
.match(CParser
.T__19
)
3461 raise NoViableAltException(self
)
3463 except RecognitionException
as re
:
3464 localctx
.exception
= re
3465 self
._errHandler
.reportError(self
, re
)
3466 self
._errHandler
.recover(self
, re
)
3471 class Initializer_listContext(ParserRuleContext
):
3473 # @param parent=None Type: ParserRuleContext
3474 # @param invokingState=-1 Type: int
3475 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3476 super().__init
__(parent
, invokingState
)
3477 self
.parser
= parser
3479 # @param i=None Type: int
3480 def initializer(self
,i
=None):
3482 return self
.getTypedRuleContexts(CParser
.InitializerContext
)
3484 return self
.getTypedRuleContext(CParser
.InitializerContext
,i
)
3487 def getRuleIndex(self
):
3488 return CParser
.RULE_initializer_list
3490 # @param listener Type: ParseTreeListener
3491 def enterRule(self
,listener
):
3492 if hasattr( listener
, "enterInitializer_list" ):
3493 listener
.enterInitializer_list(self
)
3495 # @param listener Type: ParseTreeListener
3496 def exitRule(self
,listener
):
3497 if hasattr( listener
, "exitInitializer_list" ):
3498 listener
.exitInitializer_list(self
)
3503 def initializer_list(self
):
3505 localctx
= CParser
.Initializer_listContext(self
, self
._ctx
, self
.state
)
3506 self
.enterRule(localctx
, 68, self
.RULE_initializer_list
)
3508 self
.enterOuterAlt(localctx
, 1)
3512 self
._errHandler
.sync(self
)
3513 _alt
= self
._interp
.adaptivePredict(self
._input
,62,self
._ctx
)
3514 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
3517 self
.match(CParser
.T__3
)
3521 self
._errHandler
.sync(self
)
3522 _alt
= self
._interp
.adaptivePredict(self
._input
,62,self
._ctx
)
3524 except RecognitionException
as re
:
3525 localctx
.exception
= re
3526 self
._errHandler
.reportError(self
, re
)
3527 self
._errHandler
.recover(self
, re
)
3532 class Argument_expression_listContext(ParserRuleContext
):
3534 # @param parent=None Type: ParserRuleContext
3535 # @param invokingState=-1 Type: int
3536 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3537 super().__init
__(parent
, invokingState
)
3538 self
.parser
= parser
3540 # @param i=None Type: int
3541 def assignment_expression(self
,i
=None):
3543 return self
.getTypedRuleContexts(CParser
.Assignment_expressionContext
)
3545 return self
.getTypedRuleContext(CParser
.Assignment_expressionContext
,i
)
3548 def getRuleIndex(self
):
3549 return CParser
.RULE_argument_expression_list
3551 # @param listener Type: ParseTreeListener
3552 def enterRule(self
,listener
):
3553 if hasattr( listener
, "enterArgument_expression_list" ):
3554 listener
.enterArgument_expression_list(self
)
3556 # @param listener Type: ParseTreeListener
3557 def exitRule(self
,listener
):
3558 if hasattr( listener
, "exitArgument_expression_list" ):
3559 listener
.exitArgument_expression_list(self
)
3564 def argument_expression_list(self
):
3566 localctx
= CParser
.Argument_expression_listContext(self
, self
._ctx
, self
.state
)
3567 self
.enterRule(localctx
, 70, self
.RULE_argument_expression_list
)
3568 self
._la
= 0 # Token type
3570 self
.enterOuterAlt(localctx
, 1)
3572 self
.assignment_expression()
3574 self
._errHandler
.sync(self
)
3575 _la
= self
._input
.LA(1)
3576 if _la
==CParser
.T__28
:
3578 self
.match(CParser
.T__28
)
3582 self
._errHandler
.sync(self
)
3583 _la
= self
._input
.LA(1)
3584 while _la
==CParser
.T__3
:
3586 self
.match(CParser
.T__3
)
3588 self
.assignment_expression()
3590 self
._errHandler
.sync(self
)
3591 _la
= self
._input
.LA(1)
3592 if _la
==CParser
.T__28
:
3594 self
.match(CParser
.T__28
)
3598 self
._errHandler
.sync(self
)
3599 _la
= self
._input
.LA(1)
3601 except RecognitionException
as re
:
3602 localctx
.exception
= re
3603 self
._errHandler
.reportError(self
, re
)
3604 self
._errHandler
.recover(self
, re
)
3609 class Additive_expressionContext(ParserRuleContext
):
3611 # @param parent=None Type: ParserRuleContext
3612 # @param invokingState=-1 Type: int
3613 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3614 super().__init
__(parent
, invokingState
)
3615 self
.parser
= parser
3617 # @param i=None Type: int
3618 def multiplicative_expression(self
,i
=None):
3620 return self
.getTypedRuleContexts(CParser
.Multiplicative_expressionContext
)
3622 return self
.getTypedRuleContext(CParser
.Multiplicative_expressionContext
,i
)
3625 def getRuleIndex(self
):
3626 return CParser
.RULE_additive_expression
3628 # @param listener Type: ParseTreeListener
3629 def enterRule(self
,listener
):
3630 if hasattr( listener
, "enterAdditive_expression" ):
3631 listener
.enterAdditive_expression(self
)
3633 # @param listener Type: ParseTreeListener
3634 def exitRule(self
,listener
):
3635 if hasattr( listener
, "exitAdditive_expression" ):
3636 listener
.exitAdditive_expression(self
)
3641 def additive_expression(self
):
3643 localctx
= CParser
.Additive_expressionContext(self
, self
._ctx
, self
.state
)
3644 self
.enterRule(localctx
, 72, self
.RULE_additive_expression
)
3645 self
._la
= 0 # Token type
3647 self
.enterOuterAlt(localctx
, 1)
3649 self
.multiplicative_expression()
3651 self
._errHandler
.sync(self
)
3652 _la
= self
._input
.LA(1)
3653 while _la
==CParser
.T__43
or _la
==CParser
.T__44
:
3655 self
._errHandler
.sync(self
)
3656 token
= self
._input
.LA(1)
3657 if token
in [CParser
.T__43
]:
3659 self
.match(CParser
.T__43
)
3661 self
.multiplicative_expression()
3663 elif token
in [CParser
.T__44
]:
3665 self
.match(CParser
.T__44
)
3667 self
.multiplicative_expression()
3670 raise NoViableAltException(self
)
3673 self
._errHandler
.sync(self
)
3674 _la
= self
._input
.LA(1)
3676 except RecognitionException
as re
:
3677 localctx
.exception
= re
3678 self
._errHandler
.reportError(self
, re
)
3679 self
._errHandler
.recover(self
, re
)
3684 class Multiplicative_expressionContext(ParserRuleContext
):
3686 # @param parent=None Type: ParserRuleContext
3687 # @param invokingState=-1 Type: int
3688 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3689 super().__init
__(parent
, invokingState
)
3690 self
.parser
= parser
3692 # @param i=None Type: int
3693 def cast_expression(self
,i
=None):
3695 return self
.getTypedRuleContexts(CParser
.Cast_expressionContext
)
3697 return self
.getTypedRuleContext(CParser
.Cast_expressionContext
,i
)
3700 def getRuleIndex(self
):
3701 return CParser
.RULE_multiplicative_expression
3703 # @param listener Type: ParseTreeListener
3704 def enterRule(self
,listener
):
3705 if hasattr( listener
, "enterMultiplicative_expression" ):
3706 listener
.enterMultiplicative_expression(self
)
3708 # @param listener Type: ParseTreeListener
3709 def exitRule(self
,listener
):
3710 if hasattr( listener
, "exitMultiplicative_expression" ):
3711 listener
.exitMultiplicative_expression(self
)
3716 def multiplicative_expression(self
):
3718 localctx
= CParser
.Multiplicative_expressionContext(self
, self
._ctx
, self
.state
)
3719 self
.enterRule(localctx
, 74, self
.RULE_multiplicative_expression
)
3720 self
._la
= 0 # Token type
3722 self
.enterOuterAlt(localctx
, 1)
3724 self
.cast_expression()
3726 self
._errHandler
.sync(self
)
3727 _la
= self
._input
.LA(1)
3728 while (((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__41
) |
(1 << CParser
.T__45
) |
(1 << CParser
.T__46
))) != 0):
3730 self
._errHandler
.sync(self
)
3731 token
= self
._input
.LA(1)
3732 if token
in [CParser
.T__41
]:
3734 self
.match(CParser
.T__41
)
3736 self
.cast_expression()
3738 elif token
in [CParser
.T__45
]:
3740 self
.match(CParser
.T__45
)
3742 self
.cast_expression()
3744 elif token
in [CParser
.T__46
]:
3746 self
.match(CParser
.T__46
)
3748 self
.cast_expression()
3751 raise NoViableAltException(self
)
3754 self
._errHandler
.sync(self
)
3755 _la
= self
._input
.LA(1)
3757 except RecognitionException
as re
:
3758 localctx
.exception
= re
3759 self
._errHandler
.reportError(self
, re
)
3760 self
._errHandler
.recover(self
, re
)
3765 class Cast_expressionContext(ParserRuleContext
):
3767 # @param parent=None Type: ParserRuleContext
3768 # @param invokingState=-1 Type: int
3769 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3770 super().__init
__(parent
, invokingState
)
3771 self
.parser
= parser
3773 def type_name(self
):
3774 return self
.getTypedRuleContext(CParser
.Type_nameContext
,0)
3777 def cast_expression(self
):
3778 return self
.getTypedRuleContext(CParser
.Cast_expressionContext
,0)
3781 def unary_expression(self
):
3782 return self
.getTypedRuleContext(CParser
.Unary_expressionContext
,0)
3785 def getRuleIndex(self
):
3786 return CParser
.RULE_cast_expression
3788 # @param listener Type: ParseTreeListener
3789 def enterRule(self
,listener
):
3790 if hasattr( listener
, "enterCast_expression" ):
3791 listener
.enterCast_expression(self
)
3793 # @param listener Type: ParseTreeListener
3794 def exitRule(self
,listener
):
3795 if hasattr( listener
, "exitCast_expression" ):
3796 listener
.exitCast_expression(self
)
3801 def cast_expression(self
):
3803 localctx
= CParser
.Cast_expressionContext(self
, self
._ctx
, self
.state
)
3804 self
.enterRule(localctx
, 76, self
.RULE_cast_expression
)
3807 self
._errHandler
.sync(self
)
3808 la_
= self
._interp
.adaptivePredict(self
._input
,70,self
._ctx
)
3810 self
.enterOuterAlt(localctx
, 1)
3812 self
.match(CParser
.T__37
)
3816 self
.match(CParser
.T__38
)
3818 self
.cast_expression()
3822 self
.enterOuterAlt(localctx
, 2)
3824 self
.unary_expression()
3828 except RecognitionException
as re
:
3829 localctx
.exception
= re
3830 self
._errHandler
.reportError(self
, re
)
3831 self
._errHandler
.recover(self
, re
)
3836 class Unary_expressionContext(ParserRuleContext
):
3838 # @param parent=None Type: ParserRuleContext
3839 # @param invokingState=-1 Type: int
3840 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3841 super().__init
__(parent
, invokingState
)
3842 self
.parser
= parser
3844 def postfix_expression(self
):
3845 return self
.getTypedRuleContext(CParser
.Postfix_expressionContext
,0)
3848 def unary_expression(self
):
3849 return self
.getTypedRuleContext(CParser
.Unary_expressionContext
,0)
3852 def unary_operator(self
):
3853 return self
.getTypedRuleContext(CParser
.Unary_operatorContext
,0)
3856 def cast_expression(self
):
3857 return self
.getTypedRuleContext(CParser
.Cast_expressionContext
,0)
3860 def type_name(self
):
3861 return self
.getTypedRuleContext(CParser
.Type_nameContext
,0)
3864 def getRuleIndex(self
):
3865 return CParser
.RULE_unary_expression
3867 # @param listener Type: ParseTreeListener
3868 def enterRule(self
,listener
):
3869 if hasattr( listener
, "enterUnary_expression" ):
3870 listener
.enterUnary_expression(self
)
3872 # @param listener Type: ParseTreeListener
3873 def exitRule(self
,listener
):
3874 if hasattr( listener
, "exitUnary_expression" ):
3875 listener
.exitUnary_expression(self
)
3880 def unary_expression(self
):
3882 localctx
= CParser
.Unary_expressionContext(self
, self
._ctx
, self
.state
)
3883 self
.enterRule(localctx
, 78, self
.RULE_unary_expression
)
3886 self
._errHandler
.sync(self
)
3887 la_
= self
._interp
.adaptivePredict(self
._input
,71,self
._ctx
)
3889 self
.enterOuterAlt(localctx
, 1)
3891 self
.postfix_expression()
3895 self
.enterOuterAlt(localctx
, 2)
3897 self
.match(CParser
.T__47
)
3899 self
.unary_expression()
3903 self
.enterOuterAlt(localctx
, 3)
3905 self
.match(CParser
.T__48
)
3907 self
.unary_expression()
3911 self
.enterOuterAlt(localctx
, 4)
3913 self
.unary_operator()
3915 self
.cast_expression()
3919 self
.enterOuterAlt(localctx
, 5)
3921 self
.match(CParser
.T__49
)
3923 self
.unary_expression()
3927 self
.enterOuterAlt(localctx
, 6)
3929 self
.match(CParser
.T__49
)
3931 self
.match(CParser
.T__37
)
3935 self
.match(CParser
.T__38
)
3939 except RecognitionException
as re
:
3940 localctx
.exception
= re
3941 self
._errHandler
.reportError(self
, re
)
3942 self
._errHandler
.recover(self
, re
)
3947 class Postfix_expressionContext(ParserRuleContext
):
3949 # @param parent=None Type: ParserRuleContext
3950 # @param invokingState=-1 Type: int
3951 def __init__(self
,parser
,parent
=None,invokingState
=-1):
3952 super().__init
__(parent
, invokingState
)
3953 self
.parser
= parser
3954 self
.FuncCallText
= ''
3955 self
.p
= None # Primary_expressionContext
3956 self
.a
= None # Token
3957 self
.c
= None # Argument_expression_listContext
3958 self
.b
= None # Token
3959 self
.x
= None # Token
3960 self
.y
= None # Token
3961 self
.z
= None # Token
3963 def primary_expression(self
):
3964 return self
.getTypedRuleContext(CParser
.Primary_expressionContext
,0)
3967 # @param i=None Type: int
3968 def expression(self
,i
=None):
3970 return self
.getTypedRuleContexts(CParser
.ExpressionContext
)
3972 return self
.getTypedRuleContext(CParser
.ExpressionContext
,i
)
3975 # @param i=None Type: int
3976 def macro_parameter_list(self
,i
=None):
3978 return self
.getTypedRuleContexts(CParser
.Macro_parameter_listContext
)
3980 return self
.getTypedRuleContext(CParser
.Macro_parameter_listContext
,i
)
3983 # @param i=None Type: int
3984 def argument_expression_list(self
,i
=None):
3986 return self
.getTypedRuleContexts(CParser
.Argument_expression_listContext
)
3988 return self
.getTypedRuleContext(CParser
.Argument_expression_listContext
,i
)
3991 # @param i=None Type: int
3992 def IDENTIFIER(self
,i
=None):
3994 return self
.getTokens(CParser
.IDENTIFIER
)
3996 return self
.getToken(CParser
.IDENTIFIER
, i
)
3998 def getRuleIndex(self
):
3999 return CParser
.RULE_postfix_expression
4001 # @param listener Type: ParseTreeListener
4002 def enterRule(self
,listener
):
4003 if hasattr( listener
, "enterPostfix_expression" ):
4004 listener
.enterPostfix_expression(self
)
4006 # @param listener Type: ParseTreeListener
4007 def exitRule(self
,listener
):
4008 if hasattr( listener
, "exitPostfix_expression" ):
4009 listener
.exitPostfix_expression(self
)
4014 def postfix_expression(self
):
4016 localctx
= CParser
.Postfix_expressionContext(self
, self
._ctx
, self
.state
)
4017 self
.enterRule(localctx
, 80, self
.RULE_postfix_expression
)
4019 self
.FuncCallText
=''
4022 self
.enterOuterAlt(localctx
, 1)
4024 localctx
.p
= self
.primary_expression()
4025 self
.FuncCallText
+= (None if localctx
.p
is None else self
._input
.getText((localctx
.p
.start
,localctx
.p
.stop
)))
4027 self
._errHandler
.sync(self
)
4028 _alt
= self
._interp
.adaptivePredict(self
._input
,73,self
._ctx
)
4029 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
4032 self
._errHandler
.sync(self
)
4033 la_
= self
._interp
.adaptivePredict(self
._input
,72,self
._ctx
)
4036 self
.match(CParser
.T__39
)
4040 self
.match(CParser
.T__40
)
4045 self
.match(CParser
.T__37
)
4047 localctx
.a
= self
.match(CParser
.T__38
)
4048 self
.StoreFunctionCalling((None if localctx
.p
is None else localctx
.p
.start
).line
, (None if localctx
.p
is None else localctx
.p
.start
).column
, (0 if localctx
.a
is None else localctx
.a
.line
), localctx
.a
.column
, self
.FuncCallText
, '')
4053 self
.match(CParser
.T__37
)
4055 localctx
.c
= self
.argument_expression_list()
4057 localctx
.b
= self
.match(CParser
.T__38
)
4058 self
.StoreFunctionCalling((None if localctx
.p
is None else localctx
.p
.start
).line
, (None if localctx
.p
is None else localctx
.p
.start
).column
, (0 if localctx
.b
is None else localctx
.b
.line
), localctx
.b
.column
, self
.FuncCallText
, (None if localctx
.c
is None else self
._input
.getText((localctx
.c
.start
,localctx
.c
.stop
))))
4063 self
.match(CParser
.T__37
)
4065 self
.macro_parameter_list()
4067 self
.match(CParser
.T__38
)
4072 self
.match(CParser
.T__50
)
4074 localctx
.x
= self
.match(CParser
.IDENTIFIER
)
4075 self
.FuncCallText
+= '.' + (None if localctx
.x
is None else localctx
.x
.text
)
4080 self
.match(CParser
.T__41
)
4082 localctx
.y
= self
.match(CParser
.IDENTIFIER
)
4083 self
.FuncCallText
= (None if localctx
.y
is None else localctx
.y
.text
)
4088 self
.match(CParser
.T__51
)
4090 localctx
.z
= self
.match(CParser
.IDENTIFIER
)
4091 self
.FuncCallText
+= '->' + (None if localctx
.z
is None else localctx
.z
.text
)
4096 self
.match(CParser
.T__47
)
4101 self
.match(CParser
.T__48
)
4106 self
._errHandler
.sync(self
)
4107 _alt
= self
._interp
.adaptivePredict(self
._input
,73,self
._ctx
)
4109 except RecognitionException
as re
:
4110 localctx
.exception
= re
4111 self
._errHandler
.reportError(self
, re
)
4112 self
._errHandler
.recover(self
, re
)
4117 class Macro_parameter_listContext(ParserRuleContext
):
4119 # @param parent=None Type: ParserRuleContext
4120 # @param invokingState=-1 Type: int
4121 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4122 super().__init
__(parent
, invokingState
)
4123 self
.parser
= parser
4125 # @param i=None Type: int
4126 def parameter_declaration(self
,i
=None):
4128 return self
.getTypedRuleContexts(CParser
.Parameter_declarationContext
)
4130 return self
.getTypedRuleContext(CParser
.Parameter_declarationContext
,i
)
4133 def getRuleIndex(self
):
4134 return CParser
.RULE_macro_parameter_list
4136 # @param listener Type: ParseTreeListener
4137 def enterRule(self
,listener
):
4138 if hasattr( listener
, "enterMacro_parameter_list" ):
4139 listener
.enterMacro_parameter_list(self
)
4141 # @param listener Type: ParseTreeListener
4142 def exitRule(self
,listener
):
4143 if hasattr( listener
, "exitMacro_parameter_list" ):
4144 listener
.exitMacro_parameter_list(self
)
4149 def macro_parameter_list(self
):
4151 localctx
= CParser
.Macro_parameter_listContext(self
, self
._ctx
, self
.state
)
4152 self
.enterRule(localctx
, 82, self
.RULE_macro_parameter_list
)
4153 self
._la
= 0 # Token type
4155 self
.enterOuterAlt(localctx
, 1)
4157 self
.parameter_declaration()
4159 self
._errHandler
.sync(self
)
4160 _la
= self
._input
.LA(1)
4161 while _la
==CParser
.T__3
:
4163 self
.match(CParser
.T__3
)
4165 self
.parameter_declaration()
4167 self
._errHandler
.sync(self
)
4168 _la
= self
._input
.LA(1)
4170 except RecognitionException
as re
:
4171 localctx
.exception
= re
4172 self
._errHandler
.reportError(self
, re
)
4173 self
._errHandler
.recover(self
, re
)
4178 class Unary_operatorContext(ParserRuleContext
):
4180 # @param parent=None Type: ParserRuleContext
4181 # @param invokingState=-1 Type: int
4182 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4183 super().__init
__(parent
, invokingState
)
4184 self
.parser
= parser
4187 def getRuleIndex(self
):
4188 return CParser
.RULE_unary_operator
4190 # @param listener Type: ParseTreeListener
4191 def enterRule(self
,listener
):
4192 if hasattr( listener
, "enterUnary_operator" ):
4193 listener
.enterUnary_operator(self
)
4195 # @param listener Type: ParseTreeListener
4196 def exitRule(self
,listener
):
4197 if hasattr( listener
, "exitUnary_operator" ):
4198 listener
.exitUnary_operator(self
)
4203 def unary_operator(self
):
4205 localctx
= CParser
.Unary_operatorContext(self
, self
._ctx
, self
.state
)
4206 self
.enterRule(localctx
, 84, self
.RULE_unary_operator
)
4207 self
._la
= 0 # Token type
4209 self
.enterOuterAlt(localctx
, 1)
4211 _la
= self
._input
.LA(1)
4212 if not((((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__41
) |
(1 << CParser
.T__43
) |
(1 << CParser
.T__44
) |
(1 << CParser
.T__52
) |
(1 << CParser
.T__53
) |
(1 << CParser
.T__54
))) != 0)):
4213 self
._errHandler
.recoverInline(self
)
4215 self
._errHandler
.reportMatch(self
)
4217 except RecognitionException
as re
:
4218 localctx
.exception
= re
4219 self
._errHandler
.reportError(self
, re
)
4220 self
._errHandler
.recover(self
, re
)
4225 class Primary_expressionContext(ParserRuleContext
):
4227 # @param parent=None Type: ParserRuleContext
4228 # @param invokingState=-1 Type: int
4229 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4230 super().__init
__(parent
, invokingState
)
4231 self
.parser
= parser
4233 def IDENTIFIER(self
):
4234 return self
.getToken(CParser
.IDENTIFIER
, 0)
4237 return self
.getTypedRuleContext(CParser
.ConstantContext
,0)
4240 def expression(self
):
4241 return self
.getTypedRuleContext(CParser
.ExpressionContext
,0)
4244 def getRuleIndex(self
):
4245 return CParser
.RULE_primary_expression
4247 # @param listener Type: ParseTreeListener
4248 def enterRule(self
,listener
):
4249 if hasattr( listener
, "enterPrimary_expression" ):
4250 listener
.enterPrimary_expression(self
)
4252 # @param listener Type: ParseTreeListener
4253 def exitRule(self
,listener
):
4254 if hasattr( listener
, "exitPrimary_expression" ):
4255 listener
.exitPrimary_expression(self
)
4260 def primary_expression(self
):
4262 localctx
= CParser
.Primary_expressionContext(self
, self
._ctx
, self
.state
)
4263 self
.enterRule(localctx
, 86, self
.RULE_primary_expression
)
4266 self
._errHandler
.sync(self
)
4267 la_
= self
._interp
.adaptivePredict(self
._input
,75,self
._ctx
)
4269 self
.enterOuterAlt(localctx
, 1)
4271 self
.match(CParser
.IDENTIFIER
)
4275 self
.enterOuterAlt(localctx
, 2)
4281 self
.enterOuterAlt(localctx
, 3)
4283 self
.match(CParser
.T__37
)
4287 self
.match(CParser
.T__38
)
4291 except RecognitionException
as re
:
4292 localctx
.exception
= re
4293 self
._errHandler
.reportError(self
, re
)
4294 self
._errHandler
.recover(self
, re
)
4299 class ConstantContext(ParserRuleContext
):
4301 # @param parent=None Type: ParserRuleContext
4302 # @param invokingState=-1 Type: int
4303 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4304 super().__init
__(parent
, invokingState
)
4305 self
.parser
= parser
4307 def HEX_LITERAL(self
):
4308 return self
.getToken(CParser
.HEX_LITERAL
, 0)
4310 def OCTAL_LITERAL(self
):
4311 return self
.getToken(CParser
.OCTAL_LITERAL
, 0)
4313 def DECIMAL_LITERAL(self
):
4314 return self
.getToken(CParser
.DECIMAL_LITERAL
, 0)
4316 def CHARACTER_LITERAL(self
):
4317 return self
.getToken(CParser
.CHARACTER_LITERAL
, 0)
4319 # @param i=None Type: int
4320 def IDENTIFIER(self
,i
=None):
4322 return self
.getTokens(CParser
.IDENTIFIER
)
4324 return self
.getToken(CParser
.IDENTIFIER
, i
)
4326 # @param i=None Type: int
4327 def STRING_LITERAL(self
,i
=None):
4329 return self
.getTokens(CParser
.STRING_LITERAL
)
4331 return self
.getToken(CParser
.STRING_LITERAL
, i
)
4333 def FLOATING_POINT_LITERAL(self
):
4334 return self
.getToken(CParser
.FLOATING_POINT_LITERAL
, 0)
4336 def getRuleIndex(self
):
4337 return CParser
.RULE_constant
4339 # @param listener Type: ParseTreeListener
4340 def enterRule(self
,listener
):
4341 if hasattr( listener
, "enterConstant" ):
4342 listener
.enterConstant(self
)
4344 # @param listener Type: ParseTreeListener
4345 def exitRule(self
,listener
):
4346 if hasattr( listener
, "exitConstant" ):
4347 listener
.exitConstant(self
)
4354 localctx
= CParser
.ConstantContext(self
, self
._ctx
, self
.state
)
4355 self
.enterRule(localctx
, 88, self
.RULE_constant
)
4356 self
._la
= 0 # Token type
4359 self
._errHandler
.sync(self
)
4360 token
= self
._input
.LA(1)
4361 if token
in [CParser
.HEX_LITERAL
]:
4362 self
.enterOuterAlt(localctx
, 1)
4364 self
.match(CParser
.HEX_LITERAL
)
4366 elif token
in [CParser
.OCTAL_LITERAL
]:
4367 self
.enterOuterAlt(localctx
, 2)
4369 self
.match(CParser
.OCTAL_LITERAL
)
4371 elif token
in [CParser
.DECIMAL_LITERAL
]:
4372 self
.enterOuterAlt(localctx
, 3)
4374 self
.match(CParser
.DECIMAL_LITERAL
)
4376 elif token
in [CParser
.CHARACTER_LITERAL
]:
4377 self
.enterOuterAlt(localctx
, 4)
4379 self
.match(CParser
.CHARACTER_LITERAL
)
4381 elif token
in [CParser
.IDENTIFIER
, CParser
.STRING_LITERAL
]:
4382 self
.enterOuterAlt(localctx
, 5)
4384 self
._errHandler
.sync(self
)
4386 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
4389 self
._errHandler
.sync(self
)
4390 _la
= self
._input
.LA(1)
4391 while _la
==CParser
.IDENTIFIER
:
4393 self
.match(CParser
.IDENTIFIER
)
4395 self
._errHandler
.sync(self
)
4396 _la
= self
._input
.LA(1)
4399 self
._errHandler
.sync(self
)
4401 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
4404 self
.match(CParser
.STRING_LITERAL
)
4407 raise NoViableAltException(self
)
4409 self
._errHandler
.sync(self
)
4410 _alt
= self
._interp
.adaptivePredict(self
._input
,77,self
._ctx
)
4414 raise NoViableAltException(self
)
4416 self
._errHandler
.sync(self
)
4417 _alt
= self
._interp
.adaptivePredict(self
._input
,78,self
._ctx
)
4420 self
._errHandler
.sync(self
)
4421 _la
= self
._input
.LA(1)
4422 while _la
==CParser
.IDENTIFIER
:
4424 self
.match(CParser
.IDENTIFIER
)
4426 self
._errHandler
.sync(self
)
4427 _la
= self
._input
.LA(1)
4430 elif token
in [CParser
.FLOATING_POINT_LITERAL
]:
4431 self
.enterOuterAlt(localctx
, 6)
4433 self
.match(CParser
.FLOATING_POINT_LITERAL
)
4436 raise NoViableAltException(self
)
4438 except RecognitionException
as re
:
4439 localctx
.exception
= re
4440 self
._errHandler
.reportError(self
, re
)
4441 self
._errHandler
.recover(self
, re
)
4446 class ExpressionContext(ParserRuleContext
):
4448 # @param parent=None Type: ParserRuleContext
4449 # @param invokingState=-1 Type: int
4450 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4451 super().__init
__(parent
, invokingState
)
4452 self
.parser
= parser
4454 # @param i=None Type: int
4455 def assignment_expression(self
,i
=None):
4457 return self
.getTypedRuleContexts(CParser
.Assignment_expressionContext
)
4459 return self
.getTypedRuleContext(CParser
.Assignment_expressionContext
,i
)
4462 def getRuleIndex(self
):
4463 return CParser
.RULE_expression
4465 # @param listener Type: ParseTreeListener
4466 def enterRule(self
,listener
):
4467 if hasattr( listener
, "enterExpression" ):
4468 listener
.enterExpression(self
)
4470 # @param listener Type: ParseTreeListener
4471 def exitRule(self
,listener
):
4472 if hasattr( listener
, "exitExpression" ):
4473 listener
.exitExpression(self
)
4478 def expression(self
):
4480 localctx
= CParser
.ExpressionContext(self
, self
._ctx
, self
.state
)
4481 self
.enterRule(localctx
, 90, self
.RULE_expression
)
4482 self
._la
= 0 # Token type
4484 self
.enterOuterAlt(localctx
, 1)
4486 self
.assignment_expression()
4488 self
._errHandler
.sync(self
)
4489 _la
= self
._input
.LA(1)
4490 while _la
==CParser
.T__3
:
4492 self
.match(CParser
.T__3
)
4494 self
.assignment_expression()
4496 self
._errHandler
.sync(self
)
4497 _la
= self
._input
.LA(1)
4499 except RecognitionException
as re
:
4500 localctx
.exception
= re
4501 self
._errHandler
.reportError(self
, re
)
4502 self
._errHandler
.recover(self
, re
)
4507 class Constant_expressionContext(ParserRuleContext
):
4509 # @param parent=None Type: ParserRuleContext
4510 # @param invokingState=-1 Type: int
4511 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4512 super().__init
__(parent
, invokingState
)
4513 self
.parser
= parser
4515 def conditional_expression(self
):
4516 return self
.getTypedRuleContext(CParser
.Conditional_expressionContext
,0)
4519 def getRuleIndex(self
):
4520 return CParser
.RULE_constant_expression
4522 # @param listener Type: ParseTreeListener
4523 def enterRule(self
,listener
):
4524 if hasattr( listener
, "enterConstant_expression" ):
4525 listener
.enterConstant_expression(self
)
4527 # @param listener Type: ParseTreeListener
4528 def exitRule(self
,listener
):
4529 if hasattr( listener
, "exitConstant_expression" ):
4530 listener
.exitConstant_expression(self
)
4535 def constant_expression(self
):
4537 localctx
= CParser
.Constant_expressionContext(self
, self
._ctx
, self
.state
)
4538 self
.enterRule(localctx
, 92, self
.RULE_constant_expression
)
4540 self
.enterOuterAlt(localctx
, 1)
4542 self
.conditional_expression()
4543 except RecognitionException
as re
:
4544 localctx
.exception
= re
4545 self
._errHandler
.reportError(self
, re
)
4546 self
._errHandler
.recover(self
, re
)
4551 class Assignment_expressionContext(ParserRuleContext
):
4553 # @param parent=None Type: ParserRuleContext
4554 # @param invokingState=-1 Type: int
4555 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4556 super().__init
__(parent
, invokingState
)
4557 self
.parser
= parser
4560 return self
.getTypedRuleContext(CParser
.LvalueContext
,0)
4563 def assignment_operator(self
):
4564 return self
.getTypedRuleContext(CParser
.Assignment_operatorContext
,0)
4567 def assignment_expression(self
):
4568 return self
.getTypedRuleContext(CParser
.Assignment_expressionContext
,0)
4571 def conditional_expression(self
):
4572 return self
.getTypedRuleContext(CParser
.Conditional_expressionContext
,0)
4575 def getRuleIndex(self
):
4576 return CParser
.RULE_assignment_expression
4578 # @param listener Type: ParseTreeListener
4579 def enterRule(self
,listener
):
4580 if hasattr( listener
, "enterAssignment_expression" ):
4581 listener
.enterAssignment_expression(self
)
4583 # @param listener Type: ParseTreeListener
4584 def exitRule(self
,listener
):
4585 if hasattr( listener
, "exitAssignment_expression" ):
4586 listener
.exitAssignment_expression(self
)
4591 def assignment_expression(self
):
4593 localctx
= CParser
.Assignment_expressionContext(self
, self
._ctx
, self
.state
)
4594 self
.enterRule(localctx
, 94, self
.RULE_assignment_expression
)
4597 self
._errHandler
.sync(self
)
4598 la_
= self
._interp
.adaptivePredict(self
._input
,82,self
._ctx
)
4600 self
.enterOuterAlt(localctx
, 1)
4604 self
.assignment_operator()
4606 self
.assignment_expression()
4610 self
.enterOuterAlt(localctx
, 2)
4612 self
.conditional_expression()
4616 except RecognitionException
as re
:
4617 localctx
.exception
= re
4618 self
._errHandler
.reportError(self
, re
)
4619 self
._errHandler
.recover(self
, re
)
4624 class LvalueContext(ParserRuleContext
):
4626 # @param parent=None Type: ParserRuleContext
4627 # @param invokingState=-1 Type: int
4628 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4629 super().__init
__(parent
, invokingState
)
4630 self
.parser
= parser
4632 def unary_expression(self
):
4633 return self
.getTypedRuleContext(CParser
.Unary_expressionContext
,0)
4636 def getRuleIndex(self
):
4637 return CParser
.RULE_lvalue
4639 # @param listener Type: ParseTreeListener
4640 def enterRule(self
,listener
):
4641 if hasattr( listener
, "enterLvalue" ):
4642 listener
.enterLvalue(self
)
4644 # @param listener Type: ParseTreeListener
4645 def exitRule(self
,listener
):
4646 if hasattr( listener
, "exitLvalue" ):
4647 listener
.exitLvalue(self
)
4654 localctx
= CParser
.LvalueContext(self
, self
._ctx
, self
.state
)
4655 self
.enterRule(localctx
, 96, self
.RULE_lvalue
)
4657 self
.enterOuterAlt(localctx
, 1)
4659 self
.unary_expression()
4660 except RecognitionException
as re
:
4661 localctx
.exception
= re
4662 self
._errHandler
.reportError(self
, re
)
4663 self
._errHandler
.recover(self
, re
)
4668 class Assignment_operatorContext(ParserRuleContext
):
4670 # @param parent=None Type: ParserRuleContext
4671 # @param invokingState=-1 Type: int
4672 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4673 super().__init
__(parent
, invokingState
)
4674 self
.parser
= parser
4677 def getRuleIndex(self
):
4678 return CParser
.RULE_assignment_operator
4680 # @param listener Type: ParseTreeListener
4681 def enterRule(self
,listener
):
4682 if hasattr( listener
, "enterAssignment_operator" ):
4683 listener
.enterAssignment_operator(self
)
4685 # @param listener Type: ParseTreeListener
4686 def exitRule(self
,listener
):
4687 if hasattr( listener
, "exitAssignment_operator" ):
4688 listener
.exitAssignment_operator(self
)
4693 def assignment_operator(self
):
4695 localctx
= CParser
.Assignment_operatorContext(self
, self
._ctx
, self
.state
)
4696 self
.enterRule(localctx
, 98, self
.RULE_assignment_operator
)
4697 self
._la
= 0 # Token type
4699 self
.enterOuterAlt(localctx
, 1)
4701 _la
= self
._input
.LA(1)
4702 if not(((((_la
- 5)) & ~
0x3f) == 0 and ((1 << (_la
- 5)) & ((1 << (CParser
.T__4
- 5)) |
(1 << (CParser
.T__55
- 5)) |
(1 << (CParser
.T__56
- 5)) |
(1 << (CParser
.T__57
- 5)) |
(1 << (CParser
.T__58
- 5)) |
(1 << (CParser
.T__59
- 5)) |
(1 << (CParser
.T__60
- 5)) |
(1 << (CParser
.T__61
- 5)) |
(1 << (CParser
.T__62
- 5)) |
(1 << (CParser
.T__63
- 5)) |
(1 << (CParser
.T__64
- 5)))) != 0)):
4703 self
._errHandler
.recoverInline(self
)
4705 self
._errHandler
.reportMatch(self
)
4707 except RecognitionException
as re
:
4708 localctx
.exception
= re
4709 self
._errHandler
.reportError(self
, re
)
4710 self
._errHandler
.recover(self
, re
)
4715 class Conditional_expressionContext(ParserRuleContext
):
4717 # @param parent=None Type: ParserRuleContext
4718 # @param invokingState=-1 Type: int
4719 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4720 super().__init
__(parent
, invokingState
)
4721 self
.parser
= parser
4722 self
.e
= None # Logical_or_expressionContext
4724 def logical_or_expression(self
):
4725 return self
.getTypedRuleContext(CParser
.Logical_or_expressionContext
,0)
4728 def expression(self
):
4729 return self
.getTypedRuleContext(CParser
.ExpressionContext
,0)
4732 def conditional_expression(self
):
4733 return self
.getTypedRuleContext(CParser
.Conditional_expressionContext
,0)
4736 def getRuleIndex(self
):
4737 return CParser
.RULE_conditional_expression
4739 # @param listener Type: ParseTreeListener
4740 def enterRule(self
,listener
):
4741 if hasattr( listener
, "enterConditional_expression" ):
4742 listener
.enterConditional_expression(self
)
4744 # @param listener Type: ParseTreeListener
4745 def exitRule(self
,listener
):
4746 if hasattr( listener
, "exitConditional_expression" ):
4747 listener
.exitConditional_expression(self
)
4752 def conditional_expression(self
):
4754 localctx
= CParser
.Conditional_expressionContext(self
, self
._ctx
, self
.state
)
4755 self
.enterRule(localctx
, 100, self
.RULE_conditional_expression
)
4756 self
._la
= 0 # Token type
4758 self
.enterOuterAlt(localctx
, 1)
4760 localctx
.e
= self
.logical_or_expression()
4762 self
._errHandler
.sync(self
)
4763 _la
= self
._input
.LA(1)
4764 if _la
==CParser
.T__65
:
4766 self
.match(CParser
.T__65
)
4770 self
.match(CParser
.T__22
)
4772 self
.conditional_expression()
4773 self
.StorePredicateExpression((None if localctx
.e
is None else localctx
.e
.start
).line
, (None if localctx
.e
is None else localctx
.e
.start
).column
, (None if localctx
.e
is None else localctx
.e
.stop
).line
, (None if localctx
.e
is None else localctx
.e
.stop
).column
, (None if localctx
.e
is None else self
._input
.getText((localctx
.e
.start
,localctx
.e
.stop
))))
4776 except RecognitionException
as re
:
4777 localctx
.exception
= re
4778 self
._errHandler
.reportError(self
, re
)
4779 self
._errHandler
.recover(self
, re
)
4784 class Logical_or_expressionContext(ParserRuleContext
):
4786 # @param parent=None Type: ParserRuleContext
4787 # @param invokingState=-1 Type: int
4788 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4789 super().__init
__(parent
, invokingState
)
4790 self
.parser
= parser
4792 # @param i=None Type: int
4793 def logical_and_expression(self
,i
=None):
4795 return self
.getTypedRuleContexts(CParser
.Logical_and_expressionContext
)
4797 return self
.getTypedRuleContext(CParser
.Logical_and_expressionContext
,i
)
4800 def getRuleIndex(self
):
4801 return CParser
.RULE_logical_or_expression
4803 # @param listener Type: ParseTreeListener
4804 def enterRule(self
,listener
):
4805 if hasattr( listener
, "enterLogical_or_expression" ):
4806 listener
.enterLogical_or_expression(self
)
4808 # @param listener Type: ParseTreeListener
4809 def exitRule(self
,listener
):
4810 if hasattr( listener
, "exitLogical_or_expression" ):
4811 listener
.exitLogical_or_expression(self
)
4816 def logical_or_expression(self
):
4818 localctx
= CParser
.Logical_or_expressionContext(self
, self
._ctx
, self
.state
)
4819 self
.enterRule(localctx
, 102, self
.RULE_logical_or_expression
)
4820 self
._la
= 0 # Token type
4822 self
.enterOuterAlt(localctx
, 1)
4824 self
.logical_and_expression()
4826 self
._errHandler
.sync(self
)
4827 _la
= self
._input
.LA(1)
4828 while _la
==CParser
.T__66
:
4830 self
.match(CParser
.T__66
)
4832 self
.logical_and_expression()
4834 self
._errHandler
.sync(self
)
4835 _la
= self
._input
.LA(1)
4837 except RecognitionException
as re
:
4838 localctx
.exception
= re
4839 self
._errHandler
.reportError(self
, re
)
4840 self
._errHandler
.recover(self
, re
)
4845 class Logical_and_expressionContext(ParserRuleContext
):
4847 # @param parent=None Type: ParserRuleContext
4848 # @param invokingState=-1 Type: int
4849 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4850 super().__init
__(parent
, invokingState
)
4851 self
.parser
= parser
4853 # @param i=None Type: int
4854 def inclusive_or_expression(self
,i
=None):
4856 return self
.getTypedRuleContexts(CParser
.Inclusive_or_expressionContext
)
4858 return self
.getTypedRuleContext(CParser
.Inclusive_or_expressionContext
,i
)
4861 def getRuleIndex(self
):
4862 return CParser
.RULE_logical_and_expression
4864 # @param listener Type: ParseTreeListener
4865 def enterRule(self
,listener
):
4866 if hasattr( listener
, "enterLogical_and_expression" ):
4867 listener
.enterLogical_and_expression(self
)
4869 # @param listener Type: ParseTreeListener
4870 def exitRule(self
,listener
):
4871 if hasattr( listener
, "exitLogical_and_expression" ):
4872 listener
.exitLogical_and_expression(self
)
4877 def logical_and_expression(self
):
4879 localctx
= CParser
.Logical_and_expressionContext(self
, self
._ctx
, self
.state
)
4880 self
.enterRule(localctx
, 104, self
.RULE_logical_and_expression
)
4881 self
._la
= 0 # Token type
4883 self
.enterOuterAlt(localctx
, 1)
4885 self
.inclusive_or_expression()
4887 self
._errHandler
.sync(self
)
4888 _la
= self
._input
.LA(1)
4889 while _la
==CParser
.T__67
:
4891 self
.match(CParser
.T__67
)
4893 self
.inclusive_or_expression()
4895 self
._errHandler
.sync(self
)
4896 _la
= self
._input
.LA(1)
4898 except RecognitionException
as re
:
4899 localctx
.exception
= re
4900 self
._errHandler
.reportError(self
, re
)
4901 self
._errHandler
.recover(self
, re
)
4906 class Inclusive_or_expressionContext(ParserRuleContext
):
4908 # @param parent=None Type: ParserRuleContext
4909 # @param invokingState=-1 Type: int
4910 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4911 super().__init
__(parent
, invokingState
)
4912 self
.parser
= parser
4914 # @param i=None Type: int
4915 def exclusive_or_expression(self
,i
=None):
4917 return self
.getTypedRuleContexts(CParser
.Exclusive_or_expressionContext
)
4919 return self
.getTypedRuleContext(CParser
.Exclusive_or_expressionContext
,i
)
4922 def getRuleIndex(self
):
4923 return CParser
.RULE_inclusive_or_expression
4925 # @param listener Type: ParseTreeListener
4926 def enterRule(self
,listener
):
4927 if hasattr( listener
, "enterInclusive_or_expression" ):
4928 listener
.enterInclusive_or_expression(self
)
4930 # @param listener Type: ParseTreeListener
4931 def exitRule(self
,listener
):
4932 if hasattr( listener
, "exitInclusive_or_expression" ):
4933 listener
.exitInclusive_or_expression(self
)
4938 def inclusive_or_expression(self
):
4940 localctx
= CParser
.Inclusive_or_expressionContext(self
, self
._ctx
, self
.state
)
4941 self
.enterRule(localctx
, 106, self
.RULE_inclusive_or_expression
)
4942 self
._la
= 0 # Token type
4944 self
.enterOuterAlt(localctx
, 1)
4946 self
.exclusive_or_expression()
4948 self
._errHandler
.sync(self
)
4949 _la
= self
._input
.LA(1)
4950 while _la
==CParser
.T__68
:
4952 self
.match(CParser
.T__68
)
4954 self
.exclusive_or_expression()
4956 self
._errHandler
.sync(self
)
4957 _la
= self
._input
.LA(1)
4959 except RecognitionException
as re
:
4960 localctx
.exception
= re
4961 self
._errHandler
.reportError(self
, re
)
4962 self
._errHandler
.recover(self
, re
)
4967 class Exclusive_or_expressionContext(ParserRuleContext
):
4969 # @param parent=None Type: ParserRuleContext
4970 # @param invokingState=-1 Type: int
4971 def __init__(self
,parser
,parent
=None,invokingState
=-1):
4972 super().__init
__(parent
, invokingState
)
4973 self
.parser
= parser
4975 # @param i=None Type: int
4976 def and_expression(self
,i
=None):
4978 return self
.getTypedRuleContexts(CParser
.And_expressionContext
)
4980 return self
.getTypedRuleContext(CParser
.And_expressionContext
,i
)
4983 def getRuleIndex(self
):
4984 return CParser
.RULE_exclusive_or_expression
4986 # @param listener Type: ParseTreeListener
4987 def enterRule(self
,listener
):
4988 if hasattr( listener
, "enterExclusive_or_expression" ):
4989 listener
.enterExclusive_or_expression(self
)
4991 # @param listener Type: ParseTreeListener
4992 def exitRule(self
,listener
):
4993 if hasattr( listener
, "exitExclusive_or_expression" ):
4994 listener
.exitExclusive_or_expression(self
)
4999 def exclusive_or_expression(self
):
5001 localctx
= CParser
.Exclusive_or_expressionContext(self
, self
._ctx
, self
.state
)
5002 self
.enterRule(localctx
, 108, self
.RULE_exclusive_or_expression
)
5003 self
._la
= 0 # Token type
5005 self
.enterOuterAlt(localctx
, 1)
5007 self
.and_expression()
5009 self
._errHandler
.sync(self
)
5010 _la
= self
._input
.LA(1)
5011 while _la
==CParser
.T__69
:
5013 self
.match(CParser
.T__69
)
5015 self
.and_expression()
5017 self
._errHandler
.sync(self
)
5018 _la
= self
._input
.LA(1)
5020 except RecognitionException
as re
:
5021 localctx
.exception
= re
5022 self
._errHandler
.reportError(self
, re
)
5023 self
._errHandler
.recover(self
, re
)
5028 class And_expressionContext(ParserRuleContext
):
5030 # @param parent=None Type: ParserRuleContext
5031 # @param invokingState=-1 Type: int
5032 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5033 super().__init
__(parent
, invokingState
)
5034 self
.parser
= parser
5036 # @param i=None Type: int
5037 def equality_expression(self
,i
=None):
5039 return self
.getTypedRuleContexts(CParser
.Equality_expressionContext
)
5041 return self
.getTypedRuleContext(CParser
.Equality_expressionContext
,i
)
5044 def getRuleIndex(self
):
5045 return CParser
.RULE_and_expression
5047 # @param listener Type: ParseTreeListener
5048 def enterRule(self
,listener
):
5049 if hasattr( listener
, "enterAnd_expression" ):
5050 listener
.enterAnd_expression(self
)
5052 # @param listener Type: ParseTreeListener
5053 def exitRule(self
,listener
):
5054 if hasattr( listener
, "exitAnd_expression" ):
5055 listener
.exitAnd_expression(self
)
5060 def and_expression(self
):
5062 localctx
= CParser
.And_expressionContext(self
, self
._ctx
, self
.state
)
5063 self
.enterRule(localctx
, 110, self
.RULE_and_expression
)
5064 self
._la
= 0 # Token type
5066 self
.enterOuterAlt(localctx
, 1)
5068 self
.equality_expression()
5070 self
._errHandler
.sync(self
)
5071 _la
= self
._input
.LA(1)
5072 while _la
==CParser
.T__52
:
5074 self
.match(CParser
.T__52
)
5076 self
.equality_expression()
5078 self
._errHandler
.sync(self
)
5079 _la
= self
._input
.LA(1)
5081 except RecognitionException
as re
:
5082 localctx
.exception
= re
5083 self
._errHandler
.reportError(self
, re
)
5084 self
._errHandler
.recover(self
, re
)
5089 class Equality_expressionContext(ParserRuleContext
):
5091 # @param parent=None Type: ParserRuleContext
5092 # @param invokingState=-1 Type: int
5093 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5094 super().__init
__(parent
, invokingState
)
5095 self
.parser
= parser
5097 # @param i=None Type: int
5098 def relational_expression(self
,i
=None):
5100 return self
.getTypedRuleContexts(CParser
.Relational_expressionContext
)
5102 return self
.getTypedRuleContext(CParser
.Relational_expressionContext
,i
)
5105 def getRuleIndex(self
):
5106 return CParser
.RULE_equality_expression
5108 # @param listener Type: ParseTreeListener
5109 def enterRule(self
,listener
):
5110 if hasattr( listener
, "enterEquality_expression" ):
5111 listener
.enterEquality_expression(self
)
5113 # @param listener Type: ParseTreeListener
5114 def exitRule(self
,listener
):
5115 if hasattr( listener
, "exitEquality_expression" ):
5116 listener
.exitEquality_expression(self
)
5121 def equality_expression(self
):
5123 localctx
= CParser
.Equality_expressionContext(self
, self
._ctx
, self
.state
)
5124 self
.enterRule(localctx
, 112, self
.RULE_equality_expression
)
5125 self
._la
= 0 # Token type
5127 self
.enterOuterAlt(localctx
, 1)
5129 self
.relational_expression()
5131 self
._errHandler
.sync(self
)
5132 _la
= self
._input
.LA(1)
5133 while _la
==CParser
.T__70
or _la
==CParser
.T__71
:
5135 _la
= self
._input
.LA(1)
5136 if not(_la
==CParser
.T__70
or _la
==CParser
.T__71
):
5137 self
._errHandler
.recoverInline(self
)
5139 self
._errHandler
.reportMatch(self
)
5142 self
.relational_expression()
5144 self
._errHandler
.sync(self
)
5145 _la
= self
._input
.LA(1)
5147 except RecognitionException
as re
:
5148 localctx
.exception
= re
5149 self
._errHandler
.reportError(self
, re
)
5150 self
._errHandler
.recover(self
, re
)
5155 class Relational_expressionContext(ParserRuleContext
):
5157 # @param parent=None Type: ParserRuleContext
5158 # @param invokingState=-1 Type: int
5159 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5160 super().__init
__(parent
, invokingState
)
5161 self
.parser
= parser
5163 # @param i=None Type: int
5164 def shift_expression(self
,i
=None):
5166 return self
.getTypedRuleContexts(CParser
.Shift_expressionContext
)
5168 return self
.getTypedRuleContext(CParser
.Shift_expressionContext
,i
)
5171 def getRuleIndex(self
):
5172 return CParser
.RULE_relational_expression
5174 # @param listener Type: ParseTreeListener
5175 def enterRule(self
,listener
):
5176 if hasattr( listener
, "enterRelational_expression" ):
5177 listener
.enterRelational_expression(self
)
5179 # @param listener Type: ParseTreeListener
5180 def exitRule(self
,listener
):
5181 if hasattr( listener
, "exitRelational_expression" ):
5182 listener
.exitRelational_expression(self
)
5187 def relational_expression(self
):
5189 localctx
= CParser
.Relational_expressionContext(self
, self
._ctx
, self
.state
)
5190 self
.enterRule(localctx
, 114, self
.RULE_relational_expression
)
5191 self
._la
= 0 # Token type
5193 self
.enterOuterAlt(localctx
, 1)
5195 self
.shift_expression()
5197 self
._errHandler
.sync(self
)
5198 _la
= self
._input
.LA(1)
5199 while ((((_la
- 73)) & ~
0x3f) == 0 and ((1 << (_la
- 73)) & ((1 << (CParser
.T__72
- 73)) |
(1 << (CParser
.T__73
- 73)) |
(1 << (CParser
.T__74
- 73)) |
(1 << (CParser
.T__75
- 73)))) != 0):
5201 _la
= self
._input
.LA(1)
5202 if not(((((_la
- 73)) & ~
0x3f) == 0 and ((1 << (_la
- 73)) & ((1 << (CParser
.T__72
- 73)) |
(1 << (CParser
.T__73
- 73)) |
(1 << (CParser
.T__74
- 73)) |
(1 << (CParser
.T__75
- 73)))) != 0)):
5203 self
._errHandler
.recoverInline(self
)
5205 self
._errHandler
.reportMatch(self
)
5208 self
.shift_expression()
5210 self
._errHandler
.sync(self
)
5211 _la
= self
._input
.LA(1)
5213 except RecognitionException
as re
:
5214 localctx
.exception
= re
5215 self
._errHandler
.reportError(self
, re
)
5216 self
._errHandler
.recover(self
, re
)
5221 class Shift_expressionContext(ParserRuleContext
):
5223 # @param parent=None Type: ParserRuleContext
5224 # @param invokingState=-1 Type: int
5225 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5226 super().__init
__(parent
, invokingState
)
5227 self
.parser
= parser
5229 # @param i=None Type: int
5230 def additive_expression(self
,i
=None):
5232 return self
.getTypedRuleContexts(CParser
.Additive_expressionContext
)
5234 return self
.getTypedRuleContext(CParser
.Additive_expressionContext
,i
)
5237 def getRuleIndex(self
):
5238 return CParser
.RULE_shift_expression
5240 # @param listener Type: ParseTreeListener
5241 def enterRule(self
,listener
):
5242 if hasattr( listener
, "enterShift_expression" ):
5243 listener
.enterShift_expression(self
)
5245 # @param listener Type: ParseTreeListener
5246 def exitRule(self
,listener
):
5247 if hasattr( listener
, "exitShift_expression" ):
5248 listener
.exitShift_expression(self
)
5253 def shift_expression(self
):
5255 localctx
= CParser
.Shift_expressionContext(self
, self
._ctx
, self
.state
)
5256 self
.enterRule(localctx
, 116, self
.RULE_shift_expression
)
5257 self
._la
= 0 # Token type
5259 self
.enterOuterAlt(localctx
, 1)
5261 self
.additive_expression()
5263 self
._errHandler
.sync(self
)
5264 _la
= self
._input
.LA(1)
5265 while _la
==CParser
.T__76
or _la
==CParser
.T__77
:
5267 _la
= self
._input
.LA(1)
5268 if not(_la
==CParser
.T__76
or _la
==CParser
.T__77
):
5269 self
._errHandler
.recoverInline(self
)
5271 self
._errHandler
.reportMatch(self
)
5274 self
.additive_expression()
5276 self
._errHandler
.sync(self
)
5277 _la
= self
._input
.LA(1)
5279 except RecognitionException
as re
:
5280 localctx
.exception
= re
5281 self
._errHandler
.reportError(self
, re
)
5282 self
._errHandler
.recover(self
, re
)
5287 class StatementContext(ParserRuleContext
):
5289 # @param parent=None Type: ParserRuleContext
5290 # @param invokingState=-1 Type: int
5291 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5292 super().__init
__(parent
, invokingState
)
5293 self
.parser
= parser
5295 def labeled_statement(self
):
5296 return self
.getTypedRuleContext(CParser
.Labeled_statementContext
,0)
5299 def compound_statement(self
):
5300 return self
.getTypedRuleContext(CParser
.Compound_statementContext
,0)
5303 def expression_statement(self
):
5304 return self
.getTypedRuleContext(CParser
.Expression_statementContext
,0)
5307 def selection_statement(self
):
5308 return self
.getTypedRuleContext(CParser
.Selection_statementContext
,0)
5311 def iteration_statement(self
):
5312 return self
.getTypedRuleContext(CParser
.Iteration_statementContext
,0)
5315 def jump_statement(self
):
5316 return self
.getTypedRuleContext(CParser
.Jump_statementContext
,0)
5319 def macro_statement(self
):
5320 return self
.getTypedRuleContext(CParser
.Macro_statementContext
,0)
5323 def asm2_statement(self
):
5324 return self
.getTypedRuleContext(CParser
.Asm2_statementContext
,0)
5327 def asm1_statement(self
):
5328 return self
.getTypedRuleContext(CParser
.Asm1_statementContext
,0)
5331 def asm_statement(self
):
5332 return self
.getTypedRuleContext(CParser
.Asm_statementContext
,0)
5335 def declaration(self
):
5336 return self
.getTypedRuleContext(CParser
.DeclarationContext
,0)
5339 def getRuleIndex(self
):
5340 return CParser
.RULE_statement
5342 # @param listener Type: ParseTreeListener
5343 def enterRule(self
,listener
):
5344 if hasattr( listener
, "enterStatement" ):
5345 listener
.enterStatement(self
)
5347 # @param listener Type: ParseTreeListener
5348 def exitRule(self
,listener
):
5349 if hasattr( listener
, "exitStatement" ):
5350 listener
.exitStatement(self
)
5355 def statement(self
):
5357 localctx
= CParser
.StatementContext(self
, self
._ctx
, self
.state
)
5358 self
.enterRule(localctx
, 118, self
.RULE_statement
)
5361 self
._errHandler
.sync(self
)
5362 la_
= self
._interp
.adaptivePredict(self
._input
,92,self
._ctx
)
5364 self
.enterOuterAlt(localctx
, 1)
5366 self
.labeled_statement()
5370 self
.enterOuterAlt(localctx
, 2)
5372 self
.compound_statement()
5376 self
.enterOuterAlt(localctx
, 3)
5378 self
.expression_statement()
5382 self
.enterOuterAlt(localctx
, 4)
5384 self
.selection_statement()
5388 self
.enterOuterAlt(localctx
, 5)
5390 self
.iteration_statement()
5394 self
.enterOuterAlt(localctx
, 6)
5396 self
.jump_statement()
5400 self
.enterOuterAlt(localctx
, 7)
5402 self
.macro_statement()
5406 self
.enterOuterAlt(localctx
, 8)
5408 self
.asm2_statement()
5412 self
.enterOuterAlt(localctx
, 9)
5414 self
.asm1_statement()
5418 self
.enterOuterAlt(localctx
, 10)
5420 self
.asm_statement()
5424 self
.enterOuterAlt(localctx
, 11)
5430 except RecognitionException
as re
:
5431 localctx
.exception
= re
5432 self
._errHandler
.reportError(self
, re
)
5433 self
._errHandler
.recover(self
, re
)
5438 class Asm2_statementContext(ParserRuleContext
):
5440 # @param parent=None Type: ParserRuleContext
5441 # @param invokingState=-1 Type: int
5442 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5443 super().__init
__(parent
, invokingState
)
5444 self
.parser
= parser
5446 def IDENTIFIER(self
):
5447 return self
.getToken(CParser
.IDENTIFIER
, 0)
5449 def getRuleIndex(self
):
5450 return CParser
.RULE_asm2_statement
5452 # @param listener Type: ParseTreeListener
5453 def enterRule(self
,listener
):
5454 if hasattr( listener
, "enterAsm2_statement" ):
5455 listener
.enterAsm2_statement(self
)
5457 # @param listener Type: ParseTreeListener
5458 def exitRule(self
,listener
):
5459 if hasattr( listener
, "exitAsm2_statement" ):
5460 listener
.exitAsm2_statement(self
)
5465 def asm2_statement(self
):
5467 localctx
= CParser
.Asm2_statementContext(self
, self
._ctx
, self
.state
)
5468 self
.enterRule(localctx
, 120, self
.RULE_asm2_statement
)
5469 self
._la
= 0 # Token type
5471 self
.enterOuterAlt(localctx
, 1)
5473 self
._errHandler
.sync(self
)
5474 _la
= self
._input
.LA(1)
5475 if _la
==CParser
.T__78
:
5477 self
.match(CParser
.T__78
)
5481 self
.match(CParser
.IDENTIFIER
)
5483 self
.match(CParser
.T__37
)
5485 self
._errHandler
.sync(self
)
5486 _alt
= self
._interp
.adaptivePredict(self
._input
,94,self
._ctx
)
5487 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
5490 _la
= self
._input
.LA(1)
5491 if _la
<= 0 or _la
==CParser
.T__1
:
5492 self
._errHandler
.recoverInline(self
)
5494 self
._errHandler
.reportMatch(self
)
5497 self
._errHandler
.sync(self
)
5498 _alt
= self
._interp
.adaptivePredict(self
._input
,94,self
._ctx
)
5501 self
.match(CParser
.T__38
)
5503 self
.match(CParser
.T__1
)
5504 except RecognitionException
as re
:
5505 localctx
.exception
= re
5506 self
._errHandler
.reportError(self
, re
)
5507 self
._errHandler
.recover(self
, re
)
5512 class Asm1_statementContext(ParserRuleContext
):
5514 # @param parent=None Type: ParserRuleContext
5515 # @param invokingState=-1 Type: int
5516 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5517 super().__init
__(parent
, invokingState
)
5518 self
.parser
= parser
5521 def getRuleIndex(self
):
5522 return CParser
.RULE_asm1_statement
5524 # @param listener Type: ParseTreeListener
5525 def enterRule(self
,listener
):
5526 if hasattr( listener
, "enterAsm1_statement" ):
5527 listener
.enterAsm1_statement(self
)
5529 # @param listener Type: ParseTreeListener
5530 def exitRule(self
,listener
):
5531 if hasattr( listener
, "exitAsm1_statement" ):
5532 listener
.exitAsm1_statement(self
)
5537 def asm1_statement(self
):
5539 localctx
= CParser
.Asm1_statementContext(self
, self
._ctx
, self
.state
)
5540 self
.enterRule(localctx
, 122, self
.RULE_asm1_statement
)
5541 self
._la
= 0 # Token type
5543 self
.enterOuterAlt(localctx
, 1)
5545 self
.match(CParser
.T__79
)
5547 self
.match(CParser
.T__0
)
5549 self
._errHandler
.sync(self
)
5550 _la
= self
._input
.LA(1)
5551 while (((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__0
) |
(1 << CParser
.T__1
) |
(1 << CParser
.T__2
) |
(1 << CParser
.T__3
) |
(1 << CParser
.T__4
) |
(1 << CParser
.T__5
) |
(1 << CParser
.T__6
) |
(1 << CParser
.T__7
) |
(1 << CParser
.T__8
) |
(1 << CParser
.T__9
) |
(1 << CParser
.T__10
) |
(1 << CParser
.T__11
) |
(1 << CParser
.T__12
) |
(1 << CParser
.T__13
) |
(1 << CParser
.T__14
) |
(1 << CParser
.T__15
) |
(1 << CParser
.T__16
) |
(1 << CParser
.T__17
) |
(1 << CParser
.T__18
) |
(1 << CParser
.T__20
) |
(1 << CParser
.T__21
) |
(1 << CParser
.T__22
) |
(1 << CParser
.T__23
) |
(1 << CParser
.T__24
) |
(1 << CParser
.T__25
) |
(1 << CParser
.T__26
) |
(1 << CParser
.T__27
) |
(1 << CParser
.T__28
) |
(1 << CParser
.T__29
) |
(1 << CParser
.T__30
) |
(1 << CParser
.T__31
) |
(1 << CParser
.T__32
) |
(1 << CParser
.T__33
) |
(1 << CParser
.T__34
) |
(1 << CParser
.T__35
) |
(1 << CParser
.T__36
) |
(1 << CParser
.T__37
) |
(1 << CParser
.T__38
) |
(1 << CParser
.T__39
) |
(1 << CParser
.T__40
) |
(1 << CParser
.T__41
) |
(1 << CParser
.T__42
) |
(1 << CParser
.T__43
) |
(1 << CParser
.T__44
) |
(1 << CParser
.T__45
) |
(1 << CParser
.T__46
) |
(1 << CParser
.T__47
) |
(1 << CParser
.T__48
) |
(1 << CParser
.T__49
) |
(1 << CParser
.T__50
) |
(1 << CParser
.T__51
) |
(1 << CParser
.T__52
) |
(1 << CParser
.T__53
) |
(1 << CParser
.T__54
) |
(1 << CParser
.T__55
) |
(1 << CParser
.T__56
) |
(1 << CParser
.T__57
) |
(1 << CParser
.T__58
) |
(1 << CParser
.T__59
) |
(1 << CParser
.T__60
) |
(1 << CParser
.T__61
) |
(1 << CParser
.T__62
))) != 0) or ((((_la
- 64)) & ~
0x3f) == 0 and ((1 << (_la
- 64)) & ((1 << (CParser
.T__63
- 64)) |
(1 << (CParser
.T__64
- 64)) |
(1 << (CParser
.T__65
- 64)) |
(1 << (CParser
.T__66
- 64)) |
(1 << (CParser
.T__67
- 64)) |
(1 << (CParser
.T__68
- 64)) |
(1 << (CParser
.T__69
- 64)) |
(1 << (CParser
.T__70
- 64)) |
(1 << (CParser
.T__71
- 64)) |
(1 << (CParser
.T__72
- 64)) |
(1 << (CParser
.T__73
- 64)) |
(1 << (CParser
.T__74
- 64)) |
(1 << (CParser
.T__75
- 64)) |
(1 << (CParser
.T__76
- 64)) |
(1 << (CParser
.T__77
- 64)) |
(1 << (CParser
.T__78
- 64)) |
(1 << (CParser
.T__79
- 64)) |
(1 << (CParser
.T__80
- 64)) |
(1 << (CParser
.T__81
- 64)) |
(1 << (CParser
.T__82
- 64)) |
(1 << (CParser
.T__83
- 64)) |
(1 << (CParser
.T__84
- 64)) |
(1 << (CParser
.T__85
- 64)) |
(1 << (CParser
.T__86
- 64)) |
(1 << (CParser
.T__87
- 64)) |
(1 << (CParser
.T__88
- 64)) |
(1 << (CParser
.T__89
- 64)) |
(1 << (CParser
.T__90
- 64)) |
(1 << (CParser
.T__91
- 64)) |
(1 << (CParser
.IDENTIFIER
- 64)) |
(1 << (CParser
.CHARACTER_LITERAL
- 64)) |
(1 << (CParser
.STRING_LITERAL
- 64)) |
(1 << (CParser
.HEX_LITERAL
- 64)) |
(1 << (CParser
.DECIMAL_LITERAL
- 64)) |
(1 << (CParser
.OCTAL_LITERAL
- 64)) |
(1 << (CParser
.FLOATING_POINT_LITERAL
- 64)) |
(1 << (CParser
.WS
- 64)) |
(1 << (CParser
.BS
- 64)) |
(1 << (CParser
.UnicodeVocabulary
- 64)) |
(1 << (CParser
.COMMENT
- 64)) |
(1 << (CParser
.LINE_COMMENT
- 64)) |
(1 << (CParser
.LINE_COMMAND
- 64)))) != 0):
5553 _la
= self
._input
.LA(1)
5554 if _la
<= 0 or _la
==CParser
.T__19
:
5555 self
._errHandler
.recoverInline(self
)
5557 self
._errHandler
.reportMatch(self
)
5560 self
._errHandler
.sync(self
)
5561 _la
= self
._input
.LA(1)
5564 self
.match(CParser
.T__19
)
5565 except RecognitionException
as re
:
5566 localctx
.exception
= re
5567 self
._errHandler
.reportError(self
, re
)
5568 self
._errHandler
.recover(self
, re
)
5573 class Asm_statementContext(ParserRuleContext
):
5575 # @param parent=None Type: ParserRuleContext
5576 # @param invokingState=-1 Type: int
5577 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5578 super().__init
__(parent
, invokingState
)
5579 self
.parser
= parser
5582 def getRuleIndex(self
):
5583 return CParser
.RULE_asm_statement
5585 # @param listener Type: ParseTreeListener
5586 def enterRule(self
,listener
):
5587 if hasattr( listener
, "enterAsm_statement" ):
5588 listener
.enterAsm_statement(self
)
5590 # @param listener Type: ParseTreeListener
5591 def exitRule(self
,listener
):
5592 if hasattr( listener
, "exitAsm_statement" ):
5593 listener
.exitAsm_statement(self
)
5598 def asm_statement(self
):
5600 localctx
= CParser
.Asm_statementContext(self
, self
._ctx
, self
.state
)
5601 self
.enterRule(localctx
, 124, self
.RULE_asm_statement
)
5602 self
._la
= 0 # Token type
5604 self
.enterOuterAlt(localctx
, 1)
5606 self
.match(CParser
.T__80
)
5608 self
.match(CParser
.T__0
)
5610 self
._errHandler
.sync(self
)
5611 _la
= self
._input
.LA(1)
5612 while (((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__0
) |
(1 << CParser
.T__1
) |
(1 << CParser
.T__2
) |
(1 << CParser
.T__3
) |
(1 << CParser
.T__4
) |
(1 << CParser
.T__5
) |
(1 << CParser
.T__6
) |
(1 << CParser
.T__7
) |
(1 << CParser
.T__8
) |
(1 << CParser
.T__9
) |
(1 << CParser
.T__10
) |
(1 << CParser
.T__11
) |
(1 << CParser
.T__12
) |
(1 << CParser
.T__13
) |
(1 << CParser
.T__14
) |
(1 << CParser
.T__15
) |
(1 << CParser
.T__16
) |
(1 << CParser
.T__17
) |
(1 << CParser
.T__18
) |
(1 << CParser
.T__20
) |
(1 << CParser
.T__21
) |
(1 << CParser
.T__22
) |
(1 << CParser
.T__23
) |
(1 << CParser
.T__24
) |
(1 << CParser
.T__25
) |
(1 << CParser
.T__26
) |
(1 << CParser
.T__27
) |
(1 << CParser
.T__28
) |
(1 << CParser
.T__29
) |
(1 << CParser
.T__30
) |
(1 << CParser
.T__31
) |
(1 << CParser
.T__32
) |
(1 << CParser
.T__33
) |
(1 << CParser
.T__34
) |
(1 << CParser
.T__35
) |
(1 << CParser
.T__36
) |
(1 << CParser
.T__37
) |
(1 << CParser
.T__38
) |
(1 << CParser
.T__39
) |
(1 << CParser
.T__40
) |
(1 << CParser
.T__41
) |
(1 << CParser
.T__42
) |
(1 << CParser
.T__43
) |
(1 << CParser
.T__44
) |
(1 << CParser
.T__45
) |
(1 << CParser
.T__46
) |
(1 << CParser
.T__47
) |
(1 << CParser
.T__48
) |
(1 << CParser
.T__49
) |
(1 << CParser
.T__50
) |
(1 << CParser
.T__51
) |
(1 << CParser
.T__52
) |
(1 << CParser
.T__53
) |
(1 << CParser
.T__54
) |
(1 << CParser
.T__55
) |
(1 << CParser
.T__56
) |
(1 << CParser
.T__57
) |
(1 << CParser
.T__58
) |
(1 << CParser
.T__59
) |
(1 << CParser
.T__60
) |
(1 << CParser
.T__61
) |
(1 << CParser
.T__62
))) != 0) or ((((_la
- 64)) & ~
0x3f) == 0 and ((1 << (_la
- 64)) & ((1 << (CParser
.T__63
- 64)) |
(1 << (CParser
.T__64
- 64)) |
(1 << (CParser
.T__65
- 64)) |
(1 << (CParser
.T__66
- 64)) |
(1 << (CParser
.T__67
- 64)) |
(1 << (CParser
.T__68
- 64)) |
(1 << (CParser
.T__69
- 64)) |
(1 << (CParser
.T__70
- 64)) |
(1 << (CParser
.T__71
- 64)) |
(1 << (CParser
.T__72
- 64)) |
(1 << (CParser
.T__73
- 64)) |
(1 << (CParser
.T__74
- 64)) |
(1 << (CParser
.T__75
- 64)) |
(1 << (CParser
.T__76
- 64)) |
(1 << (CParser
.T__77
- 64)) |
(1 << (CParser
.T__78
- 64)) |
(1 << (CParser
.T__79
- 64)) |
(1 << (CParser
.T__80
- 64)) |
(1 << (CParser
.T__81
- 64)) |
(1 << (CParser
.T__82
- 64)) |
(1 << (CParser
.T__83
- 64)) |
(1 << (CParser
.T__84
- 64)) |
(1 << (CParser
.T__85
- 64)) |
(1 << (CParser
.T__86
- 64)) |
(1 << (CParser
.T__87
- 64)) |
(1 << (CParser
.T__88
- 64)) |
(1 << (CParser
.T__89
- 64)) |
(1 << (CParser
.T__90
- 64)) |
(1 << (CParser
.T__91
- 64)) |
(1 << (CParser
.IDENTIFIER
- 64)) |
(1 << (CParser
.CHARACTER_LITERAL
- 64)) |
(1 << (CParser
.STRING_LITERAL
- 64)) |
(1 << (CParser
.HEX_LITERAL
- 64)) |
(1 << (CParser
.DECIMAL_LITERAL
- 64)) |
(1 << (CParser
.OCTAL_LITERAL
- 64)) |
(1 << (CParser
.FLOATING_POINT_LITERAL
- 64)) |
(1 << (CParser
.WS
- 64)) |
(1 << (CParser
.BS
- 64)) |
(1 << (CParser
.UnicodeVocabulary
- 64)) |
(1 << (CParser
.COMMENT
- 64)) |
(1 << (CParser
.LINE_COMMENT
- 64)) |
(1 << (CParser
.LINE_COMMAND
- 64)))) != 0):
5614 _la
= self
._input
.LA(1)
5615 if _la
<= 0 or _la
==CParser
.T__19
:
5616 self
._errHandler
.recoverInline(self
)
5618 self
._errHandler
.reportMatch(self
)
5621 self
._errHandler
.sync(self
)
5622 _la
= self
._input
.LA(1)
5625 self
.match(CParser
.T__19
)
5626 except RecognitionException
as re
:
5627 localctx
.exception
= re
5628 self
._errHandler
.reportError(self
, re
)
5629 self
._errHandler
.recover(self
, re
)
5634 class Macro_statementContext(ParserRuleContext
):
5636 # @param parent=None Type: ParserRuleContext
5637 # @param invokingState=-1 Type: int
5638 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5639 super().__init
__(parent
, invokingState
)
5640 self
.parser
= parser
5642 def IDENTIFIER(self
):
5643 return self
.getToken(CParser
.IDENTIFIER
, 0)
5645 # @param i=None Type: int
5646 def declaration(self
,i
=None):
5648 return self
.getTypedRuleContexts(CParser
.DeclarationContext
)
5650 return self
.getTypedRuleContext(CParser
.DeclarationContext
,i
)
5653 def statement_list(self
):
5654 return self
.getTypedRuleContext(CParser
.Statement_listContext
,0)
5657 def expression(self
):
5658 return self
.getTypedRuleContext(CParser
.ExpressionContext
,0)
5661 def getRuleIndex(self
):
5662 return CParser
.RULE_macro_statement
5664 # @param listener Type: ParseTreeListener
5665 def enterRule(self
,listener
):
5666 if hasattr( listener
, "enterMacro_statement" ):
5667 listener
.enterMacro_statement(self
)
5669 # @param listener Type: ParseTreeListener
5670 def exitRule(self
,listener
):
5671 if hasattr( listener
, "exitMacro_statement" ):
5672 listener
.exitMacro_statement(self
)
5677 def macro_statement(self
):
5679 localctx
= CParser
.Macro_statementContext(self
, self
._ctx
, self
.state
)
5680 self
.enterRule(localctx
, 126, self
.RULE_macro_statement
)
5681 self
._la
= 0 # Token type
5683 self
.enterOuterAlt(localctx
, 1)
5685 self
.match(CParser
.IDENTIFIER
)
5687 self
.match(CParser
.T__37
)
5689 self
._errHandler
.sync(self
)
5690 _alt
= self
._interp
.adaptivePredict(self
._input
,97,self
._ctx
)
5691 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
5696 self
._errHandler
.sync(self
)
5697 _alt
= self
._interp
.adaptivePredict(self
._input
,97,self
._ctx
)
5700 self
._errHandler
.sync(self
)
5701 la_
= self
._interp
.adaptivePredict(self
._input
,98,self
._ctx
)
5704 self
.statement_list()
5708 self
._errHandler
.sync(self
)
5709 _la
= self
._input
.LA(1)
5710 if ((((_la
- 38)) & ~
0x3f) == 0 and ((1 << (_la
- 38)) & ((1 << (CParser
.T__37
- 38)) |
(1 << (CParser
.T__41
- 38)) |
(1 << (CParser
.T__43
- 38)) |
(1 << (CParser
.T__44
- 38)) |
(1 << (CParser
.T__47
- 38)) |
(1 << (CParser
.T__48
- 38)) |
(1 << (CParser
.T__49
- 38)) |
(1 << (CParser
.T__52
- 38)) |
(1 << (CParser
.T__53
- 38)) |
(1 << (CParser
.T__54
- 38)) |
(1 << (CParser
.IDENTIFIER
- 38)) |
(1 << (CParser
.CHARACTER_LITERAL
- 38)) |
(1 << (CParser
.STRING_LITERAL
- 38)) |
(1 << (CParser
.HEX_LITERAL
- 38)) |
(1 << (CParser
.DECIMAL_LITERAL
- 38)) |
(1 << (CParser
.OCTAL_LITERAL
- 38)) |
(1 << (CParser
.FLOATING_POINT_LITERAL
- 38)))) != 0):
5716 self
.match(CParser
.T__38
)
5717 except RecognitionException
as re
:
5718 localctx
.exception
= re
5719 self
._errHandler
.reportError(self
, re
)
5720 self
._errHandler
.recover(self
, re
)
5725 class Labeled_statementContext(ParserRuleContext
):
5727 # @param parent=None Type: ParserRuleContext
5728 # @param invokingState=-1 Type: int
5729 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5730 super().__init
__(parent
, invokingState
)
5731 self
.parser
= parser
5733 def IDENTIFIER(self
):
5734 return self
.getToken(CParser
.IDENTIFIER
, 0)
5736 def statement(self
):
5737 return self
.getTypedRuleContext(CParser
.StatementContext
,0)
5740 def constant_expression(self
):
5741 return self
.getTypedRuleContext(CParser
.Constant_expressionContext
,0)
5744 def getRuleIndex(self
):
5745 return CParser
.RULE_labeled_statement
5747 # @param listener Type: ParseTreeListener
5748 def enterRule(self
,listener
):
5749 if hasattr( listener
, "enterLabeled_statement" ):
5750 listener
.enterLabeled_statement(self
)
5752 # @param listener Type: ParseTreeListener
5753 def exitRule(self
,listener
):
5754 if hasattr( listener
, "exitLabeled_statement" ):
5755 listener
.exitLabeled_statement(self
)
5760 def labeled_statement(self
):
5762 localctx
= CParser
.Labeled_statementContext(self
, self
._ctx
, self
.state
)
5763 self
.enterRule(localctx
, 128, self
.RULE_labeled_statement
)
5766 self
._errHandler
.sync(self
)
5767 token
= self
._input
.LA(1)
5768 if token
in [CParser
.IDENTIFIER
]:
5769 self
.enterOuterAlt(localctx
, 1)
5771 self
.match(CParser
.IDENTIFIER
)
5773 self
.match(CParser
.T__22
)
5777 elif token
in [CParser
.T__81
]:
5778 self
.enterOuterAlt(localctx
, 2)
5780 self
.match(CParser
.T__81
)
5782 self
.constant_expression()
5784 self
.match(CParser
.T__22
)
5788 elif token
in [CParser
.T__82
]:
5789 self
.enterOuterAlt(localctx
, 3)
5791 self
.match(CParser
.T__82
)
5793 self
.match(CParser
.T__22
)
5798 raise NoViableAltException(self
)
5800 except RecognitionException
as re
:
5801 localctx
.exception
= re
5802 self
._errHandler
.reportError(self
, re
)
5803 self
._errHandler
.recover(self
, re
)
5808 class Compound_statementContext(ParserRuleContext
):
5810 # @param parent=None Type: ParserRuleContext
5811 # @param invokingState=-1 Type: int
5812 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5813 super().__init
__(parent
, invokingState
)
5814 self
.parser
= parser
5816 # @param i=None Type: int
5817 def declaration(self
,i
=None):
5819 return self
.getTypedRuleContexts(CParser
.DeclarationContext
)
5821 return self
.getTypedRuleContext(CParser
.DeclarationContext
,i
)
5824 def statement_list(self
):
5825 return self
.getTypedRuleContext(CParser
.Statement_listContext
,0)
5828 def getRuleIndex(self
):
5829 return CParser
.RULE_compound_statement
5831 # @param listener Type: ParseTreeListener
5832 def enterRule(self
,listener
):
5833 if hasattr( listener
, "enterCompound_statement" ):
5834 listener
.enterCompound_statement(self
)
5836 # @param listener Type: ParseTreeListener
5837 def exitRule(self
,listener
):
5838 if hasattr( listener
, "exitCompound_statement" ):
5839 listener
.exitCompound_statement(self
)
5844 def compound_statement(self
):
5846 localctx
= CParser
.Compound_statementContext(self
, self
._ctx
, self
.state
)
5847 self
.enterRule(localctx
, 130, self
.RULE_compound_statement
)
5848 self
._la
= 0 # Token type
5850 self
.enterOuterAlt(localctx
, 1)
5852 self
.match(CParser
.T__0
)
5854 self
._errHandler
.sync(self
)
5855 _alt
= self
._interp
.adaptivePredict(self
._input
,101,self
._ctx
)
5856 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
5861 self
._errHandler
.sync(self
)
5862 _alt
= self
._interp
.adaptivePredict(self
._input
,101,self
._ctx
)
5865 self
._errHandler
.sync(self
)
5866 _la
= self
._input
.LA(1)
5867 if (((_la
) & ~
0x3f) == 0 and ((1 << _la
) & ((1 << CParser
.T__0
) |
(1 << CParser
.T__1
) |
(1 << CParser
.T__2
) |
(1 << CParser
.T__5
) |
(1 << CParser
.T__6
) |
(1 << CParser
.T__7
) |
(1 << CParser
.T__8
) |
(1 << CParser
.T__9
) |
(1 << CParser
.T__10
) |
(1 << CParser
.T__11
) |
(1 << CParser
.T__12
) |
(1 << CParser
.T__13
) |
(1 << CParser
.T__14
) |
(1 << CParser
.T__15
) |
(1 << CParser
.T__16
) |
(1 << CParser
.T__17
) |
(1 << CParser
.T__18
) |
(1 << CParser
.T__20
) |
(1 << CParser
.T__21
) |
(1 << CParser
.T__23
) |
(1 << CParser
.T__24
) |
(1 << CParser
.T__25
) |
(1 << CParser
.T__26
) |
(1 << CParser
.T__27
) |
(1 << CParser
.T__28
) |
(1 << CParser
.T__29
) |
(1 << CParser
.T__30
) |
(1 << CParser
.T__31
) |
(1 << CParser
.T__32
) |
(1 << CParser
.T__33
) |
(1 << CParser
.T__34
) |
(1 << CParser
.T__35
) |
(1 << CParser
.T__36
) |
(1 << CParser
.T__37
) |
(1 << CParser
.T__41
) |
(1 << CParser
.T__43
) |
(1 << CParser
.T__44
) |
(1 << CParser
.T__47
) |
(1 << CParser
.T__48
) |
(1 << CParser
.T__49
) |
(1 << CParser
.T__52
) |
(1 << CParser
.T__53
) |
(1 << CParser
.T__54
))) != 0) or ((((_la
- 79)) & ~
0x3f) == 0 and ((1 << (_la
- 79)) & ((1 << (CParser
.T__78
- 79)) |
(1 << (CParser
.T__79
- 79)) |
(1 << (CParser
.T__80
- 79)) |
(1 << (CParser
.T__81
- 79)) |
(1 << (CParser
.T__82
- 79)) |
(1 << (CParser
.T__83
- 79)) |
(1 << (CParser
.T__85
- 79)) |
(1 << (CParser
.T__86
- 79)) |
(1 << (CParser
.T__87
- 79)) |
(1 << (CParser
.T__88
- 79)) |
(1 << (CParser
.T__89
- 79)) |
(1 << (CParser
.T__90
- 79)) |
(1 << (CParser
.T__91
- 79)) |
(1 << (CParser
.IDENTIFIER
- 79)) |
(1 << (CParser
.CHARACTER_LITERAL
- 79)) |
(1 << (CParser
.STRING_LITERAL
- 79)) |
(1 << (CParser
.HEX_LITERAL
- 79)) |
(1 << (CParser
.DECIMAL_LITERAL
- 79)) |
(1 << (CParser
.OCTAL_LITERAL
- 79)) |
(1 << (CParser
.FLOATING_POINT_LITERAL
- 79)))) != 0):
5869 self
.statement_list()
5873 self
.match(CParser
.T__19
)
5874 except RecognitionException
as re
:
5875 localctx
.exception
= re
5876 self
._errHandler
.reportError(self
, re
)
5877 self
._errHandler
.recover(self
, re
)
5882 class Statement_listContext(ParserRuleContext
):
5884 # @param parent=None Type: ParserRuleContext
5885 # @param invokingState=-1 Type: int
5886 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5887 super().__init
__(parent
, invokingState
)
5888 self
.parser
= parser
5890 # @param i=None Type: int
5891 def statement(self
,i
=None):
5893 return self
.getTypedRuleContexts(CParser
.StatementContext
)
5895 return self
.getTypedRuleContext(CParser
.StatementContext
,i
)
5898 def getRuleIndex(self
):
5899 return CParser
.RULE_statement_list
5901 # @param listener Type: ParseTreeListener
5902 def enterRule(self
,listener
):
5903 if hasattr( listener
, "enterStatement_list" ):
5904 listener
.enterStatement_list(self
)
5906 # @param listener Type: ParseTreeListener
5907 def exitRule(self
,listener
):
5908 if hasattr( listener
, "exitStatement_list" ):
5909 listener
.exitStatement_list(self
)
5914 def statement_list(self
):
5916 localctx
= CParser
.Statement_listContext(self
, self
._ctx
, self
.state
)
5917 self
.enterRule(localctx
, 132, self
.RULE_statement_list
)
5919 self
.enterOuterAlt(localctx
, 1)
5921 self
._errHandler
.sync(self
)
5923 while _alt
!=2 and _alt
!=ATN
.INVALID_ALT_NUMBER
:
5929 raise NoViableAltException(self
)
5931 self
._errHandler
.sync(self
)
5932 _alt
= self
._interp
.adaptivePredict(self
._input
,103,self
._ctx
)
5934 except RecognitionException
as re
:
5935 localctx
.exception
= re
5936 self
._errHandler
.reportError(self
, re
)
5937 self
._errHandler
.recover(self
, re
)
5942 class Expression_statementContext(ParserRuleContext
):
5944 # @param parent=None Type: ParserRuleContext
5945 # @param invokingState=-1 Type: int
5946 def __init__(self
,parser
,parent
=None,invokingState
=-1):
5947 super().__init
__(parent
, invokingState
)
5948 self
.parser
= parser
5950 def expression(self
):
5951 return self
.getTypedRuleContext(CParser
.ExpressionContext
,0)
5954 def getRuleIndex(self
):
5955 return CParser
.RULE_expression_statement
5957 # @param listener Type: ParseTreeListener
5958 def enterRule(self
,listener
):
5959 if hasattr( listener
, "enterExpression_statement" ):
5960 listener
.enterExpression_statement(self
)
5962 # @param listener Type: ParseTreeListener
5963 def exitRule(self
,listener
):
5964 if hasattr( listener
, "exitExpression_statement" ):
5965 listener
.exitExpression_statement(self
)
5970 def expression_statement(self
):
5972 localctx
= CParser
.Expression_statementContext(self
, self
._ctx
, self
.state
)
5973 self
.enterRule(localctx
, 134, self
.RULE_expression_statement
)
5976 self
._errHandler
.sync(self
)
5977 token
= self
._input
.LA(1)
5978 if token
in [CParser
.T__1
]:
5979 self
.enterOuterAlt(localctx
, 1)
5981 self
.match(CParser
.T__1
)
5983 elif token
in [CParser
.T__37
, CParser
.T__41
, CParser
.T__43
, CParser
.T__44
, CParser
.T__47
, CParser
.T__48
, CParser
.T__49
, CParser
.T__52
, CParser
.T__53
, CParser
.T__54
, CParser
.IDENTIFIER
, CParser
.CHARACTER_LITERAL
, CParser
.STRING_LITERAL
, CParser
.HEX_LITERAL
, CParser
.DECIMAL_LITERAL
, CParser
.OCTAL_LITERAL
, CParser
.FLOATING_POINT_LITERAL
]:
5984 self
.enterOuterAlt(localctx
, 2)
5988 self
.match(CParser
.T__1
)
5991 raise NoViableAltException(self
)
5993 except RecognitionException
as re
:
5994 localctx
.exception
= re
5995 self
._errHandler
.reportError(self
, re
)
5996 self
._errHandler
.recover(self
, re
)
6001 class Selection_statementContext(ParserRuleContext
):
6003 # @param parent=None Type: ParserRuleContext
6004 # @param invokingState=-1 Type: int
6005 def __init__(self
,parser
,parent
=None,invokingState
=-1):
6006 super().__init
__(parent
, invokingState
)
6007 self
.parser
= parser
6008 self
.e
= None # ExpressionContext
6010 # @param i=None Type: int
6011 def statement(self
,i
=None):
6013 return self
.getTypedRuleContexts(CParser
.StatementContext
)
6015 return self
.getTypedRuleContext(CParser
.StatementContext
,i
)
6018 def expression(self
):
6019 return self
.getTypedRuleContext(CParser
.ExpressionContext
,0)
6022 def getRuleIndex(self
):
6023 return CParser
.RULE_selection_statement
6025 # @param listener Type: ParseTreeListener
6026 def enterRule(self
,listener
):
6027 if hasattr( listener
, "enterSelection_statement" ):
6028 listener
.enterSelection_statement(self
)
6030 # @param listener Type: ParseTreeListener
6031 def exitRule(self
,listener
):
6032 if hasattr( listener
, "exitSelection_statement" ):
6033 listener
.exitSelection_statement(self
)
6038 def selection_statement(self
):
6040 localctx
= CParser
.Selection_statementContext(self
, self
._ctx
, self
.state
)
6041 self
.enterRule(localctx
, 136, self
.RULE_selection_statement
)
6044 self
._errHandler
.sync(self
)
6045 token
= self
._input
.LA(1)
6046 if token
in [CParser
.T__83
]:
6047 self
.enterOuterAlt(localctx
, 1)
6049 self
.match(CParser
.T__83
)
6051 self
.match(CParser
.T__37
)
6053 localctx
.e
= self
.expression()
6055 self
.match(CParser
.T__38
)
6056 self
.StorePredicateExpression((None if localctx
.e
is None else localctx
.e
.start
).line
, (None if localctx
.e
is None else localctx
.e
.start
).column
, (None if localctx
.e
is None else localctx
.e
.stop
).line
, (None if localctx
.e
is None else localctx
.e
.stop
).column
, (None if localctx
.e
is None else self
._input
.getText((localctx
.e
.start
,localctx
.e
.stop
))))
6060 self
._errHandler
.sync(self
)
6061 la_
= self
._interp
.adaptivePredict(self
._input
,105,self
._ctx
)
6064 self
.match(CParser
.T__84
)
6070 elif token
in [CParser
.T__85
]:
6071 self
.enterOuterAlt(localctx
, 2)
6073 self
.match(CParser
.T__85
)
6075 self
.match(CParser
.T__37
)
6079 self
.match(CParser
.T__38
)
6084 raise NoViableAltException(self
)
6086 except RecognitionException
as re
:
6087 localctx
.exception
= re
6088 self
._errHandler
.reportError(self
, re
)
6089 self
._errHandler
.recover(self
, re
)
6094 class Iteration_statementContext(ParserRuleContext
):
6096 # @param parent=None Type: ParserRuleContext
6097 # @param invokingState=-1 Type: int
6098 def __init__(self
,parser
,parent
=None,invokingState
=-1):
6099 super().__init
__(parent
, invokingState
)
6100 self
.parser
= parser
6101 self
.e
= None # ExpressionContext
6103 def statement(self
):
6104 return self
.getTypedRuleContext(CParser
.StatementContext
,0)
6107 def expression(self
):
6108 return self
.getTypedRuleContext(CParser
.ExpressionContext
,0)
6111 def getRuleIndex(self
):
6112 return CParser
.RULE_iteration_statement
6114 # @param listener Type: ParseTreeListener
6115 def enterRule(self
,listener
):
6116 if hasattr( listener
, "enterIteration_statement" ):
6117 listener
.enterIteration_statement(self
)
6119 # @param listener Type: ParseTreeListener
6120 def exitRule(self
,listener
):
6121 if hasattr( listener
, "exitIteration_statement" ):
6122 listener
.exitIteration_statement(self
)
6127 def iteration_statement(self
):
6129 localctx
= CParser
.Iteration_statementContext(self
, self
._ctx
, self
.state
)
6130 self
.enterRule(localctx
, 138, self
.RULE_iteration_statement
)
6133 self
._errHandler
.sync(self
)
6134 token
= self
._input
.LA(1)
6135 if token
in [CParser
.T__86
]:
6136 self
.enterOuterAlt(localctx
, 1)
6138 self
.match(CParser
.T__86
)
6140 self
.match(CParser
.T__37
)
6142 localctx
.e
= self
.expression()
6144 self
.match(CParser
.T__38
)
6147 self
.StorePredicateExpression((None if localctx
.e
is None else localctx
.e
.start
).line
, (None if localctx
.e
is None else localctx
.e
.start
).column
, (None if localctx
.e
is None else localctx
.e
.stop
).line
, (None if localctx
.e
is None else localctx
.e
.stop
).column
, (None if localctx
.e
is None else self
._input
.getText((localctx
.e
.start
,localctx
.e
.stop
))))
6149 elif token
in [CParser
.T__87
]:
6150 self
.enterOuterAlt(localctx
, 2)
6152 self
.match(CParser
.T__87
)
6156 self
.match(CParser
.T__86
)
6158 self
.match(CParser
.T__37
)
6160 localctx
.e
= self
.expression()
6162 self
.match(CParser
.T__38
)
6164 self
.match(CParser
.T__1
)
6165 self
.StorePredicateExpression((None if localctx
.e
is None else localctx
.e
.start
).line
, (None if localctx
.e
is None else localctx
.e
.start
).column
, (None if localctx
.e
is None else localctx
.e
.stop
).line
, (None if localctx
.e
is None else localctx
.e
.stop
).column
, (None if localctx
.e
is None else self
._input
.getText((localctx
.e
.start
,localctx
.e
.stop
))))
6168 raise NoViableAltException(self
)
6170 except RecognitionException
as re
:
6171 localctx
.exception
= re
6172 self
._errHandler
.reportError(self
, re
)
6173 self
._errHandler
.recover(self
, re
)
6178 class Jump_statementContext(ParserRuleContext
):
6180 # @param parent=None Type: ParserRuleContext
6181 # @param invokingState=-1 Type: int
6182 def __init__(self
,parser
,parent
=None,invokingState
=-1):
6183 super().__init
__(parent
, invokingState
)
6184 self
.parser
= parser
6186 def IDENTIFIER(self
):
6187 return self
.getToken(CParser
.IDENTIFIER
, 0)
6189 def expression(self
):
6190 return self
.getTypedRuleContext(CParser
.ExpressionContext
,0)
6193 def getRuleIndex(self
):
6194 return CParser
.RULE_jump_statement
6196 # @param listener Type: ParseTreeListener
6197 def enterRule(self
,listener
):
6198 if hasattr( listener
, "enterJump_statement" ):
6199 listener
.enterJump_statement(self
)
6201 # @param listener Type: ParseTreeListener
6202 def exitRule(self
,listener
):
6203 if hasattr( listener
, "exitJump_statement" ):
6204 listener
.exitJump_statement(self
)
6209 def jump_statement(self
):
6211 localctx
= CParser
.Jump_statementContext(self
, self
._ctx
, self
.state
)
6212 self
.enterRule(localctx
, 140, self
.RULE_jump_statement
)
6215 self
._errHandler
.sync(self
)
6216 la_
= self
._interp
.adaptivePredict(self
._input
,108,self
._ctx
)
6218 self
.enterOuterAlt(localctx
, 1)
6220 self
.match(CParser
.T__88
)
6222 self
.match(CParser
.IDENTIFIER
)
6224 self
.match(CParser
.T__1
)
6228 self
.enterOuterAlt(localctx
, 2)
6230 self
.match(CParser
.T__89
)
6232 self
.match(CParser
.T__1
)
6236 self
.enterOuterAlt(localctx
, 3)
6238 self
.match(CParser
.T__90
)
6240 self
.match(CParser
.T__1
)
6244 self
.enterOuterAlt(localctx
, 4)
6246 self
.match(CParser
.T__91
)
6248 self
.match(CParser
.T__1
)
6252 self
.enterOuterAlt(localctx
, 5)
6254 self
.match(CParser
.T__91
)
6258 self
.match(CParser
.T__1
)
6262 except RecognitionException
as re
:
6263 localctx
.exception
= re
6264 self
._errHandler
.reportError(self
, re
)
6265 self
._errHandler
.recover(self
, re
)