1# Generated from C.g4 by ANTLR 4.7.1 2# encoding: utf-8 3from antlr4 import * 4from io import StringIO 5from typing.io import TextIO 6import sys 7 8 9## @file 10# The file defines the parser for C source files. 11# 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 15# 16# Copyright (c) 2009 - 2010, Intel Corporation All rights reserved. 17# 18# SPDX-License-Identifier: BSD-2-Clause-Patent 19# 20## 21 22import Ecc.CodeFragment as CodeFragment 23import Ecc.FileProfile as FileProfile 24 25def serializedATN(): 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() 476 477 478class CParser ( Parser ): 479 480 grammarFileName = "C.g4" 481 482 atn = ATNDeserializer().deserialize(serializedATN()) 483 484 decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] 485 486 sharedContextCache = PredictionContextCache() 487 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'" ] 505 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" ] 533 534 RULE_translation_unit = 0 535 RULE_external_declaration = 1 536 RULE_function_definition = 2 537 RULE_declaration_specifiers = 3 538 RULE_declaration = 4 539 RULE_init_declarator_list = 5 540 RULE_init_declarator = 6 541 RULE_storage_class_specifier = 7 542 RULE_type_specifier = 8 543 RULE_type_id = 9 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 553 RULE_enumerator = 19 554 RULE_type_qualifier = 20 555 RULE_declarator = 21 556 RULE_direct_declarator = 22 557 RULE_declarator_suffix = 23 558 RULE_pointer = 24 559 RULE_parameter_type_list = 25 560 RULE_parameter_list = 26 561 RULE_parameter_declaration = 27 562 RULE_identifier_list = 28 563 RULE_type_name = 29 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 578 RULE_constant = 44 579 RULE_expression = 45 580 RULE_constant_expression = 46 581 RULE_assignment_expression = 47 582 RULE_lvalue = 48 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 593 RULE_statement = 59 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 605 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" ] 630 631 EOF = Token.EOF 632 T__0=1 633 T__1=2 634 T__2=3 635 T__3=4 636 T__4=5 637 T__5=6 638 T__6=7 639 T__7=8 640 T__8=9 641 T__9=10 642 T__10=11 643 T__11=12 644 T__12=13 645 T__13=14 646 T__14=15 647 T__15=16 648 T__16=17 649 T__17=18 650 T__18=19 651 T__19=20 652 T__20=21 653 T__21=22 654 T__22=23 655 T__23=24 656 T__24=25 657 T__25=26 658 T__26=27 659 T__27=28 660 T__28=29 661 T__29=30 662 T__30=31 663 T__31=32 664 T__32=33 665 T__33=34 666 T__34=35 667 T__35=36 668 T__36=37 669 T__37=38 670 T__38=39 671 T__39=40 672 T__40=41 673 T__41=42 674 T__42=43 675 T__43=44 676 T__44=45 677 T__45=46 678 T__46=47 679 T__47=48 680 T__48=49 681 T__49=50 682 T__50=51 683 T__51=52 684 T__52=53 685 T__53=54 686 T__54=55 687 T__55=56 688 T__56=57 689 T__57=58 690 T__58=59 691 T__59=60 692 T__60=61 693 T__61=62 694 T__62=63 695 T__63=64 696 T__64=65 697 T__65=66 698 T__66=67 699 T__67=68 700 T__68=69 701 T__69=70 702 T__70=71 703 T__71=72 704 T__72=73 705 T__73=74 706 T__74=75 707 T__75=76 708 T__76=77 709 T__77=78 710 T__78=79 711 T__79=80 712 T__80=81 713 T__81=82 714 T__82=83 715 T__83=84 716 T__84=85 717 T__85=86 718 T__86=87 719 T__87=88 720 T__88=89 721 T__89=90 722 T__90=91 723 T__91=92 724 IDENTIFIER=93 725 CHARACTER_LITERAL=94 726 STRING_LITERAL=95 727 HEX_LITERAL=96 728 DECIMAL_LITERAL=97 729 OCTAL_LITERAL=98 730 FLOATING_POINT_LITERAL=99 731 WS=100 732 BS=101 733 UnicodeVocabulary=102 734 COMMENT=103 735 LINE_COMMENT=104 736 LINE_COMMAND=105 737 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 745 746 747 748 749 def printTokenInfo(self,line,offset,tokenText): 750 print(str(line)+ ',' + str(offset) + ':' + str(tokenText)) 751 752 def StorePredicateExpression(self,StartLine,StartOffset,EndLine,EndOffset,Text): 753 PredExp = CodeFragment.PredicateExpression(Text, (StartLine, StartOffset), (EndLine, EndOffset)) 754 FileProfile.PredicateExpressionList.append(PredExp) 755 756 def StoreEnumerationDefinition(self,StartLine,StartOffset,EndLine,EndOffset,Text): 757 EnumDef = CodeFragment.EnumerationDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset)) 758 FileProfile.EnumerationDefinitionList.append(EnumDef) 759 760 def StoreStructUnionDefinition(self,StartLine,StartOffset,EndLine,EndOffset,Text): 761 SUDef = CodeFragment.StructUnionDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset)) 762 FileProfile.StructUnionDefinitionList.append(SUDef) 763 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) 767 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) 771 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) 775 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) 779 780 781 782 class Translation_unitContext(ParserRuleContext): 783 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) 788 self.parser = parser 789 790 # @param i=None Type: int 791 def external_declaration(self,i=None): 792 if i is None: 793 return self.getTypedRuleContexts(CParser.External_declarationContext) 794 else: 795 return self.getTypedRuleContext(CParser.External_declarationContext,i) 796 797 798 def getRuleIndex(self): 799 return CParser.RULE_translation_unit 800 801 # @param listener Type: ParseTreeListener 802 def enterRule(self,listener): 803 if hasattr( listener, "enterTranslation_unit" ): 804 listener.enterTranslation_unit(self) 805 806 # @param listener Type: ParseTreeListener 807 def exitRule(self,listener): 808 if hasattr( listener, "exitTranslation_unit" ): 809 listener.exitTranslation_unit(self) 810 811 812 813 814 def translation_unit(self): 815 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 819 try: 820 self.enterOuterAlt(localctx, 1) 821 self.state = 145 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: 825 self.state = 142 826 self.external_declaration() 827 self.state = 147 828 self._errHandler.sync(self) 829 _la = self._input.LA(1) 830 831 except RecognitionException as re: 832 localctx.exception = re 833 self._errHandler.reportError(self, re) 834 self._errHandler.recover(self, re) 835 finally: 836 self.exitRule() 837 return localctx 838 839 class External_declarationContext(ParserRuleContext): 840 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) 845 self.parser = parser 846 847 def declarator(self): 848 return self.getTypedRuleContext(CParser.DeclaratorContext,0) 849 850 851 def declaration_specifiers(self): 852 return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0) 853 854 855 # @param i=None Type: int 856 def declaration(self,i=None): 857 if i is None: 858 return self.getTypedRuleContexts(CParser.DeclarationContext) 859 else: 860 return self.getTypedRuleContext(CParser.DeclarationContext,i) 861 862 863 def function_definition(self): 864 return self.getTypedRuleContext(CParser.Function_definitionContext,0) 865 866 867 def macro_statement(self): 868 return self.getTypedRuleContext(CParser.Macro_statementContext,0) 869 870 871 def getRuleIndex(self): 872 return CParser.RULE_external_declaration 873 874 # @param listener Type: ParseTreeListener 875 def enterRule(self,listener): 876 if hasattr( listener, "enterExternal_declaration" ): 877 listener.enterExternal_declaration(self) 878 879 # @param listener Type: ParseTreeListener 880 def exitRule(self,listener): 881 if hasattr( listener, "exitExternal_declaration" ): 882 listener.exitExternal_declaration(self) 883 884 885 886 887 def external_declaration(self): 888 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 892 try: 893 self.state = 166 894 self._errHandler.sync(self) 895 la_ = self._interp.adaptivePredict(self._input,4,self._ctx) 896 if la_ == 1: 897 self.enterOuterAlt(localctx, 1) 898 self.state = 149 899 self._errHandler.sync(self) 900 la_ = self._interp.adaptivePredict(self._input,1,self._ctx) 901 if la_ == 1: 902 self.state = 148 903 self.declaration_specifiers() 904 905 906 self.state = 151 907 self.declarator() 908 self.state = 155 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: 912 self.state = 152 913 self.declaration() 914 self.state = 157 915 self._errHandler.sync(self) 916 _la = self._input.LA(1) 917 918 self.state = 158 919 self.match(CParser.T__0) 920 pass 921 922 elif la_ == 2: 923 self.enterOuterAlt(localctx, 2) 924 self.state = 160 925 self.function_definition() 926 pass 927 928 elif la_ == 3: 929 self.enterOuterAlt(localctx, 3) 930 self.state = 161 931 self.declaration() 932 pass 933 934 elif la_ == 4: 935 self.enterOuterAlt(localctx, 4) 936 self.state = 162 937 self.macro_statement() 938 self.state = 164 939 self._errHandler.sync(self) 940 _la = self._input.LA(1) 941 if _la==CParser.T__1: 942 self.state = 163 943 self.match(CParser.T__1) 944 945 946 pass 947 948 949 except RecognitionException as re: 950 localctx.exception = re 951 self._errHandler.reportError(self, re) 952 self._errHandler.recover(self, re) 953 finally: 954 self.exitRule() 955 return localctx 956 957 class Function_definitionContext(ParserRuleContext): 958 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) 963 self.parser = parser 964 self.ModifierText = '' 965 self.DeclText = '' 966 self.LBLine = 0 967 self.LBOffset = 0 968 self.DeclLine = 0 969 self.DeclOffset = 0 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 975 976 def declarator(self): 977 return self.getTypedRuleContext(CParser.DeclaratorContext,0) 978 979 980 def compound_statement(self): 981 return self.getTypedRuleContext(CParser.Compound_statementContext,0) 982 983 984 def declaration_specifiers(self): 985 return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0) 986 987 988 # @param i=None Type: int 989 def declaration(self,i=None): 990 if i is None: 991 return self.getTypedRuleContexts(CParser.DeclarationContext) 992 else: 993 return self.getTypedRuleContext(CParser.DeclarationContext,i) 994 995 996 def getRuleIndex(self): 997 return CParser.RULE_function_definition 998 999 # @param listener Type: ParseTreeListener 1000 def enterRule(self,listener): 1001 if hasattr( listener, "enterFunction_definition" ): 1002 listener.enterFunction_definition(self) 1003 1004 # @param listener Type: ParseTreeListener 1005 def exitRule(self,listener): 1006 if hasattr( listener, "exitFunction_definition" ): 1007 listener.exitFunction_definition(self) 1008 1009 1010 1011 1012 def function_definition(self): 1013 1014 localctx = CParser.Function_definitionContext(self, self._ctx, self.state) 1015 self.enterRule(localctx, 4, self.RULE_function_definition) 1016 1017 ModifierText = ''; 1018 DeclText = ''; 1019 LBLine = 0; 1020 LBOffset = 0; 1021 DeclLine = 0; 1022 DeclOffset = 0; 1023 1024 self._la = 0 # Token type 1025 try: 1026 self.enterOuterAlt(localctx, 1) 1027 self.state = 169 1028 self._errHandler.sync(self) 1029 la_ = self._interp.adaptivePredict(self._input,5,self._ctx) 1030 if la_ == 1: 1031 self.state = 168 1032 localctx.d = localctx._declaration_specifiers = self.declaration_specifiers() 1033 1034 1035 self.state = 171 1036 localctx._declarator = self.declarator() 1037 self.state = 180 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]: 1041 self.state = 173 1042 self._errHandler.sync(self) 1043 _la = self._input.LA(1) 1044 while True: 1045 self.state = 172 1046 self.declaration() 1047 self.state = 175 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): 1051 break 1052 1053 self.state = 177 1054 localctx.a = self.compound_statement() 1055 pass 1056 elif token in [CParser.T__0]: 1057 self.state = 179 1058 localctx.b = self.compound_statement() 1059 pass 1060 else: 1061 raise NoViableAltException(self) 1062 1063 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))) 1066 else: 1067 ModifierText = '' 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 1074 else: 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 1077 1078 self._ctx.stop = self._input.LT(-1) 1079 1080 self.StoreFunctionDefinition(localctx.start.line, localctx.start.column, localctx.stop.line, localctx.stop.column, ModifierText, DeclText, LBLine, LBOffset, DeclLine, DeclOffset) 1081 1082 except RecognitionException as re: 1083 localctx.exception = re 1084 self._errHandler.reportError(self, re) 1085 self._errHandler.recover(self, re) 1086 finally: 1087 self.exitRule() 1088 return localctx 1089 1090 class Declaration_specifiersContext(ParserRuleContext): 1091 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 1097 1098 # @param i=None Type: int 1099 def storage_class_specifier(self,i=None): 1100 if i is None: 1101 return self.getTypedRuleContexts(CParser.Storage_class_specifierContext) 1102 else: 1103 return self.getTypedRuleContext(CParser.Storage_class_specifierContext,i) 1104 1105 1106 # @param i=None Type: int 1107 def type_specifier(self,i=None): 1108 if i is None: 1109 return self.getTypedRuleContexts(CParser.Type_specifierContext) 1110 else: 1111 return self.getTypedRuleContext(CParser.Type_specifierContext,i) 1112 1113 1114 # @param i=None Type: int 1115 def type_qualifier(self,i=None): 1116 if i is None: 1117 return self.getTypedRuleContexts(CParser.Type_qualifierContext) 1118 else: 1119 return self.getTypedRuleContext(CParser.Type_qualifierContext,i) 1120 1121 1122 def getRuleIndex(self): 1123 return CParser.RULE_declaration_specifiers 1124 1125 # @param listener Type: ParseTreeListener 1126 def enterRule(self,listener): 1127 if hasattr( listener, "enterDeclaration_specifiers" ): 1128 listener.enterDeclaration_specifiers(self) 1129 1130 # @param listener Type: ParseTreeListener 1131 def exitRule(self,listener): 1132 if hasattr( listener, "exitDeclaration_specifiers" ): 1133 listener.exitDeclaration_specifiers(self) 1134 1135 1136 1137 1138 def declaration_specifiers(self): 1139 1140 localctx = CParser.Declaration_specifiersContext(self, self._ctx, self.state) 1141 self.enterRule(localctx, 6, self.RULE_declaration_specifiers) 1142 try: 1143 self.enterOuterAlt(localctx, 1) 1144 self.state = 187 1145 self._errHandler.sync(self) 1146 _alt = 1 1147 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 1148 if _alt == 1: 1149 self.state = 187 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]: 1153 self.state = 184 1154 self.storage_class_specifier() 1155 pass 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]: 1157 self.state = 185 1158 self.type_specifier() 1159 pass 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]: 1161 self.state = 186 1162 self.type_qualifier() 1163 pass 1164 else: 1165 raise NoViableAltException(self) 1166 1167 1168 else: 1169 raise NoViableAltException(self) 1170 self.state = 189 1171 self._errHandler.sync(self) 1172 _alt = self._interp.adaptivePredict(self._input,9,self._ctx) 1173 1174 except RecognitionException as re: 1175 localctx.exception = re 1176 self._errHandler.reportError(self, re) 1177 self._errHandler.recover(self, re) 1178 finally: 1179 self.exitRule() 1180 return localctx 1181 1182 class DeclarationContext(ParserRuleContext): 1183 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 1196 1197 def init_declarator_list(self): 1198 return self.getTypedRuleContext(CParser.Init_declarator_listContext,0) 1199 1200 1201 def declaration_specifiers(self): 1202 return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0) 1203 1204 1205 def getRuleIndex(self): 1206 return CParser.RULE_declaration 1207 1208 # @param listener Type: ParseTreeListener 1209 def enterRule(self,listener): 1210 if hasattr( listener, "enterDeclaration" ): 1211 listener.enterDeclaration(self) 1212 1213 # @param listener Type: ParseTreeListener 1214 def exitRule(self,listener): 1215 if hasattr( listener, "exitDeclaration" ): 1216 listener.exitDeclaration(self) 1217 1218 1219 1220 1221 def declaration(self): 1222 1223 localctx = CParser.DeclarationContext(self, self._ctx, self.state) 1224 self.enterRule(localctx, 8, self.RULE_declaration) 1225 self._la = 0 # Token type 1226 try: 1227 self.state = 206 1228 self._errHandler.sync(self) 1229 token = self._input.LA(1) 1230 if token in [CParser.T__2]: 1231 self.enterOuterAlt(localctx, 1) 1232 self.state = 191 1233 localctx.a = self.match(CParser.T__2) 1234 self.state = 193 1235 self._errHandler.sync(self) 1236 la_ = self._interp.adaptivePredict(self._input,10,self._ctx) 1237 if la_ == 1: 1238 self.state = 192 1239 localctx.b = self.declaration_specifiers() 1240 1241 1242 self.state = 195 1243 localctx.c = self.init_declarator_list() 1244 self.state = 196 1245 localctx.d = self.match(CParser.T__1) 1246 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)))) 1249 else: 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)))) 1251 1252 pass 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) 1255 self.state = 199 1256 localctx.s = self.declaration_specifiers() 1257 self.state = 201 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): 1261 self.state = 200 1262 localctx.t = self.init_declarator_list() 1263 1264 1265 self.state = 203 1266 localctx.e = self.match(CParser.T__1) 1267 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)))) 1270 1271 pass 1272 else: 1273 raise NoViableAltException(self) 1274 1275 except RecognitionException as re: 1276 localctx.exception = re 1277 self._errHandler.reportError(self, re) 1278 self._errHandler.recover(self, re) 1279 finally: 1280 self.exitRule() 1281 return localctx 1282 1283 class Init_declarator_listContext(ParserRuleContext): 1284 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 1290 1291 # @param i=None Type: int 1292 def init_declarator(self,i=None): 1293 if i is None: 1294 return self.getTypedRuleContexts(CParser.Init_declaratorContext) 1295 else: 1296 return self.getTypedRuleContext(CParser.Init_declaratorContext,i) 1297 1298 1299 def getRuleIndex(self): 1300 return CParser.RULE_init_declarator_list 1301 1302 # @param listener Type: ParseTreeListener 1303 def enterRule(self,listener): 1304 if hasattr( listener, "enterInit_declarator_list" ): 1305 listener.enterInit_declarator_list(self) 1306 1307 # @param listener Type: ParseTreeListener 1308 def exitRule(self,listener): 1309 if hasattr( listener, "exitInit_declarator_list" ): 1310 listener.exitInit_declarator_list(self) 1311 1312 1313 1314 1315 def init_declarator_list(self): 1316 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 1320 try: 1321 self.enterOuterAlt(localctx, 1) 1322 self.state = 208 1323 self.init_declarator() 1324 self.state = 213 1325 self._errHandler.sync(self) 1326 _la = self._input.LA(1) 1327 while _la==CParser.T__3: 1328 self.state = 209 1329 self.match(CParser.T__3) 1330 self.state = 210 1331 self.init_declarator() 1332 self.state = 215 1333 self._errHandler.sync(self) 1334 _la = self._input.LA(1) 1335 1336 except RecognitionException as re: 1337 localctx.exception = re 1338 self._errHandler.reportError(self, re) 1339 self._errHandler.recover(self, re) 1340 finally: 1341 self.exitRule() 1342 return localctx 1343 1344 class Init_declaratorContext(ParserRuleContext): 1345 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 1351 1352 def declarator(self): 1353 return self.getTypedRuleContext(CParser.DeclaratorContext,0) 1354 1355 1356 def initializer(self): 1357 return self.getTypedRuleContext(CParser.InitializerContext,0) 1358 1359 1360 def getRuleIndex(self): 1361 return CParser.RULE_init_declarator 1362 1363 # @param listener Type: ParseTreeListener 1364 def enterRule(self,listener): 1365 if hasattr( listener, "enterInit_declarator" ): 1366 listener.enterInit_declarator(self) 1367 1368 # @param listener Type: ParseTreeListener 1369 def exitRule(self,listener): 1370 if hasattr( listener, "exitInit_declarator" ): 1371 listener.exitInit_declarator(self) 1372 1373 1374 1375 1376 def init_declarator(self): 1377 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 1381 try: 1382 self.enterOuterAlt(localctx, 1) 1383 self.state = 216 1384 self.declarator() 1385 self.state = 219 1386 self._errHandler.sync(self) 1387 _la = self._input.LA(1) 1388 if _la==CParser.T__4: 1389 self.state = 217 1390 self.match(CParser.T__4) 1391 self.state = 218 1392 self.initializer() 1393 1394 1395 except RecognitionException as re: 1396 localctx.exception = re 1397 self._errHandler.reportError(self, re) 1398 self._errHandler.recover(self, re) 1399 finally: 1400 self.exitRule() 1401 return localctx 1402 1403 class Storage_class_specifierContext(ParserRuleContext): 1404 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 1410 1411 1412 def getRuleIndex(self): 1413 return CParser.RULE_storage_class_specifier 1414 1415 # @param listener Type: ParseTreeListener 1416 def enterRule(self,listener): 1417 if hasattr( listener, "enterStorage_class_specifier" ): 1418 listener.enterStorage_class_specifier(self) 1419 1420 # @param listener Type: ParseTreeListener 1421 def exitRule(self,listener): 1422 if hasattr( listener, "exitStorage_class_specifier" ): 1423 listener.exitStorage_class_specifier(self) 1424 1425 1426 1427 1428 def storage_class_specifier(self): 1429 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 1433 try: 1434 self.enterOuterAlt(localctx, 1) 1435 self.state = 221 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) 1439 else: 1440 self._errHandler.reportMatch(self) 1441 self.consume() 1442 except RecognitionException as re: 1443 localctx.exception = re 1444 self._errHandler.reportError(self, re) 1445 self._errHandler.recover(self, re) 1446 finally: 1447 self.exitRule() 1448 return localctx 1449 1450 class Type_specifierContext(ParserRuleContext): 1451 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 1459 1460 def struct_or_union_specifier(self): 1461 return self.getTypedRuleContext(CParser.Struct_or_union_specifierContext,0) 1462 1463 1464 def enum_specifier(self): 1465 return self.getTypedRuleContext(CParser.Enum_specifierContext,0) 1466 1467 1468 def IDENTIFIER(self): 1469 return self.getToken(CParser.IDENTIFIER, 0) 1470 1471 def declarator(self): 1472 return self.getTypedRuleContext(CParser.DeclaratorContext,0) 1473 1474 1475 # @param i=None Type: int 1476 def type_qualifier(self,i=None): 1477 if i is None: 1478 return self.getTypedRuleContexts(CParser.Type_qualifierContext) 1479 else: 1480 return self.getTypedRuleContext(CParser.Type_qualifierContext,i) 1481 1482 1483 def type_id(self): 1484 return self.getTypedRuleContext(CParser.Type_idContext,0) 1485 1486 1487 def getRuleIndex(self): 1488 return CParser.RULE_type_specifier 1489 1490 # @param listener Type: ParseTreeListener 1491 def enterRule(self,listener): 1492 if hasattr( listener, "enterType_specifier" ): 1493 listener.enterType_specifier(self) 1494 1495 # @param listener Type: ParseTreeListener 1496 def exitRule(self,listener): 1497 if hasattr( listener, "exitType_specifier" ): 1498 listener.exitType_specifier(self) 1499 1500 1501 1502 1503 def type_specifier(self): 1504 1505 localctx = CParser.Type_specifierContext(self, self._ctx, self.state) 1506 self.enterRule(localctx, 16, self.RULE_type_specifier) 1507 try: 1508 self.state = 247 1509 self._errHandler.sync(self) 1510 la_ = self._interp.adaptivePredict(self._input,16,self._ctx) 1511 if la_ == 1: 1512 self.enterOuterAlt(localctx, 1) 1513 self.state = 223 1514 self.match(CParser.T__10) 1515 pass 1516 1517 elif la_ == 2: 1518 self.enterOuterAlt(localctx, 2) 1519 self.state = 224 1520 self.match(CParser.T__11) 1521 pass 1522 1523 elif la_ == 3: 1524 self.enterOuterAlt(localctx, 3) 1525 self.state = 225 1526 self.match(CParser.T__12) 1527 pass 1528 1529 elif la_ == 4: 1530 self.enterOuterAlt(localctx, 4) 1531 self.state = 226 1532 self.match(CParser.T__13) 1533 pass 1534 1535 elif la_ == 5: 1536 self.enterOuterAlt(localctx, 5) 1537 self.state = 227 1538 self.match(CParser.T__14) 1539 pass 1540 1541 elif la_ == 6: 1542 self.enterOuterAlt(localctx, 6) 1543 self.state = 228 1544 self.match(CParser.T__15) 1545 pass 1546 1547 elif la_ == 7: 1548 self.enterOuterAlt(localctx, 7) 1549 self.state = 229 1550 self.match(CParser.T__16) 1551 pass 1552 1553 elif la_ == 8: 1554 self.enterOuterAlt(localctx, 8) 1555 self.state = 230 1556 self.match(CParser.T__17) 1557 pass 1558 1559 elif la_ == 9: 1560 self.enterOuterAlt(localctx, 9) 1561 self.state = 231 1562 self.match(CParser.T__18) 1563 pass 1564 1565 elif la_ == 10: 1566 self.enterOuterAlt(localctx, 10) 1567 self.state = 232 1568 localctx.s = self.struct_or_union_specifier() 1569 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)))) 1572 1573 pass 1574 1575 elif la_ == 11: 1576 self.enterOuterAlt(localctx, 11) 1577 self.state = 235 1578 localctx.e = self.enum_specifier() 1579 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)))) 1582 1583 pass 1584 1585 elif la_ == 12: 1586 self.enterOuterAlt(localctx, 12) 1587 self.state = 238 1588 self.match(CParser.IDENTIFIER) 1589 self.state = 242 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: 1593 if _alt==1: 1594 self.state = 239 1595 self.type_qualifier() 1596 self.state = 244 1597 self._errHandler.sync(self) 1598 _alt = self._interp.adaptivePredict(self._input,15,self._ctx) 1599 1600 self.state = 245 1601 self.declarator() 1602 pass 1603 1604 elif la_ == 13: 1605 self.enterOuterAlt(localctx, 13) 1606 self.state = 246 1607 self.type_id() 1608 pass 1609 1610 1611 except RecognitionException as re: 1612 localctx.exception = re 1613 self._errHandler.reportError(self, re) 1614 self._errHandler.recover(self, re) 1615 finally: 1616 self.exitRule() 1617 return localctx 1618 1619 class Type_idContext(ParserRuleContext): 1620 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 1626 1627 def IDENTIFIER(self): 1628 return self.getToken(CParser.IDENTIFIER, 0) 1629 1630 def getRuleIndex(self): 1631 return CParser.RULE_type_id 1632 1633 # @param listener Type: ParseTreeListener 1634 def enterRule(self,listener): 1635 if hasattr( listener, "enterType_id" ): 1636 listener.enterType_id(self) 1637 1638 # @param listener Type: ParseTreeListener 1639 def exitRule(self,listener): 1640 if hasattr( listener, "exitType_id" ): 1641 listener.exitType_id(self) 1642 1643 1644 1645 1646 def type_id(self): 1647 1648 localctx = CParser.Type_idContext(self, self._ctx, self.state) 1649 self.enterRule(localctx, 18, self.RULE_type_id) 1650 try: 1651 self.enterOuterAlt(localctx, 1) 1652 self.state = 249 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) 1658 finally: 1659 self.exitRule() 1660 return localctx 1661 1662 class Struct_or_union_specifierContext(ParserRuleContext): 1663 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 1669 1670 def struct_or_union(self): 1671 return self.getTypedRuleContext(CParser.Struct_or_unionContext,0) 1672 1673 1674 def struct_declaration_list(self): 1675 return self.getTypedRuleContext(CParser.Struct_declaration_listContext,0) 1676 1677 1678 def IDENTIFIER(self): 1679 return self.getToken(CParser.IDENTIFIER, 0) 1680 1681 def getRuleIndex(self): 1682 return CParser.RULE_struct_or_union_specifier 1683 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) 1688 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) 1693 1694 1695 1696 1697 def struct_or_union_specifier(self): 1698 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 1702 try: 1703 self.state = 262 1704 self._errHandler.sync(self) 1705 la_ = self._interp.adaptivePredict(self._input,18,self._ctx) 1706 if la_ == 1: 1707 self.enterOuterAlt(localctx, 1) 1708 self.state = 251 1709 self.struct_or_union() 1710 self.state = 253 1711 self._errHandler.sync(self) 1712 _la = self._input.LA(1) 1713 if _la==CParser.IDENTIFIER: 1714 self.state = 252 1715 self.match(CParser.IDENTIFIER) 1716 1717 1718 self.state = 255 1719 self.match(CParser.T__0) 1720 self.state = 256 1721 self.struct_declaration_list() 1722 self.state = 257 1723 self.match(CParser.T__19) 1724 pass 1725 1726 elif la_ == 2: 1727 self.enterOuterAlt(localctx, 2) 1728 self.state = 259 1729 self.struct_or_union() 1730 self.state = 260 1731 self.match(CParser.IDENTIFIER) 1732 pass 1733 1734 1735 except RecognitionException as re: 1736 localctx.exception = re 1737 self._errHandler.reportError(self, re) 1738 self._errHandler.recover(self, re) 1739 finally: 1740 self.exitRule() 1741 return localctx 1742 1743 class Struct_or_unionContext(ParserRuleContext): 1744 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 1750 1751 1752 def getRuleIndex(self): 1753 return CParser.RULE_struct_or_union 1754 1755 # @param listener Type: ParseTreeListener 1756 def enterRule(self,listener): 1757 if hasattr( listener, "enterStruct_or_union" ): 1758 listener.enterStruct_or_union(self) 1759 1760 # @param listener Type: ParseTreeListener 1761 def exitRule(self,listener): 1762 if hasattr( listener, "exitStruct_or_union" ): 1763 listener.exitStruct_or_union(self) 1764 1765 1766 1767 1768 def struct_or_union(self): 1769 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 1773 try: 1774 self.enterOuterAlt(localctx, 1) 1775 self.state = 264 1776 _la = self._input.LA(1) 1777 if not(_la==CParser.T__20 or _la==CParser.T__21): 1778 self._errHandler.recoverInline(self) 1779 else: 1780 self._errHandler.reportMatch(self) 1781 self.consume() 1782 except RecognitionException as re: 1783 localctx.exception = re 1784 self._errHandler.reportError(self, re) 1785 self._errHandler.recover(self, re) 1786 finally: 1787 self.exitRule() 1788 return localctx 1789 1790 class Struct_declaration_listContext(ParserRuleContext): 1791 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 1797 1798 # @param i=None Type: int 1799 def struct_declaration(self,i=None): 1800 if i is None: 1801 return self.getTypedRuleContexts(CParser.Struct_declarationContext) 1802 else: 1803 return self.getTypedRuleContext(CParser.Struct_declarationContext,i) 1804 1805 1806 def getRuleIndex(self): 1807 return CParser.RULE_struct_declaration_list 1808 1809 # @param listener Type: ParseTreeListener 1810 def enterRule(self,listener): 1811 if hasattr( listener, "enterStruct_declaration_list" ): 1812 listener.enterStruct_declaration_list(self) 1813 1814 # @param listener Type: ParseTreeListener 1815 def exitRule(self,listener): 1816 if hasattr( listener, "exitStruct_declaration_list" ): 1817 listener.exitStruct_declaration_list(self) 1818 1819 1820 1821 1822 def struct_declaration_list(self): 1823 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 1827 try: 1828 self.enterOuterAlt(localctx, 1) 1829 self.state = 267 1830 self._errHandler.sync(self) 1831 _la = self._input.LA(1) 1832 while True: 1833 self.state = 266 1834 self.struct_declaration() 1835 self.state = 269 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): 1839 break 1840 1841 except RecognitionException as re: 1842 localctx.exception = re 1843 self._errHandler.reportError(self, re) 1844 self._errHandler.recover(self, re) 1845 finally: 1846 self.exitRule() 1847 return localctx 1848 1849 class Struct_declarationContext(ParserRuleContext): 1850 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 1856 1857 def specifier_qualifier_list(self): 1858 return self.getTypedRuleContext(CParser.Specifier_qualifier_listContext,0) 1859 1860 1861 def struct_declarator_list(self): 1862 return self.getTypedRuleContext(CParser.Struct_declarator_listContext,0) 1863 1864 1865 def getRuleIndex(self): 1866 return CParser.RULE_struct_declaration 1867 1868 # @param listener Type: ParseTreeListener 1869 def enterRule(self,listener): 1870 if hasattr( listener, "enterStruct_declaration" ): 1871 listener.enterStruct_declaration(self) 1872 1873 # @param listener Type: ParseTreeListener 1874 def exitRule(self,listener): 1875 if hasattr( listener, "exitStruct_declaration" ): 1876 listener.exitStruct_declaration(self) 1877 1878 1879 1880 1881 def struct_declaration(self): 1882 1883 localctx = CParser.Struct_declarationContext(self, self._ctx, self.state) 1884 self.enterRule(localctx, 26, self.RULE_struct_declaration) 1885 try: 1886 self.enterOuterAlt(localctx, 1) 1887 self.state = 271 1888 self.specifier_qualifier_list() 1889 self.state = 272 1890 self.struct_declarator_list() 1891 self.state = 273 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) 1897 finally: 1898 self.exitRule() 1899 return localctx 1900 1901 class Specifier_qualifier_listContext(ParserRuleContext): 1902 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 1908 1909 # @param i=None Type: int 1910 def type_qualifier(self,i=None): 1911 if i is None: 1912 return self.getTypedRuleContexts(CParser.Type_qualifierContext) 1913 else: 1914 return self.getTypedRuleContext(CParser.Type_qualifierContext,i) 1915 1916 1917 # @param i=None Type: int 1918 def type_specifier(self,i=None): 1919 if i is None: 1920 return self.getTypedRuleContexts(CParser.Type_specifierContext) 1921 else: 1922 return self.getTypedRuleContext(CParser.Type_specifierContext,i) 1923 1924 1925 def getRuleIndex(self): 1926 return CParser.RULE_specifier_qualifier_list 1927 1928 # @param listener Type: ParseTreeListener 1929 def enterRule(self,listener): 1930 if hasattr( listener, "enterSpecifier_qualifier_list" ): 1931 listener.enterSpecifier_qualifier_list(self) 1932 1933 # @param listener Type: ParseTreeListener 1934 def exitRule(self,listener): 1935 if hasattr( listener, "exitSpecifier_qualifier_list" ): 1936 listener.exitSpecifier_qualifier_list(self) 1937 1938 1939 1940 1941 def specifier_qualifier_list(self): 1942 1943 localctx = CParser.Specifier_qualifier_listContext(self, self._ctx, self.state) 1944 self.enterRule(localctx, 28, self.RULE_specifier_qualifier_list) 1945 try: 1946 self.enterOuterAlt(localctx, 1) 1947 self.state = 277 1948 self._errHandler.sync(self) 1949 _alt = 1 1950 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 1951 if _alt == 1: 1952 self.state = 277 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]: 1956 self.state = 275 1957 self.type_qualifier() 1958 pass 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]: 1960 self.state = 276 1961 self.type_specifier() 1962 pass 1963 else: 1964 raise NoViableAltException(self) 1965 1966 1967 else: 1968 raise NoViableAltException(self) 1969 self.state = 279 1970 self._errHandler.sync(self) 1971 _alt = self._interp.adaptivePredict(self._input,21,self._ctx) 1972 1973 except RecognitionException as re: 1974 localctx.exception = re 1975 self._errHandler.reportError(self, re) 1976 self._errHandler.recover(self, re) 1977 finally: 1978 self.exitRule() 1979 return localctx 1980 1981 class Struct_declarator_listContext(ParserRuleContext): 1982 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 1988 1989 # @param i=None Type: int 1990 def struct_declarator(self,i=None): 1991 if i is None: 1992 return self.getTypedRuleContexts(CParser.Struct_declaratorContext) 1993 else: 1994 return self.getTypedRuleContext(CParser.Struct_declaratorContext,i) 1995 1996 1997 def getRuleIndex(self): 1998 return CParser.RULE_struct_declarator_list 1999 2000 # @param listener Type: ParseTreeListener 2001 def enterRule(self,listener): 2002 if hasattr( listener, "enterStruct_declarator_list" ): 2003 listener.enterStruct_declarator_list(self) 2004 2005 # @param listener Type: ParseTreeListener 2006 def exitRule(self,listener): 2007 if hasattr( listener, "exitStruct_declarator_list" ): 2008 listener.exitStruct_declarator_list(self) 2009 2010 2011 2012 2013 def struct_declarator_list(self): 2014 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 2018 try: 2019 self.enterOuterAlt(localctx, 1) 2020 self.state = 281 2021 self.struct_declarator() 2022 self.state = 286 2023 self._errHandler.sync(self) 2024 _la = self._input.LA(1) 2025 while _la==CParser.T__3: 2026 self.state = 282 2027 self.match(CParser.T__3) 2028 self.state = 283 2029 self.struct_declarator() 2030 self.state = 288 2031 self._errHandler.sync(self) 2032 _la = self._input.LA(1) 2033 2034 except RecognitionException as re: 2035 localctx.exception = re 2036 self._errHandler.reportError(self, re) 2037 self._errHandler.recover(self, re) 2038 finally: 2039 self.exitRule() 2040 return localctx 2041 2042 class Struct_declaratorContext(ParserRuleContext): 2043 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 2049 2050 def declarator(self): 2051 return self.getTypedRuleContext(CParser.DeclaratorContext,0) 2052 2053 2054 def constant_expression(self): 2055 return self.getTypedRuleContext(CParser.Constant_expressionContext,0) 2056 2057 2058 def getRuleIndex(self): 2059 return CParser.RULE_struct_declarator 2060 2061 # @param listener Type: ParseTreeListener 2062 def enterRule(self,listener): 2063 if hasattr( listener, "enterStruct_declarator" ): 2064 listener.enterStruct_declarator(self) 2065 2066 # @param listener Type: ParseTreeListener 2067 def exitRule(self,listener): 2068 if hasattr( listener, "exitStruct_declarator" ): 2069 listener.exitStruct_declarator(self) 2070 2071 2072 2073 2074 def struct_declarator(self): 2075 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 2079 try: 2080 self.state = 296 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) 2085 self.state = 289 2086 self.declarator() 2087 self.state = 292 2088 self._errHandler.sync(self) 2089 _la = self._input.LA(1) 2090 if _la==CParser.T__22: 2091 self.state = 290 2092 self.match(CParser.T__22) 2093 self.state = 291 2094 self.constant_expression() 2095 2096 2097 pass 2098 elif token in [CParser.T__22]: 2099 self.enterOuterAlt(localctx, 2) 2100 self.state = 294 2101 self.match(CParser.T__22) 2102 self.state = 295 2103 self.constant_expression() 2104 pass 2105 else: 2106 raise NoViableAltException(self) 2107 2108 except RecognitionException as re: 2109 localctx.exception = re 2110 self._errHandler.reportError(self, re) 2111 self._errHandler.recover(self, re) 2112 finally: 2113 self.exitRule() 2114 return localctx 2115 2116 class Enum_specifierContext(ParserRuleContext): 2117 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 2123 2124 def enumerator_list(self): 2125 return self.getTypedRuleContext(CParser.Enumerator_listContext,0) 2126 2127 2128 def IDENTIFIER(self): 2129 return self.getToken(CParser.IDENTIFIER, 0) 2130 2131 def getRuleIndex(self): 2132 return CParser.RULE_enum_specifier 2133 2134 # @param listener Type: ParseTreeListener 2135 def enterRule(self,listener): 2136 if hasattr( listener, "enterEnum_specifier" ): 2137 listener.enterEnum_specifier(self) 2138 2139 # @param listener Type: ParseTreeListener 2140 def exitRule(self,listener): 2141 if hasattr( listener, "exitEnum_specifier" ): 2142 listener.exitEnum_specifier(self) 2143 2144 2145 2146 2147 def enum_specifier(self): 2148 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 2152 try: 2153 self.state = 317 2154 self._errHandler.sync(self) 2155 la_ = self._interp.adaptivePredict(self._input,27,self._ctx) 2156 if la_ == 1: 2157 self.enterOuterAlt(localctx, 1) 2158 self.state = 298 2159 self.match(CParser.T__23) 2160 self.state = 299 2161 self.match(CParser.T__0) 2162 self.state = 300 2163 self.enumerator_list() 2164 self.state = 302 2165 self._errHandler.sync(self) 2166 _la = self._input.LA(1) 2167 if _la==CParser.T__3: 2168 self.state = 301 2169 self.match(CParser.T__3) 2170 2171 2172 self.state = 304 2173 self.match(CParser.T__19) 2174 pass 2175 2176 elif la_ == 2: 2177 self.enterOuterAlt(localctx, 2) 2178 self.state = 306 2179 self.match(CParser.T__23) 2180 self.state = 307 2181 self.match(CParser.IDENTIFIER) 2182 self.state = 308 2183 self.match(CParser.T__0) 2184 self.state = 309 2185 self.enumerator_list() 2186 self.state = 311 2187 self._errHandler.sync(self) 2188 _la = self._input.LA(1) 2189 if _la==CParser.T__3: 2190 self.state = 310 2191 self.match(CParser.T__3) 2192 2193 2194 self.state = 313 2195 self.match(CParser.T__19) 2196 pass 2197 2198 elif la_ == 3: 2199 self.enterOuterAlt(localctx, 3) 2200 self.state = 315 2201 self.match(CParser.T__23) 2202 self.state = 316 2203 self.match(CParser.IDENTIFIER) 2204 pass 2205 2206 2207 except RecognitionException as re: 2208 localctx.exception = re 2209 self._errHandler.reportError(self, re) 2210 self._errHandler.recover(self, re) 2211 finally: 2212 self.exitRule() 2213 return localctx 2214 2215 class Enumerator_listContext(ParserRuleContext): 2216 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 2222 2223 # @param i=None Type: int 2224 def enumerator(self,i=None): 2225 if i is None: 2226 return self.getTypedRuleContexts(CParser.EnumeratorContext) 2227 else: 2228 return self.getTypedRuleContext(CParser.EnumeratorContext,i) 2229 2230 2231 def getRuleIndex(self): 2232 return CParser.RULE_enumerator_list 2233 2234 # @param listener Type: ParseTreeListener 2235 def enterRule(self,listener): 2236 if hasattr( listener, "enterEnumerator_list" ): 2237 listener.enterEnumerator_list(self) 2238 2239 # @param listener Type: ParseTreeListener 2240 def exitRule(self,listener): 2241 if hasattr( listener, "exitEnumerator_list" ): 2242 listener.exitEnumerator_list(self) 2243 2244 2245 2246 2247 def enumerator_list(self): 2248 2249 localctx = CParser.Enumerator_listContext(self, self._ctx, self.state) 2250 self.enterRule(localctx, 36, self.RULE_enumerator_list) 2251 try: 2252 self.enterOuterAlt(localctx, 1) 2253 self.state = 319 2254 self.enumerator() 2255 self.state = 324 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: 2259 if _alt==1: 2260 self.state = 320 2261 self.match(CParser.T__3) 2262 self.state = 321 2263 self.enumerator() 2264 self.state = 326 2265 self._errHandler.sync(self) 2266 _alt = self._interp.adaptivePredict(self._input,28,self._ctx) 2267 2268 except RecognitionException as re: 2269 localctx.exception = re 2270 self._errHandler.reportError(self, re) 2271 self._errHandler.recover(self, re) 2272 finally: 2273 self.exitRule() 2274 return localctx 2275 2276 class EnumeratorContext(ParserRuleContext): 2277 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 2283 2284 def IDENTIFIER(self): 2285 return self.getToken(CParser.IDENTIFIER, 0) 2286 2287 def constant_expression(self): 2288 return self.getTypedRuleContext(CParser.Constant_expressionContext,0) 2289 2290 2291 def getRuleIndex(self): 2292 return CParser.RULE_enumerator 2293 2294 # @param listener Type: ParseTreeListener 2295 def enterRule(self,listener): 2296 if hasattr( listener, "enterEnumerator" ): 2297 listener.enterEnumerator(self) 2298 2299 # @param listener Type: ParseTreeListener 2300 def exitRule(self,listener): 2301 if hasattr( listener, "exitEnumerator" ): 2302 listener.exitEnumerator(self) 2303 2304 2305 2306 2307 def enumerator(self): 2308 2309 localctx = CParser.EnumeratorContext(self, self._ctx, self.state) 2310 self.enterRule(localctx, 38, self.RULE_enumerator) 2311 self._la = 0 # Token type 2312 try: 2313 self.enterOuterAlt(localctx, 1) 2314 self.state = 327 2315 self.match(CParser.IDENTIFIER) 2316 self.state = 330 2317 self._errHandler.sync(self) 2318 _la = self._input.LA(1) 2319 if _la==CParser.T__4: 2320 self.state = 328 2321 self.match(CParser.T__4) 2322 self.state = 329 2323 self.constant_expression() 2324 2325 2326 except RecognitionException as re: 2327 localctx.exception = re 2328 self._errHandler.reportError(self, re) 2329 self._errHandler.recover(self, re) 2330 finally: 2331 self.exitRule() 2332 return localctx 2333 2334 class Type_qualifierContext(ParserRuleContext): 2335 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 2341 2342 2343 def getRuleIndex(self): 2344 return CParser.RULE_type_qualifier 2345 2346 # @param listener Type: ParseTreeListener 2347 def enterRule(self,listener): 2348 if hasattr( listener, "enterType_qualifier" ): 2349 listener.enterType_qualifier(self) 2350 2351 # @param listener Type: ParseTreeListener 2352 def exitRule(self,listener): 2353 if hasattr( listener, "exitType_qualifier" ): 2354 listener.exitType_qualifier(self) 2355 2356 2357 2358 2359 def type_qualifier(self): 2360 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 2364 try: 2365 self.enterOuterAlt(localctx, 1) 2366 self.state = 332 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) 2370 else: 2371 self._errHandler.reportMatch(self) 2372 self.consume() 2373 except RecognitionException as re: 2374 localctx.exception = re 2375 self._errHandler.reportError(self, re) 2376 self._errHandler.recover(self, re) 2377 finally: 2378 self.exitRule() 2379 return localctx 2380 2381 class DeclaratorContext(ParserRuleContext): 2382 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 2388 2389 def direct_declarator(self): 2390 return self.getTypedRuleContext(CParser.Direct_declaratorContext,0) 2391 2392 2393 def pointer(self): 2394 return self.getTypedRuleContext(CParser.PointerContext,0) 2395 2396 2397 def getRuleIndex(self): 2398 return CParser.RULE_declarator 2399 2400 # @param listener Type: ParseTreeListener 2401 def enterRule(self,listener): 2402 if hasattr( listener, "enterDeclarator" ): 2403 listener.enterDeclarator(self) 2404 2405 # @param listener Type: ParseTreeListener 2406 def exitRule(self,listener): 2407 if hasattr( listener, "exitDeclarator" ): 2408 listener.exitDeclarator(self) 2409 2410 2411 2412 2413 def declarator(self): 2414 2415 localctx = CParser.DeclaratorContext(self, self._ctx, self.state) 2416 self.enterRule(localctx, 42, self.RULE_declarator) 2417 self._la = 0 # Token type 2418 try: 2419 self.state = 348 2420 self._errHandler.sync(self) 2421 la_ = self._interp.adaptivePredict(self._input,34,self._ctx) 2422 if la_ == 1: 2423 self.enterOuterAlt(localctx, 1) 2424 self.state = 335 2425 self._errHandler.sync(self) 2426 _la = self._input.LA(1) 2427 if _la==CParser.T__41: 2428 self.state = 334 2429 self.pointer() 2430 2431 2432 self.state = 338 2433 self._errHandler.sync(self) 2434 _la = self._input.LA(1) 2435 if _la==CParser.T__33: 2436 self.state = 337 2437 self.match(CParser.T__33) 2438 2439 2440 self.state = 341 2441 self._errHandler.sync(self) 2442 _la = self._input.LA(1) 2443 if _la==CParser.T__34: 2444 self.state = 340 2445 self.match(CParser.T__34) 2446 2447 2448 self.state = 344 2449 self._errHandler.sync(self) 2450 _la = self._input.LA(1) 2451 if _la==CParser.T__35: 2452 self.state = 343 2453 self.match(CParser.T__35) 2454 2455 2456 self.state = 346 2457 self.direct_declarator() 2458 pass 2459 2460 elif la_ == 2: 2461 self.enterOuterAlt(localctx, 2) 2462 self.state = 347 2463 self.pointer() 2464 pass 2465 2466 2467 except RecognitionException as re: 2468 localctx.exception = re 2469 self._errHandler.reportError(self, re) 2470 self._errHandler.recover(self, re) 2471 finally: 2472 self.exitRule() 2473 return localctx 2474 2475 class Direct_declaratorContext(ParserRuleContext): 2476 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 2482 2483 def IDENTIFIER(self): 2484 return self.getToken(CParser.IDENTIFIER, 0) 2485 2486 # @param i=None Type: int 2487 def declarator_suffix(self,i=None): 2488 if i is None: 2489 return self.getTypedRuleContexts(CParser.Declarator_suffixContext) 2490 else: 2491 return self.getTypedRuleContext(CParser.Declarator_suffixContext,i) 2492 2493 2494 def declarator(self): 2495 return self.getTypedRuleContext(CParser.DeclaratorContext,0) 2496 2497 2498 def getRuleIndex(self): 2499 return CParser.RULE_direct_declarator 2500 2501 # @param listener Type: ParseTreeListener 2502 def enterRule(self,listener): 2503 if hasattr( listener, "enterDirect_declarator" ): 2504 listener.enterDirect_declarator(self) 2505 2506 # @param listener Type: ParseTreeListener 2507 def exitRule(self,listener): 2508 if hasattr( listener, "exitDirect_declarator" ): 2509 listener.exitDirect_declarator(self) 2510 2511 2512 2513 2514 def direct_declarator(self): 2515 2516 localctx = CParser.Direct_declaratorContext(self, self._ctx, self.state) 2517 self.enterRule(localctx, 44, self.RULE_direct_declarator) 2518 try: 2519 self.state = 368 2520 self._errHandler.sync(self) 2521 token = self._input.LA(1) 2522 if token in [CParser.IDENTIFIER]: 2523 self.enterOuterAlt(localctx, 1) 2524 self.state = 350 2525 self.match(CParser.IDENTIFIER) 2526 self.state = 354 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: 2530 if _alt==1: 2531 self.state = 351 2532 self.declarator_suffix() 2533 self.state = 356 2534 self._errHandler.sync(self) 2535 _alt = self._interp.adaptivePredict(self._input,35,self._ctx) 2536 2537 pass 2538 elif token in [CParser.T__37]: 2539 self.enterOuterAlt(localctx, 2) 2540 self.state = 357 2541 self.match(CParser.T__37) 2542 self.state = 359 2543 self._errHandler.sync(self) 2544 la_ = self._interp.adaptivePredict(self._input,36,self._ctx) 2545 if la_ == 1: 2546 self.state = 358 2547 self.match(CParser.T__33) 2548 2549 2550 self.state = 361 2551 self.declarator() 2552 self.state = 362 2553 self.match(CParser.T__38) 2554 self.state = 364 2555 self._errHandler.sync(self) 2556 _alt = 1 2557 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 2558 if _alt == 1: 2559 self.state = 363 2560 self.declarator_suffix() 2561 2562 else: 2563 raise NoViableAltException(self) 2564 self.state = 366 2565 self._errHandler.sync(self) 2566 _alt = self._interp.adaptivePredict(self._input,37,self._ctx) 2567 2568 pass 2569 else: 2570 raise NoViableAltException(self) 2571 2572 except RecognitionException as re: 2573 localctx.exception = re 2574 self._errHandler.reportError(self, re) 2575 self._errHandler.recover(self, re) 2576 finally: 2577 self.exitRule() 2578 return localctx 2579 2580 class Declarator_suffixContext(ParserRuleContext): 2581 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 2587 2588 def constant_expression(self): 2589 return self.getTypedRuleContext(CParser.Constant_expressionContext,0) 2590 2591 2592 def parameter_type_list(self): 2593 return self.getTypedRuleContext(CParser.Parameter_type_listContext,0) 2594 2595 2596 def identifier_list(self): 2597 return self.getTypedRuleContext(CParser.Identifier_listContext,0) 2598 2599 2600 def getRuleIndex(self): 2601 return CParser.RULE_declarator_suffix 2602 2603 # @param listener Type: ParseTreeListener 2604 def enterRule(self,listener): 2605 if hasattr( listener, "enterDeclarator_suffix" ): 2606 listener.enterDeclarator_suffix(self) 2607 2608 # @param listener Type: ParseTreeListener 2609 def exitRule(self,listener): 2610 if hasattr( listener, "exitDeclarator_suffix" ): 2611 listener.exitDeclarator_suffix(self) 2612 2613 2614 2615 2616 def declarator_suffix(self): 2617 2618 localctx = CParser.Declarator_suffixContext(self, self._ctx, self.state) 2619 self.enterRule(localctx, 46, self.RULE_declarator_suffix) 2620 try: 2621 self.state = 386 2622 self._errHandler.sync(self) 2623 la_ = self._interp.adaptivePredict(self._input,39,self._ctx) 2624 if la_ == 1: 2625 self.enterOuterAlt(localctx, 1) 2626 self.state = 370 2627 self.match(CParser.T__39) 2628 self.state = 371 2629 self.constant_expression() 2630 self.state = 372 2631 self.match(CParser.T__40) 2632 pass 2633 2634 elif la_ == 2: 2635 self.enterOuterAlt(localctx, 2) 2636 self.state = 374 2637 self.match(CParser.T__39) 2638 self.state = 375 2639 self.match(CParser.T__40) 2640 pass 2641 2642 elif la_ == 3: 2643 self.enterOuterAlt(localctx, 3) 2644 self.state = 376 2645 self.match(CParser.T__37) 2646 self.state = 377 2647 self.parameter_type_list() 2648 self.state = 378 2649 self.match(CParser.T__38) 2650 pass 2651 2652 elif la_ == 4: 2653 self.enterOuterAlt(localctx, 4) 2654 self.state = 380 2655 self.match(CParser.T__37) 2656 self.state = 381 2657 self.identifier_list() 2658 self.state = 382 2659 self.match(CParser.T__38) 2660 pass 2661 2662 elif la_ == 5: 2663 self.enterOuterAlt(localctx, 5) 2664 self.state = 384 2665 self.match(CParser.T__37) 2666 self.state = 385 2667 self.match(CParser.T__38) 2668 pass 2669 2670 2671 except RecognitionException as re: 2672 localctx.exception = re 2673 self._errHandler.reportError(self, re) 2674 self._errHandler.recover(self, re) 2675 finally: 2676 self.exitRule() 2677 return localctx 2678 2679 class PointerContext(ParserRuleContext): 2680 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 2686 2687 # @param i=None Type: int 2688 def type_qualifier(self,i=None): 2689 if i is None: 2690 return self.getTypedRuleContexts(CParser.Type_qualifierContext) 2691 else: 2692 return self.getTypedRuleContext(CParser.Type_qualifierContext,i) 2693 2694 2695 def pointer(self): 2696 return self.getTypedRuleContext(CParser.PointerContext,0) 2697 2698 2699 def getRuleIndex(self): 2700 return CParser.RULE_pointer 2701 2702 # @param listener Type: ParseTreeListener 2703 def enterRule(self,listener): 2704 if hasattr( listener, "enterPointer" ): 2705 listener.enterPointer(self) 2706 2707 # @param listener Type: ParseTreeListener 2708 def exitRule(self,listener): 2709 if hasattr( listener, "exitPointer" ): 2710 listener.exitPointer(self) 2711 2712 2713 2714 2715 def pointer(self): 2716 2717 localctx = CParser.PointerContext(self, self._ctx, self.state) 2718 self.enterRule(localctx, 48, self.RULE_pointer) 2719 try: 2720 self.state = 400 2721 self._errHandler.sync(self) 2722 la_ = self._interp.adaptivePredict(self._input,42,self._ctx) 2723 if la_ == 1: 2724 self.enterOuterAlt(localctx, 1) 2725 self.state = 388 2726 self.match(CParser.T__41) 2727 self.state = 390 2728 self._errHandler.sync(self) 2729 _alt = 1 2730 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 2731 if _alt == 1: 2732 self.state = 389 2733 self.type_qualifier() 2734 2735 else: 2736 raise NoViableAltException(self) 2737 self.state = 392 2738 self._errHandler.sync(self) 2739 _alt = self._interp.adaptivePredict(self._input,40,self._ctx) 2740 2741 self.state = 395 2742 self._errHandler.sync(self) 2743 la_ = self._interp.adaptivePredict(self._input,41,self._ctx) 2744 if la_ == 1: 2745 self.state = 394 2746 self.pointer() 2747 2748 2749 pass 2750 2751 elif la_ == 2: 2752 self.enterOuterAlt(localctx, 2) 2753 self.state = 397 2754 self.match(CParser.T__41) 2755 self.state = 398 2756 self.pointer() 2757 pass 2758 2759 elif la_ == 3: 2760 self.enterOuterAlt(localctx, 3) 2761 self.state = 399 2762 self.match(CParser.T__41) 2763 pass 2764 2765 2766 except RecognitionException as re: 2767 localctx.exception = re 2768 self._errHandler.reportError(self, re) 2769 self._errHandler.recover(self, re) 2770 finally: 2771 self.exitRule() 2772 return localctx 2773 2774 class Parameter_type_listContext(ParserRuleContext): 2775 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 2781 2782 def parameter_list(self): 2783 return self.getTypedRuleContext(CParser.Parameter_listContext,0) 2784 2785 2786 def getRuleIndex(self): 2787 return CParser.RULE_parameter_type_list 2788 2789 # @param listener Type: ParseTreeListener 2790 def enterRule(self,listener): 2791 if hasattr( listener, "enterParameter_type_list" ): 2792 listener.enterParameter_type_list(self) 2793 2794 # @param listener Type: ParseTreeListener 2795 def exitRule(self,listener): 2796 if hasattr( listener, "exitParameter_type_list" ): 2797 listener.exitParameter_type_list(self) 2798 2799 2800 2801 2802 def parameter_type_list(self): 2803 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 2807 try: 2808 self.enterOuterAlt(localctx, 1) 2809 self.state = 402 2810 self.parameter_list() 2811 self.state = 408 2812 self._errHandler.sync(self) 2813 _la = self._input.LA(1) 2814 if _la==CParser.T__3: 2815 self.state = 403 2816 self.match(CParser.T__3) 2817 self.state = 405 2818 self._errHandler.sync(self) 2819 _la = self._input.LA(1) 2820 if _la==CParser.T__28: 2821 self.state = 404 2822 self.match(CParser.T__28) 2823 2824 2825 self.state = 407 2826 self.match(CParser.T__42) 2827 2828 2829 except RecognitionException as re: 2830 localctx.exception = re 2831 self._errHandler.reportError(self, re) 2832 self._errHandler.recover(self, re) 2833 finally: 2834 self.exitRule() 2835 return localctx 2836 2837 class Parameter_listContext(ParserRuleContext): 2838 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 2844 2845 # @param i=None Type: int 2846 def parameter_declaration(self,i=None): 2847 if i is None: 2848 return self.getTypedRuleContexts(CParser.Parameter_declarationContext) 2849 else: 2850 return self.getTypedRuleContext(CParser.Parameter_declarationContext,i) 2851 2852 2853 def getRuleIndex(self): 2854 return CParser.RULE_parameter_list 2855 2856 # @param listener Type: ParseTreeListener 2857 def enterRule(self,listener): 2858 if hasattr( listener, "enterParameter_list" ): 2859 listener.enterParameter_list(self) 2860 2861 # @param listener Type: ParseTreeListener 2862 def exitRule(self,listener): 2863 if hasattr( listener, "exitParameter_list" ): 2864 listener.exitParameter_list(self) 2865 2866 2867 2868 2869 def parameter_list(self): 2870 2871 localctx = CParser.Parameter_listContext(self, self._ctx, self.state) 2872 self.enterRule(localctx, 52, self.RULE_parameter_list) 2873 try: 2874 self.enterOuterAlt(localctx, 1) 2875 self.state = 410 2876 self.parameter_declaration() 2877 self.state = 418 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: 2881 if _alt==1: 2882 self.state = 411 2883 self.match(CParser.T__3) 2884 self.state = 413 2885 self._errHandler.sync(self) 2886 la_ = self._interp.adaptivePredict(self._input,45,self._ctx) 2887 if la_ == 1: 2888 self.state = 412 2889 self.match(CParser.T__28) 2890 2891 2892 self.state = 415 2893 self.parameter_declaration() 2894 self.state = 420 2895 self._errHandler.sync(self) 2896 _alt = self._interp.adaptivePredict(self._input,46,self._ctx) 2897 2898 except RecognitionException as re: 2899 localctx.exception = re 2900 self._errHandler.reportError(self, re) 2901 self._errHandler.recover(self, re) 2902 finally: 2903 self.exitRule() 2904 return localctx 2905 2906 class Parameter_declarationContext(ParserRuleContext): 2907 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 2913 2914 def declaration_specifiers(self): 2915 return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0) 2916 2917 2918 # @param i=None Type: int 2919 def declarator(self,i=None): 2920 if i is None: 2921 return self.getTypedRuleContexts(CParser.DeclaratorContext) 2922 else: 2923 return self.getTypedRuleContext(CParser.DeclaratorContext,i) 2924 2925 2926 # @param i=None Type: int 2927 def abstract_declarator(self,i=None): 2928 if i is None: 2929 return self.getTypedRuleContexts(CParser.Abstract_declaratorContext) 2930 else: 2931 return self.getTypedRuleContext(CParser.Abstract_declaratorContext,i) 2932 2933 2934 def IDENTIFIER(self): 2935 return self.getToken(CParser.IDENTIFIER, 0) 2936 2937 # @param i=None Type: int 2938 def pointer(self,i=None): 2939 if i is None: 2940 return self.getTypedRuleContexts(CParser.PointerContext) 2941 else: 2942 return self.getTypedRuleContext(CParser.PointerContext,i) 2943 2944 2945 def getRuleIndex(self): 2946 return CParser.RULE_parameter_declaration 2947 2948 # @param listener Type: ParseTreeListener 2949 def enterRule(self,listener): 2950 if hasattr( listener, "enterParameter_declaration" ): 2951 listener.enterParameter_declaration(self) 2952 2953 # @param listener Type: ParseTreeListener 2954 def exitRule(self,listener): 2955 if hasattr( listener, "exitParameter_declaration" ): 2956 listener.exitParameter_declaration(self) 2957 2958 2959 2960 2961 def parameter_declaration(self): 2962 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 2966 try: 2967 self.state = 439 2968 self._errHandler.sync(self) 2969 la_ = self._interp.adaptivePredict(self._input,51,self._ctx) 2970 if la_ == 1: 2971 self.enterOuterAlt(localctx, 1) 2972 self.state = 421 2973 self.declaration_specifiers() 2974 self.state = 426 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): 2978 self.state = 424 2979 self._errHandler.sync(self) 2980 la_ = self._interp.adaptivePredict(self._input,47,self._ctx) 2981 if la_ == 1: 2982 self.state = 422 2983 self.declarator() 2984 pass 2985 2986 elif la_ == 2: 2987 self.state = 423 2988 self.abstract_declarator() 2989 pass 2990 2991 2992 self.state = 428 2993 self._errHandler.sync(self) 2994 _la = self._input.LA(1) 2995 2996 self.state = 430 2997 self._errHandler.sync(self) 2998 _la = self._input.LA(1) 2999 if _la==CParser.T__28: 3000 self.state = 429 3001 self.match(CParser.T__28) 3002 3003 3004 pass 3005 3006 elif la_ == 2: 3007 self.enterOuterAlt(localctx, 2) 3008 self.state = 435 3009 self._errHandler.sync(self) 3010 _la = self._input.LA(1) 3011 while _la==CParser.T__41: 3012 self.state = 432 3013 self.pointer() 3014 self.state = 437 3015 self._errHandler.sync(self) 3016 _la = self._input.LA(1) 3017 3018 self.state = 438 3019 self.match(CParser.IDENTIFIER) 3020 pass 3021 3022 3023 except RecognitionException as re: 3024 localctx.exception = re 3025 self._errHandler.reportError(self, re) 3026 self._errHandler.recover(self, re) 3027 finally: 3028 self.exitRule() 3029 return localctx 3030 3031 class Identifier_listContext(ParserRuleContext): 3032 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 3038 3039 # @param i=None Type: int 3040 def IDENTIFIER(self,i=None): 3041 if i is None: 3042 return self.getTokens(CParser.IDENTIFIER) 3043 else: 3044 return self.getToken(CParser.IDENTIFIER, i) 3045 3046 def getRuleIndex(self): 3047 return CParser.RULE_identifier_list 3048 3049 # @param listener Type: ParseTreeListener 3050 def enterRule(self,listener): 3051 if hasattr( listener, "enterIdentifier_list" ): 3052 listener.enterIdentifier_list(self) 3053 3054 # @param listener Type: ParseTreeListener 3055 def exitRule(self,listener): 3056 if hasattr( listener, "exitIdentifier_list" ): 3057 listener.exitIdentifier_list(self) 3058 3059 3060 3061 3062 def identifier_list(self): 3063 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 3067 try: 3068 self.enterOuterAlt(localctx, 1) 3069 self.state = 441 3070 self.match(CParser.IDENTIFIER) 3071 self.state = 446 3072 self._errHandler.sync(self) 3073 _la = self._input.LA(1) 3074 while _la==CParser.T__3: 3075 self.state = 442 3076 self.match(CParser.T__3) 3077 self.state = 443 3078 self.match(CParser.IDENTIFIER) 3079 self.state = 448 3080 self._errHandler.sync(self) 3081 _la = self._input.LA(1) 3082 3083 except RecognitionException as re: 3084 localctx.exception = re 3085 self._errHandler.reportError(self, re) 3086 self._errHandler.recover(self, re) 3087 finally: 3088 self.exitRule() 3089 return localctx 3090 3091 class Type_nameContext(ParserRuleContext): 3092 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 3098 3099 def specifier_qualifier_list(self): 3100 return self.getTypedRuleContext(CParser.Specifier_qualifier_listContext,0) 3101 3102 3103 def abstract_declarator(self): 3104 return self.getTypedRuleContext(CParser.Abstract_declaratorContext,0) 3105 3106 3107 def type_id(self): 3108 return self.getTypedRuleContext(CParser.Type_idContext,0) 3109 3110 3111 def getRuleIndex(self): 3112 return CParser.RULE_type_name 3113 3114 # @param listener Type: ParseTreeListener 3115 def enterRule(self,listener): 3116 if hasattr( listener, "enterType_name" ): 3117 listener.enterType_name(self) 3118 3119 # @param listener Type: ParseTreeListener 3120 def exitRule(self,listener): 3121 if hasattr( listener, "exitType_name" ): 3122 listener.exitType_name(self) 3123 3124 3125 3126 3127 def type_name(self): 3128 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 3132 try: 3133 self.state = 454 3134 self._errHandler.sync(self) 3135 la_ = self._interp.adaptivePredict(self._input,54,self._ctx) 3136 if la_ == 1: 3137 self.enterOuterAlt(localctx, 1) 3138 self.state = 449 3139 self.specifier_qualifier_list() 3140 self.state = 451 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): 3144 self.state = 450 3145 self.abstract_declarator() 3146 3147 3148 pass 3149 3150 elif la_ == 2: 3151 self.enterOuterAlt(localctx, 2) 3152 self.state = 453 3153 self.type_id() 3154 pass 3155 3156 3157 except RecognitionException as re: 3158 localctx.exception = re 3159 self._errHandler.reportError(self, re) 3160 self._errHandler.recover(self, re) 3161 finally: 3162 self.exitRule() 3163 return localctx 3164 3165 class Abstract_declaratorContext(ParserRuleContext): 3166 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 3172 3173 def pointer(self): 3174 return self.getTypedRuleContext(CParser.PointerContext,0) 3175 3176 3177 def direct_abstract_declarator(self): 3178 return self.getTypedRuleContext(CParser.Direct_abstract_declaratorContext,0) 3179 3180 3181 def getRuleIndex(self): 3182 return CParser.RULE_abstract_declarator 3183 3184 # @param listener Type: ParseTreeListener 3185 def enterRule(self,listener): 3186 if hasattr( listener, "enterAbstract_declarator" ): 3187 listener.enterAbstract_declarator(self) 3188 3189 # @param listener Type: ParseTreeListener 3190 def exitRule(self,listener): 3191 if hasattr( listener, "exitAbstract_declarator" ): 3192 listener.exitAbstract_declarator(self) 3193 3194 3195 3196 3197 def abstract_declarator(self): 3198 3199 localctx = CParser.Abstract_declaratorContext(self, self._ctx, self.state) 3200 self.enterRule(localctx, 60, self.RULE_abstract_declarator) 3201 try: 3202 self.state = 461 3203 self._errHandler.sync(self) 3204 token = self._input.LA(1) 3205 if token in [CParser.T__41]: 3206 self.enterOuterAlt(localctx, 1) 3207 self.state = 456 3208 self.pointer() 3209 self.state = 458 3210 self._errHandler.sync(self) 3211 la_ = self._interp.adaptivePredict(self._input,55,self._ctx) 3212 if la_ == 1: 3213 self.state = 457 3214 self.direct_abstract_declarator() 3215 3216 3217 pass 3218 elif token in [CParser.T__37, CParser.T__39]: 3219 self.enterOuterAlt(localctx, 2) 3220 self.state = 460 3221 self.direct_abstract_declarator() 3222 pass 3223 else: 3224 raise NoViableAltException(self) 3225 3226 except RecognitionException as re: 3227 localctx.exception = re 3228 self._errHandler.reportError(self, re) 3229 self._errHandler.recover(self, re) 3230 finally: 3231 self.exitRule() 3232 return localctx 3233 3234 class Direct_abstract_declaratorContext(ParserRuleContext): 3235 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 3241 3242 def abstract_declarator(self): 3243 return self.getTypedRuleContext(CParser.Abstract_declaratorContext,0) 3244 3245 3246 # @param i=None Type: int 3247 def abstract_declarator_suffix(self,i=None): 3248 if i is None: 3249 return self.getTypedRuleContexts(CParser.Abstract_declarator_suffixContext) 3250 else: 3251 return self.getTypedRuleContext(CParser.Abstract_declarator_suffixContext,i) 3252 3253 3254 def getRuleIndex(self): 3255 return CParser.RULE_direct_abstract_declarator 3256 3257 # @param listener Type: ParseTreeListener 3258 def enterRule(self,listener): 3259 if hasattr( listener, "enterDirect_abstract_declarator" ): 3260 listener.enterDirect_abstract_declarator(self) 3261 3262 # @param listener Type: ParseTreeListener 3263 def exitRule(self,listener): 3264 if hasattr( listener, "exitDirect_abstract_declarator" ): 3265 listener.exitDirect_abstract_declarator(self) 3266 3267 3268 3269 def direct_abstract_declarator(self): 3270 3271 localctx = CParser.Direct_abstract_declaratorContext(self, self._ctx, self.state) 3272 self.enterRule(localctx, 62, self.RULE_direct_abstract_declarator) 3273 try: 3274 self.enterOuterAlt(localctx, 1) 3275 self.state = 468 3276 self._errHandler.sync(self) 3277 la_ = self._interp.adaptivePredict(self._input,57,self._ctx) 3278 if la_ == 1: 3279 self.state = 463 3280 self.match(CParser.T__37) 3281 self.state = 464 3282 self.abstract_declarator() 3283 self.state = 465 3284 self.match(CParser.T__38) 3285 pass 3286 3287 elif la_ == 2: 3288 self.state = 467 3289 self.abstract_declarator_suffix() 3290 pass 3291 3292 3293 self.state = 473 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: 3297 if _alt==1: 3298 self.state = 470 3299 self.abstract_declarator_suffix() 3300 self.state = 475 3301 self._errHandler.sync(self) 3302 _alt = self._interp.adaptivePredict(self._input,58,self._ctx) 3303 3304 except RecognitionException as re: 3305 localctx.exception = re 3306 self._errHandler.reportError(self, re) 3307 self._errHandler.recover(self, re) 3308 finally: 3309 self.exitRule() 3310 return localctx 3311 3312 class Abstract_declarator_suffixContext(ParserRuleContext): 3313 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 3319 3320 def constant_expression(self): 3321 return self.getTypedRuleContext(CParser.Constant_expressionContext,0) 3322 3323 3324 def parameter_type_list(self): 3325 return self.getTypedRuleContext(CParser.Parameter_type_listContext,0) 3326 3327 3328 def getRuleIndex(self): 3329 return CParser.RULE_abstract_declarator_suffix 3330 3331 # @param listener Type: ParseTreeListener 3332 def enterRule(self,listener): 3333 if hasattr( listener, "enterAbstract_declarator_suffix" ): 3334 listener.enterAbstract_declarator_suffix(self) 3335 3336 # @param listener Type: ParseTreeListener 3337 def exitRule(self,listener): 3338 if hasattr( listener, "exitAbstract_declarator_suffix" ): 3339 listener.exitAbstract_declarator_suffix(self) 3340 3341 3342 3343 3344 def abstract_declarator_suffix(self): 3345 3346 localctx = CParser.Abstract_declarator_suffixContext(self, self._ctx, self.state) 3347 self.enterRule(localctx, 64, self.RULE_abstract_declarator_suffix) 3348 try: 3349 self.state = 488 3350 self._errHandler.sync(self) 3351 la_ = self._interp.adaptivePredict(self._input,59,self._ctx) 3352 if la_ == 1: 3353 self.enterOuterAlt(localctx, 1) 3354 self.state = 476 3355 self.match(CParser.T__39) 3356 self.state = 477 3357 self.match(CParser.T__40) 3358 pass 3359 3360 elif la_ == 2: 3361 self.enterOuterAlt(localctx, 2) 3362 self.state = 478 3363 self.match(CParser.T__39) 3364 self.state = 479 3365 self.constant_expression() 3366 self.state = 480 3367 self.match(CParser.T__40) 3368 pass 3369 3370 elif la_ == 3: 3371 self.enterOuterAlt(localctx, 3) 3372 self.state = 482 3373 self.match(CParser.T__37) 3374 self.state = 483 3375 self.match(CParser.T__38) 3376 pass 3377 3378 elif la_ == 4: 3379 self.enterOuterAlt(localctx, 4) 3380 self.state = 484 3381 self.match(CParser.T__37) 3382 self.state = 485 3383 self.parameter_type_list() 3384 self.state = 486 3385 self.match(CParser.T__38) 3386 pass 3387 3388 3389 except RecognitionException as re: 3390 localctx.exception = re 3391 self._errHandler.reportError(self, re) 3392 self._errHandler.recover(self, re) 3393 finally: 3394 self.exitRule() 3395 return localctx 3396 3397 class InitializerContext(ParserRuleContext): 3398 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 3404 3405 def assignment_expression(self): 3406 return self.getTypedRuleContext(CParser.Assignment_expressionContext,0) 3407 3408 3409 def initializer_list(self): 3410 return self.getTypedRuleContext(CParser.Initializer_listContext,0) 3411 3412 3413 def getRuleIndex(self): 3414 return CParser.RULE_initializer 3415 3416 # @param listener Type: ParseTreeListener 3417 def enterRule(self,listener): 3418 if hasattr( listener, "enterInitializer" ): 3419 listener.enterInitializer(self) 3420 3421 # @param listener Type: ParseTreeListener 3422 def exitRule(self,listener): 3423 if hasattr( listener, "exitInitializer" ): 3424 listener.exitInitializer(self) 3425 3426 3427 3428 3429 def initializer(self): 3430 3431 localctx = CParser.InitializerContext(self, self._ctx, self.state) 3432 self.enterRule(localctx, 66, self.RULE_initializer) 3433 self._la = 0 # Token type 3434 try: 3435 self.state = 498 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) 3440 self.state = 490 3441 self.assignment_expression() 3442 pass 3443 elif token in [CParser.T__0]: 3444 self.enterOuterAlt(localctx, 2) 3445 self.state = 491 3446 self.match(CParser.T__0) 3447 self.state = 492 3448 self.initializer_list() 3449 self.state = 494 3450 self._errHandler.sync(self) 3451 _la = self._input.LA(1) 3452 if _la==CParser.T__3: 3453 self.state = 493 3454 self.match(CParser.T__3) 3455 3456 3457 self.state = 496 3458 self.match(CParser.T__19) 3459 pass 3460 else: 3461 raise NoViableAltException(self) 3462 3463 except RecognitionException as re: 3464 localctx.exception = re 3465 self._errHandler.reportError(self, re) 3466 self._errHandler.recover(self, re) 3467 finally: 3468 self.exitRule() 3469 return localctx 3470 3471 class Initializer_listContext(ParserRuleContext): 3472 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 3478 3479 # @param i=None Type: int 3480 def initializer(self,i=None): 3481 if i is None: 3482 return self.getTypedRuleContexts(CParser.InitializerContext) 3483 else: 3484 return self.getTypedRuleContext(CParser.InitializerContext,i) 3485 3486 3487 def getRuleIndex(self): 3488 return CParser.RULE_initializer_list 3489 3490 # @param listener Type: ParseTreeListener 3491 def enterRule(self,listener): 3492 if hasattr( listener, "enterInitializer_list" ): 3493 listener.enterInitializer_list(self) 3494 3495 # @param listener Type: ParseTreeListener 3496 def exitRule(self,listener): 3497 if hasattr( listener, "exitInitializer_list" ): 3498 listener.exitInitializer_list(self) 3499 3500 3501 3502 3503 def initializer_list(self): 3504 3505 localctx = CParser.Initializer_listContext(self, self._ctx, self.state) 3506 self.enterRule(localctx, 68, self.RULE_initializer_list) 3507 try: 3508 self.enterOuterAlt(localctx, 1) 3509 self.state = 500 3510 self.initializer() 3511 self.state = 505 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: 3515 if _alt==1: 3516 self.state = 501 3517 self.match(CParser.T__3) 3518 self.state = 502 3519 self.initializer() 3520 self.state = 507 3521 self._errHandler.sync(self) 3522 _alt = self._interp.adaptivePredict(self._input,62,self._ctx) 3523 3524 except RecognitionException as re: 3525 localctx.exception = re 3526 self._errHandler.reportError(self, re) 3527 self._errHandler.recover(self, re) 3528 finally: 3529 self.exitRule() 3530 return localctx 3531 3532 class Argument_expression_listContext(ParserRuleContext): 3533 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 3539 3540 # @param i=None Type: int 3541 def assignment_expression(self,i=None): 3542 if i is None: 3543 return self.getTypedRuleContexts(CParser.Assignment_expressionContext) 3544 else: 3545 return self.getTypedRuleContext(CParser.Assignment_expressionContext,i) 3546 3547 3548 def getRuleIndex(self): 3549 return CParser.RULE_argument_expression_list 3550 3551 # @param listener Type: ParseTreeListener 3552 def enterRule(self,listener): 3553 if hasattr( listener, "enterArgument_expression_list" ): 3554 listener.enterArgument_expression_list(self) 3555 3556 # @param listener Type: ParseTreeListener 3557 def exitRule(self,listener): 3558 if hasattr( listener, "exitArgument_expression_list" ): 3559 listener.exitArgument_expression_list(self) 3560 3561 3562 3563 3564 def argument_expression_list(self): 3565 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 3569 try: 3570 self.enterOuterAlt(localctx, 1) 3571 self.state = 508 3572 self.assignment_expression() 3573 self.state = 510 3574 self._errHandler.sync(self) 3575 _la = self._input.LA(1) 3576 if _la==CParser.T__28: 3577 self.state = 509 3578 self.match(CParser.T__28) 3579 3580 3581 self.state = 519 3582 self._errHandler.sync(self) 3583 _la = self._input.LA(1) 3584 while _la==CParser.T__3: 3585 self.state = 512 3586 self.match(CParser.T__3) 3587 self.state = 513 3588 self.assignment_expression() 3589 self.state = 515 3590 self._errHandler.sync(self) 3591 _la = self._input.LA(1) 3592 if _la==CParser.T__28: 3593 self.state = 514 3594 self.match(CParser.T__28) 3595 3596 3597 self.state = 521 3598 self._errHandler.sync(self) 3599 _la = self._input.LA(1) 3600 3601 except RecognitionException as re: 3602 localctx.exception = re 3603 self._errHandler.reportError(self, re) 3604 self._errHandler.recover(self, re) 3605 finally: 3606 self.exitRule() 3607 return localctx 3608 3609 class Additive_expressionContext(ParserRuleContext): 3610 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 3616 3617 # @param i=None Type: int 3618 def multiplicative_expression(self,i=None): 3619 if i is None: 3620 return self.getTypedRuleContexts(CParser.Multiplicative_expressionContext) 3621 else: 3622 return self.getTypedRuleContext(CParser.Multiplicative_expressionContext,i) 3623 3624 3625 def getRuleIndex(self): 3626 return CParser.RULE_additive_expression 3627 3628 # @param listener Type: ParseTreeListener 3629 def enterRule(self,listener): 3630 if hasattr( listener, "enterAdditive_expression" ): 3631 listener.enterAdditive_expression(self) 3632 3633 # @param listener Type: ParseTreeListener 3634 def exitRule(self,listener): 3635 if hasattr( listener, "exitAdditive_expression" ): 3636 listener.exitAdditive_expression(self) 3637 3638 3639 3640 3641 def additive_expression(self): 3642 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 3646 try: 3647 self.enterOuterAlt(localctx, 1) 3648 self.state = 522 3649 self.multiplicative_expression() 3650 self.state = 529 3651 self._errHandler.sync(self) 3652 _la = self._input.LA(1) 3653 while _la==CParser.T__43 or _la==CParser.T__44: 3654 self.state = 527 3655 self._errHandler.sync(self) 3656 token = self._input.LA(1) 3657 if token in [CParser.T__43]: 3658 self.state = 523 3659 self.match(CParser.T__43) 3660 self.state = 524 3661 self.multiplicative_expression() 3662 pass 3663 elif token in [CParser.T__44]: 3664 self.state = 525 3665 self.match(CParser.T__44) 3666 self.state = 526 3667 self.multiplicative_expression() 3668 pass 3669 else: 3670 raise NoViableAltException(self) 3671 3672 self.state = 531 3673 self._errHandler.sync(self) 3674 _la = self._input.LA(1) 3675 3676 except RecognitionException as re: 3677 localctx.exception = re 3678 self._errHandler.reportError(self, re) 3679 self._errHandler.recover(self, re) 3680 finally: 3681 self.exitRule() 3682 return localctx 3683 3684 class Multiplicative_expressionContext(ParserRuleContext): 3685 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 3691 3692 # @param i=None Type: int 3693 def cast_expression(self,i=None): 3694 if i is None: 3695 return self.getTypedRuleContexts(CParser.Cast_expressionContext) 3696 else: 3697 return self.getTypedRuleContext(CParser.Cast_expressionContext,i) 3698 3699 3700 def getRuleIndex(self): 3701 return CParser.RULE_multiplicative_expression 3702 3703 # @param listener Type: ParseTreeListener 3704 def enterRule(self,listener): 3705 if hasattr( listener, "enterMultiplicative_expression" ): 3706 listener.enterMultiplicative_expression(self) 3707 3708 # @param listener Type: ParseTreeListener 3709 def exitRule(self,listener): 3710 if hasattr( listener, "exitMultiplicative_expression" ): 3711 listener.exitMultiplicative_expression(self) 3712 3713 3714 3715 3716 def multiplicative_expression(self): 3717 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 3721 try: 3722 self.enterOuterAlt(localctx, 1) 3723 self.state = 532 3724 self.cast_expression() 3725 self.state = 541 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): 3729 self.state = 539 3730 self._errHandler.sync(self) 3731 token = self._input.LA(1) 3732 if token in [CParser.T__41]: 3733 self.state = 533 3734 self.match(CParser.T__41) 3735 self.state = 534 3736 self.cast_expression() 3737 pass 3738 elif token in [CParser.T__45]: 3739 self.state = 535 3740 self.match(CParser.T__45) 3741 self.state = 536 3742 self.cast_expression() 3743 pass 3744 elif token in [CParser.T__46]: 3745 self.state = 537 3746 self.match(CParser.T__46) 3747 self.state = 538 3748 self.cast_expression() 3749 pass 3750 else: 3751 raise NoViableAltException(self) 3752 3753 self.state = 543 3754 self._errHandler.sync(self) 3755 _la = self._input.LA(1) 3756 3757 except RecognitionException as re: 3758 localctx.exception = re 3759 self._errHandler.reportError(self, re) 3760 self._errHandler.recover(self, re) 3761 finally: 3762 self.exitRule() 3763 return localctx 3764 3765 class Cast_expressionContext(ParserRuleContext): 3766 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 3772 3773 def type_name(self): 3774 return self.getTypedRuleContext(CParser.Type_nameContext,0) 3775 3776 3777 def cast_expression(self): 3778 return self.getTypedRuleContext(CParser.Cast_expressionContext,0) 3779 3780 3781 def unary_expression(self): 3782 return self.getTypedRuleContext(CParser.Unary_expressionContext,0) 3783 3784 3785 def getRuleIndex(self): 3786 return CParser.RULE_cast_expression 3787 3788 # @param listener Type: ParseTreeListener 3789 def enterRule(self,listener): 3790 if hasattr( listener, "enterCast_expression" ): 3791 listener.enterCast_expression(self) 3792 3793 # @param listener Type: ParseTreeListener 3794 def exitRule(self,listener): 3795 if hasattr( listener, "exitCast_expression" ): 3796 listener.exitCast_expression(self) 3797 3798 3799 3800 3801 def cast_expression(self): 3802 3803 localctx = CParser.Cast_expressionContext(self, self._ctx, self.state) 3804 self.enterRule(localctx, 76, self.RULE_cast_expression) 3805 try: 3806 self.state = 550 3807 self._errHandler.sync(self) 3808 la_ = self._interp.adaptivePredict(self._input,70,self._ctx) 3809 if la_ == 1: 3810 self.enterOuterAlt(localctx, 1) 3811 self.state = 544 3812 self.match(CParser.T__37) 3813 self.state = 545 3814 self.type_name() 3815 self.state = 546 3816 self.match(CParser.T__38) 3817 self.state = 547 3818 self.cast_expression() 3819 pass 3820 3821 elif la_ == 2: 3822 self.enterOuterAlt(localctx, 2) 3823 self.state = 549 3824 self.unary_expression() 3825 pass 3826 3827 3828 except RecognitionException as re: 3829 localctx.exception = re 3830 self._errHandler.reportError(self, re) 3831 self._errHandler.recover(self, re) 3832 finally: 3833 self.exitRule() 3834 return localctx 3835 3836 class Unary_expressionContext(ParserRuleContext): 3837 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 3843 3844 def postfix_expression(self): 3845 return self.getTypedRuleContext(CParser.Postfix_expressionContext,0) 3846 3847 3848 def unary_expression(self): 3849 return self.getTypedRuleContext(CParser.Unary_expressionContext,0) 3850 3851 3852 def unary_operator(self): 3853 return self.getTypedRuleContext(CParser.Unary_operatorContext,0) 3854 3855 3856 def cast_expression(self): 3857 return self.getTypedRuleContext(CParser.Cast_expressionContext,0) 3858 3859 3860 def type_name(self): 3861 return self.getTypedRuleContext(CParser.Type_nameContext,0) 3862 3863 3864 def getRuleIndex(self): 3865 return CParser.RULE_unary_expression 3866 3867 # @param listener Type: ParseTreeListener 3868 def enterRule(self,listener): 3869 if hasattr( listener, "enterUnary_expression" ): 3870 listener.enterUnary_expression(self) 3871 3872 # @param listener Type: ParseTreeListener 3873 def exitRule(self,listener): 3874 if hasattr( listener, "exitUnary_expression" ): 3875 listener.exitUnary_expression(self) 3876 3877 3878 3879 3880 def unary_expression(self): 3881 3882 localctx = CParser.Unary_expressionContext(self, self._ctx, self.state) 3883 self.enterRule(localctx, 78, self.RULE_unary_expression) 3884 try: 3885 self.state = 567 3886 self._errHandler.sync(self) 3887 la_ = self._interp.adaptivePredict(self._input,71,self._ctx) 3888 if la_ == 1: 3889 self.enterOuterAlt(localctx, 1) 3890 self.state = 552 3891 self.postfix_expression() 3892 pass 3893 3894 elif la_ == 2: 3895 self.enterOuterAlt(localctx, 2) 3896 self.state = 553 3897 self.match(CParser.T__47) 3898 self.state = 554 3899 self.unary_expression() 3900 pass 3901 3902 elif la_ == 3: 3903 self.enterOuterAlt(localctx, 3) 3904 self.state = 555 3905 self.match(CParser.T__48) 3906 self.state = 556 3907 self.unary_expression() 3908 pass 3909 3910 elif la_ == 4: 3911 self.enterOuterAlt(localctx, 4) 3912 self.state = 557 3913 self.unary_operator() 3914 self.state = 558 3915 self.cast_expression() 3916 pass 3917 3918 elif la_ == 5: 3919 self.enterOuterAlt(localctx, 5) 3920 self.state = 560 3921 self.match(CParser.T__49) 3922 self.state = 561 3923 self.unary_expression() 3924 pass 3925 3926 elif la_ == 6: 3927 self.enterOuterAlt(localctx, 6) 3928 self.state = 562 3929 self.match(CParser.T__49) 3930 self.state = 563 3931 self.match(CParser.T__37) 3932 self.state = 564 3933 self.type_name() 3934 self.state = 565 3935 self.match(CParser.T__38) 3936 pass 3937 3938 3939 except RecognitionException as re: 3940 localctx.exception = re 3941 self._errHandler.reportError(self, re) 3942 self._errHandler.recover(self, re) 3943 finally: 3944 self.exitRule() 3945 return localctx 3946 3947 class Postfix_expressionContext(ParserRuleContext): 3948 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 3962 3963 def primary_expression(self): 3964 return self.getTypedRuleContext(CParser.Primary_expressionContext,0) 3965 3966 3967 # @param i=None Type: int 3968 def expression(self,i=None): 3969 if i is None: 3970 return self.getTypedRuleContexts(CParser.ExpressionContext) 3971 else: 3972 return self.getTypedRuleContext(CParser.ExpressionContext,i) 3973 3974 3975 # @param i=None Type: int 3976 def macro_parameter_list(self,i=None): 3977 if i is None: 3978 return self.getTypedRuleContexts(CParser.Macro_parameter_listContext) 3979 else: 3980 return self.getTypedRuleContext(CParser.Macro_parameter_listContext,i) 3981 3982 3983 # @param i=None Type: int 3984 def argument_expression_list(self,i=None): 3985 if i is None: 3986 return self.getTypedRuleContexts(CParser.Argument_expression_listContext) 3987 else: 3988 return self.getTypedRuleContext(CParser.Argument_expression_listContext,i) 3989 3990 3991 # @param i=None Type: int 3992 def IDENTIFIER(self,i=None): 3993 if i is None: 3994 return self.getTokens(CParser.IDENTIFIER) 3995 else: 3996 return self.getToken(CParser.IDENTIFIER, i) 3997 3998 def getRuleIndex(self): 3999 return CParser.RULE_postfix_expression 4000 4001 # @param listener Type: ParseTreeListener 4002 def enterRule(self,listener): 4003 if hasattr( listener, "enterPostfix_expression" ): 4004 listener.enterPostfix_expression(self) 4005 4006 # @param listener Type: ParseTreeListener 4007 def exitRule(self,listener): 4008 if hasattr( listener, "exitPostfix_expression" ): 4009 listener.exitPostfix_expression(self) 4010 4011 4012 4013 4014 def postfix_expression(self): 4015 4016 localctx = CParser.Postfix_expressionContext(self, self._ctx, self.state) 4017 self.enterRule(localctx, 80, self.RULE_postfix_expression) 4018 4019 self.FuncCallText='' 4020 4021 try: 4022 self.enterOuterAlt(localctx, 1) 4023 self.state = 569 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))) 4026 self.state = 600 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: 4030 if _alt==1: 4031 self.state = 598 4032 self._errHandler.sync(self) 4033 la_ = self._interp.adaptivePredict(self._input,72,self._ctx) 4034 if la_ == 1: 4035 self.state = 571 4036 self.match(CParser.T__39) 4037 self.state = 572 4038 self.expression() 4039 self.state = 573 4040 self.match(CParser.T__40) 4041 pass 4042 4043 elif la_ == 2: 4044 self.state = 575 4045 self.match(CParser.T__37) 4046 self.state = 576 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, '') 4049 pass 4050 4051 elif la_ == 3: 4052 self.state = 578 4053 self.match(CParser.T__37) 4054 self.state = 579 4055 localctx.c = self.argument_expression_list() 4056 self.state = 580 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)))) 4059 pass 4060 4061 elif la_ == 4: 4062 self.state = 583 4063 self.match(CParser.T__37) 4064 self.state = 584 4065 self.macro_parameter_list() 4066 self.state = 585 4067 self.match(CParser.T__38) 4068 pass 4069 4070 elif la_ == 5: 4071 self.state = 587 4072 self.match(CParser.T__50) 4073 self.state = 588 4074 localctx.x = self.match(CParser.IDENTIFIER) 4075 self.FuncCallText += '.' + (None if localctx.x is None else localctx.x.text) 4076 pass 4077 4078 elif la_ == 6: 4079 self.state = 590 4080 self.match(CParser.T__41) 4081 self.state = 591 4082 localctx.y = self.match(CParser.IDENTIFIER) 4083 self.FuncCallText = (None if localctx.y is None else localctx.y.text) 4084 pass 4085 4086 elif la_ == 7: 4087 self.state = 593 4088 self.match(CParser.T__51) 4089 self.state = 594 4090 localctx.z = self.match(CParser.IDENTIFIER) 4091 self.FuncCallText += '->' + (None if localctx.z is None else localctx.z.text) 4092 pass 4093 4094 elif la_ == 8: 4095 self.state = 596 4096 self.match(CParser.T__47) 4097 pass 4098 4099 elif la_ == 9: 4100 self.state = 597 4101 self.match(CParser.T__48) 4102 pass 4103 4104 4105 self.state = 602 4106 self._errHandler.sync(self) 4107 _alt = self._interp.adaptivePredict(self._input,73,self._ctx) 4108 4109 except RecognitionException as re: 4110 localctx.exception = re 4111 self._errHandler.reportError(self, re) 4112 self._errHandler.recover(self, re) 4113 finally: 4114 self.exitRule() 4115 return localctx 4116 4117 class Macro_parameter_listContext(ParserRuleContext): 4118 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 4124 4125 # @param i=None Type: int 4126 def parameter_declaration(self,i=None): 4127 if i is None: 4128 return self.getTypedRuleContexts(CParser.Parameter_declarationContext) 4129 else: 4130 return self.getTypedRuleContext(CParser.Parameter_declarationContext,i) 4131 4132 4133 def getRuleIndex(self): 4134 return CParser.RULE_macro_parameter_list 4135 4136 # @param listener Type: ParseTreeListener 4137 def enterRule(self,listener): 4138 if hasattr( listener, "enterMacro_parameter_list" ): 4139 listener.enterMacro_parameter_list(self) 4140 4141 # @param listener Type: ParseTreeListener 4142 def exitRule(self,listener): 4143 if hasattr( listener, "exitMacro_parameter_list" ): 4144 listener.exitMacro_parameter_list(self) 4145 4146 4147 4148 4149 def macro_parameter_list(self): 4150 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 4154 try: 4155 self.enterOuterAlt(localctx, 1) 4156 self.state = 603 4157 self.parameter_declaration() 4158 self.state = 608 4159 self._errHandler.sync(self) 4160 _la = self._input.LA(1) 4161 while _la==CParser.T__3: 4162 self.state = 604 4163 self.match(CParser.T__3) 4164 self.state = 605 4165 self.parameter_declaration() 4166 self.state = 610 4167 self._errHandler.sync(self) 4168 _la = self._input.LA(1) 4169 4170 except RecognitionException as re: 4171 localctx.exception = re 4172 self._errHandler.reportError(self, re) 4173 self._errHandler.recover(self, re) 4174 finally: 4175 self.exitRule() 4176 return localctx 4177 4178 class Unary_operatorContext(ParserRuleContext): 4179 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 4185 4186 4187 def getRuleIndex(self): 4188 return CParser.RULE_unary_operator 4189 4190 # @param listener Type: ParseTreeListener 4191 def enterRule(self,listener): 4192 if hasattr( listener, "enterUnary_operator" ): 4193 listener.enterUnary_operator(self) 4194 4195 # @param listener Type: ParseTreeListener 4196 def exitRule(self,listener): 4197 if hasattr( listener, "exitUnary_operator" ): 4198 listener.exitUnary_operator(self) 4199 4200 4201 4202 4203 def unary_operator(self): 4204 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 4208 try: 4209 self.enterOuterAlt(localctx, 1) 4210 self.state = 611 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) 4214 else: 4215 self._errHandler.reportMatch(self) 4216 self.consume() 4217 except RecognitionException as re: 4218 localctx.exception = re 4219 self._errHandler.reportError(self, re) 4220 self._errHandler.recover(self, re) 4221 finally: 4222 self.exitRule() 4223 return localctx 4224 4225 class Primary_expressionContext(ParserRuleContext): 4226 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 4232 4233 def IDENTIFIER(self): 4234 return self.getToken(CParser.IDENTIFIER, 0) 4235 4236 def constant(self): 4237 return self.getTypedRuleContext(CParser.ConstantContext,0) 4238 4239 4240 def expression(self): 4241 return self.getTypedRuleContext(CParser.ExpressionContext,0) 4242 4243 4244 def getRuleIndex(self): 4245 return CParser.RULE_primary_expression 4246 4247 # @param listener Type: ParseTreeListener 4248 def enterRule(self,listener): 4249 if hasattr( listener, "enterPrimary_expression" ): 4250 listener.enterPrimary_expression(self) 4251 4252 # @param listener Type: ParseTreeListener 4253 def exitRule(self,listener): 4254 if hasattr( listener, "exitPrimary_expression" ): 4255 listener.exitPrimary_expression(self) 4256 4257 4258 4259 4260 def primary_expression(self): 4261 4262 localctx = CParser.Primary_expressionContext(self, self._ctx, self.state) 4263 self.enterRule(localctx, 86, self.RULE_primary_expression) 4264 try: 4265 self.state = 619 4266 self._errHandler.sync(self) 4267 la_ = self._interp.adaptivePredict(self._input,75,self._ctx) 4268 if la_ == 1: 4269 self.enterOuterAlt(localctx, 1) 4270 self.state = 613 4271 self.match(CParser.IDENTIFIER) 4272 pass 4273 4274 elif la_ == 2: 4275 self.enterOuterAlt(localctx, 2) 4276 self.state = 614 4277 self.constant() 4278 pass 4279 4280 elif la_ == 3: 4281 self.enterOuterAlt(localctx, 3) 4282 self.state = 615 4283 self.match(CParser.T__37) 4284 self.state = 616 4285 self.expression() 4286 self.state = 617 4287 self.match(CParser.T__38) 4288 pass 4289 4290 4291 except RecognitionException as re: 4292 localctx.exception = re 4293 self._errHandler.reportError(self, re) 4294 self._errHandler.recover(self, re) 4295 finally: 4296 self.exitRule() 4297 return localctx 4298 4299 class ConstantContext(ParserRuleContext): 4300 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 4306 4307 def HEX_LITERAL(self): 4308 return self.getToken(CParser.HEX_LITERAL, 0) 4309 4310 def OCTAL_LITERAL(self): 4311 return self.getToken(CParser.OCTAL_LITERAL, 0) 4312 4313 def DECIMAL_LITERAL(self): 4314 return self.getToken(CParser.DECIMAL_LITERAL, 0) 4315 4316 def CHARACTER_LITERAL(self): 4317 return self.getToken(CParser.CHARACTER_LITERAL, 0) 4318 4319 # @param i=None Type: int 4320 def IDENTIFIER(self,i=None): 4321 if i is None: 4322 return self.getTokens(CParser.IDENTIFIER) 4323 else: 4324 return self.getToken(CParser.IDENTIFIER, i) 4325 4326 # @param i=None Type: int 4327 def STRING_LITERAL(self,i=None): 4328 if i is None: 4329 return self.getTokens(CParser.STRING_LITERAL) 4330 else: 4331 return self.getToken(CParser.STRING_LITERAL, i) 4332 4333 def FLOATING_POINT_LITERAL(self): 4334 return self.getToken(CParser.FLOATING_POINT_LITERAL, 0) 4335 4336 def getRuleIndex(self): 4337 return CParser.RULE_constant 4338 4339 # @param listener Type: ParseTreeListener 4340 def enterRule(self,listener): 4341 if hasattr( listener, "enterConstant" ): 4342 listener.enterConstant(self) 4343 4344 # @param listener Type: ParseTreeListener 4345 def exitRule(self,listener): 4346 if hasattr( listener, "exitConstant" ): 4347 listener.exitConstant(self) 4348 4349 4350 4351 4352 def constant(self): 4353 4354 localctx = CParser.ConstantContext(self, self._ctx, self.state) 4355 self.enterRule(localctx, 88, self.RULE_constant) 4356 self._la = 0 # Token type 4357 try: 4358 self.state = 647 4359 self._errHandler.sync(self) 4360 token = self._input.LA(1) 4361 if token in [CParser.HEX_LITERAL]: 4362 self.enterOuterAlt(localctx, 1) 4363 self.state = 621 4364 self.match(CParser.HEX_LITERAL) 4365 pass 4366 elif token in [CParser.OCTAL_LITERAL]: 4367 self.enterOuterAlt(localctx, 2) 4368 self.state = 622 4369 self.match(CParser.OCTAL_LITERAL) 4370 pass 4371 elif token in [CParser.DECIMAL_LITERAL]: 4372 self.enterOuterAlt(localctx, 3) 4373 self.state = 623 4374 self.match(CParser.DECIMAL_LITERAL) 4375 pass 4376 elif token in [CParser.CHARACTER_LITERAL]: 4377 self.enterOuterAlt(localctx, 4) 4378 self.state = 624 4379 self.match(CParser.CHARACTER_LITERAL) 4380 pass 4381 elif token in [CParser.IDENTIFIER, CParser.STRING_LITERAL]: 4382 self.enterOuterAlt(localctx, 5) 4383 self.state = 636 4384 self._errHandler.sync(self) 4385 _alt = 1 4386 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 4387 if _alt == 1: 4388 self.state = 628 4389 self._errHandler.sync(self) 4390 _la = self._input.LA(1) 4391 while _la==CParser.IDENTIFIER: 4392 self.state = 625 4393 self.match(CParser.IDENTIFIER) 4394 self.state = 630 4395 self._errHandler.sync(self) 4396 _la = self._input.LA(1) 4397 4398 self.state = 632 4399 self._errHandler.sync(self) 4400 _alt = 1 4401 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 4402 if _alt == 1: 4403 self.state = 631 4404 self.match(CParser.STRING_LITERAL) 4405 4406 else: 4407 raise NoViableAltException(self) 4408 self.state = 634 4409 self._errHandler.sync(self) 4410 _alt = self._interp.adaptivePredict(self._input,77,self._ctx) 4411 4412 4413 else: 4414 raise NoViableAltException(self) 4415 self.state = 638 4416 self._errHandler.sync(self) 4417 _alt = self._interp.adaptivePredict(self._input,78,self._ctx) 4418 4419 self.state = 643 4420 self._errHandler.sync(self) 4421 _la = self._input.LA(1) 4422 while _la==CParser.IDENTIFIER: 4423 self.state = 640 4424 self.match(CParser.IDENTIFIER) 4425 self.state = 645 4426 self._errHandler.sync(self) 4427 _la = self._input.LA(1) 4428 4429 pass 4430 elif token in [CParser.FLOATING_POINT_LITERAL]: 4431 self.enterOuterAlt(localctx, 6) 4432 self.state = 646 4433 self.match(CParser.FLOATING_POINT_LITERAL) 4434 pass 4435 else: 4436 raise NoViableAltException(self) 4437 4438 except RecognitionException as re: 4439 localctx.exception = re 4440 self._errHandler.reportError(self, re) 4441 self._errHandler.recover(self, re) 4442 finally: 4443 self.exitRule() 4444 return localctx 4445 4446 class ExpressionContext(ParserRuleContext): 4447 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 4453 4454 # @param i=None Type: int 4455 def assignment_expression(self,i=None): 4456 if i is None: 4457 return self.getTypedRuleContexts(CParser.Assignment_expressionContext) 4458 else: 4459 return self.getTypedRuleContext(CParser.Assignment_expressionContext,i) 4460 4461 4462 def getRuleIndex(self): 4463 return CParser.RULE_expression 4464 4465 # @param listener Type: ParseTreeListener 4466 def enterRule(self,listener): 4467 if hasattr( listener, "enterExpression" ): 4468 listener.enterExpression(self) 4469 4470 # @param listener Type: ParseTreeListener 4471 def exitRule(self,listener): 4472 if hasattr( listener, "exitExpression" ): 4473 listener.exitExpression(self) 4474 4475 4476 4477 4478 def expression(self): 4479 4480 localctx = CParser.ExpressionContext(self, self._ctx, self.state) 4481 self.enterRule(localctx, 90, self.RULE_expression) 4482 self._la = 0 # Token type 4483 try: 4484 self.enterOuterAlt(localctx, 1) 4485 self.state = 649 4486 self.assignment_expression() 4487 self.state = 654 4488 self._errHandler.sync(self) 4489 _la = self._input.LA(1) 4490 while _la==CParser.T__3: 4491 self.state = 650 4492 self.match(CParser.T__3) 4493 self.state = 651 4494 self.assignment_expression() 4495 self.state = 656 4496 self._errHandler.sync(self) 4497 _la = self._input.LA(1) 4498 4499 except RecognitionException as re: 4500 localctx.exception = re 4501 self._errHandler.reportError(self, re) 4502 self._errHandler.recover(self, re) 4503 finally: 4504 self.exitRule() 4505 return localctx 4506 4507 class Constant_expressionContext(ParserRuleContext): 4508 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 4514 4515 def conditional_expression(self): 4516 return self.getTypedRuleContext(CParser.Conditional_expressionContext,0) 4517 4518 4519 def getRuleIndex(self): 4520 return CParser.RULE_constant_expression 4521 4522 # @param listener Type: ParseTreeListener 4523 def enterRule(self,listener): 4524 if hasattr( listener, "enterConstant_expression" ): 4525 listener.enterConstant_expression(self) 4526 4527 # @param listener Type: ParseTreeListener 4528 def exitRule(self,listener): 4529 if hasattr( listener, "exitConstant_expression" ): 4530 listener.exitConstant_expression(self) 4531 4532 4533 4534 4535 def constant_expression(self): 4536 4537 localctx = CParser.Constant_expressionContext(self, self._ctx, self.state) 4538 self.enterRule(localctx, 92, self.RULE_constant_expression) 4539 try: 4540 self.enterOuterAlt(localctx, 1) 4541 self.state = 657 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) 4547 finally: 4548 self.exitRule() 4549 return localctx 4550 4551 class Assignment_expressionContext(ParserRuleContext): 4552 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 4558 4559 def lvalue(self): 4560 return self.getTypedRuleContext(CParser.LvalueContext,0) 4561 4562 4563 def assignment_operator(self): 4564 return self.getTypedRuleContext(CParser.Assignment_operatorContext,0) 4565 4566 4567 def assignment_expression(self): 4568 return self.getTypedRuleContext(CParser.Assignment_expressionContext,0) 4569 4570 4571 def conditional_expression(self): 4572 return self.getTypedRuleContext(CParser.Conditional_expressionContext,0) 4573 4574 4575 def getRuleIndex(self): 4576 return CParser.RULE_assignment_expression 4577 4578 # @param listener Type: ParseTreeListener 4579 def enterRule(self,listener): 4580 if hasattr( listener, "enterAssignment_expression" ): 4581 listener.enterAssignment_expression(self) 4582 4583 # @param listener Type: ParseTreeListener 4584 def exitRule(self,listener): 4585 if hasattr( listener, "exitAssignment_expression" ): 4586 listener.exitAssignment_expression(self) 4587 4588 4589 4590 4591 def assignment_expression(self): 4592 4593 localctx = CParser.Assignment_expressionContext(self, self._ctx, self.state) 4594 self.enterRule(localctx, 94, self.RULE_assignment_expression) 4595 try: 4596 self.state = 664 4597 self._errHandler.sync(self) 4598 la_ = self._interp.adaptivePredict(self._input,82,self._ctx) 4599 if la_ == 1: 4600 self.enterOuterAlt(localctx, 1) 4601 self.state = 659 4602 self.lvalue() 4603 self.state = 660 4604 self.assignment_operator() 4605 self.state = 661 4606 self.assignment_expression() 4607 pass 4608 4609 elif la_ == 2: 4610 self.enterOuterAlt(localctx, 2) 4611 self.state = 663 4612 self.conditional_expression() 4613 pass 4614 4615 4616 except RecognitionException as re: 4617 localctx.exception = re 4618 self._errHandler.reportError(self, re) 4619 self._errHandler.recover(self, re) 4620 finally: 4621 self.exitRule() 4622 return localctx 4623 4624 class LvalueContext(ParserRuleContext): 4625 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 4631 4632 def unary_expression(self): 4633 return self.getTypedRuleContext(CParser.Unary_expressionContext,0) 4634 4635 4636 def getRuleIndex(self): 4637 return CParser.RULE_lvalue 4638 4639 # @param listener Type: ParseTreeListener 4640 def enterRule(self,listener): 4641 if hasattr( listener, "enterLvalue" ): 4642 listener.enterLvalue(self) 4643 4644 # @param listener Type: ParseTreeListener 4645 def exitRule(self,listener): 4646 if hasattr( listener, "exitLvalue" ): 4647 listener.exitLvalue(self) 4648 4649 4650 4651 4652 def lvalue(self): 4653 4654 localctx = CParser.LvalueContext(self, self._ctx, self.state) 4655 self.enterRule(localctx, 96, self.RULE_lvalue) 4656 try: 4657 self.enterOuterAlt(localctx, 1) 4658 self.state = 666 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) 4664 finally: 4665 self.exitRule() 4666 return localctx 4667 4668 class Assignment_operatorContext(ParserRuleContext): 4669 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 4675 4676 4677 def getRuleIndex(self): 4678 return CParser.RULE_assignment_operator 4679 4680 # @param listener Type: ParseTreeListener 4681 def enterRule(self,listener): 4682 if hasattr( listener, "enterAssignment_operator" ): 4683 listener.enterAssignment_operator(self) 4684 4685 # @param listener Type: ParseTreeListener 4686 def exitRule(self,listener): 4687 if hasattr( listener, "exitAssignment_operator" ): 4688 listener.exitAssignment_operator(self) 4689 4690 4691 4692 4693 def assignment_operator(self): 4694 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 4698 try: 4699 self.enterOuterAlt(localctx, 1) 4700 self.state = 668 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) 4704 else: 4705 self._errHandler.reportMatch(self) 4706 self.consume() 4707 except RecognitionException as re: 4708 localctx.exception = re 4709 self._errHandler.reportError(self, re) 4710 self._errHandler.recover(self, re) 4711 finally: 4712 self.exitRule() 4713 return localctx 4714 4715 class Conditional_expressionContext(ParserRuleContext): 4716 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 4723 4724 def logical_or_expression(self): 4725 return self.getTypedRuleContext(CParser.Logical_or_expressionContext,0) 4726 4727 4728 def expression(self): 4729 return self.getTypedRuleContext(CParser.ExpressionContext,0) 4730 4731 4732 def conditional_expression(self): 4733 return self.getTypedRuleContext(CParser.Conditional_expressionContext,0) 4734 4735 4736 def getRuleIndex(self): 4737 return CParser.RULE_conditional_expression 4738 4739 # @param listener Type: ParseTreeListener 4740 def enterRule(self,listener): 4741 if hasattr( listener, "enterConditional_expression" ): 4742 listener.enterConditional_expression(self) 4743 4744 # @param listener Type: ParseTreeListener 4745 def exitRule(self,listener): 4746 if hasattr( listener, "exitConditional_expression" ): 4747 listener.exitConditional_expression(self) 4748 4749 4750 4751 4752 def conditional_expression(self): 4753 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 4757 try: 4758 self.enterOuterAlt(localctx, 1) 4759 self.state = 670 4760 localctx.e = self.logical_or_expression() 4761 self.state = 677 4762 self._errHandler.sync(self) 4763 _la = self._input.LA(1) 4764 if _la==CParser.T__65: 4765 self.state = 671 4766 self.match(CParser.T__65) 4767 self.state = 672 4768 self.expression() 4769 self.state = 673 4770 self.match(CParser.T__22) 4771 self.state = 674 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)))) 4774 4775 4776 except RecognitionException as re: 4777 localctx.exception = re 4778 self._errHandler.reportError(self, re) 4779 self._errHandler.recover(self, re) 4780 finally: 4781 self.exitRule() 4782 return localctx 4783 4784 class Logical_or_expressionContext(ParserRuleContext): 4785 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 4791 4792 # @param i=None Type: int 4793 def logical_and_expression(self,i=None): 4794 if i is None: 4795 return self.getTypedRuleContexts(CParser.Logical_and_expressionContext) 4796 else: 4797 return self.getTypedRuleContext(CParser.Logical_and_expressionContext,i) 4798 4799 4800 def getRuleIndex(self): 4801 return CParser.RULE_logical_or_expression 4802 4803 # @param listener Type: ParseTreeListener 4804 def enterRule(self,listener): 4805 if hasattr( listener, "enterLogical_or_expression" ): 4806 listener.enterLogical_or_expression(self) 4807 4808 # @param listener Type: ParseTreeListener 4809 def exitRule(self,listener): 4810 if hasattr( listener, "exitLogical_or_expression" ): 4811 listener.exitLogical_or_expression(self) 4812 4813 4814 4815 4816 def logical_or_expression(self): 4817 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 4821 try: 4822 self.enterOuterAlt(localctx, 1) 4823 self.state = 679 4824 self.logical_and_expression() 4825 self.state = 684 4826 self._errHandler.sync(self) 4827 _la = self._input.LA(1) 4828 while _la==CParser.T__66: 4829 self.state = 680 4830 self.match(CParser.T__66) 4831 self.state = 681 4832 self.logical_and_expression() 4833 self.state = 686 4834 self._errHandler.sync(self) 4835 _la = self._input.LA(1) 4836 4837 except RecognitionException as re: 4838 localctx.exception = re 4839 self._errHandler.reportError(self, re) 4840 self._errHandler.recover(self, re) 4841 finally: 4842 self.exitRule() 4843 return localctx 4844 4845 class Logical_and_expressionContext(ParserRuleContext): 4846 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 4852 4853 # @param i=None Type: int 4854 def inclusive_or_expression(self,i=None): 4855 if i is None: 4856 return self.getTypedRuleContexts(CParser.Inclusive_or_expressionContext) 4857 else: 4858 return self.getTypedRuleContext(CParser.Inclusive_or_expressionContext,i) 4859 4860 4861 def getRuleIndex(self): 4862 return CParser.RULE_logical_and_expression 4863 4864 # @param listener Type: ParseTreeListener 4865 def enterRule(self,listener): 4866 if hasattr( listener, "enterLogical_and_expression" ): 4867 listener.enterLogical_and_expression(self) 4868 4869 # @param listener Type: ParseTreeListener 4870 def exitRule(self,listener): 4871 if hasattr( listener, "exitLogical_and_expression" ): 4872 listener.exitLogical_and_expression(self) 4873 4874 4875 4876 4877 def logical_and_expression(self): 4878 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 4882 try: 4883 self.enterOuterAlt(localctx, 1) 4884 self.state = 687 4885 self.inclusive_or_expression() 4886 self.state = 692 4887 self._errHandler.sync(self) 4888 _la = self._input.LA(1) 4889 while _la==CParser.T__67: 4890 self.state = 688 4891 self.match(CParser.T__67) 4892 self.state = 689 4893 self.inclusive_or_expression() 4894 self.state = 694 4895 self._errHandler.sync(self) 4896 _la = self._input.LA(1) 4897 4898 except RecognitionException as re: 4899 localctx.exception = re 4900 self._errHandler.reportError(self, re) 4901 self._errHandler.recover(self, re) 4902 finally: 4903 self.exitRule() 4904 return localctx 4905 4906 class Inclusive_or_expressionContext(ParserRuleContext): 4907 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 4913 4914 # @param i=None Type: int 4915 def exclusive_or_expression(self,i=None): 4916 if i is None: 4917 return self.getTypedRuleContexts(CParser.Exclusive_or_expressionContext) 4918 else: 4919 return self.getTypedRuleContext(CParser.Exclusive_or_expressionContext,i) 4920 4921 4922 def getRuleIndex(self): 4923 return CParser.RULE_inclusive_or_expression 4924 4925 # @param listener Type: ParseTreeListener 4926 def enterRule(self,listener): 4927 if hasattr( listener, "enterInclusive_or_expression" ): 4928 listener.enterInclusive_or_expression(self) 4929 4930 # @param listener Type: ParseTreeListener 4931 def exitRule(self,listener): 4932 if hasattr( listener, "exitInclusive_or_expression" ): 4933 listener.exitInclusive_or_expression(self) 4934 4935 4936 4937 4938 def inclusive_or_expression(self): 4939 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 4943 try: 4944 self.enterOuterAlt(localctx, 1) 4945 self.state = 695 4946 self.exclusive_or_expression() 4947 self.state = 700 4948 self._errHandler.sync(self) 4949 _la = self._input.LA(1) 4950 while _la==CParser.T__68: 4951 self.state = 696 4952 self.match(CParser.T__68) 4953 self.state = 697 4954 self.exclusive_or_expression() 4955 self.state = 702 4956 self._errHandler.sync(self) 4957 _la = self._input.LA(1) 4958 4959 except RecognitionException as re: 4960 localctx.exception = re 4961 self._errHandler.reportError(self, re) 4962 self._errHandler.recover(self, re) 4963 finally: 4964 self.exitRule() 4965 return localctx 4966 4967 class Exclusive_or_expressionContext(ParserRuleContext): 4968 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 4974 4975 # @param i=None Type: int 4976 def and_expression(self,i=None): 4977 if i is None: 4978 return self.getTypedRuleContexts(CParser.And_expressionContext) 4979 else: 4980 return self.getTypedRuleContext(CParser.And_expressionContext,i) 4981 4982 4983 def getRuleIndex(self): 4984 return CParser.RULE_exclusive_or_expression 4985 4986 # @param listener Type: ParseTreeListener 4987 def enterRule(self,listener): 4988 if hasattr( listener, "enterExclusive_or_expression" ): 4989 listener.enterExclusive_or_expression(self) 4990 4991 # @param listener Type: ParseTreeListener 4992 def exitRule(self,listener): 4993 if hasattr( listener, "exitExclusive_or_expression" ): 4994 listener.exitExclusive_or_expression(self) 4995 4996 4997 4998 4999 def exclusive_or_expression(self): 5000 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 5004 try: 5005 self.enterOuterAlt(localctx, 1) 5006 self.state = 703 5007 self.and_expression() 5008 self.state = 708 5009 self._errHandler.sync(self) 5010 _la = self._input.LA(1) 5011 while _la==CParser.T__69: 5012 self.state = 704 5013 self.match(CParser.T__69) 5014 self.state = 705 5015 self.and_expression() 5016 self.state = 710 5017 self._errHandler.sync(self) 5018 _la = self._input.LA(1) 5019 5020 except RecognitionException as re: 5021 localctx.exception = re 5022 self._errHandler.reportError(self, re) 5023 self._errHandler.recover(self, re) 5024 finally: 5025 self.exitRule() 5026 return localctx 5027 5028 class And_expressionContext(ParserRuleContext): 5029 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 5035 5036 # @param i=None Type: int 5037 def equality_expression(self,i=None): 5038 if i is None: 5039 return self.getTypedRuleContexts(CParser.Equality_expressionContext) 5040 else: 5041 return self.getTypedRuleContext(CParser.Equality_expressionContext,i) 5042 5043 5044 def getRuleIndex(self): 5045 return CParser.RULE_and_expression 5046 5047 # @param listener Type: ParseTreeListener 5048 def enterRule(self,listener): 5049 if hasattr( listener, "enterAnd_expression" ): 5050 listener.enterAnd_expression(self) 5051 5052 # @param listener Type: ParseTreeListener 5053 def exitRule(self,listener): 5054 if hasattr( listener, "exitAnd_expression" ): 5055 listener.exitAnd_expression(self) 5056 5057 5058 5059 5060 def and_expression(self): 5061 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 5065 try: 5066 self.enterOuterAlt(localctx, 1) 5067 self.state = 711 5068 self.equality_expression() 5069 self.state = 716 5070 self._errHandler.sync(self) 5071 _la = self._input.LA(1) 5072 while _la==CParser.T__52: 5073 self.state = 712 5074 self.match(CParser.T__52) 5075 self.state = 713 5076 self.equality_expression() 5077 self.state = 718 5078 self._errHandler.sync(self) 5079 _la = self._input.LA(1) 5080 5081 except RecognitionException as re: 5082 localctx.exception = re 5083 self._errHandler.reportError(self, re) 5084 self._errHandler.recover(self, re) 5085 finally: 5086 self.exitRule() 5087 return localctx 5088 5089 class Equality_expressionContext(ParserRuleContext): 5090 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 5096 5097 # @param i=None Type: int 5098 def relational_expression(self,i=None): 5099 if i is None: 5100 return self.getTypedRuleContexts(CParser.Relational_expressionContext) 5101 else: 5102 return self.getTypedRuleContext(CParser.Relational_expressionContext,i) 5103 5104 5105 def getRuleIndex(self): 5106 return CParser.RULE_equality_expression 5107 5108 # @param listener Type: ParseTreeListener 5109 def enterRule(self,listener): 5110 if hasattr( listener, "enterEquality_expression" ): 5111 listener.enterEquality_expression(self) 5112 5113 # @param listener Type: ParseTreeListener 5114 def exitRule(self,listener): 5115 if hasattr( listener, "exitEquality_expression" ): 5116 listener.exitEquality_expression(self) 5117 5118 5119 5120 5121 def equality_expression(self): 5122 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 5126 try: 5127 self.enterOuterAlt(localctx, 1) 5128 self.state = 719 5129 self.relational_expression() 5130 self.state = 724 5131 self._errHandler.sync(self) 5132 _la = self._input.LA(1) 5133 while _la==CParser.T__70 or _la==CParser.T__71: 5134 self.state = 720 5135 _la = self._input.LA(1) 5136 if not(_la==CParser.T__70 or _la==CParser.T__71): 5137 self._errHandler.recoverInline(self) 5138 else: 5139 self._errHandler.reportMatch(self) 5140 self.consume() 5141 self.state = 721 5142 self.relational_expression() 5143 self.state = 726 5144 self._errHandler.sync(self) 5145 _la = self._input.LA(1) 5146 5147 except RecognitionException as re: 5148 localctx.exception = re 5149 self._errHandler.reportError(self, re) 5150 self._errHandler.recover(self, re) 5151 finally: 5152 self.exitRule() 5153 return localctx 5154 5155 class Relational_expressionContext(ParserRuleContext): 5156 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 5162 5163 # @param i=None Type: int 5164 def shift_expression(self,i=None): 5165 if i is None: 5166 return self.getTypedRuleContexts(CParser.Shift_expressionContext) 5167 else: 5168 return self.getTypedRuleContext(CParser.Shift_expressionContext,i) 5169 5170 5171 def getRuleIndex(self): 5172 return CParser.RULE_relational_expression 5173 5174 # @param listener Type: ParseTreeListener 5175 def enterRule(self,listener): 5176 if hasattr( listener, "enterRelational_expression" ): 5177 listener.enterRelational_expression(self) 5178 5179 # @param listener Type: ParseTreeListener 5180 def exitRule(self,listener): 5181 if hasattr( listener, "exitRelational_expression" ): 5182 listener.exitRelational_expression(self) 5183 5184 5185 5186 5187 def relational_expression(self): 5188 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 5192 try: 5193 self.enterOuterAlt(localctx, 1) 5194 self.state = 727 5195 self.shift_expression() 5196 self.state = 732 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): 5200 self.state = 728 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) 5204 else: 5205 self._errHandler.reportMatch(self) 5206 self.consume() 5207 self.state = 729 5208 self.shift_expression() 5209 self.state = 734 5210 self._errHandler.sync(self) 5211 _la = self._input.LA(1) 5212 5213 except RecognitionException as re: 5214 localctx.exception = re 5215 self._errHandler.reportError(self, re) 5216 self._errHandler.recover(self, re) 5217 finally: 5218 self.exitRule() 5219 return localctx 5220 5221 class Shift_expressionContext(ParserRuleContext): 5222 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 5228 5229 # @param i=None Type: int 5230 def additive_expression(self,i=None): 5231 if i is None: 5232 return self.getTypedRuleContexts(CParser.Additive_expressionContext) 5233 else: 5234 return self.getTypedRuleContext(CParser.Additive_expressionContext,i) 5235 5236 5237 def getRuleIndex(self): 5238 return CParser.RULE_shift_expression 5239 5240 # @param listener Type: ParseTreeListener 5241 def enterRule(self,listener): 5242 if hasattr( listener, "enterShift_expression" ): 5243 listener.enterShift_expression(self) 5244 5245 # @param listener Type: ParseTreeListener 5246 def exitRule(self,listener): 5247 if hasattr( listener, "exitShift_expression" ): 5248 listener.exitShift_expression(self) 5249 5250 5251 5252 5253 def shift_expression(self): 5254 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 5258 try: 5259 self.enterOuterAlt(localctx, 1) 5260 self.state = 735 5261 self.additive_expression() 5262 self.state = 740 5263 self._errHandler.sync(self) 5264 _la = self._input.LA(1) 5265 while _la==CParser.T__76 or _la==CParser.T__77: 5266 self.state = 736 5267 _la = self._input.LA(1) 5268 if not(_la==CParser.T__76 or _la==CParser.T__77): 5269 self._errHandler.recoverInline(self) 5270 else: 5271 self._errHandler.reportMatch(self) 5272 self.consume() 5273 self.state = 737 5274 self.additive_expression() 5275 self.state = 742 5276 self._errHandler.sync(self) 5277 _la = self._input.LA(1) 5278 5279 except RecognitionException as re: 5280 localctx.exception = re 5281 self._errHandler.reportError(self, re) 5282 self._errHandler.recover(self, re) 5283 finally: 5284 self.exitRule() 5285 return localctx 5286 5287 class StatementContext(ParserRuleContext): 5288 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 5294 5295 def labeled_statement(self): 5296 return self.getTypedRuleContext(CParser.Labeled_statementContext,0) 5297 5298 5299 def compound_statement(self): 5300 return self.getTypedRuleContext(CParser.Compound_statementContext,0) 5301 5302 5303 def expression_statement(self): 5304 return self.getTypedRuleContext(CParser.Expression_statementContext,0) 5305 5306 5307 def selection_statement(self): 5308 return self.getTypedRuleContext(CParser.Selection_statementContext,0) 5309 5310 5311 def iteration_statement(self): 5312 return self.getTypedRuleContext(CParser.Iteration_statementContext,0) 5313 5314 5315 def jump_statement(self): 5316 return self.getTypedRuleContext(CParser.Jump_statementContext,0) 5317 5318 5319 def macro_statement(self): 5320 return self.getTypedRuleContext(CParser.Macro_statementContext,0) 5321 5322 5323 def asm2_statement(self): 5324 return self.getTypedRuleContext(CParser.Asm2_statementContext,0) 5325 5326 5327 def asm1_statement(self): 5328 return self.getTypedRuleContext(CParser.Asm1_statementContext,0) 5329 5330 5331 def asm_statement(self): 5332 return self.getTypedRuleContext(CParser.Asm_statementContext,0) 5333 5334 5335 def declaration(self): 5336 return self.getTypedRuleContext(CParser.DeclarationContext,0) 5337 5338 5339 def getRuleIndex(self): 5340 return CParser.RULE_statement 5341 5342 # @param listener Type: ParseTreeListener 5343 def enterRule(self,listener): 5344 if hasattr( listener, "enterStatement" ): 5345 listener.enterStatement(self) 5346 5347 # @param listener Type: ParseTreeListener 5348 def exitRule(self,listener): 5349 if hasattr( listener, "exitStatement" ): 5350 listener.exitStatement(self) 5351 5352 5353 5354 5355 def statement(self): 5356 5357 localctx = CParser.StatementContext(self, self._ctx, self.state) 5358 self.enterRule(localctx, 118, self.RULE_statement) 5359 try: 5360 self.state = 754 5361 self._errHandler.sync(self) 5362 la_ = self._interp.adaptivePredict(self._input,92,self._ctx) 5363 if la_ == 1: 5364 self.enterOuterAlt(localctx, 1) 5365 self.state = 743 5366 self.labeled_statement() 5367 pass 5368 5369 elif la_ == 2: 5370 self.enterOuterAlt(localctx, 2) 5371 self.state = 744 5372 self.compound_statement() 5373 pass 5374 5375 elif la_ == 3: 5376 self.enterOuterAlt(localctx, 3) 5377 self.state = 745 5378 self.expression_statement() 5379 pass 5380 5381 elif la_ == 4: 5382 self.enterOuterAlt(localctx, 4) 5383 self.state = 746 5384 self.selection_statement() 5385 pass 5386 5387 elif la_ == 5: 5388 self.enterOuterAlt(localctx, 5) 5389 self.state = 747 5390 self.iteration_statement() 5391 pass 5392 5393 elif la_ == 6: 5394 self.enterOuterAlt(localctx, 6) 5395 self.state = 748 5396 self.jump_statement() 5397 pass 5398 5399 elif la_ == 7: 5400 self.enterOuterAlt(localctx, 7) 5401 self.state = 749 5402 self.macro_statement() 5403 pass 5404 5405 elif la_ == 8: 5406 self.enterOuterAlt(localctx, 8) 5407 self.state = 750 5408 self.asm2_statement() 5409 pass 5410 5411 elif la_ == 9: 5412 self.enterOuterAlt(localctx, 9) 5413 self.state = 751 5414 self.asm1_statement() 5415 pass 5416 5417 elif la_ == 10: 5418 self.enterOuterAlt(localctx, 10) 5419 self.state = 752 5420 self.asm_statement() 5421 pass 5422 5423 elif la_ == 11: 5424 self.enterOuterAlt(localctx, 11) 5425 self.state = 753 5426 self.declaration() 5427 pass 5428 5429 5430 except RecognitionException as re: 5431 localctx.exception = re 5432 self._errHandler.reportError(self, re) 5433 self._errHandler.recover(self, re) 5434 finally: 5435 self.exitRule() 5436 return localctx 5437 5438 class Asm2_statementContext(ParserRuleContext): 5439 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 5445 5446 def IDENTIFIER(self): 5447 return self.getToken(CParser.IDENTIFIER, 0) 5448 5449 def getRuleIndex(self): 5450 return CParser.RULE_asm2_statement 5451 5452 # @param listener Type: ParseTreeListener 5453 def enterRule(self,listener): 5454 if hasattr( listener, "enterAsm2_statement" ): 5455 listener.enterAsm2_statement(self) 5456 5457 # @param listener Type: ParseTreeListener 5458 def exitRule(self,listener): 5459 if hasattr( listener, "exitAsm2_statement" ): 5460 listener.exitAsm2_statement(self) 5461 5462 5463 5464 5465 def asm2_statement(self): 5466 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 5470 try: 5471 self.enterOuterAlt(localctx, 1) 5472 self.state = 757 5473 self._errHandler.sync(self) 5474 _la = self._input.LA(1) 5475 if _la==CParser.T__78: 5476 self.state = 756 5477 self.match(CParser.T__78) 5478 5479 5480 self.state = 759 5481 self.match(CParser.IDENTIFIER) 5482 self.state = 760 5483 self.match(CParser.T__37) 5484 self.state = 764 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: 5488 if _alt==1: 5489 self.state = 761 5490 _la = self._input.LA(1) 5491 if _la <= 0 or _la==CParser.T__1: 5492 self._errHandler.recoverInline(self) 5493 else: 5494 self._errHandler.reportMatch(self) 5495 self.consume() 5496 self.state = 766 5497 self._errHandler.sync(self) 5498 _alt = self._interp.adaptivePredict(self._input,94,self._ctx) 5499 5500 self.state = 767 5501 self.match(CParser.T__38) 5502 self.state = 768 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) 5508 finally: 5509 self.exitRule() 5510 return localctx 5511 5512 class Asm1_statementContext(ParserRuleContext): 5513 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 5519 5520 5521 def getRuleIndex(self): 5522 return CParser.RULE_asm1_statement 5523 5524 # @param listener Type: ParseTreeListener 5525 def enterRule(self,listener): 5526 if hasattr( listener, "enterAsm1_statement" ): 5527 listener.enterAsm1_statement(self) 5528 5529 # @param listener Type: ParseTreeListener 5530 def exitRule(self,listener): 5531 if hasattr( listener, "exitAsm1_statement" ): 5532 listener.exitAsm1_statement(self) 5533 5534 5535 5536 5537 def asm1_statement(self): 5538 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 5542 try: 5543 self.enterOuterAlt(localctx, 1) 5544 self.state = 770 5545 self.match(CParser.T__79) 5546 self.state = 771 5547 self.match(CParser.T__0) 5548 self.state = 775 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): 5552 self.state = 772 5553 _la = self._input.LA(1) 5554 if _la <= 0 or _la==CParser.T__19: 5555 self._errHandler.recoverInline(self) 5556 else: 5557 self._errHandler.reportMatch(self) 5558 self.consume() 5559 self.state = 777 5560 self._errHandler.sync(self) 5561 _la = self._input.LA(1) 5562 5563 self.state = 778 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) 5569 finally: 5570 self.exitRule() 5571 return localctx 5572 5573 class Asm_statementContext(ParserRuleContext): 5574 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 5580 5581 5582 def getRuleIndex(self): 5583 return CParser.RULE_asm_statement 5584 5585 # @param listener Type: ParseTreeListener 5586 def enterRule(self,listener): 5587 if hasattr( listener, "enterAsm_statement" ): 5588 listener.enterAsm_statement(self) 5589 5590 # @param listener Type: ParseTreeListener 5591 def exitRule(self,listener): 5592 if hasattr( listener, "exitAsm_statement" ): 5593 listener.exitAsm_statement(self) 5594 5595 5596 5597 5598 def asm_statement(self): 5599 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 5603 try: 5604 self.enterOuterAlt(localctx, 1) 5605 self.state = 780 5606 self.match(CParser.T__80) 5607 self.state = 781 5608 self.match(CParser.T__0) 5609 self.state = 785 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): 5613 self.state = 782 5614 _la = self._input.LA(1) 5615 if _la <= 0 or _la==CParser.T__19: 5616 self._errHandler.recoverInline(self) 5617 else: 5618 self._errHandler.reportMatch(self) 5619 self.consume() 5620 self.state = 787 5621 self._errHandler.sync(self) 5622 _la = self._input.LA(1) 5623 5624 self.state = 788 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) 5630 finally: 5631 self.exitRule() 5632 return localctx 5633 5634 class Macro_statementContext(ParserRuleContext): 5635 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 5641 5642 def IDENTIFIER(self): 5643 return self.getToken(CParser.IDENTIFIER, 0) 5644 5645 # @param i=None Type: int 5646 def declaration(self,i=None): 5647 if i is None: 5648 return self.getTypedRuleContexts(CParser.DeclarationContext) 5649 else: 5650 return self.getTypedRuleContext(CParser.DeclarationContext,i) 5651 5652 5653 def statement_list(self): 5654 return self.getTypedRuleContext(CParser.Statement_listContext,0) 5655 5656 5657 def expression(self): 5658 return self.getTypedRuleContext(CParser.ExpressionContext,0) 5659 5660 5661 def getRuleIndex(self): 5662 return CParser.RULE_macro_statement 5663 5664 # @param listener Type: ParseTreeListener 5665 def enterRule(self,listener): 5666 if hasattr( listener, "enterMacro_statement" ): 5667 listener.enterMacro_statement(self) 5668 5669 # @param listener Type: ParseTreeListener 5670 def exitRule(self,listener): 5671 if hasattr( listener, "exitMacro_statement" ): 5672 listener.exitMacro_statement(self) 5673 5674 5675 5676 5677 def macro_statement(self): 5678 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 5682 try: 5683 self.enterOuterAlt(localctx, 1) 5684 self.state = 790 5685 self.match(CParser.IDENTIFIER) 5686 self.state = 791 5687 self.match(CParser.T__37) 5688 self.state = 795 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: 5692 if _alt==1: 5693 self.state = 792 5694 self.declaration() 5695 self.state = 797 5696 self._errHandler.sync(self) 5697 _alt = self._interp.adaptivePredict(self._input,97,self._ctx) 5698 5699 self.state = 799 5700 self._errHandler.sync(self) 5701 la_ = self._interp.adaptivePredict(self._input,98,self._ctx) 5702 if la_ == 1: 5703 self.state = 798 5704 self.statement_list() 5705 5706 5707 self.state = 802 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): 5711 self.state = 801 5712 self.expression() 5713 5714 5715 self.state = 804 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) 5721 finally: 5722 self.exitRule() 5723 return localctx 5724 5725 class Labeled_statementContext(ParserRuleContext): 5726 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 5732 5733 def IDENTIFIER(self): 5734 return self.getToken(CParser.IDENTIFIER, 0) 5735 5736 def statement(self): 5737 return self.getTypedRuleContext(CParser.StatementContext,0) 5738 5739 5740 def constant_expression(self): 5741 return self.getTypedRuleContext(CParser.Constant_expressionContext,0) 5742 5743 5744 def getRuleIndex(self): 5745 return CParser.RULE_labeled_statement 5746 5747 # @param listener Type: ParseTreeListener 5748 def enterRule(self,listener): 5749 if hasattr( listener, "enterLabeled_statement" ): 5750 listener.enterLabeled_statement(self) 5751 5752 # @param listener Type: ParseTreeListener 5753 def exitRule(self,listener): 5754 if hasattr( listener, "exitLabeled_statement" ): 5755 listener.exitLabeled_statement(self) 5756 5757 5758 5759 5760 def labeled_statement(self): 5761 5762 localctx = CParser.Labeled_statementContext(self, self._ctx, self.state) 5763 self.enterRule(localctx, 128, self.RULE_labeled_statement) 5764 try: 5765 self.state = 817 5766 self._errHandler.sync(self) 5767 token = self._input.LA(1) 5768 if token in [CParser.IDENTIFIER]: 5769 self.enterOuterAlt(localctx, 1) 5770 self.state = 806 5771 self.match(CParser.IDENTIFIER) 5772 self.state = 807 5773 self.match(CParser.T__22) 5774 self.state = 808 5775 self.statement() 5776 pass 5777 elif token in [CParser.T__81]: 5778 self.enterOuterAlt(localctx, 2) 5779 self.state = 809 5780 self.match(CParser.T__81) 5781 self.state = 810 5782 self.constant_expression() 5783 self.state = 811 5784 self.match(CParser.T__22) 5785 self.state = 812 5786 self.statement() 5787 pass 5788 elif token in [CParser.T__82]: 5789 self.enterOuterAlt(localctx, 3) 5790 self.state = 814 5791 self.match(CParser.T__82) 5792 self.state = 815 5793 self.match(CParser.T__22) 5794 self.state = 816 5795 self.statement() 5796 pass 5797 else: 5798 raise NoViableAltException(self) 5799 5800 except RecognitionException as re: 5801 localctx.exception = re 5802 self._errHandler.reportError(self, re) 5803 self._errHandler.recover(self, re) 5804 finally: 5805 self.exitRule() 5806 return localctx 5807 5808 class Compound_statementContext(ParserRuleContext): 5809 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 5815 5816 # @param i=None Type: int 5817 def declaration(self,i=None): 5818 if i is None: 5819 return self.getTypedRuleContexts(CParser.DeclarationContext) 5820 else: 5821 return self.getTypedRuleContext(CParser.DeclarationContext,i) 5822 5823 5824 def statement_list(self): 5825 return self.getTypedRuleContext(CParser.Statement_listContext,0) 5826 5827 5828 def getRuleIndex(self): 5829 return CParser.RULE_compound_statement 5830 5831 # @param listener Type: ParseTreeListener 5832 def enterRule(self,listener): 5833 if hasattr( listener, "enterCompound_statement" ): 5834 listener.enterCompound_statement(self) 5835 5836 # @param listener Type: ParseTreeListener 5837 def exitRule(self,listener): 5838 if hasattr( listener, "exitCompound_statement" ): 5839 listener.exitCompound_statement(self) 5840 5841 5842 5843 5844 def compound_statement(self): 5845 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 5849 try: 5850 self.enterOuterAlt(localctx, 1) 5851 self.state = 819 5852 self.match(CParser.T__0) 5853 self.state = 823 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: 5857 if _alt==1: 5858 self.state = 820 5859 self.declaration() 5860 self.state = 825 5861 self._errHandler.sync(self) 5862 _alt = self._interp.adaptivePredict(self._input,101,self._ctx) 5863 5864 self.state = 827 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): 5868 self.state = 826 5869 self.statement_list() 5870 5871 5872 self.state = 829 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) 5878 finally: 5879 self.exitRule() 5880 return localctx 5881 5882 class Statement_listContext(ParserRuleContext): 5883 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 5889 5890 # @param i=None Type: int 5891 def statement(self,i=None): 5892 if i is None: 5893 return self.getTypedRuleContexts(CParser.StatementContext) 5894 else: 5895 return self.getTypedRuleContext(CParser.StatementContext,i) 5896 5897 5898 def getRuleIndex(self): 5899 return CParser.RULE_statement_list 5900 5901 # @param listener Type: ParseTreeListener 5902 def enterRule(self,listener): 5903 if hasattr( listener, "enterStatement_list" ): 5904 listener.enterStatement_list(self) 5905 5906 # @param listener Type: ParseTreeListener 5907 def exitRule(self,listener): 5908 if hasattr( listener, "exitStatement_list" ): 5909 listener.exitStatement_list(self) 5910 5911 5912 5913 5914 def statement_list(self): 5915 5916 localctx = CParser.Statement_listContext(self, self._ctx, self.state) 5917 self.enterRule(localctx, 132, self.RULE_statement_list) 5918 try: 5919 self.enterOuterAlt(localctx, 1) 5920 self.state = 832 5921 self._errHandler.sync(self) 5922 _alt = 1 5923 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 5924 if _alt == 1: 5925 self.state = 831 5926 self.statement() 5927 5928 else: 5929 raise NoViableAltException(self) 5930 self.state = 834 5931 self._errHandler.sync(self) 5932 _alt = self._interp.adaptivePredict(self._input,103,self._ctx) 5933 5934 except RecognitionException as re: 5935 localctx.exception = re 5936 self._errHandler.reportError(self, re) 5937 self._errHandler.recover(self, re) 5938 finally: 5939 self.exitRule() 5940 return localctx 5941 5942 class Expression_statementContext(ParserRuleContext): 5943 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 5949 5950 def expression(self): 5951 return self.getTypedRuleContext(CParser.ExpressionContext,0) 5952 5953 5954 def getRuleIndex(self): 5955 return CParser.RULE_expression_statement 5956 5957 # @param listener Type: ParseTreeListener 5958 def enterRule(self,listener): 5959 if hasattr( listener, "enterExpression_statement" ): 5960 listener.enterExpression_statement(self) 5961 5962 # @param listener Type: ParseTreeListener 5963 def exitRule(self,listener): 5964 if hasattr( listener, "exitExpression_statement" ): 5965 listener.exitExpression_statement(self) 5966 5967 5968 5969 5970 def expression_statement(self): 5971 5972 localctx = CParser.Expression_statementContext(self, self._ctx, self.state) 5973 self.enterRule(localctx, 134, self.RULE_expression_statement) 5974 try: 5975 self.state = 840 5976 self._errHandler.sync(self) 5977 token = self._input.LA(1) 5978 if token in [CParser.T__1]: 5979 self.enterOuterAlt(localctx, 1) 5980 self.state = 836 5981 self.match(CParser.T__1) 5982 pass 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) 5985 self.state = 837 5986 self.expression() 5987 self.state = 838 5988 self.match(CParser.T__1) 5989 pass 5990 else: 5991 raise NoViableAltException(self) 5992 5993 except RecognitionException as re: 5994 localctx.exception = re 5995 self._errHandler.reportError(self, re) 5996 self._errHandler.recover(self, re) 5997 finally: 5998 self.exitRule() 5999 return localctx 6000 6001 class Selection_statementContext(ParserRuleContext): 6002 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 6009 6010 # @param i=None Type: int 6011 def statement(self,i=None): 6012 if i is None: 6013 return self.getTypedRuleContexts(CParser.StatementContext) 6014 else: 6015 return self.getTypedRuleContext(CParser.StatementContext,i) 6016 6017 6018 def expression(self): 6019 return self.getTypedRuleContext(CParser.ExpressionContext,0) 6020 6021 6022 def getRuleIndex(self): 6023 return CParser.RULE_selection_statement 6024 6025 # @param listener Type: ParseTreeListener 6026 def enterRule(self,listener): 6027 if hasattr( listener, "enterSelection_statement" ): 6028 listener.enterSelection_statement(self) 6029 6030 # @param listener Type: ParseTreeListener 6031 def exitRule(self,listener): 6032 if hasattr( listener, "exitSelection_statement" ): 6033 listener.exitSelection_statement(self) 6034 6035 6036 6037 6038 def selection_statement(self): 6039 6040 localctx = CParser.Selection_statementContext(self, self._ctx, self.state) 6041 self.enterRule(localctx, 136, self.RULE_selection_statement) 6042 try: 6043 self.state = 858 6044 self._errHandler.sync(self) 6045 token = self._input.LA(1) 6046 if token in [CParser.T__83]: 6047 self.enterOuterAlt(localctx, 1) 6048 self.state = 842 6049 self.match(CParser.T__83) 6050 self.state = 843 6051 self.match(CParser.T__37) 6052 self.state = 844 6053 localctx.e = self.expression() 6054 self.state = 845 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)))) 6057 self.state = 847 6058 self.statement() 6059 self.state = 850 6060 self._errHandler.sync(self) 6061 la_ = self._interp.adaptivePredict(self._input,105,self._ctx) 6062 if la_ == 1: 6063 self.state = 848 6064 self.match(CParser.T__84) 6065 self.state = 849 6066 self.statement() 6067 6068 6069 pass 6070 elif token in [CParser.T__85]: 6071 self.enterOuterAlt(localctx, 2) 6072 self.state = 852 6073 self.match(CParser.T__85) 6074 self.state = 853 6075 self.match(CParser.T__37) 6076 self.state = 854 6077 self.expression() 6078 self.state = 855 6079 self.match(CParser.T__38) 6080 self.state = 856 6081 self.statement() 6082 pass 6083 else: 6084 raise NoViableAltException(self) 6085 6086 except RecognitionException as re: 6087 localctx.exception = re 6088 self._errHandler.reportError(self, re) 6089 self._errHandler.recover(self, re) 6090 finally: 6091 self.exitRule() 6092 return localctx 6093 6094 class Iteration_statementContext(ParserRuleContext): 6095 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 6102 6103 def statement(self): 6104 return self.getTypedRuleContext(CParser.StatementContext,0) 6105 6106 6107 def expression(self): 6108 return self.getTypedRuleContext(CParser.ExpressionContext,0) 6109 6110 6111 def getRuleIndex(self): 6112 return CParser.RULE_iteration_statement 6113 6114 # @param listener Type: ParseTreeListener 6115 def enterRule(self,listener): 6116 if hasattr( listener, "enterIteration_statement" ): 6117 listener.enterIteration_statement(self) 6118 6119 # @param listener Type: ParseTreeListener 6120 def exitRule(self,listener): 6121 if hasattr( listener, "exitIteration_statement" ): 6122 listener.exitIteration_statement(self) 6123 6124 6125 6126 6127 def iteration_statement(self): 6128 6129 localctx = CParser.Iteration_statementContext(self, self._ctx, self.state) 6130 self.enterRule(localctx, 138, self.RULE_iteration_statement) 6131 try: 6132 self.state = 876 6133 self._errHandler.sync(self) 6134 token = self._input.LA(1) 6135 if token in [CParser.T__86]: 6136 self.enterOuterAlt(localctx, 1) 6137 self.state = 860 6138 self.match(CParser.T__86) 6139 self.state = 861 6140 self.match(CParser.T__37) 6141 self.state = 862 6142 localctx.e = self.expression() 6143 self.state = 863 6144 self.match(CParser.T__38) 6145 self.state = 864 6146 self.statement() 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)))) 6148 pass 6149 elif token in [CParser.T__87]: 6150 self.enterOuterAlt(localctx, 2) 6151 self.state = 867 6152 self.match(CParser.T__87) 6153 self.state = 868 6154 self.statement() 6155 self.state = 869 6156 self.match(CParser.T__86) 6157 self.state = 870 6158 self.match(CParser.T__37) 6159 self.state = 871 6160 localctx.e = self.expression() 6161 self.state = 872 6162 self.match(CParser.T__38) 6163 self.state = 873 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)))) 6166 pass 6167 else: 6168 raise NoViableAltException(self) 6169 6170 except RecognitionException as re: 6171 localctx.exception = re 6172 self._errHandler.reportError(self, re) 6173 self._errHandler.recover(self, re) 6174 finally: 6175 self.exitRule() 6176 return localctx 6177 6178 class Jump_statementContext(ParserRuleContext): 6179 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 6185 6186 def IDENTIFIER(self): 6187 return self.getToken(CParser.IDENTIFIER, 0) 6188 6189 def expression(self): 6190 return self.getTypedRuleContext(CParser.ExpressionContext,0) 6191 6192 6193 def getRuleIndex(self): 6194 return CParser.RULE_jump_statement 6195 6196 # @param listener Type: ParseTreeListener 6197 def enterRule(self,listener): 6198 if hasattr( listener, "enterJump_statement" ): 6199 listener.enterJump_statement(self) 6200 6201 # @param listener Type: ParseTreeListener 6202 def exitRule(self,listener): 6203 if hasattr( listener, "exitJump_statement" ): 6204 listener.exitJump_statement(self) 6205 6206 6207 6208 6209 def jump_statement(self): 6210 6211 localctx = CParser.Jump_statementContext(self, self._ctx, self.state) 6212 self.enterRule(localctx, 140, self.RULE_jump_statement) 6213 try: 6214 self.state = 891 6215 self._errHandler.sync(self) 6216 la_ = self._interp.adaptivePredict(self._input,108,self._ctx) 6217 if la_ == 1: 6218 self.enterOuterAlt(localctx, 1) 6219 self.state = 878 6220 self.match(CParser.T__88) 6221 self.state = 879 6222 self.match(CParser.IDENTIFIER) 6223 self.state = 880 6224 self.match(CParser.T__1) 6225 pass 6226 6227 elif la_ == 2: 6228 self.enterOuterAlt(localctx, 2) 6229 self.state = 881 6230 self.match(CParser.T__89) 6231 self.state = 882 6232 self.match(CParser.T__1) 6233 pass 6234 6235 elif la_ == 3: 6236 self.enterOuterAlt(localctx, 3) 6237 self.state = 883 6238 self.match(CParser.T__90) 6239 self.state = 884 6240 self.match(CParser.T__1) 6241 pass 6242 6243 elif la_ == 4: 6244 self.enterOuterAlt(localctx, 4) 6245 self.state = 885 6246 self.match(CParser.T__91) 6247 self.state = 886 6248 self.match(CParser.T__1) 6249 pass 6250 6251 elif la_ == 5: 6252 self.enterOuterAlt(localctx, 5) 6253 self.state = 887 6254 self.match(CParser.T__91) 6255 self.state = 888 6256 self.expression() 6257 self.state = 889 6258 self.match(CParser.T__1) 6259 pass 6260 6261 6262 except RecognitionException as re: 6263 localctx.exception = re 6264 self._errHandler.reportError(self, re) 6265 self._errHandler.recover(self, re) 6266 finally: 6267 self.exitRule() 6268 return localctx 6269 6270 6271 6272 6273 6274