BaseTools/Source/Python/Eot/CParser4/CParser.py

   1 # Generated from C.g4 by ANTLR 4.7.1
   2 # encoding: utf-8
   3 from antlr4 import *
   4 from io import StringIO
   5 from typing.io import TextIO
   6 import 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
  22 import Ecc.CodeFragment as CodeFragment
  23 import Ecc.FileProfile as FileProfile
  24
  25 def 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
 478 class 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