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 # This program and the accompanying materials are licensed and made available
  19 # under the terms and conditions of the BSD License which accompanies this
  20 # distribution.  The full text of the license may be found at:
  21 #   http://opensource.org/licenses/bsd-license.php
  22 #
  23 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  24 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  25 #
  26 ##
  27
  28 import Ecc.CodeFragment as CodeFragment
  29 import Ecc.FileProfile as FileProfile
  30
  31 def serializedATN():
  32     with StringIO() as buf:
  33         buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3k")
  34         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")
  35         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")
  36         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
  37         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
  38         buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
  39         buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
  40         buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
  41         buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
  42         buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
  43         buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
  44         buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\3\2\7\2\u0092\n\2\f\2\16\2\u0095")
  45         buf.write("\13\2\3\3\5\3\u0098\n\3\3\3\3\3\7\3\u009c\n\3\f\3\16\3")
  46         buf.write("\u009f\13\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00a7\n\3\5\3")
  47         buf.write("\u00a9\n\3\3\4\5\4\u00ac\n\4\3\4\3\4\6\4\u00b0\n\4\r\4")
  48         buf.write("\16\4\u00b1\3\4\3\4\3\4\5\4\u00b7\n\4\3\4\3\4\3\5\3\5")
  49         buf.write("\3\5\6\5\u00be\n\5\r\5\16\5\u00bf\3\6\3\6\5\6\u00c4\n")
  50         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")
  51         buf.write("\6\u00d1\n\6\3\7\3\7\3\7\7\7\u00d6\n\7\f\7\16\7\u00d9")
  52         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")
  53         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")
  54         buf.write("\7\n\u00f3\n\n\f\n\16\n\u00f6\13\n\3\n\3\n\5\n\u00fa\n")
  55         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")
  56         buf.write("\3\f\3\f\5\f\u0109\n\f\3\r\3\r\3\16\6\16\u010e\n\16\r")
  57         buf.write("\16\16\16\u010f\3\17\3\17\3\17\3\17\3\20\3\20\6\20\u0118")
  58         buf.write("\n\20\r\20\16\20\u0119\3\21\3\21\3\21\7\21\u011f\n\21")
  59         buf.write("\f\21\16\21\u0122\13\21\3\22\3\22\3\22\5\22\u0127\n\22")
  60         buf.write("\3\22\3\22\5\22\u012b\n\22\3\23\3\23\3\23\3\23\5\23\u0131")
  61         buf.write("\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u013a\n")
  62         buf.write("\23\3\23\3\23\3\23\3\23\5\23\u0140\n\23\3\24\3\24\3\24")
  63         buf.write("\7\24\u0145\n\24\f\24\16\24\u0148\13\24\3\25\3\25\3\25")
  64         buf.write("\5\25\u014d\n\25\3\26\3\26\3\27\5\27\u0152\n\27\3\27\5")
  65         buf.write("\27\u0155\n\27\3\27\5\27\u0158\n\27\3\27\5\27\u015b\n")
  66         buf.write("\27\3\27\3\27\5\27\u015f\n\27\3\30\3\30\7\30\u0163\n\30")
  67         buf.write("\f\30\16\30\u0166\13\30\3\30\3\30\5\30\u016a\n\30\3\30")
  68         buf.write("\3\30\3\30\6\30\u016f\n\30\r\30\16\30\u0170\5\30\u0173")
  69         buf.write("\n\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
  70         buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0185\n\31\3\32\3")
  71         buf.write("\32\6\32\u0189\n\32\r\32\16\32\u018a\3\32\5\32\u018e\n")
  72         buf.write("\32\3\32\3\32\3\32\5\32\u0193\n\32\3\33\3\33\3\33\5\33")
  73         buf.write("\u0198\n\33\3\33\5\33\u019b\n\33\3\34\3\34\3\34\5\34\u01a0")
  74         buf.write("\n\34\3\34\7\34\u01a3\n\34\f\34\16\34\u01a6\13\34\3\35")
  75         buf.write("\3\35\3\35\7\35\u01ab\n\35\f\35\16\35\u01ae\13\35\3\35")
  76         buf.write("\5\35\u01b1\n\35\3\35\7\35\u01b4\n\35\f\35\16\35\u01b7")
  77         buf.write("\13\35\3\35\5\35\u01ba\n\35\3\36\3\36\3\36\7\36\u01bf")
  78         buf.write("\n\36\f\36\16\36\u01c2\13\36\3\37\3\37\5\37\u01c6\n\37")
  79         buf.write("\3\37\5\37\u01c9\n\37\3 \3 \5 \u01cd\n \3 \5 \u01d0\n")
  80         buf.write(" \3!\3!\3!\3!\3!\5!\u01d7\n!\3!\7!\u01da\n!\f!\16!\u01dd")
  81         buf.write("\13!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5")
  82         buf.write("\"\u01eb\n\"\3#\3#\3#\3#\5#\u01f1\n#\3#\3#\5#\u01f5\n")
  83         buf.write("#\3$\3$\3$\7$\u01fa\n$\f$\16$\u01fd\13$\3%\3%\5%\u0201")
  84         buf.write("\n%\3%\3%\3%\5%\u0206\n%\7%\u0208\n%\f%\16%\u020b\13%")
  85         buf.write("\3&\3&\3&\3&\3&\7&\u0212\n&\f&\16&\u0215\13&\3\'\3\'\3")
  86         buf.write("\'\3\'\3\'\3\'\3\'\7\'\u021e\n\'\f\'\16\'\u0221\13\'\3")
  87         buf.write("(\3(\3(\3(\3(\3(\5(\u0229\n(\3)\3)\3)\3)\3)\3)\3)\3)\3")
  88         buf.write(")\3)\3)\3)\3)\3)\3)\5)\u023a\n)\3*\3*\3*\3*\3*\3*\3*\3")
  89         buf.write("*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3")
  90         buf.write("*\3*\3*\3*\7*\u0259\n*\f*\16*\u025c\13*\3+\3+\3+\7+\u0261")
  91         buf.write("\n+\f+\16+\u0264\13+\3,\3,\3-\3-\3-\3-\3-\3-\5-\u026e")
  92         buf.write("\n-\3.\3.\3.\3.\3.\7.\u0275\n.\f.\16.\u0278\13.\3.\6.")
  93         buf.write("\u027b\n.\r.\16.\u027c\6.\u027f\n.\r.\16.\u0280\3.\7.")
  94         buf.write("\u0284\n.\f.\16.\u0287\13.\3.\5.\u028a\n.\3/\3/\3/\7/")
  95         buf.write("\u028f\n/\f/\16/\u0292\13/\3\60\3\60\3\61\3\61\3\61\3")
  96         buf.write("\61\3\61\5\61\u029b\n\61\3\62\3\62\3\63\3\63\3\64\3\64")
  97         buf.write("\3\64\3\64\3\64\3\64\3\64\5\64\u02a8\n\64\3\65\3\65\3")
  98         buf.write("\65\7\65\u02ad\n\65\f\65\16\65\u02b0\13\65\3\66\3\66\3")
  99         buf.write("\66\7\66\u02b5\n\66\f\66\16\66\u02b8\13\66\3\67\3\67\3")
 100         buf.write("\67\7\67\u02bd\n\67\f\67\16\67\u02c0\13\67\38\38\38\7")
 101         buf.write("8\u02c5\n8\f8\168\u02c8\138\39\39\39\79\u02cd\n9\f9\16")
 102         buf.write("9\u02d0\139\3:\3:\3:\7:\u02d5\n:\f:\16:\u02d8\13:\3;\3")
 103         buf.write(";\3;\7;\u02dd\n;\f;\16;\u02e0\13;\3<\3<\3<\7<\u02e5\n")
 104         buf.write("<\f<\16<\u02e8\13<\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\5")
 105         buf.write("=\u02f5\n=\3>\5>\u02f8\n>\3>\3>\3>\7>\u02fd\n>\f>\16>")
 106         buf.write("\u0300\13>\3>\3>\3>\3?\3?\3?\7?\u0308\n?\f?\16?\u030b")
 107         buf.write("\13?\3?\3?\3@\3@\3@\7@\u0312\n@\f@\16@\u0315\13@\3@\3")
 108         buf.write("@\3A\3A\3A\7A\u031c\nA\fA\16A\u031f\13A\3A\5A\u0322\n")
 109         buf.write("A\3A\5A\u0325\nA\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3")
 110         buf.write("B\5B\u0334\nB\3C\3C\7C\u0338\nC\fC\16C\u033b\13C\3C\5")
 111         buf.write("C\u033e\nC\3C\3C\3D\6D\u0343\nD\rD\16D\u0344\3E\3E\3E")
 112         buf.write("\3E\5E\u034b\nE\3F\3F\3F\3F\3F\3F\3F\3F\5F\u0355\nF\3")
 113         buf.write("F\3F\3F\3F\3F\3F\5F\u035d\nF\3G\3G\3G\3G\3G\3G\3G\3G\3")
 114         buf.write("G\3G\3G\3G\3G\3G\3G\3G\5G\u036f\nG\3H\3H\3H\3H\3H\3H\3")
 115         buf.write("H\3H\3H\3H\3H\3H\3H\5H\u037e\nH\3H\2\2I\2\4\6\b\n\f\16")
 116         buf.write("\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDF")
 117         buf.write("HJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086")
 118         buf.write("\u0088\u008a\u008c\u008e\2\f\3\2\b\f\3\2\27\30\3\2\33")
 119         buf.write("\'\5\2,,./\679\4\2\7\7:C\3\2IJ\3\2KN\3\2OP\3\2\4\4\3\2")
 120         buf.write("\26\26\2\u03d8\2\u0093\3\2\2\2\4\u00a8\3\2\2\2\6\u00ab")
 121         buf.write("\3\2\2\2\b\u00bd\3\2\2\2\n\u00d0\3\2\2\2\f\u00d2\3\2\2")
 122         buf.write("\2\16\u00da\3\2\2\2\20\u00df\3\2\2\2\22\u00f9\3\2\2\2")
 123         buf.write("\24\u00fb\3\2\2\2\26\u0108\3\2\2\2\30\u010a\3\2\2\2\32")
 124         buf.write("\u010d\3\2\2\2\34\u0111\3\2\2\2\36\u0117\3\2\2\2 \u011b")
 125         buf.write("\3\2\2\2\"\u012a\3\2\2\2$\u013f\3\2\2\2&\u0141\3\2\2\2")
 126         buf.write("(\u0149\3\2\2\2*\u014e\3\2\2\2,\u015e\3\2\2\2.\u0172\3")
 127         buf.write("\2\2\2\60\u0184\3\2\2\2\62\u0192\3\2\2\2\64\u0194\3\2")
 128         buf.write("\2\2\66\u019c\3\2\2\28\u01b9\3\2\2\2:\u01bb\3\2\2\2<\u01c8")
 129         buf.write("\3\2\2\2>\u01cf\3\2\2\2@\u01d6\3\2\2\2B\u01ea\3\2\2\2")
 130         buf.write("D\u01f4\3\2\2\2F\u01f6\3\2\2\2H\u01fe\3\2\2\2J\u020c\3")
 131         buf.write("\2\2\2L\u0216\3\2\2\2N\u0228\3\2\2\2P\u0239\3\2\2\2R\u023b")
 132         buf.write("\3\2\2\2T\u025d\3\2\2\2V\u0265\3\2\2\2X\u026d\3\2\2\2")
 133         buf.write("Z\u0289\3\2\2\2\\\u028b\3\2\2\2^\u0293\3\2\2\2`\u029a")
 134         buf.write("\3\2\2\2b\u029c\3\2\2\2d\u029e\3\2\2\2f\u02a0\3\2\2\2")
 135         buf.write("h\u02a9\3\2\2\2j\u02b1\3\2\2\2l\u02b9\3\2\2\2n\u02c1\3")
 136         buf.write("\2\2\2p\u02c9\3\2\2\2r\u02d1\3\2\2\2t\u02d9\3\2\2\2v\u02e1")
 137         buf.write("\3\2\2\2x\u02f4\3\2\2\2z\u02f7\3\2\2\2|\u0304\3\2\2\2")
 138         buf.write("~\u030e\3\2\2\2\u0080\u0318\3\2\2\2\u0082\u0333\3\2\2")
 139         buf.write("\2\u0084\u0335\3\2\2\2\u0086\u0342\3\2\2\2\u0088\u034a")
 140         buf.write("\3\2\2\2\u008a\u035c\3\2\2\2\u008c\u036e\3\2\2\2\u008e")
 141         buf.write("\u037d\3\2\2\2\u0090\u0092\5\4\3\2\u0091\u0090\3\2\2\2")
 142         buf.write("\u0092\u0095\3\2\2\2\u0093\u0091\3\2\2\2\u0093\u0094\3")
 143         buf.write("\2\2\2\u0094\3\3\2\2\2\u0095\u0093\3\2\2\2\u0096\u0098")
 144         buf.write("\5\b\5\2\u0097\u0096\3\2\2\2\u0097\u0098\3\2\2\2\u0098")
 145         buf.write("\u0099\3\2\2\2\u0099\u009d\5,\27\2\u009a\u009c\5\n\6\2")
 146         buf.write("\u009b\u009a\3\2\2\2\u009c\u009f\3\2\2\2\u009d\u009b\3")
 147         buf.write("\2\2\2\u009d\u009e\3\2\2\2\u009e\u00a0\3\2\2\2\u009f\u009d")
 148         buf.write("\3\2\2\2\u00a0\u00a1\7\3\2\2\u00a1\u00a9\3\2\2\2\u00a2")
 149         buf.write("\u00a9\5\6\4\2\u00a3\u00a9\5\n\6\2\u00a4\u00a6\5\u0080")
 150         buf.write("A\2\u00a5\u00a7\7\4\2\2\u00a6\u00a5\3\2\2\2\u00a6\u00a7")
 151         buf.write("\3\2\2\2\u00a7\u00a9\3\2\2\2\u00a8\u0097\3\2\2\2\u00a8")
 152         buf.write("\u00a2\3\2\2\2\u00a8\u00a3\3\2\2\2\u00a8\u00a4\3\2\2\2")
 153         buf.write("\u00a9\5\3\2\2\2\u00aa\u00ac\5\b\5\2\u00ab\u00aa\3\2\2")
 154         buf.write("\2\u00ab\u00ac\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00b6")
 155         buf.write("\5,\27\2\u00ae\u00b0\5\n\6\2\u00af\u00ae\3\2\2\2\u00b0")
 156         buf.write("\u00b1\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2\2\2")
 157         buf.write("\u00b2\u00b3\3\2\2\2\u00b3\u00b4\5\u0084C\2\u00b4\u00b7")
 158         buf.write("\3\2\2\2\u00b5\u00b7\5\u0084C\2\u00b6\u00af\3\2\2\2\u00b6")
 159         buf.write("\u00b5\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\b\4\1\2")
 160         buf.write("\u00b9\7\3\2\2\2\u00ba\u00be\5\20\t\2\u00bb\u00be\5\22")
 161         buf.write("\n\2\u00bc\u00be\5*\26\2\u00bd\u00ba\3\2\2\2\u00bd\u00bb")
 162         buf.write("\3\2\2\2\u00bd\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf")
 163         buf.write("\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\t\3\2\2\2\u00c1")
 164         buf.write("\u00c3\7\5\2\2\u00c2\u00c4\5\b\5\2\u00c3\u00c2\3\2\2\2")
 165         buf.write("\u00c3\u00c4\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c6\5")
 166         buf.write("\f\7\2\u00c6\u00c7\7\4\2\2\u00c7\u00c8\b\6\1\2\u00c8\u00d1")
 167         buf.write("\3\2\2\2\u00c9\u00cb\5\b\5\2\u00ca\u00cc\5\f\7\2\u00cb")
 168         buf.write("\u00ca\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2")
 169         buf.write("\u00cd\u00ce\7\4\2\2\u00ce\u00cf\b\6\1\2\u00cf\u00d1\3")
 170         buf.write("\2\2\2\u00d0\u00c1\3\2\2\2\u00d0\u00c9\3\2\2\2\u00d1\13")
 171         buf.write("\3\2\2\2\u00d2\u00d7\5\16\b\2\u00d3\u00d4\7\6\2\2\u00d4")
 172         buf.write("\u00d6\5\16\b\2\u00d5\u00d3\3\2\2\2\u00d6\u00d9\3\2\2")
 173         buf.write("\2\u00d7\u00d5\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\r\3\2")
 174         buf.write("\2\2\u00d9\u00d7\3\2\2\2\u00da\u00dd\5,\27\2\u00db\u00dc")
 175         buf.write("\7\7\2\2\u00dc\u00de\5D#\2\u00dd\u00db\3\2\2\2\u00dd\u00de")
 176         buf.write("\3\2\2\2\u00de\17\3\2\2\2\u00df\u00e0\t\2\2\2\u00e0\21")
 177         buf.write("\3\2\2\2\u00e1\u00fa\7\r\2\2\u00e2\u00fa\7\16\2\2\u00e3")
 178         buf.write("\u00fa\7\17\2\2\u00e4\u00fa\7\20\2\2\u00e5\u00fa\7\21")
 179         buf.write("\2\2\u00e6\u00fa\7\22\2\2\u00e7\u00fa\7\23\2\2\u00e8\u00fa")
 180         buf.write("\7\24\2\2\u00e9\u00fa\7\25\2\2\u00ea\u00eb\5\26\f\2\u00eb")
 181         buf.write("\u00ec\b\n\1\2\u00ec\u00fa\3\2\2\2\u00ed\u00ee\5$\23\2")
 182         buf.write("\u00ee\u00ef\b\n\1\2\u00ef\u00fa\3\2\2\2\u00f0\u00f4\7")
 183         buf.write("_\2\2\u00f1\u00f3\5*\26\2\u00f2\u00f1\3\2\2\2\u00f3\u00f6")
 184         buf.write("\3\2\2\2\u00f4\u00f2\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5")
 185         buf.write("\u00f7\3\2\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00fa\5,\27\2")
 186         buf.write("\u00f8\u00fa\5\24\13\2\u00f9\u00e1\3\2\2\2\u00f9\u00e2")
 187         buf.write("\3\2\2\2\u00f9\u00e3\3\2\2\2\u00f9\u00e4\3\2\2\2\u00f9")
 188         buf.write("\u00e5\3\2\2\2\u00f9\u00e6\3\2\2\2\u00f9\u00e7\3\2\2\2")
 189         buf.write("\u00f9\u00e8\3\2\2\2\u00f9\u00e9\3\2\2\2\u00f9\u00ea\3")
 190         buf.write("\2\2\2\u00f9\u00ed\3\2\2\2\u00f9\u00f0\3\2\2\2\u00f9\u00f8")
 191         buf.write("\3\2\2\2\u00fa\23\3\2\2\2\u00fb\u00fc\7_\2\2\u00fc\25")
 192         buf.write("\3\2\2\2\u00fd\u00ff\5\30\r\2\u00fe\u0100\7_\2\2\u00ff")
 193         buf.write("\u00fe\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101\3\2\2\2")
 194         buf.write("\u0101\u0102\7\3\2\2\u0102\u0103\5\32\16\2\u0103\u0104")
 195         buf.write("\7\26\2\2\u0104\u0109\3\2\2\2\u0105\u0106\5\30\r\2\u0106")
 196         buf.write("\u0107\7_\2\2\u0107\u0109\3\2\2\2\u0108\u00fd\3\2\2\2")
 197         buf.write("\u0108\u0105\3\2\2\2\u0109\27\3\2\2\2\u010a\u010b\t\3")
 198         buf.write("\2\2\u010b\31\3\2\2\2\u010c\u010e\5\34\17\2\u010d\u010c")
 199         buf.write("\3\2\2\2\u010e\u010f\3\2\2\2\u010f\u010d\3\2\2\2\u010f")
 200         buf.write("\u0110\3\2\2\2\u0110\33\3\2\2\2\u0111\u0112\5\36\20\2")
 201         buf.write("\u0112\u0113\5 \21\2\u0113\u0114\7\4\2\2\u0114\35\3\2")
 202         buf.write("\2\2\u0115\u0118\5*\26\2\u0116\u0118\5\22\n\2\u0117\u0115")
 203         buf.write("\3\2\2\2\u0117\u0116\3\2\2\2\u0118\u0119\3\2\2\2\u0119")
 204         buf.write("\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a\37\3\2\2\2\u011b")
 205         buf.write("\u0120\5\"\22\2\u011c\u011d\7\6\2\2\u011d\u011f\5\"\22")
 206         buf.write("\2\u011e\u011c\3\2\2\2\u011f\u0122\3\2\2\2\u0120\u011e")
 207         buf.write("\3\2\2\2\u0120\u0121\3\2\2\2\u0121!\3\2\2\2\u0122\u0120")
 208         buf.write("\3\2\2\2\u0123\u0126\5,\27\2\u0124\u0125\7\31\2\2\u0125")
 209         buf.write("\u0127\5^\60\2\u0126\u0124\3\2\2\2\u0126\u0127\3\2\2\2")
 210         buf.write("\u0127\u012b\3\2\2\2\u0128\u0129\7\31\2\2\u0129\u012b")
 211         buf.write("\5^\60\2\u012a\u0123\3\2\2\2\u012a\u0128\3\2\2\2\u012b")
 212         buf.write("#\3\2\2\2\u012c\u012d\7\32\2\2\u012d\u012e\7\3\2\2\u012e")
 213         buf.write("\u0130\5&\24\2\u012f\u0131\7\6\2\2\u0130\u012f\3\2\2\2")
 214         buf.write("\u0130\u0131\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0133\7")
 215         buf.write("\26\2\2\u0133\u0140\3\2\2\2\u0134\u0135\7\32\2\2\u0135")
 216         buf.write("\u0136\7_\2\2\u0136\u0137\7\3\2\2\u0137\u0139\5&\24\2")
 217         buf.write("\u0138\u013a\7\6\2\2\u0139\u0138\3\2\2\2\u0139\u013a\3")
 218         buf.write("\2\2\2\u013a\u013b\3\2\2\2\u013b\u013c\7\26\2\2\u013c")
 219         buf.write("\u0140\3\2\2\2\u013d\u013e\7\32\2\2\u013e\u0140\7_\2\2")
 220         buf.write("\u013f\u012c\3\2\2\2\u013f\u0134\3\2\2\2\u013f\u013d\3")
 221         buf.write("\2\2\2\u0140%\3\2\2\2\u0141\u0146\5(\25\2\u0142\u0143")
 222         buf.write("\7\6\2\2\u0143\u0145\5(\25\2\u0144\u0142\3\2\2\2\u0145")
 223         buf.write("\u0148\3\2\2\2\u0146\u0144\3\2\2\2\u0146\u0147\3\2\2\2")
 224         buf.write("\u0147\'\3\2\2\2\u0148\u0146\3\2\2\2\u0149\u014c\7_\2")
 225         buf.write("\2\u014a\u014b\7\7\2\2\u014b\u014d\5^\60\2\u014c\u014a")
 226         buf.write("\3\2\2\2\u014c\u014d\3\2\2\2\u014d)\3\2\2\2\u014e\u014f")
 227         buf.write("\t\4\2\2\u014f+\3\2\2\2\u0150\u0152\5\62\32\2\u0151\u0150")
 228         buf.write("\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0154\3\2\2\2\u0153")
 229         buf.write("\u0155\7$\2\2\u0154\u0153\3\2\2\2\u0154\u0155\3\2\2\2")
 230         buf.write("\u0155\u0157\3\2\2\2\u0156\u0158\7%\2\2\u0157\u0156\3")
 231         buf.write("\2\2\2\u0157\u0158\3\2\2\2\u0158\u015a\3\2\2\2\u0159\u015b")
 232         buf.write("\7&\2\2\u015a\u0159\3\2\2\2\u015a\u015b\3\2\2\2\u015b")
 233         buf.write("\u015c\3\2\2\2\u015c\u015f\5.\30\2\u015d\u015f\5\62\32")
 234         buf.write("\2\u015e\u0151\3\2\2\2\u015e\u015d\3\2\2\2\u015f-\3\2")
 235         buf.write("\2\2\u0160\u0164\7_\2\2\u0161\u0163\5\60\31\2\u0162\u0161")
 236         buf.write("\3\2\2\2\u0163\u0166\3\2\2\2\u0164\u0162\3\2\2\2\u0164")
 237         buf.write("\u0165\3\2\2\2\u0165\u0173\3\2\2\2\u0166\u0164\3\2\2\2")
 238         buf.write("\u0167\u0169\7(\2\2\u0168\u016a\7$\2\2\u0169\u0168\3\2")
 239         buf.write("\2\2\u0169\u016a\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u016c")
 240         buf.write("\5,\27\2\u016c\u016e\7)\2\2\u016d\u016f\5\60\31\2\u016e")
 241         buf.write("\u016d\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u016e\3\2\2\2")
 242         buf.write("\u0170\u0171\3\2\2\2\u0171\u0173\3\2\2\2\u0172\u0160\3")
 243         buf.write("\2\2\2\u0172\u0167\3\2\2\2\u0173/\3\2\2\2\u0174\u0175")
 244         buf.write("\7*\2\2\u0175\u0176\5^\60\2\u0176\u0177\7+\2\2\u0177\u0185")
 245         buf.write("\3\2\2\2\u0178\u0179\7*\2\2\u0179\u0185\7+\2\2\u017a\u017b")
 246         buf.write("\7(\2\2\u017b\u017c\5\64\33\2\u017c\u017d\7)\2\2\u017d")
 247         buf.write("\u0185\3\2\2\2\u017e\u017f\7(\2\2\u017f\u0180\5:\36\2")
 248         buf.write("\u0180\u0181\7)\2\2\u0181\u0185\3\2\2\2\u0182\u0183\7")
 249         buf.write("(\2\2\u0183\u0185\7)\2\2\u0184\u0174\3\2\2\2\u0184\u0178")
 250         buf.write("\3\2\2\2\u0184\u017a\3\2\2\2\u0184\u017e\3\2\2\2\u0184")
 251         buf.write("\u0182\3\2\2\2\u0185\61\3\2\2\2\u0186\u0188\7,\2\2\u0187")
 252         buf.write("\u0189\5*\26\2\u0188\u0187\3\2\2\2\u0189\u018a\3\2\2\2")
 253         buf.write("\u018a\u0188\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018d\3")
 254         buf.write("\2\2\2\u018c\u018e\5\62\32\2\u018d\u018c\3\2\2\2\u018d")
 255         buf.write("\u018e\3\2\2\2\u018e\u0193\3\2\2\2\u018f\u0190\7,\2\2")
 256         buf.write("\u0190\u0193\5\62\32\2\u0191\u0193\7,\2\2\u0192\u0186")
 257         buf.write("\3\2\2\2\u0192\u018f\3\2\2\2\u0192\u0191\3\2\2\2\u0193")
 258         buf.write("\63\3\2\2\2\u0194\u019a\5\66\34\2\u0195\u0197\7\6\2\2")
 259         buf.write("\u0196\u0198\7\37\2\2\u0197\u0196\3\2\2\2\u0197\u0198")
 260         buf.write("\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019b\7-\2\2\u019a")
 261         buf.write("\u0195\3\2\2\2\u019a\u019b\3\2\2\2\u019b\65\3\2\2\2\u019c")
 262         buf.write("\u01a4\58\35\2\u019d\u019f\7\6\2\2\u019e\u01a0\7\37\2")
 263         buf.write("\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1")
 264         buf.write("\3\2\2\2\u01a1\u01a3\58\35\2\u01a2\u019d\3\2\2\2\u01a3")
 265         buf.write("\u01a6\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2")
 266         buf.write("\u01a5\67\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a7\u01ac\5\b")
 267         buf.write("\5\2\u01a8\u01ab\5,\27\2\u01a9\u01ab\5> \2\u01aa\u01a8")
 268         buf.write("\3\2\2\2\u01aa\u01a9\3\2\2\2\u01ab\u01ae\3\2\2\2\u01ac")
 269         buf.write("\u01aa\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\u01b0\3\2\2\2")
 270         buf.write("\u01ae\u01ac\3\2\2\2\u01af\u01b1\7\37\2\2\u01b0\u01af")
 271         buf.write("\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01ba\3\2\2\2\u01b2")
 272         buf.write("\u01b4\5\62\32\2\u01b3\u01b2\3\2\2\2\u01b4\u01b7\3\2\2")
 273         buf.write("\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b8")
 274         buf.write("\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01ba\7_\2\2\u01b9")
 275         buf.write("\u01a7\3\2\2\2\u01b9\u01b5\3\2\2\2\u01ba9\3\2\2\2\u01bb")
 276         buf.write("\u01c0\7_\2\2\u01bc\u01bd\7\6\2\2\u01bd\u01bf\7_\2\2\u01be")
 277         buf.write("\u01bc\3\2\2\2\u01bf\u01c2\3\2\2\2\u01c0\u01be\3\2\2\2")
 278         buf.write("\u01c0\u01c1\3\2\2\2\u01c1;\3\2\2\2\u01c2\u01c0\3\2\2")
 279         buf.write("\2\u01c3\u01c5\5\36\20\2\u01c4\u01c6\5> \2\u01c5\u01c4")
 280         buf.write("\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6\u01c9\3\2\2\2\u01c7")
 281         buf.write("\u01c9\5\24\13\2\u01c8\u01c3\3\2\2\2\u01c8\u01c7\3\2\2")
 282         buf.write("\2\u01c9=\3\2\2\2\u01ca\u01cc\5\62\32\2\u01cb\u01cd\5")
 283         buf.write("@!\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01d0")
 284         buf.write("\3\2\2\2\u01ce\u01d0\5@!\2\u01cf\u01ca\3\2\2\2\u01cf\u01ce")
 285         buf.write("\3\2\2\2\u01d0?\3\2\2\2\u01d1\u01d2\7(\2\2\u01d2\u01d3")
 286         buf.write("\5> \2\u01d3\u01d4\7)\2\2\u01d4\u01d7\3\2\2\2\u01d5\u01d7")
 287         buf.write("\5B\"\2\u01d6\u01d1\3\2\2\2\u01d6\u01d5\3\2\2\2\u01d7")
 288         buf.write("\u01db\3\2\2\2\u01d8\u01da\5B\"\2\u01d9\u01d8\3\2\2\2")
 289         buf.write("\u01da\u01dd\3\2\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3")
 290         buf.write("\2\2\2\u01dcA\3\2\2\2\u01dd\u01db\3\2\2\2\u01de\u01df")
 291         buf.write("\7*\2\2\u01df\u01eb\7+\2\2\u01e0\u01e1\7*\2\2\u01e1\u01e2")
 292         buf.write("\5^\60\2\u01e2\u01e3\7+\2\2\u01e3\u01eb\3\2\2\2\u01e4")
 293         buf.write("\u01e5\7(\2\2\u01e5\u01eb\7)\2\2\u01e6\u01e7\7(\2\2\u01e7")
 294         buf.write("\u01e8\5\64\33\2\u01e8\u01e9\7)\2\2\u01e9\u01eb\3\2\2")
 295         buf.write("\2\u01ea\u01de\3\2\2\2\u01ea\u01e0\3\2\2\2\u01ea\u01e4")
 296         buf.write("\3\2\2\2\u01ea\u01e6\3\2\2\2\u01ebC\3\2\2\2\u01ec\u01f5")
 297         buf.write("\5`\61\2\u01ed\u01ee\7\3\2\2\u01ee\u01f0\5F$\2\u01ef\u01f1")
 298         buf.write("\7\6\2\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1")
 299         buf.write("\u01f2\3\2\2\2\u01f2\u01f3\7\26\2\2\u01f3\u01f5\3\2\2")
 300         buf.write("\2\u01f4\u01ec\3\2\2\2\u01f4\u01ed\3\2\2\2\u01f5E\3\2")
 301         buf.write("\2\2\u01f6\u01fb\5D#\2\u01f7\u01f8\7\6\2\2\u01f8\u01fa")
 302         buf.write("\5D#\2\u01f9\u01f7\3\2\2\2\u01fa\u01fd\3\2\2\2\u01fb\u01f9")
 303         buf.write("\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fcG\3\2\2\2\u01fd\u01fb")
 304         buf.write("\3\2\2\2\u01fe\u0200\5`\61\2\u01ff\u0201\7\37\2\2\u0200")
 305         buf.write("\u01ff\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0209\3\2\2\2")
 306         buf.write("\u0202\u0203\7\6\2\2\u0203\u0205\5`\61\2\u0204\u0206\7")
 307         buf.write("\37\2\2\u0205\u0204\3\2\2\2\u0205\u0206\3\2\2\2\u0206")
 308         buf.write("\u0208\3\2\2\2\u0207\u0202\3\2\2\2\u0208\u020b\3\2\2\2")
 309         buf.write("\u0209\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020aI\3\2\2")
 310         buf.write("\2\u020b\u0209\3\2\2\2\u020c\u0213\5L\'\2\u020d\u020e")
 311         buf.write("\7.\2\2\u020e\u0212\5L\'\2\u020f\u0210\7/\2\2\u0210\u0212")
 312         buf.write("\5L\'\2\u0211\u020d\3\2\2\2\u0211\u020f\3\2\2\2\u0212")
 313         buf.write("\u0215\3\2\2\2\u0213\u0211\3\2\2\2\u0213\u0214\3\2\2\2")
 314         buf.write("\u0214K\3\2\2\2\u0215\u0213\3\2\2\2\u0216\u021f\5N(\2")
 315         buf.write("\u0217\u0218\7,\2\2\u0218\u021e\5N(\2\u0219\u021a\7\60")
 316         buf.write("\2\2\u021a\u021e\5N(\2\u021b\u021c\7\61\2\2\u021c\u021e")
 317         buf.write("\5N(\2\u021d\u0217\3\2\2\2\u021d\u0219\3\2\2\2\u021d\u021b")
 318         buf.write("\3\2\2\2\u021e\u0221\3\2\2\2\u021f\u021d\3\2\2\2\u021f")
 319         buf.write("\u0220\3\2\2\2\u0220M\3\2\2\2\u0221\u021f\3\2\2\2\u0222")
 320         buf.write("\u0223\7(\2\2\u0223\u0224\5<\37\2\u0224\u0225\7)\2\2\u0225")
 321         buf.write("\u0226\5N(\2\u0226\u0229\3\2\2\2\u0227\u0229\5P)\2\u0228")
 322         buf.write("\u0222\3\2\2\2\u0228\u0227\3\2\2\2\u0229O\3\2\2\2\u022a")
 323         buf.write("\u023a\5R*\2\u022b\u022c\7\62\2\2\u022c\u023a\5P)\2\u022d")
 324         buf.write("\u022e\7\63\2\2\u022e\u023a\5P)\2\u022f\u0230\5V,\2\u0230")
 325         buf.write("\u0231\5N(\2\u0231\u023a\3\2\2\2\u0232\u0233\7\64\2\2")
 326         buf.write("\u0233\u023a\5P)\2\u0234\u0235\7\64\2\2\u0235\u0236\7")
 327         buf.write("(\2\2\u0236\u0237\5<\37\2\u0237\u0238\7)\2\2\u0238\u023a")
 328         buf.write("\3\2\2\2\u0239\u022a\3\2\2\2\u0239\u022b\3\2\2\2\u0239")
 329         buf.write("\u022d\3\2\2\2\u0239\u022f\3\2\2\2\u0239\u0232\3\2\2\2")
 330         buf.write("\u0239\u0234\3\2\2\2\u023aQ\3\2\2\2\u023b\u023c\5X-\2")
 331         buf.write("\u023c\u025a\b*\1\2\u023d\u023e\7*\2\2\u023e\u023f\5\\")
 332         buf.write("/\2\u023f\u0240\7+\2\2\u0240\u0259\3\2\2\2\u0241\u0242")
 333         buf.write("\7(\2\2\u0242\u0243\7)\2\2\u0243\u0259\b*\1\2\u0244\u0245")
 334         buf.write("\7(\2\2\u0245\u0246\5H%\2\u0246\u0247\7)\2\2\u0247\u0248")
 335         buf.write("\b*\1\2\u0248\u0259\3\2\2\2\u0249\u024a\7(\2\2\u024a\u024b")
 336         buf.write("\5T+\2\u024b\u024c\7)\2\2\u024c\u0259\3\2\2\2\u024d\u024e")
 337         buf.write("\7\65\2\2\u024e\u024f\7_\2\2\u024f\u0259\b*\1\2\u0250")
 338         buf.write("\u0251\7,\2\2\u0251\u0252\7_\2\2\u0252\u0259\b*\1\2\u0253")
 339         buf.write("\u0254\7\66\2\2\u0254\u0255\7_\2\2\u0255\u0259\b*\1\2")
 340         buf.write("\u0256\u0259\7\62\2\2\u0257\u0259\7\63\2\2\u0258\u023d")
 341         buf.write("\3\2\2\2\u0258\u0241\3\2\2\2\u0258\u0244\3\2\2\2\u0258")
 342         buf.write("\u0249\3\2\2\2\u0258\u024d\3\2\2\2\u0258\u0250\3\2\2\2")
 343         buf.write("\u0258\u0253\3\2\2\2\u0258\u0256\3\2\2\2\u0258\u0257\3")
 344         buf.write("\2\2\2\u0259\u025c\3\2\2\2\u025a\u0258\3\2\2\2\u025a\u025b")
 345         buf.write("\3\2\2\2\u025bS\3\2\2\2\u025c\u025a\3\2\2\2\u025d\u0262")
 346         buf.write("\58\35\2\u025e\u025f\7\6\2\2\u025f\u0261\58\35\2\u0260")
 347         buf.write("\u025e\3\2\2\2\u0261\u0264\3\2\2\2\u0262\u0260\3\2\2\2")
 348         buf.write("\u0262\u0263\3\2\2\2\u0263U\3\2\2\2\u0264\u0262\3\2\2")
 349         buf.write("\2\u0265\u0266\t\5\2\2\u0266W\3\2\2\2\u0267\u026e\7_\2")
 350         buf.write("\2\u0268\u026e\5Z.\2\u0269\u026a\7(\2\2\u026a\u026b\5")
 351         buf.write("\\/\2\u026b\u026c\7)\2\2\u026c\u026e\3\2\2\2\u026d\u0267")
 352         buf.write("\3\2\2\2\u026d\u0268\3\2\2\2\u026d\u0269\3\2\2\2\u026e")
 353         buf.write("Y\3\2\2\2\u026f\u028a\7b\2\2\u0270\u028a\7d\2\2\u0271")
 354         buf.write("\u028a\7c\2\2\u0272\u028a\7`\2\2\u0273\u0275\7_\2\2\u0274")
 355         buf.write("\u0273\3\2\2\2\u0275\u0278\3\2\2\2\u0276\u0274\3\2\2\2")
 356         buf.write("\u0276\u0277\3\2\2\2\u0277\u027a\3\2\2\2\u0278\u0276\3")
 357         buf.write("\2\2\2\u0279\u027b\7a\2\2\u027a\u0279\3\2\2\2\u027b\u027c")
 358         buf.write("\3\2\2\2\u027c\u027a\3\2\2\2\u027c\u027d\3\2\2\2\u027d")
 359         buf.write("\u027f\3\2\2\2\u027e\u0276\3\2\2\2\u027f\u0280\3\2\2\2")
 360         buf.write("\u0280\u027e\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0285\3")
 361         buf.write("\2\2\2\u0282\u0284\7_\2\2\u0283\u0282\3\2\2\2\u0284\u0287")
 362         buf.write("\3\2\2\2\u0285\u0283\3\2\2\2\u0285\u0286\3\2\2\2\u0286")
 363         buf.write("\u028a\3\2\2\2\u0287\u0285\3\2\2\2\u0288\u028a\7e\2\2")
 364         buf.write("\u0289\u026f\3\2\2\2\u0289\u0270\3\2\2\2\u0289\u0271\3")
 365         buf.write("\2\2\2\u0289\u0272\3\2\2\2\u0289\u027e\3\2\2\2\u0289\u0288")
 366         buf.write("\3\2\2\2\u028a[\3\2\2\2\u028b\u0290\5`\61\2\u028c\u028d")
 367         buf.write("\7\6\2\2\u028d\u028f\5`\61\2\u028e\u028c\3\2\2\2\u028f")
 368         buf.write("\u0292\3\2\2\2\u0290\u028e\3\2\2\2\u0290\u0291\3\2\2\2")
 369         buf.write("\u0291]\3\2\2\2\u0292\u0290\3\2\2\2\u0293\u0294\5f\64")
 370         buf.write("\2\u0294_\3\2\2\2\u0295\u0296\5b\62\2\u0296\u0297\5d\63")
 371         buf.write("\2\u0297\u0298\5`\61\2\u0298\u029b\3\2\2\2\u0299\u029b")
 372         buf.write("\5f\64\2\u029a\u0295\3\2\2\2\u029a\u0299\3\2\2\2\u029b")
 373         buf.write("a\3\2\2\2\u029c\u029d\5P)\2\u029dc\3\2\2\2\u029e\u029f")
 374         buf.write("\t\6\2\2\u029fe\3\2\2\2\u02a0\u02a7\5h\65\2\u02a1\u02a2")
 375         buf.write("\7D\2\2\u02a2\u02a3\5\\/\2\u02a3\u02a4\7\31\2\2\u02a4")
 376         buf.write("\u02a5\5f\64\2\u02a5\u02a6\b\64\1\2\u02a6\u02a8\3\2\2")
 377         buf.write("\2\u02a7\u02a1\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8g\3\2")
 378         buf.write("\2\2\u02a9\u02ae\5j\66\2\u02aa\u02ab\7E\2\2\u02ab\u02ad")
 379         buf.write("\5j\66\2\u02ac\u02aa\3\2\2\2\u02ad\u02b0\3\2\2\2\u02ae")
 380         buf.write("\u02ac\3\2\2\2\u02ae\u02af\3\2\2\2\u02afi\3\2\2\2\u02b0")
 381         buf.write("\u02ae\3\2\2\2\u02b1\u02b6\5l\67\2\u02b2\u02b3\7F\2\2")
 382         buf.write("\u02b3\u02b5\5l\67\2\u02b4\u02b2\3\2\2\2\u02b5\u02b8\3")
 383         buf.write("\2\2\2\u02b6\u02b4\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7k")
 384         buf.write("\3\2\2\2\u02b8\u02b6\3\2\2\2\u02b9\u02be\5n8\2\u02ba\u02bb")
 385         buf.write("\7G\2\2\u02bb\u02bd\5n8\2\u02bc\u02ba\3\2\2\2\u02bd\u02c0")
 386         buf.write("\3\2\2\2\u02be\u02bc\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf")
 387         buf.write("m\3\2\2\2\u02c0\u02be\3\2\2\2\u02c1\u02c6\5p9\2\u02c2")
 388         buf.write("\u02c3\7H\2\2\u02c3\u02c5\5p9\2\u02c4\u02c2\3\2\2\2\u02c5")
 389         buf.write("\u02c8\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c6\u02c7\3\2\2\2")
 390         buf.write("\u02c7o\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c9\u02ce\5r:\2")
 391         buf.write("\u02ca\u02cb\7\67\2\2\u02cb\u02cd\5r:\2\u02cc\u02ca\3")
 392         buf.write("\2\2\2\u02cd\u02d0\3\2\2\2\u02ce\u02cc\3\2\2\2\u02ce\u02cf")
 393         buf.write("\3\2\2\2\u02cfq\3\2\2\2\u02d0\u02ce\3\2\2\2\u02d1\u02d6")
 394         buf.write("\5t;\2\u02d2\u02d3\t\7\2\2\u02d3\u02d5\5t;\2\u02d4\u02d2")
 395         buf.write("\3\2\2\2\u02d5\u02d8\3\2\2\2\u02d6\u02d4\3\2\2\2\u02d6")
 396         buf.write("\u02d7\3\2\2\2\u02d7s\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d9")
 397         buf.write("\u02de\5v<\2\u02da\u02db\t\b\2\2\u02db\u02dd\5v<\2\u02dc")
 398         buf.write("\u02da\3\2\2\2\u02dd\u02e0\3\2\2\2\u02de\u02dc\3\2\2\2")
 399         buf.write("\u02de\u02df\3\2\2\2\u02dfu\3\2\2\2\u02e0\u02de\3\2\2")
 400         buf.write("\2\u02e1\u02e6\5J&\2\u02e2\u02e3\t\t\2\2\u02e3\u02e5\5")
 401         buf.write("J&\2\u02e4\u02e2\3\2\2\2\u02e5\u02e8\3\2\2\2\u02e6\u02e4")
 402         buf.write("\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7w\3\2\2\2\u02e8\u02e6")
 403         buf.write("\3\2\2\2\u02e9\u02f5\5\u0082B\2\u02ea\u02f5\5\u0084C\2")
 404         buf.write("\u02eb\u02f5\5\u0088E\2\u02ec\u02f5\5\u008aF\2\u02ed\u02f5")
 405         buf.write("\5\u008cG\2\u02ee\u02f5\5\u008eH\2\u02ef\u02f5\5\u0080")
 406         buf.write("A\2\u02f0\u02f5\5z>\2\u02f1\u02f5\5|?\2\u02f2\u02f5\5")
 407         buf.write("~@\2\u02f3\u02f5\5\n\6\2\u02f4\u02e9\3\2\2\2\u02f4\u02ea")
 408         buf.write("\3\2\2\2\u02f4\u02eb\3\2\2\2\u02f4\u02ec\3\2\2\2\u02f4")
 409         buf.write("\u02ed\3\2\2\2\u02f4\u02ee\3\2\2\2\u02f4\u02ef\3\2\2\2")
 410         buf.write("\u02f4\u02f0\3\2\2\2\u02f4\u02f1\3\2\2\2\u02f4\u02f2\3")
 411         buf.write("\2\2\2\u02f4\u02f3\3\2\2\2\u02f5y\3\2\2\2\u02f6\u02f8")
 412         buf.write("\7Q\2\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8")
 413         buf.write("\u02f9\3\2\2\2\u02f9\u02fa\7_\2\2\u02fa\u02fe\7(\2\2\u02fb")
 414         buf.write("\u02fd\n\n\2\2\u02fc\u02fb\3\2\2\2\u02fd\u0300\3\2\2\2")
 415         buf.write("\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0301\3")
 416         buf.write("\2\2\2\u0300\u02fe\3\2\2\2\u0301\u0302\7)\2\2\u0302\u0303")
 417         buf.write("\7\4\2\2\u0303{\3\2\2\2\u0304\u0305\7R\2\2\u0305\u0309")
 418         buf.write("\7\3\2\2\u0306\u0308\n\13\2\2\u0307\u0306\3\2\2\2\u0308")
 419         buf.write("\u030b\3\2\2\2\u0309\u0307\3\2\2\2\u0309\u030a\3\2\2\2")
 420         buf.write("\u030a\u030c\3\2\2\2\u030b\u0309\3\2\2\2\u030c\u030d\7")
 421         buf.write("\26\2\2\u030d}\3\2\2\2\u030e\u030f\7S\2\2\u030f\u0313")
 422         buf.write("\7\3\2\2\u0310\u0312\n\13\2\2\u0311\u0310\3\2\2\2\u0312")
 423         buf.write("\u0315\3\2\2\2\u0313\u0311\3\2\2\2\u0313\u0314\3\2\2\2")
 424         buf.write("\u0314\u0316\3\2\2\2\u0315\u0313\3\2\2\2\u0316\u0317\7")
 425         buf.write("\26\2\2\u0317\177\3\2\2\2\u0318\u0319\7_\2\2\u0319\u031d")
 426         buf.write("\7(\2\2\u031a\u031c\5\n\6\2\u031b\u031a\3\2\2\2\u031c")
 427         buf.write("\u031f\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031e\3\2\2\2")
 428         buf.write("\u031e\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u0320\u0322\5")
 429         buf.write("\u0086D\2\u0321\u0320\3\2\2\2\u0321\u0322\3\2\2\2\u0322")
 430         buf.write("\u0324\3\2\2\2\u0323\u0325\5\\/\2\u0324\u0323\3\2\2\2")
 431         buf.write("\u0324\u0325\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u0327\7")
 432         buf.write(")\2\2\u0327\u0081\3\2\2\2\u0328\u0329\7_\2\2\u0329\u032a")
 433         buf.write("\7\31\2\2\u032a\u0334\5x=\2\u032b\u032c\7T\2\2\u032c\u032d")
 434         buf.write("\5^\60\2\u032d\u032e\7\31\2\2\u032e\u032f\5x=\2\u032f")
 435         buf.write("\u0334\3\2\2\2\u0330\u0331\7U\2\2\u0331\u0332\7\31\2\2")
 436         buf.write("\u0332\u0334\5x=\2\u0333\u0328\3\2\2\2\u0333\u032b\3\2")
 437         buf.write("\2\2\u0333\u0330\3\2\2\2\u0334\u0083\3\2\2\2\u0335\u0339")
 438         buf.write("\7\3\2\2\u0336\u0338\5\n\6\2\u0337\u0336\3\2\2\2\u0338")
 439         buf.write("\u033b\3\2\2\2\u0339\u0337\3\2\2\2\u0339\u033a\3\2\2\2")
 440         buf.write("\u033a\u033d\3\2\2\2\u033b\u0339\3\2\2\2\u033c\u033e\5")
 441         buf.write("\u0086D\2\u033d\u033c\3\2\2\2\u033d\u033e\3\2\2\2\u033e")
 442         buf.write("\u033f\3\2\2\2\u033f\u0340\7\26\2\2\u0340\u0085\3\2\2")
 443         buf.write("\2\u0341\u0343\5x=\2\u0342\u0341\3\2\2\2\u0343\u0344\3")
 444         buf.write("\2\2\2\u0344\u0342\3\2\2\2\u0344\u0345\3\2\2\2\u0345\u0087")
 445         buf.write("\3\2\2\2\u0346\u034b\7\4\2\2\u0347\u0348\5\\/\2\u0348")
 446         buf.write("\u0349\7\4\2\2\u0349\u034b\3\2\2\2\u034a\u0346\3\2\2\2")
 447         buf.write("\u034a\u0347\3\2\2\2\u034b\u0089\3\2\2\2\u034c\u034d\7")
 448         buf.write("V\2\2\u034d\u034e\7(\2\2\u034e\u034f\5\\/\2\u034f\u0350")
 449         buf.write("\7)\2\2\u0350\u0351\bF\1\2\u0351\u0354\5x=\2\u0352\u0353")
 450         buf.write("\7W\2\2\u0353\u0355\5x=\2\u0354\u0352\3\2\2\2\u0354\u0355")
 451         buf.write("\3\2\2\2\u0355\u035d\3\2\2\2\u0356\u0357\7X\2\2\u0357")
 452         buf.write("\u0358\7(\2\2\u0358\u0359\5\\/\2\u0359\u035a\7)\2\2\u035a")
 453         buf.write("\u035b\5x=\2\u035b\u035d\3\2\2\2\u035c\u034c\3\2\2\2\u035c")
 454         buf.write("\u0356\3\2\2\2\u035d\u008b\3\2\2\2\u035e\u035f\7Y\2\2")
 455         buf.write("\u035f\u0360\7(\2\2\u0360\u0361\5\\/\2\u0361\u0362\7)")
 456         buf.write("\2\2\u0362\u0363\5x=\2\u0363\u0364\bG\1\2\u0364\u036f")
 457         buf.write("\3\2\2\2\u0365\u0366\7Z\2\2\u0366\u0367\5x=\2\u0367\u0368")
 458         buf.write("\7Y\2\2\u0368\u0369\7(\2\2\u0369\u036a\5\\/\2\u036a\u036b")
 459         buf.write("\7)\2\2\u036b\u036c\7\4\2\2\u036c\u036d\bG\1\2\u036d\u036f")
 460         buf.write("\3\2\2\2\u036e\u035e\3\2\2\2\u036e\u0365\3\2\2\2\u036f")
 461         buf.write("\u008d\3\2\2\2\u0370\u0371\7[\2\2\u0371\u0372\7_\2\2\u0372")
 462         buf.write("\u037e\7\4\2\2\u0373\u0374\7\\\2\2\u0374\u037e\7\4\2\2")
 463         buf.write("\u0375\u0376\7]\2\2\u0376\u037e\7\4\2\2\u0377\u0378\7")
 464         buf.write("^\2\2\u0378\u037e\7\4\2\2\u0379\u037a\7^\2\2\u037a\u037b")
 465         buf.write("\5\\/\2\u037b\u037c\7\4\2\2\u037c\u037e\3\2\2\2\u037d")
 466         buf.write("\u0370\3\2\2\2\u037d\u0373\3\2\2\2\u037d\u0375\3\2\2\2")
 467         buf.write("\u037d\u0377\3\2\2\2\u037d\u0379\3\2\2\2\u037e\u008f\3")
 468         buf.write("\2\2\2o\u0093\u0097\u009d\u00a6\u00a8\u00ab\u00b1\u00b6")
 469         buf.write("\u00bd\u00bf\u00c3\u00cb\u00d0\u00d7\u00dd\u00f4\u00f9")
 470         buf.write("\u00ff\u0108\u010f\u0117\u0119\u0120\u0126\u012a\u0130")
 471         buf.write("\u0139\u013f\u0146\u014c\u0151\u0154\u0157\u015a\u015e")
 472         buf.write("\u0164\u0169\u0170\u0172\u0184\u018a\u018d\u0192\u0197")
 473         buf.write("\u019a\u019f\u01a4\u01aa\u01ac\u01b0\u01b5\u01b9\u01c0")
 474         buf.write("\u01c5\u01c8\u01cc\u01cf\u01d6\u01db\u01ea\u01f0\u01f4")
 475         buf.write("\u01fb\u0200\u0205\u0209\u0211\u0213\u021d\u021f\u0228")
 476         buf.write("\u0239\u0258\u025a\u0262\u026d\u0276\u027c\u0280\u0285")
 477         buf.write("\u0289\u0290\u029a\u02a7\u02ae\u02b6\u02be\u02c6\u02ce")
 478         buf.write("\u02d6\u02de\u02e6\u02f4\u02f7\u02fe\u0309\u0313\u031d")
 479         buf.write("\u0321\u0324\u0333\u0339\u033d\u0344\u034a\u0354\u035c")
 480         buf.write("\u036e\u037d")
 481         return buf.getvalue()
 482
 483
 484 class CParser ( Parser ):
 485
 486     grammarFileName = "C.g4"
 487
 488     atn = ATNDeserializer().deserialize(serializedATN())
 489
 490     decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
 491
 492     sharedContextCache = PredictionContextCache()
 493
 494     literalNames = [ "<INVALID>", "'{'", "';'", "'typedef'", "','", "'='",
 495                      "'extern'", "'static'", "'auto'", "'register'", "'STATIC'",
 496                      "'void'", "'char'", "'short'", "'int'", "'long'", "'float'",
 497                      "'double'", "'signed'", "'unsigned'", "'}'", "'struct'",
 498                      "'union'", "':'", "'enum'", "'const'", "'volatile'",
 499                      "'IN'", "'OUT'", "'OPTIONAL'", "'CONST'", "'UNALIGNED'",
 500                      "'VOLATILE'", "'GLOBAL_REMOVE_IF_UNREFERENCED'", "'EFIAPI'",
 501                      "'EFI_BOOTSERVICE'", "'EFI_RUNTIMESERVICE'", "'PACKED'",
 502                      "'('", "')'", "'['", "']'", "'*'", "'...'", "'+'",
 503                      "'-'", "'/'", "'%'", "'++'", "'--'", "'sizeof'", "'.'",
 504                      "'->'", "'&'", "'~'", "'!'", "'*='", "'/='", "'%='",
 505                      "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", "'|='",
 506                      "'?'", "'||'", "'&&'", "'|'", "'^'", "'=='", "'!='",
 507                      "'<'", "'>'", "'<='", "'>='", "'<<'", "'>>'", "'__asm__'",
 508                      "'_asm'", "'__asm'", "'case'", "'default'", "'if'",
 509                      "'else'", "'switch'", "'while'", "'do'", "'goto'",
 510                      "'continue'", "'break'", "'return'" ]
 511
 512     symbolicNames = [ "<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>", "<INVALID>", "<INVALID>", "<INVALID>",
 530                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 531                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 532                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 533                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 534                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
 535                       "<INVALID>", "IDENTIFIER", "CHARACTER_LITERAL", "STRING_LITERAL",
 536                       "HEX_LITERAL", "DECIMAL_LITERAL", "OCTAL_LITERAL",
 537                       "FLOATING_POINT_LITERAL", "WS", "BS", "UnicodeVocabulary",
 538                       "COMMENT", "LINE_COMMENT", "LINE_COMMAND" ]
 539
 540     RULE_translation_unit = 0
 541     RULE_external_declaration = 1
 542     RULE_function_definition = 2
 543     RULE_declaration_specifiers = 3
 544     RULE_declaration = 4
 545     RULE_init_declarator_list = 5
 546     RULE_init_declarator = 6
 547     RULE_storage_class_specifier = 7
 548     RULE_type_specifier = 8
 549     RULE_type_id = 9
 550     RULE_struct_or_union_specifier = 10
 551     RULE_struct_or_union = 11
 552     RULE_struct_declaration_list = 12
 553     RULE_struct_declaration = 13
 554     RULE_specifier_qualifier_list = 14
 555     RULE_struct_declarator_list = 15
 556     RULE_struct_declarator = 16
 557     RULE_enum_specifier = 17
 558     RULE_enumerator_list = 18
 559     RULE_enumerator = 19
 560     RULE_type_qualifier = 20
 561     RULE_declarator = 21
 562     RULE_direct_declarator = 22
 563     RULE_declarator_suffix = 23
 564     RULE_pointer = 24
 565     RULE_parameter_type_list = 25
 566     RULE_parameter_list = 26
 567     RULE_parameter_declaration = 27
 568     RULE_identifier_list = 28
 569     RULE_type_name = 29
 570     RULE_abstract_declarator = 30
 571     RULE_direct_abstract_declarator = 31
 572     RULE_abstract_declarator_suffix = 32
 573     RULE_initializer = 33
 574     RULE_initializer_list = 34
 575     RULE_argument_expression_list = 35
 576     RULE_additive_expression = 36
 577     RULE_multiplicative_expression = 37
 578     RULE_cast_expression = 38
 579     RULE_unary_expression = 39
 580     RULE_postfix_expression = 40
 581     RULE_macro_parameter_list = 41
 582     RULE_unary_operator = 42
 583     RULE_primary_expression = 43
 584     RULE_constant = 44
 585     RULE_expression = 45
 586     RULE_constant_expression = 46
 587     RULE_assignment_expression = 47
 588     RULE_lvalue = 48
 589     RULE_assignment_operator = 49
 590     RULE_conditional_expression = 50
 591     RULE_logical_or_expression = 51
 592     RULE_logical_and_expression = 52
 593     RULE_inclusive_or_expression = 53
 594     RULE_exclusive_or_expression = 54
 595     RULE_and_expression = 55
 596     RULE_equality_expression = 56
 597     RULE_relational_expression = 57
 598     RULE_shift_expression = 58
 599     RULE_statement = 59
 600     RULE_asm2_statement = 60
 601     RULE_asm1_statement = 61
 602     RULE_asm_statement = 62
 603     RULE_macro_statement = 63
 604     RULE_labeled_statement = 64
 605     RULE_compound_statement = 65
 606     RULE_statement_list = 66
 607     RULE_expression_statement = 67
 608     RULE_selection_statement = 68
 609     RULE_iteration_statement = 69
 610     RULE_jump_statement = 70
 611
 612     ruleNames =  [ "translation_unit", "external_declaration", "function_definition",
 613                    "declaration_specifiers", "declaration", "init_declarator_list",
 614                    "init_declarator", "storage_class_specifier", "type_specifier",
 615                    "type_id", "struct_or_union_specifier", "struct_or_union",
 616                    "struct_declaration_list", "struct_declaration", "specifier_qualifier_list",
 617                    "struct_declarator_list", "struct_declarator", "enum_specifier",
 618                    "enumerator_list", "enumerator", "type_qualifier", "declarator",
 619                    "direct_declarator", "declarator_suffix", "pointer",
 620                    "parameter_type_list", "parameter_list", "parameter_declaration",
 621                    "identifier_list", "type_name", "abstract_declarator",
 622                    "direct_abstract_declarator", "abstract_declarator_suffix",
 623                    "initializer", "initializer_list", "argument_expression_list",
 624                    "additive_expression", "multiplicative_expression", "cast_expression",
 625                    "unary_expression", "postfix_expression", "macro_parameter_list",
 626                    "unary_operator", "primary_expression", "constant", "expression",
 627                    "constant_expression", "assignment_expression", "lvalue",
 628                    "assignment_operator", "conditional_expression", "logical_or_expression",
 629                    "logical_and_expression", "inclusive_or_expression",
 630                    "exclusive_or_expression", "and_expression", "equality_expression",
 631                    "relational_expression", "shift_expression", "statement",
 632                    "asm2_statement", "asm1_statement", "asm_statement",
 633                    "macro_statement", "labeled_statement", "compound_statement",
 634                    "statement_list", "expression_statement", "selection_statement",
 635                    "iteration_statement", "jump_statement" ]
 636
 637     EOF = Token.EOF
 638     T__0=1
 639     T__1=2
 640     T__2=3
 641     T__3=4
 642     T__4=5
 643     T__5=6
 644     T__6=7
 645     T__7=8
 646     T__8=9
 647     T__9=10
 648     T__10=11
 649     T__11=12
 650     T__12=13
 651     T__13=14
 652     T__14=15
 653     T__15=16
 654     T__16=17
 655     T__17=18
 656     T__18=19
 657     T__19=20
 658     T__20=21
 659     T__21=22
 660     T__22=23
 661     T__23=24
 662     T__24=25
 663     T__25=26
 664     T__26=27
 665     T__27=28
 666     T__28=29
 667     T__29=30
 668     T__30=31
 669     T__31=32
 670     T__32=33
 671     T__33=34
 672     T__34=35
 673     T__35=36
 674     T__36=37
 675     T__37=38
 676     T__38=39
 677     T__39=40
 678     T__40=41
 679     T__41=42
 680     T__42=43
 681     T__43=44
 682     T__44=45
 683     T__45=46
 684     T__46=47
 685     T__47=48
 686     T__48=49
 687     T__49=50
 688     T__50=51
 689     T__51=52
 690     T__52=53
 691     T__53=54
 692     T__54=55
 693     T__55=56
 694     T__56=57
 695     T__57=58
 696     T__58=59
 697     T__59=60
 698     T__60=61
 699     T__61=62
 700     T__62=63
 701     T__63=64
 702     T__64=65
 703     T__65=66
 704     T__66=67
 705     T__67=68
 706     T__68=69
 707     T__69=70
 708     T__70=71
 709     T__71=72
 710     T__72=73
 711     T__73=74
 712     T__74=75
 713     T__75=76
 714     T__76=77
 715     T__77=78
 716     T__78=79
 717     T__79=80
 718     T__80=81
 719     T__81=82
 720     T__82=83
 721     T__83=84
 722     T__84=85
 723     T__85=86
 724     T__86=87
 725     T__87=88
 726     T__88=89
 727     T__89=90
 728     T__90=91
 729     T__91=92
 730     IDENTIFIER=93
 731     CHARACTER_LITERAL=94
 732     STRING_LITERAL=95
 733     HEX_LITERAL=96
 734     DECIMAL_LITERAL=97
 735     OCTAL_LITERAL=98
 736     FLOATING_POINT_LITERAL=99
 737     WS=100
 738     BS=101
 739     UnicodeVocabulary=102
 740     COMMENT=103
 741     LINE_COMMENT=104
 742     LINE_COMMAND=105
 743
 744     # @param  input Type: TokenStream
 745     # @param  output= sys.stdout Type: TextIO
 746     def __init__(self,input,output= sys.stdout):
 747         super().__init__(input, output)
 748         self.checkVersion("4.7.1")
 749         self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
 750         self._predicates = None
 751
 752
 753
 754
 755     def printTokenInfo(self,line,offset,tokenText):
 756         print(str(line)+ ',' + str(offset) + ':' + str(tokenText))
 757
 758     def StorePredicateExpression(self,StartLine,StartOffset,EndLine,EndOffset,Text):
 759         PredExp = CodeFragment.PredicateExpression(Text, (StartLine, StartOffset), (EndLine, EndOffset))
 760         FileProfile.PredicateExpressionList.append(PredExp)
 761
 762     def StoreEnumerationDefinition(self,StartLine,StartOffset,EndLine,EndOffset,Text):
 763         EnumDef = CodeFragment.EnumerationDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset))
 764         FileProfile.EnumerationDefinitionList.append(EnumDef)
 765
 766     def StoreStructUnionDefinition(self,StartLine,StartOffset,EndLine,EndOffset,Text):
 767         SUDef = CodeFragment.StructUnionDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset))
 768         FileProfile.StructUnionDefinitionList.append(SUDef)
 769
 770     def StoreTypedefDefinition(self,StartLine,StartOffset,EndLine,EndOffset,FromText,ToText):
 771         Tdef = CodeFragment.TypedefDefinition(FromText, ToText, (StartLine, StartOffset), (EndLine, EndOffset))
 772         FileProfile.TypedefDefinitionList.append(Tdef)
 773
 774     def StoreFunctionDefinition(self,StartLine,StartOffset,EndLine,EndOffset,ModifierText,DeclText,LeftBraceLine,LeftBraceOffset,DeclLine,DeclOffset):
 775         FuncDef = CodeFragment.FunctionDefinition(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset), (LeftBraceLine, LeftBraceOffset), (DeclLine, DeclOffset))
 776         FileProfile.FunctionDefinitionList.append(FuncDef)
 777
 778     def StoreVariableDeclaration(self,StartLine,StartOffset,EndLine,EndOffset,ModifierText,DeclText):
 779         VarDecl = CodeFragment.VariableDeclaration(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset))
 780         FileProfile.VariableDeclarationList.append(VarDecl)
 781
 782     def StoreFunctionCalling(self,StartLine,StartOffset,EndLine,EndOffset,FuncName,ParamList):
 783         FuncCall = CodeFragment.FunctionCalling(FuncName, ParamList, (StartLine, StartOffset), (EndLine, EndOffset))
 784         FileProfile.FunctionCallingList.append(FuncCall)
 785
 786
 787
 788     class Translation_unitContext(ParserRuleContext):
 789
 790         # @param  parent=None Type: ParserRuleContext
 791         # @param  invokingState=-1 Type: int
 792         def __init__(self,parser,parent=None,invokingState=-1):
 793             super().__init__(parent, invokingState)
 794             self.parser = parser
 795
 796         # @param  i=None Type: int
 797         def external_declaration(self,i=None):
 798             if i is None:
 799                 return self.getTypedRuleContexts(CParser.External_declarationContext)
 800             else:
 801                 return self.getTypedRuleContext(CParser.External_declarationContext,i)
 802
 803
 804         def getRuleIndex(self):
 805             return CParser.RULE_translation_unit
 806
 807         # @param  listener Type: ParseTreeListener
 808         def enterRule(self,listener):
 809             if hasattr( listener, "enterTranslation_unit" ):
 810                 listener.enterTranslation_unit(self)
 811
 812         # @param  listener Type: ParseTreeListener
 813         def exitRule(self,listener):
 814             if hasattr( listener, "exitTranslation_unit" ):
 815                 listener.exitTranslation_unit(self)
 816
 817
 818
 819
 820     def translation_unit(self):
 821
 822         localctx = CParser.Translation_unitContext(self, self._ctx, self.state)
 823         self.enterRule(localctx, 0, self.RULE_translation_unit)
 824         self._la = 0 # Token type
 825         try:
 826             self.enterOuterAlt(localctx, 1)
 827             self.state = 145
 828             self._errHandler.sync(self)
 829             _la = self._input.LA(1)
 830             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:
 831                 self.state = 142
 832                 self.external_declaration()
 833                 self.state = 147
 834                 self._errHandler.sync(self)
 835                 _la = self._input.LA(1)
 836
 837         except RecognitionException as re:
 838             localctx.exception = re
 839             self._errHandler.reportError(self, re)
 840             self._errHandler.recover(self, re)
 841         finally:
 842             self.exitRule()
 843         return localctx
 844
 845     class External_declarationContext(ParserRuleContext):
 846
 847         # @param  parent=None Type: ParserRuleContext
 848         # @param  invokingState=-1 Type: int
 849         def __init__(self,parser,parent=None,invokingState=-1):
 850             super().__init__(parent, invokingState)
 851             self.parser = parser
 852
 853         def declarator(self):
 854             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
 855
 856
 857         def declaration_specifiers(self):
 858             return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
 859
 860
 861         # @param  i=None Type: int
 862         def declaration(self,i=None):
 863             if i is None:
 864                 return self.getTypedRuleContexts(CParser.DeclarationContext)
 865             else:
 866                 return self.getTypedRuleContext(CParser.DeclarationContext,i)
 867
 868
 869         def function_definition(self):
 870             return self.getTypedRuleContext(CParser.Function_definitionContext,0)
 871
 872
 873         def macro_statement(self):
 874             return self.getTypedRuleContext(CParser.Macro_statementContext,0)
 875
 876
 877         def getRuleIndex(self):
 878             return CParser.RULE_external_declaration
 879
 880         # @param  listener Type: ParseTreeListener
 881         def enterRule(self,listener):
 882             if hasattr( listener, "enterExternal_declaration" ):
 883                 listener.enterExternal_declaration(self)
 884
 885         # @param  listener Type: ParseTreeListener
 886         def exitRule(self,listener):
 887             if hasattr( listener, "exitExternal_declaration" ):
 888                 listener.exitExternal_declaration(self)
 889
 890
 891
 892
 893     def external_declaration(self):
 894
 895         localctx = CParser.External_declarationContext(self, self._ctx, self.state)
 896         self.enterRule(localctx, 2, self.RULE_external_declaration)
 897         self._la = 0 # Token type
 898         try:
 899             self.state = 166
 900             self._errHandler.sync(self)
 901             la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
 902             if la_ == 1:
 903                 self.enterOuterAlt(localctx, 1)
 904                 self.state = 149
 905                 self._errHandler.sync(self)
 906                 la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
 907                 if la_ == 1:
 908                     self.state = 148
 909                     self.declaration_specifiers()
 910
 911
 912                 self.state = 151
 913                 self.declarator()
 914                 self.state = 155
 915                 self._errHandler.sync(self)
 916                 _la = self._input.LA(1)
 917                 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:
 918                     self.state = 152
 919                     self.declaration()
 920                     self.state = 157
 921                     self._errHandler.sync(self)
 922                     _la = self._input.LA(1)
 923
 924                 self.state = 158
 925                 self.match(CParser.T__0)
 926                 pass
 927
 928             elif la_ == 2:
 929                 self.enterOuterAlt(localctx, 2)
 930                 self.state = 160
 931                 self.function_definition()
 932                 pass
 933
 934             elif la_ == 3:
 935                 self.enterOuterAlt(localctx, 3)
 936                 self.state = 161
 937                 self.declaration()
 938                 pass
 939
 940             elif la_ == 4:
 941                 self.enterOuterAlt(localctx, 4)
 942                 self.state = 162
 943                 self.macro_statement()
 944                 self.state = 164
 945                 self._errHandler.sync(self)
 946                 _la = self._input.LA(1)
 947                 if _la==CParser.T__1:
 948                     self.state = 163
 949                     self.match(CParser.T__1)
 950
 951
 952                 pass
 953
 954
 955         except RecognitionException as re:
 956             localctx.exception = re
 957             self._errHandler.reportError(self, re)
 958             self._errHandler.recover(self, re)
 959         finally:
 960             self.exitRule()
 961         return localctx
 962
 963     class Function_definitionContext(ParserRuleContext):
 964
 965         # @param  parent=None Type: ParserRuleContext
 966         # @param  invokingState=-1 Type: int
 967         def __init__(self,parser,parent=None,invokingState=-1):
 968             super().__init__(parent, invokingState)
 969             self.parser = parser
 970             self.ModifierText = ''
 971             self.DeclText = ''
 972             self.LBLine = 0
 973             self.LBOffset = 0
 974             self.DeclLine = 0
 975             self.DeclOffset = 0
 976             self.d = None # Declaration_specifiersContext
 977             self._declaration_specifiers = None # Declaration_specifiersContext
 978             self._declarator = None # DeclaratorContext
 979             self.a = None # Compound_statementContext
 980             self.b = None # Compound_statementContext
 981
 982         def declarator(self):
 983             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
 984
 985
 986         def compound_statement(self):
 987             return self.getTypedRuleContext(CParser.Compound_statementContext,0)
 988
 989
 990         def declaration_specifiers(self):
 991             return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
 992
 993
 994         # @param  i=None Type: int
 995         def declaration(self,i=None):
 996             if i is None:
 997                 return self.getTypedRuleContexts(CParser.DeclarationContext)
 998             else:
 999                 return self.getTypedRuleContext(CParser.DeclarationContext,i)
1000
1001
1002         def getRuleIndex(self):
1003             return CParser.RULE_function_definition
1004
1005         # @param  listener Type: ParseTreeListener
1006         def enterRule(self,listener):
1007             if hasattr( listener, "enterFunction_definition" ):
1008                 listener.enterFunction_definition(self)
1009
1010         # @param  listener Type: ParseTreeListener
1011         def exitRule(self,listener):
1012             if hasattr( listener, "exitFunction_definition" ):
1013                 listener.exitFunction_definition(self)
1014
1015
1016
1017
1018     def function_definition(self):
1019
1020         localctx = CParser.Function_definitionContext(self, self._ctx, self.state)
1021         self.enterRule(localctx, 4, self.RULE_function_definition)
1022
1023         ModifierText = '';
1024         DeclText = '';
1025         LBLine = 0;
1026         LBOffset = 0;
1027         DeclLine = 0;
1028         DeclOffset = 0;
1029
1030         self._la = 0 # Token type
1031         try:
1032             self.enterOuterAlt(localctx, 1)
1033             self.state = 169
1034             self._errHandler.sync(self)
1035             la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
1036             if la_ == 1:
1037                 self.state = 168
1038                 localctx.d = localctx._declaration_specifiers = self.declaration_specifiers()
1039
1040
1041             self.state = 171
1042             localctx._declarator = self.declarator()
1043             self.state = 180
1044             self._errHandler.sync(self)
1045             token = self._input.LA(1)
1046             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]:
1047                 self.state = 173
1048                 self._errHandler.sync(self)
1049                 _la = self._input.LA(1)
1050                 while True:
1051                     self.state = 172
1052                     self.declaration()
1053                     self.state = 175
1054                     self._errHandler.sync(self)
1055                     _la = self._input.LA(1)
1056                     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):
1057                         break
1058
1059                 self.state = 177
1060                 localctx.a = self.compound_statement()
1061                 pass
1062             elif token in [CParser.T__0]:
1063                 self.state = 179
1064                 localctx.b = self.compound_statement()
1065                 pass
1066             else:
1067                 raise NoViableAltException(self)
1068
1069
1070             if localctx.d != None:
1071                 ModifierText = (None if localctx._declaration_specifiers is None else self._input.getText((localctx._declaration_specifiers.start,localctx._declaration_specifiers.stop)))
1072             else:
1073                 ModifierText = ''
1074             DeclText = (None if localctx._declarator is None else self._input.getText((localctx._declarator.start,localctx._declarator.stop)))
1075             DeclLine = (None if localctx._declarator is None else localctx._declarator.start).line
1076             DeclOffset = (None if localctx._declarator is None else localctx._declarator.start).column
1077             if localctx.a != None:
1078                 LBLine = (None if localctx.a is None else localctx.a.start).line
1079                 LBOffset = (None if localctx.a is None else localctx.a.start).column
1080             else:
1081                 LBLine = (None if localctx.b is None else localctx.b.start).line
1082                 LBOffset = (None if localctx.b is None else localctx.b.start).column
1083
1084             self._ctx.stop = self._input.LT(-1)
1085
1086             self.StoreFunctionDefinition(localctx.start.line, localctx.start.column, localctx.stop.line, localctx.stop.column, ModifierText, DeclText, LBLine, LBOffset, DeclLine, DeclOffset)
1087
1088         except RecognitionException as re:
1089             localctx.exception = re
1090             self._errHandler.reportError(self, re)
1091             self._errHandler.recover(self, re)
1092         finally:
1093             self.exitRule()
1094         return localctx
1095
1096     class Declaration_specifiersContext(ParserRuleContext):
1097
1098         # @param  parent=None Type: ParserRuleContext
1099         # @param  invokingState=-1 Type: int
1100         def __init__(self,parser,parent=None,invokingState=-1):
1101             super().__init__(parent, invokingState)
1102             self.parser = parser
1103
1104         # @param  i=None Type: int
1105         def storage_class_specifier(self,i=None):
1106             if i is None:
1107                 return self.getTypedRuleContexts(CParser.Storage_class_specifierContext)
1108             else:
1109                 return self.getTypedRuleContext(CParser.Storage_class_specifierContext,i)
1110
1111
1112         # @param  i=None Type: int
1113         def type_specifier(self,i=None):
1114             if i is None:
1115                 return self.getTypedRuleContexts(CParser.Type_specifierContext)
1116             else:
1117                 return self.getTypedRuleContext(CParser.Type_specifierContext,i)
1118
1119
1120         # @param  i=None Type: int
1121         def type_qualifier(self,i=None):
1122             if i is None:
1123                 return self.getTypedRuleContexts(CParser.Type_qualifierContext)
1124             else:
1125                 return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
1126
1127
1128         def getRuleIndex(self):
1129             return CParser.RULE_declaration_specifiers
1130
1131         # @param  listener Type: ParseTreeListener
1132         def enterRule(self,listener):
1133             if hasattr( listener, "enterDeclaration_specifiers" ):
1134                 listener.enterDeclaration_specifiers(self)
1135
1136         # @param  listener Type: ParseTreeListener
1137         def exitRule(self,listener):
1138             if hasattr( listener, "exitDeclaration_specifiers" ):
1139                 listener.exitDeclaration_specifiers(self)
1140
1141
1142
1143
1144     def declaration_specifiers(self):
1145
1146         localctx = CParser.Declaration_specifiersContext(self, self._ctx, self.state)
1147         self.enterRule(localctx, 6, self.RULE_declaration_specifiers)
1148         try:
1149             self.enterOuterAlt(localctx, 1)
1150             self.state = 187
1151             self._errHandler.sync(self)
1152             _alt = 1
1153             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1154                 if _alt == 1:
1155                     self.state = 187
1156                     self._errHandler.sync(self)
1157                     token = self._input.LA(1)
1158                     if token in [CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9]:
1159                         self.state = 184
1160                         self.storage_class_specifier()
1161                         pass
1162                     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]:
1163                         self.state = 185
1164                         self.type_specifier()
1165                         pass
1166                     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]:
1167                         self.state = 186
1168                         self.type_qualifier()
1169                         pass
1170                     else:
1171                         raise NoViableAltException(self)
1172
1173
1174                 else:
1175                     raise NoViableAltException(self)
1176                 self.state = 189
1177                 self._errHandler.sync(self)
1178                 _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
1179
1180         except RecognitionException as re:
1181             localctx.exception = re
1182             self._errHandler.reportError(self, re)
1183             self._errHandler.recover(self, re)
1184         finally:
1185             self.exitRule()
1186         return localctx
1187
1188     class DeclarationContext(ParserRuleContext):
1189
1190         # @param  parent=None Type: ParserRuleContext
1191         # @param  invokingState=-1 Type: int
1192         def __init__(self,parser,parent=None,invokingState=-1):
1193             super().__init__(parent, invokingState)
1194             self.parser = parser
1195             self.a = None # Token
1196             self.b = None # Declaration_specifiersContext
1197             self.c = None # Init_declarator_listContext
1198             self.d = None # Token
1199             self.s = None # Declaration_specifiersContext
1200             self.t = None # Init_declarator_listContext
1201             self.e = None # Token
1202
1203         def init_declarator_list(self):
1204             return self.getTypedRuleContext(CParser.Init_declarator_listContext,0)
1205
1206
1207         def declaration_specifiers(self):
1208             return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
1209
1210
1211         def getRuleIndex(self):
1212             return CParser.RULE_declaration
1213
1214         # @param  listener Type: ParseTreeListener
1215         def enterRule(self,listener):
1216             if hasattr( listener, "enterDeclaration" ):
1217                 listener.enterDeclaration(self)
1218
1219         # @param  listener Type: ParseTreeListener
1220         def exitRule(self,listener):
1221             if hasattr( listener, "exitDeclaration" ):
1222                 listener.exitDeclaration(self)
1223
1224
1225
1226
1227     def declaration(self):
1228
1229         localctx = CParser.DeclarationContext(self, self._ctx, self.state)
1230         self.enterRule(localctx, 8, self.RULE_declaration)
1231         self._la = 0 # Token type
1232         try:
1233             self.state = 206
1234             self._errHandler.sync(self)
1235             token = self._input.LA(1)
1236             if token in [CParser.T__2]:
1237                 self.enterOuterAlt(localctx, 1)
1238                 self.state = 191
1239                 localctx.a = self.match(CParser.T__2)
1240                 self.state = 193
1241                 self._errHandler.sync(self)
1242                 la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
1243                 if la_ == 1:
1244                     self.state = 192
1245                     localctx.b = self.declaration_specifiers()
1246
1247
1248                 self.state = 195
1249                 localctx.c = self.init_declarator_list()
1250                 self.state = 196
1251                 localctx.d = self.match(CParser.T__1)
1252
1253                 if localctx.b is not None:
1254                     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))))
1255                 else:
1256                     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))))
1257
1258                 pass
1259             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]:
1260                 self.enterOuterAlt(localctx, 2)
1261                 self.state = 199
1262                 localctx.s = self.declaration_specifiers()
1263                 self.state = 201
1264                 self._errHandler.sync(self)
1265                 _la = self._input.LA(1)
1266                 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):
1267                     self.state = 200
1268                     localctx.t = self.init_declarator_list()
1269
1270
1271                 self.state = 203
1272                 localctx.e = self.match(CParser.T__1)
1273
1274                 if localctx.t is not None:
1275                     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))))
1276
1277                 pass
1278             else:
1279                 raise NoViableAltException(self)
1280
1281         except RecognitionException as re:
1282             localctx.exception = re
1283             self._errHandler.reportError(self, re)
1284             self._errHandler.recover(self, re)
1285         finally:
1286             self.exitRule()
1287         return localctx
1288
1289     class Init_declarator_listContext(ParserRuleContext):
1290
1291         # @param  parent=None Type: ParserRuleContext
1292         # @param  invokingState=-1 Type: int
1293         def __init__(self,parser,parent=None,invokingState=-1):
1294             super().__init__(parent, invokingState)
1295             self.parser = parser
1296
1297         # @param  i=None Type: int
1298         def init_declarator(self,i=None):
1299             if i is None:
1300                 return self.getTypedRuleContexts(CParser.Init_declaratorContext)
1301             else:
1302                 return self.getTypedRuleContext(CParser.Init_declaratorContext,i)
1303
1304
1305         def getRuleIndex(self):
1306             return CParser.RULE_init_declarator_list
1307
1308         # @param  listener Type: ParseTreeListener
1309         def enterRule(self,listener):
1310             if hasattr( listener, "enterInit_declarator_list" ):
1311                 listener.enterInit_declarator_list(self)
1312
1313         # @param  listener Type: ParseTreeListener
1314         def exitRule(self,listener):
1315             if hasattr( listener, "exitInit_declarator_list" ):
1316                 listener.exitInit_declarator_list(self)
1317
1318
1319
1320
1321     def init_declarator_list(self):
1322
1323         localctx = CParser.Init_declarator_listContext(self, self._ctx, self.state)
1324         self.enterRule(localctx, 10, self.RULE_init_declarator_list)
1325         self._la = 0 # Token type
1326         try:
1327             self.enterOuterAlt(localctx, 1)
1328             self.state = 208
1329             self.init_declarator()
1330             self.state = 213
1331             self._errHandler.sync(self)
1332             _la = self._input.LA(1)
1333             while _la==CParser.T__3:
1334                 self.state = 209
1335                 self.match(CParser.T__3)
1336                 self.state = 210
1337                 self.init_declarator()
1338                 self.state = 215
1339                 self._errHandler.sync(self)
1340                 _la = self._input.LA(1)
1341
1342         except RecognitionException as re:
1343             localctx.exception = re
1344             self._errHandler.reportError(self, re)
1345             self._errHandler.recover(self, re)
1346         finally:
1347             self.exitRule()
1348         return localctx
1349
1350     class Init_declaratorContext(ParserRuleContext):
1351
1352         # @param  parent=None Type: ParserRuleContext
1353         # @param  invokingState=-1 Type: int
1354         def __init__(self,parser,parent=None,invokingState=-1):
1355             super().__init__(parent, invokingState)
1356             self.parser = parser
1357
1358         def declarator(self):
1359             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
1360
1361
1362         def initializer(self):
1363             return self.getTypedRuleContext(CParser.InitializerContext,0)
1364
1365
1366         def getRuleIndex(self):
1367             return CParser.RULE_init_declarator
1368
1369         # @param  listener Type: ParseTreeListener
1370         def enterRule(self,listener):
1371             if hasattr( listener, "enterInit_declarator" ):
1372                 listener.enterInit_declarator(self)
1373
1374         # @param  listener Type: ParseTreeListener
1375         def exitRule(self,listener):
1376             if hasattr( listener, "exitInit_declarator" ):
1377                 listener.exitInit_declarator(self)
1378
1379
1380
1381
1382     def init_declarator(self):
1383
1384         localctx = CParser.Init_declaratorContext(self, self._ctx, self.state)
1385         self.enterRule(localctx, 12, self.RULE_init_declarator)
1386         self._la = 0 # Token type
1387         try:
1388             self.enterOuterAlt(localctx, 1)
1389             self.state = 216
1390             self.declarator()
1391             self.state = 219
1392             self._errHandler.sync(self)
1393             _la = self._input.LA(1)
1394             if _la==CParser.T__4:
1395                 self.state = 217
1396                 self.match(CParser.T__4)
1397                 self.state = 218
1398                 self.initializer()
1399
1400
1401         except RecognitionException as re:
1402             localctx.exception = re
1403             self._errHandler.reportError(self, re)
1404             self._errHandler.recover(self, re)
1405         finally:
1406             self.exitRule()
1407         return localctx
1408
1409     class Storage_class_specifierContext(ParserRuleContext):
1410
1411         # @param  parent=None Type: ParserRuleContext
1412         # @param  invokingState=-1 Type: int
1413         def __init__(self,parser,parent=None,invokingState=-1):
1414             super().__init__(parent, invokingState)
1415             self.parser = parser
1416
1417
1418         def getRuleIndex(self):
1419             return CParser.RULE_storage_class_specifier
1420
1421         # @param  listener Type: ParseTreeListener
1422         def enterRule(self,listener):
1423             if hasattr( listener, "enterStorage_class_specifier" ):
1424                 listener.enterStorage_class_specifier(self)
1425
1426         # @param  listener Type: ParseTreeListener
1427         def exitRule(self,listener):
1428             if hasattr( listener, "exitStorage_class_specifier" ):
1429                 listener.exitStorage_class_specifier(self)
1430
1431
1432
1433
1434     def storage_class_specifier(self):
1435
1436         localctx = CParser.Storage_class_specifierContext(self, self._ctx, self.state)
1437         self.enterRule(localctx, 14, self.RULE_storage_class_specifier)
1438         self._la = 0 # Token type
1439         try:
1440             self.enterOuterAlt(localctx, 1)
1441             self.state = 221
1442             _la = self._input.LA(1)
1443             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)):
1444                 self._errHandler.recoverInline(self)
1445             else:
1446                 self._errHandler.reportMatch(self)
1447                 self.consume()
1448         except RecognitionException as re:
1449             localctx.exception = re
1450             self._errHandler.reportError(self, re)
1451             self._errHandler.recover(self, re)
1452         finally:
1453             self.exitRule()
1454         return localctx
1455
1456     class Type_specifierContext(ParserRuleContext):
1457
1458         # @param  parent=None Type: ParserRuleContext
1459         # @param  invokingState=-1 Type: int
1460         def __init__(self,parser,parent=None,invokingState=-1):
1461             super().__init__(parent, invokingState)
1462             self.parser = parser
1463             self.s = None # Struct_or_union_specifierContext
1464             self.e = None # Enum_specifierContext
1465
1466         def struct_or_union_specifier(self):
1467             return self.getTypedRuleContext(CParser.Struct_or_union_specifierContext,0)
1468
1469
1470         def enum_specifier(self):
1471             return self.getTypedRuleContext(CParser.Enum_specifierContext,0)
1472
1473
1474         def IDENTIFIER(self):
1475             return self.getToken(CParser.IDENTIFIER, 0)
1476
1477         def declarator(self):
1478             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
1479
1480
1481         # @param  i=None Type: int
1482         def type_qualifier(self,i=None):
1483             if i is None:
1484                 return self.getTypedRuleContexts(CParser.Type_qualifierContext)
1485             else:
1486                 return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
1487
1488
1489         def type_id(self):
1490             return self.getTypedRuleContext(CParser.Type_idContext,0)
1491
1492
1493         def getRuleIndex(self):
1494             return CParser.RULE_type_specifier
1495
1496         # @param  listener Type: ParseTreeListener
1497         def enterRule(self,listener):
1498             if hasattr( listener, "enterType_specifier" ):
1499                 listener.enterType_specifier(self)
1500
1501         # @param  listener Type: ParseTreeListener
1502         def exitRule(self,listener):
1503             if hasattr( listener, "exitType_specifier" ):
1504                 listener.exitType_specifier(self)
1505
1506
1507
1508
1509     def type_specifier(self):
1510
1511         localctx = CParser.Type_specifierContext(self, self._ctx, self.state)
1512         self.enterRule(localctx, 16, self.RULE_type_specifier)
1513         try:
1514             self.state = 247
1515             self._errHandler.sync(self)
1516             la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
1517             if la_ == 1:
1518                 self.enterOuterAlt(localctx, 1)
1519                 self.state = 223
1520                 self.match(CParser.T__10)
1521                 pass
1522
1523             elif la_ == 2:
1524                 self.enterOuterAlt(localctx, 2)
1525                 self.state = 224
1526                 self.match(CParser.T__11)
1527                 pass
1528
1529             elif la_ == 3:
1530                 self.enterOuterAlt(localctx, 3)
1531                 self.state = 225
1532                 self.match(CParser.T__12)
1533                 pass
1534
1535             elif la_ == 4:
1536                 self.enterOuterAlt(localctx, 4)
1537                 self.state = 226
1538                 self.match(CParser.T__13)
1539                 pass
1540
1541             elif la_ == 5:
1542                 self.enterOuterAlt(localctx, 5)
1543                 self.state = 227
1544                 self.match(CParser.T__14)
1545                 pass
1546
1547             elif la_ == 6:
1548                 self.enterOuterAlt(localctx, 6)
1549                 self.state = 228
1550                 self.match(CParser.T__15)
1551                 pass
1552
1553             elif la_ == 7:
1554                 self.enterOuterAlt(localctx, 7)
1555                 self.state = 229
1556                 self.match(CParser.T__16)
1557                 pass
1558
1559             elif la_ == 8:
1560                 self.enterOuterAlt(localctx, 8)
1561                 self.state = 230
1562                 self.match(CParser.T__17)
1563                 pass
1564
1565             elif la_ == 9:
1566                 self.enterOuterAlt(localctx, 9)
1567                 self.state = 231
1568                 self.match(CParser.T__18)
1569                 pass
1570
1571             elif la_ == 10:
1572                 self.enterOuterAlt(localctx, 10)
1573                 self.state = 232
1574                 localctx.s = self.struct_or_union_specifier()
1575
1576                 if localctx.s.stop is not None:
1577                     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))))
1578
1579                 pass
1580
1581             elif la_ == 11:
1582                 self.enterOuterAlt(localctx, 11)
1583                 self.state = 235
1584                 localctx.e = self.enum_specifier()
1585
1586                 if localctx.e.stop is not None:
1587                     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))))
1588
1589                 pass
1590
1591             elif la_ == 12:
1592                 self.enterOuterAlt(localctx, 12)
1593                 self.state = 238
1594                 self.match(CParser.IDENTIFIER)
1595                 self.state = 242
1596                 self._errHandler.sync(self)
1597                 _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
1598                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1599                     if _alt==1:
1600                         self.state = 239
1601                         self.type_qualifier()
1602                     self.state = 244
1603                     self._errHandler.sync(self)
1604                     _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
1605
1606                 self.state = 245
1607                 self.declarator()
1608                 pass
1609
1610             elif la_ == 13:
1611                 self.enterOuterAlt(localctx, 13)
1612                 self.state = 246
1613                 self.type_id()
1614                 pass
1615
1616
1617         except RecognitionException as re:
1618             localctx.exception = re
1619             self._errHandler.reportError(self, re)
1620             self._errHandler.recover(self, re)
1621         finally:
1622             self.exitRule()
1623         return localctx
1624
1625     class Type_idContext(ParserRuleContext):
1626
1627         # @param  parent=None Type: ParserRuleContext
1628         # @param  invokingState=-1 Type: int
1629         def __init__(self,parser,parent=None,invokingState=-1):
1630             super().__init__(parent, invokingState)
1631             self.parser = parser
1632
1633         def IDENTIFIER(self):
1634             return self.getToken(CParser.IDENTIFIER, 0)
1635
1636         def getRuleIndex(self):
1637             return CParser.RULE_type_id
1638
1639         # @param  listener Type: ParseTreeListener
1640         def enterRule(self,listener):
1641             if hasattr( listener, "enterType_id" ):
1642                 listener.enterType_id(self)
1643
1644         # @param  listener Type: ParseTreeListener
1645         def exitRule(self,listener):
1646             if hasattr( listener, "exitType_id" ):
1647                 listener.exitType_id(self)
1648
1649
1650
1651
1652     def type_id(self):
1653
1654         localctx = CParser.Type_idContext(self, self._ctx, self.state)
1655         self.enterRule(localctx, 18, self.RULE_type_id)
1656         try:
1657             self.enterOuterAlt(localctx, 1)
1658             self.state = 249
1659             self.match(CParser.IDENTIFIER)
1660         except RecognitionException as re:
1661             localctx.exception = re
1662             self._errHandler.reportError(self, re)
1663             self._errHandler.recover(self, re)
1664         finally:
1665             self.exitRule()
1666         return localctx
1667
1668     class Struct_or_union_specifierContext(ParserRuleContext):
1669
1670         # @param  parent=None Type: ParserRuleContext
1671         # @param  invokingState=-1 Type: int
1672         def __init__(self,parser,parent=None,invokingState=-1):
1673             super().__init__(parent, invokingState)
1674             self.parser = parser
1675
1676         def struct_or_union(self):
1677             return self.getTypedRuleContext(CParser.Struct_or_unionContext,0)
1678
1679
1680         def struct_declaration_list(self):
1681             return self.getTypedRuleContext(CParser.Struct_declaration_listContext,0)
1682
1683
1684         def IDENTIFIER(self):
1685             return self.getToken(CParser.IDENTIFIER, 0)
1686
1687         def getRuleIndex(self):
1688             return CParser.RULE_struct_or_union_specifier
1689
1690         # @param  listener Type: ParseTreeListener
1691         def enterRule(self,listener):
1692             if hasattr( listener, "enterStruct_or_union_specifier" ):
1693                 listener.enterStruct_or_union_specifier(self)
1694
1695         # @param  listener Type: ParseTreeListener
1696         def exitRule(self,listener):
1697             if hasattr( listener, "exitStruct_or_union_specifier" ):
1698                 listener.exitStruct_or_union_specifier(self)
1699
1700
1701
1702
1703     def struct_or_union_specifier(self):
1704
1705         localctx = CParser.Struct_or_union_specifierContext(self, self._ctx, self.state)
1706         self.enterRule(localctx, 20, self.RULE_struct_or_union_specifier)
1707         self._la = 0 # Token type
1708         try:
1709             self.state = 262
1710             self._errHandler.sync(self)
1711             la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
1712             if la_ == 1:
1713                 self.enterOuterAlt(localctx, 1)
1714                 self.state = 251
1715                 self.struct_or_union()
1716                 self.state = 253
1717                 self._errHandler.sync(self)
1718                 _la = self._input.LA(1)
1719                 if _la==CParser.IDENTIFIER:
1720                     self.state = 252
1721                     self.match(CParser.IDENTIFIER)
1722
1723
1724                 self.state = 255
1725                 self.match(CParser.T__0)
1726                 self.state = 256
1727                 self.struct_declaration_list()
1728                 self.state = 257
1729                 self.match(CParser.T__19)
1730                 pass
1731
1732             elif la_ == 2:
1733                 self.enterOuterAlt(localctx, 2)
1734                 self.state = 259
1735                 self.struct_or_union()
1736                 self.state = 260
1737                 self.match(CParser.IDENTIFIER)
1738                 pass
1739
1740
1741         except RecognitionException as re:
1742             localctx.exception = re
1743             self._errHandler.reportError(self, re)
1744             self._errHandler.recover(self, re)
1745         finally:
1746             self.exitRule()
1747         return localctx
1748
1749     class Struct_or_unionContext(ParserRuleContext):
1750
1751         # @param  parent=None Type: ParserRuleContext
1752         # @param  invokingState=-1 Type: int
1753         def __init__(self,parser,parent=None,invokingState=-1):
1754             super().__init__(parent, invokingState)
1755             self.parser = parser
1756
1757
1758         def getRuleIndex(self):
1759             return CParser.RULE_struct_or_union
1760
1761         # @param  listener Type: ParseTreeListener
1762         def enterRule(self,listener):
1763             if hasattr( listener, "enterStruct_or_union" ):
1764                 listener.enterStruct_or_union(self)
1765
1766         # @param  listener Type: ParseTreeListener
1767         def exitRule(self,listener):
1768             if hasattr( listener, "exitStruct_or_union" ):
1769                 listener.exitStruct_or_union(self)
1770
1771
1772
1773
1774     def struct_or_union(self):
1775
1776         localctx = CParser.Struct_or_unionContext(self, self._ctx, self.state)
1777         self.enterRule(localctx, 22, self.RULE_struct_or_union)
1778         self._la = 0 # Token type
1779         try:
1780             self.enterOuterAlt(localctx, 1)
1781             self.state = 264
1782             _la = self._input.LA(1)
1783             if not(_la==CParser.T__20 or _la==CParser.T__21):
1784                 self._errHandler.recoverInline(self)
1785             else:
1786                 self._errHandler.reportMatch(self)
1787                 self.consume()
1788         except RecognitionException as re:
1789             localctx.exception = re
1790             self._errHandler.reportError(self, re)
1791             self._errHandler.recover(self, re)
1792         finally:
1793             self.exitRule()
1794         return localctx
1795
1796     class Struct_declaration_listContext(ParserRuleContext):
1797
1798         # @param  parent=None Type: ParserRuleContext
1799         # @param  invokingState=-1 Type: int
1800         def __init__(self,parser,parent=None,invokingState=-1):
1801             super().__init__(parent, invokingState)
1802             self.parser = parser
1803
1804         # @param  i=None Type: int
1805         def struct_declaration(self,i=None):
1806             if i is None:
1807                 return self.getTypedRuleContexts(CParser.Struct_declarationContext)
1808             else:
1809                 return self.getTypedRuleContext(CParser.Struct_declarationContext,i)
1810
1811
1812         def getRuleIndex(self):
1813             return CParser.RULE_struct_declaration_list
1814
1815         # @param  listener Type: ParseTreeListener
1816         def enterRule(self,listener):
1817             if hasattr( listener, "enterStruct_declaration_list" ):
1818                 listener.enterStruct_declaration_list(self)
1819
1820         # @param  listener Type: ParseTreeListener
1821         def exitRule(self,listener):
1822             if hasattr( listener, "exitStruct_declaration_list" ):
1823                 listener.exitStruct_declaration_list(self)
1824
1825
1826
1827
1828     def struct_declaration_list(self):
1829
1830         localctx = CParser.Struct_declaration_listContext(self, self._ctx, self.state)
1831         self.enterRule(localctx, 24, self.RULE_struct_declaration_list)
1832         self._la = 0 # Token type
1833         try:
1834             self.enterOuterAlt(localctx, 1)
1835             self.state = 267
1836             self._errHandler.sync(self)
1837             _la = self._input.LA(1)
1838             while True:
1839                 self.state = 266
1840                 self.struct_declaration()
1841                 self.state = 269
1842                 self._errHandler.sync(self)
1843                 _la = self._input.LA(1)
1844                 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):
1845                     break
1846
1847         except RecognitionException as re:
1848             localctx.exception = re
1849             self._errHandler.reportError(self, re)
1850             self._errHandler.recover(self, re)
1851         finally:
1852             self.exitRule()
1853         return localctx
1854
1855     class Struct_declarationContext(ParserRuleContext):
1856
1857         # @param  parent=None Type: ParserRuleContext
1858         # @param  invokingState=-1 Type: int
1859         def __init__(self,parser,parent=None,invokingState=-1):
1860             super().__init__(parent, invokingState)
1861             self.parser = parser
1862
1863         def specifier_qualifier_list(self):
1864             return self.getTypedRuleContext(CParser.Specifier_qualifier_listContext,0)
1865
1866
1867         def struct_declarator_list(self):
1868             return self.getTypedRuleContext(CParser.Struct_declarator_listContext,0)
1869
1870
1871         def getRuleIndex(self):
1872             return CParser.RULE_struct_declaration
1873
1874         # @param  listener Type: ParseTreeListener
1875         def enterRule(self,listener):
1876             if hasattr( listener, "enterStruct_declaration" ):
1877                 listener.enterStruct_declaration(self)
1878
1879         # @param  listener Type: ParseTreeListener
1880         def exitRule(self,listener):
1881             if hasattr( listener, "exitStruct_declaration" ):
1882                 listener.exitStruct_declaration(self)
1883
1884
1885
1886
1887     def struct_declaration(self):
1888
1889         localctx = CParser.Struct_declarationContext(self, self._ctx, self.state)
1890         self.enterRule(localctx, 26, self.RULE_struct_declaration)
1891         try:
1892             self.enterOuterAlt(localctx, 1)
1893             self.state = 271
1894             self.specifier_qualifier_list()
1895             self.state = 272
1896             self.struct_declarator_list()
1897             self.state = 273
1898             self.match(CParser.T__1)
1899         except RecognitionException as re:
1900             localctx.exception = re
1901             self._errHandler.reportError(self, re)
1902             self._errHandler.recover(self, re)
1903         finally:
1904             self.exitRule()
1905         return localctx
1906
1907     class Specifier_qualifier_listContext(ParserRuleContext):
1908
1909         # @param  parent=None Type: ParserRuleContext
1910         # @param  invokingState=-1 Type: int
1911         def __init__(self,parser,parent=None,invokingState=-1):
1912             super().__init__(parent, invokingState)
1913             self.parser = parser
1914
1915         # @param  i=None Type: int
1916         def type_qualifier(self,i=None):
1917             if i is None:
1918                 return self.getTypedRuleContexts(CParser.Type_qualifierContext)
1919             else:
1920                 return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
1921
1922
1923         # @param  i=None Type: int
1924         def type_specifier(self,i=None):
1925             if i is None:
1926                 return self.getTypedRuleContexts(CParser.Type_specifierContext)
1927             else:
1928                 return self.getTypedRuleContext(CParser.Type_specifierContext,i)
1929
1930
1931         def getRuleIndex(self):
1932             return CParser.RULE_specifier_qualifier_list
1933
1934         # @param  listener Type: ParseTreeListener
1935         def enterRule(self,listener):
1936             if hasattr( listener, "enterSpecifier_qualifier_list" ):
1937                 listener.enterSpecifier_qualifier_list(self)
1938
1939         # @param  listener Type: ParseTreeListener
1940         def exitRule(self,listener):
1941             if hasattr( listener, "exitSpecifier_qualifier_list" ):
1942                 listener.exitSpecifier_qualifier_list(self)
1943
1944
1945
1946
1947     def specifier_qualifier_list(self):
1948
1949         localctx = CParser.Specifier_qualifier_listContext(self, self._ctx, self.state)
1950         self.enterRule(localctx, 28, self.RULE_specifier_qualifier_list)
1951         try:
1952             self.enterOuterAlt(localctx, 1)
1953             self.state = 277
1954             self._errHandler.sync(self)
1955             _alt = 1
1956             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1957                 if _alt == 1:
1958                     self.state = 277
1959                     self._errHandler.sync(self)
1960                     token = self._input.LA(1)
1961                     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]:
1962                         self.state = 275
1963                         self.type_qualifier()
1964                         pass
1965                     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]:
1966                         self.state = 276
1967                         self.type_specifier()
1968                         pass
1969                     else:
1970                         raise NoViableAltException(self)
1971
1972
1973                 else:
1974                     raise NoViableAltException(self)
1975                 self.state = 279
1976                 self._errHandler.sync(self)
1977                 _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
1978
1979         except RecognitionException as re:
1980             localctx.exception = re
1981             self._errHandler.reportError(self, re)
1982             self._errHandler.recover(self, re)
1983         finally:
1984             self.exitRule()
1985         return localctx
1986
1987     class Struct_declarator_listContext(ParserRuleContext):
1988
1989         # @param  parent=None Type: ParserRuleContext
1990         # @param  invokingState=-1 Type: int
1991         def __init__(self,parser,parent=None,invokingState=-1):
1992             super().__init__(parent, invokingState)
1993             self.parser = parser
1994
1995         # @param  i=None Type: int
1996         def struct_declarator(self,i=None):
1997             if i is None:
1998                 return self.getTypedRuleContexts(CParser.Struct_declaratorContext)
1999             else:
2000                 return self.getTypedRuleContext(CParser.Struct_declaratorContext,i)
2001
2002
2003         def getRuleIndex(self):
2004             return CParser.RULE_struct_declarator_list
2005
2006         # @param  listener Type: ParseTreeListener
2007         def enterRule(self,listener):
2008             if hasattr( listener, "enterStruct_declarator_list" ):
2009                 listener.enterStruct_declarator_list(self)
2010
2011         # @param  listener Type: ParseTreeListener
2012         def exitRule(self,listener):
2013             if hasattr( listener, "exitStruct_declarator_list" ):
2014                 listener.exitStruct_declarator_list(self)
2015
2016
2017
2018
2019     def struct_declarator_list(self):
2020
2021         localctx = CParser.Struct_declarator_listContext(self, self._ctx, self.state)
2022         self.enterRule(localctx, 30, self.RULE_struct_declarator_list)
2023         self._la = 0 # Token type
2024         try:
2025             self.enterOuterAlt(localctx, 1)
2026             self.state = 281
2027             self.struct_declarator()
2028             self.state = 286
2029             self._errHandler.sync(self)
2030             _la = self._input.LA(1)
2031             while _la==CParser.T__3:
2032                 self.state = 282
2033                 self.match(CParser.T__3)
2034                 self.state = 283
2035                 self.struct_declarator()
2036                 self.state = 288
2037                 self._errHandler.sync(self)
2038                 _la = self._input.LA(1)
2039
2040         except RecognitionException as re:
2041             localctx.exception = re
2042             self._errHandler.reportError(self, re)
2043             self._errHandler.recover(self, re)
2044         finally:
2045             self.exitRule()
2046         return localctx
2047
2048     class Struct_declaratorContext(ParserRuleContext):
2049
2050         # @param  parent=None Type: ParserRuleContext
2051         # @param  invokingState=-1 Type: int
2052         def __init__(self,parser,parent=None,invokingState=-1):
2053             super().__init__(parent, invokingState)
2054             self.parser = parser
2055
2056         def declarator(self):
2057             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
2058
2059
2060         def constant_expression(self):
2061             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
2062
2063
2064         def getRuleIndex(self):
2065             return CParser.RULE_struct_declarator
2066
2067         # @param  listener Type: ParseTreeListener
2068         def enterRule(self,listener):
2069             if hasattr( listener, "enterStruct_declarator" ):
2070                 listener.enterStruct_declarator(self)
2071
2072         # @param  listener Type: ParseTreeListener
2073         def exitRule(self,listener):
2074             if hasattr( listener, "exitStruct_declarator" ):
2075                 listener.exitStruct_declarator(self)
2076
2077
2078
2079
2080     def struct_declarator(self):
2081
2082         localctx = CParser.Struct_declaratorContext(self, self._ctx, self.state)
2083         self.enterRule(localctx, 32, self.RULE_struct_declarator)
2084         self._la = 0 # Token type
2085         try:
2086             self.state = 296
2087             self._errHandler.sync(self)
2088             token = self._input.LA(1)
2089             if token in [CParser.T__33, CParser.T__34, CParser.T__35, CParser.T__37, CParser.T__41, CParser.IDENTIFIER]:
2090                 self.enterOuterAlt(localctx, 1)
2091                 self.state = 289
2092                 self.declarator()
2093                 self.state = 292
2094                 self._errHandler.sync(self)
2095                 _la = self._input.LA(1)
2096                 if _la==CParser.T__22:
2097                     self.state = 290
2098                     self.match(CParser.T__22)
2099                     self.state = 291
2100                     self.constant_expression()
2101
2102
2103                 pass
2104             elif token in [CParser.T__22]:
2105                 self.enterOuterAlt(localctx, 2)
2106                 self.state = 294
2107                 self.match(CParser.T__22)
2108                 self.state = 295
2109                 self.constant_expression()
2110                 pass
2111             else:
2112                 raise NoViableAltException(self)
2113
2114         except RecognitionException as re:
2115             localctx.exception = re
2116             self._errHandler.reportError(self, re)
2117             self._errHandler.recover(self, re)
2118         finally:
2119             self.exitRule()
2120         return localctx
2121
2122     class Enum_specifierContext(ParserRuleContext):
2123
2124         # @param  parent=None Type: ParserRuleContext
2125         # @param  invokingState=-1 Type: int
2126         def __init__(self,parser,parent=None,invokingState=-1):
2127             super().__init__(parent, invokingState)
2128             self.parser = parser
2129
2130         def enumerator_list(self):
2131             return self.getTypedRuleContext(CParser.Enumerator_listContext,0)
2132
2133
2134         def IDENTIFIER(self):
2135             return self.getToken(CParser.IDENTIFIER, 0)
2136
2137         def getRuleIndex(self):
2138             return CParser.RULE_enum_specifier
2139
2140         # @param  listener Type: ParseTreeListener
2141         def enterRule(self,listener):
2142             if hasattr( listener, "enterEnum_specifier" ):
2143                 listener.enterEnum_specifier(self)
2144
2145         # @param  listener Type: ParseTreeListener
2146         def exitRule(self,listener):
2147             if hasattr( listener, "exitEnum_specifier" ):
2148                 listener.exitEnum_specifier(self)
2149
2150
2151
2152
2153     def enum_specifier(self):
2154
2155         localctx = CParser.Enum_specifierContext(self, self._ctx, self.state)
2156         self.enterRule(localctx, 34, self.RULE_enum_specifier)
2157         self._la = 0 # Token type
2158         try:
2159             self.state = 317
2160             self._errHandler.sync(self)
2161             la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
2162             if la_ == 1:
2163                 self.enterOuterAlt(localctx, 1)
2164                 self.state = 298
2165                 self.match(CParser.T__23)
2166                 self.state = 299
2167                 self.match(CParser.T__0)
2168                 self.state = 300
2169                 self.enumerator_list()
2170                 self.state = 302
2171                 self._errHandler.sync(self)
2172                 _la = self._input.LA(1)
2173                 if _la==CParser.T__3:
2174                     self.state = 301
2175                     self.match(CParser.T__3)
2176
2177
2178                 self.state = 304
2179                 self.match(CParser.T__19)
2180                 pass
2181
2182             elif la_ == 2:
2183                 self.enterOuterAlt(localctx, 2)
2184                 self.state = 306
2185                 self.match(CParser.T__23)
2186                 self.state = 307
2187                 self.match(CParser.IDENTIFIER)
2188                 self.state = 308
2189                 self.match(CParser.T__0)
2190                 self.state = 309
2191                 self.enumerator_list()
2192                 self.state = 311
2193                 self._errHandler.sync(self)
2194                 _la = self._input.LA(1)
2195                 if _la==CParser.T__3:
2196                     self.state = 310
2197                     self.match(CParser.T__3)
2198
2199
2200                 self.state = 313
2201                 self.match(CParser.T__19)
2202                 pass
2203
2204             elif la_ == 3:
2205                 self.enterOuterAlt(localctx, 3)
2206                 self.state = 315
2207                 self.match(CParser.T__23)
2208                 self.state = 316
2209                 self.match(CParser.IDENTIFIER)
2210                 pass
2211
2212
2213         except RecognitionException as re:
2214             localctx.exception = re
2215             self._errHandler.reportError(self, re)
2216             self._errHandler.recover(self, re)
2217         finally:
2218             self.exitRule()
2219         return localctx
2220
2221     class Enumerator_listContext(ParserRuleContext):
2222
2223         # @param  parent=None Type: ParserRuleContext
2224         # @param  invokingState=-1 Type: int
2225         def __init__(self,parser,parent=None,invokingState=-1):
2226             super().__init__(parent, invokingState)
2227             self.parser = parser
2228
2229         # @param  i=None Type: int
2230         def enumerator(self,i=None):
2231             if i is None:
2232                 return self.getTypedRuleContexts(CParser.EnumeratorContext)
2233             else:
2234                 return self.getTypedRuleContext(CParser.EnumeratorContext,i)
2235
2236
2237         def getRuleIndex(self):
2238             return CParser.RULE_enumerator_list
2239
2240         # @param  listener Type: ParseTreeListener
2241         def enterRule(self,listener):
2242             if hasattr( listener, "enterEnumerator_list" ):
2243                 listener.enterEnumerator_list(self)
2244
2245         # @param  listener Type: ParseTreeListener
2246         def exitRule(self,listener):
2247             if hasattr( listener, "exitEnumerator_list" ):
2248                 listener.exitEnumerator_list(self)
2249
2250
2251
2252
2253     def enumerator_list(self):
2254
2255         localctx = CParser.Enumerator_listContext(self, self._ctx, self.state)
2256         self.enterRule(localctx, 36, self.RULE_enumerator_list)
2257         try:
2258             self.enterOuterAlt(localctx, 1)
2259             self.state = 319
2260             self.enumerator()
2261             self.state = 324
2262             self._errHandler.sync(self)
2263             _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
2264             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2265                 if _alt==1:
2266                     self.state = 320
2267                     self.match(CParser.T__3)
2268                     self.state = 321
2269                     self.enumerator()
2270                 self.state = 326
2271                 self._errHandler.sync(self)
2272                 _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
2273
2274         except RecognitionException as re:
2275             localctx.exception = re
2276             self._errHandler.reportError(self, re)
2277             self._errHandler.recover(self, re)
2278         finally:
2279             self.exitRule()
2280         return localctx
2281
2282     class EnumeratorContext(ParserRuleContext):
2283
2284         # @param  parent=None Type: ParserRuleContext
2285         # @param  invokingState=-1 Type: int
2286         def __init__(self,parser,parent=None,invokingState=-1):
2287             super().__init__(parent, invokingState)
2288             self.parser = parser
2289
2290         def IDENTIFIER(self):
2291             return self.getToken(CParser.IDENTIFIER, 0)
2292
2293         def constant_expression(self):
2294             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
2295
2296
2297         def getRuleIndex(self):
2298             return CParser.RULE_enumerator
2299
2300         # @param  listener Type: ParseTreeListener
2301         def enterRule(self,listener):
2302             if hasattr( listener, "enterEnumerator" ):
2303                 listener.enterEnumerator(self)
2304
2305         # @param  listener Type: ParseTreeListener
2306         def exitRule(self,listener):
2307             if hasattr( listener, "exitEnumerator" ):
2308                 listener.exitEnumerator(self)
2309
2310
2311
2312
2313     def enumerator(self):
2314
2315         localctx = CParser.EnumeratorContext(self, self._ctx, self.state)
2316         self.enterRule(localctx, 38, self.RULE_enumerator)
2317         self._la = 0 # Token type
2318         try:
2319             self.enterOuterAlt(localctx, 1)
2320             self.state = 327
2321             self.match(CParser.IDENTIFIER)
2322             self.state = 330
2323             self._errHandler.sync(self)
2324             _la = self._input.LA(1)
2325             if _la==CParser.T__4:
2326                 self.state = 328
2327                 self.match(CParser.T__4)
2328                 self.state = 329
2329                 self.constant_expression()
2330
2331
2332         except RecognitionException as re:
2333             localctx.exception = re
2334             self._errHandler.reportError(self, re)
2335             self._errHandler.recover(self, re)
2336         finally:
2337             self.exitRule()
2338         return localctx
2339
2340     class Type_qualifierContext(ParserRuleContext):
2341
2342         # @param  parent=None Type: ParserRuleContext
2343         # @param  invokingState=-1 Type: int
2344         def __init__(self,parser,parent=None,invokingState=-1):
2345             super().__init__(parent, invokingState)
2346             self.parser = parser
2347
2348
2349         def getRuleIndex(self):
2350             return CParser.RULE_type_qualifier
2351
2352         # @param  listener Type: ParseTreeListener
2353         def enterRule(self,listener):
2354             if hasattr( listener, "enterType_qualifier" ):
2355                 listener.enterType_qualifier(self)
2356
2357         # @param  listener Type: ParseTreeListener
2358         def exitRule(self,listener):
2359             if hasattr( listener, "exitType_qualifier" ):
2360                 listener.exitType_qualifier(self)
2361
2362
2363
2364
2365     def type_qualifier(self):
2366
2367         localctx = CParser.Type_qualifierContext(self, self._ctx, self.state)
2368         self.enterRule(localctx, 40, self.RULE_type_qualifier)
2369         self._la = 0 # Token type
2370         try:
2371             self.enterOuterAlt(localctx, 1)
2372             self.state = 332
2373             _la = self._input.LA(1)
2374             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)):
2375                 self._errHandler.recoverInline(self)
2376             else:
2377                 self._errHandler.reportMatch(self)
2378                 self.consume()
2379         except RecognitionException as re:
2380             localctx.exception = re
2381             self._errHandler.reportError(self, re)
2382             self._errHandler.recover(self, re)
2383         finally:
2384             self.exitRule()
2385         return localctx
2386
2387     class DeclaratorContext(ParserRuleContext):
2388
2389         # @param  parent=None Type: ParserRuleContext
2390         # @param  invokingState=-1 Type: int
2391         def __init__(self,parser,parent=None,invokingState=-1):
2392             super().__init__(parent, invokingState)
2393             self.parser = parser
2394
2395         def direct_declarator(self):
2396             return self.getTypedRuleContext(CParser.Direct_declaratorContext,0)
2397
2398
2399         def pointer(self):
2400             return self.getTypedRuleContext(CParser.PointerContext,0)
2401
2402
2403         def getRuleIndex(self):
2404             return CParser.RULE_declarator
2405
2406         # @param  listener Type: ParseTreeListener
2407         def enterRule(self,listener):
2408             if hasattr( listener, "enterDeclarator" ):
2409                 listener.enterDeclarator(self)
2410
2411         # @param  listener Type: ParseTreeListener
2412         def exitRule(self,listener):
2413             if hasattr( listener, "exitDeclarator" ):
2414                 listener.exitDeclarator(self)
2415
2416
2417
2418
2419     def declarator(self):
2420
2421         localctx = CParser.DeclaratorContext(self, self._ctx, self.state)
2422         self.enterRule(localctx, 42, self.RULE_declarator)
2423         self._la = 0 # Token type
2424         try:
2425             self.state = 348
2426             self._errHandler.sync(self)
2427             la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
2428             if la_ == 1:
2429                 self.enterOuterAlt(localctx, 1)
2430                 self.state = 335
2431                 self._errHandler.sync(self)
2432                 _la = self._input.LA(1)
2433                 if _la==CParser.T__41:
2434                     self.state = 334
2435                     self.pointer()
2436
2437
2438                 self.state = 338
2439                 self._errHandler.sync(self)
2440                 _la = self._input.LA(1)
2441                 if _la==CParser.T__33:
2442                     self.state = 337
2443                     self.match(CParser.T__33)
2444
2445
2446                 self.state = 341
2447                 self._errHandler.sync(self)
2448                 _la = self._input.LA(1)
2449                 if _la==CParser.T__34:
2450                     self.state = 340
2451                     self.match(CParser.T__34)
2452
2453
2454                 self.state = 344
2455                 self._errHandler.sync(self)
2456                 _la = self._input.LA(1)
2457                 if _la==CParser.T__35:
2458                     self.state = 343
2459                     self.match(CParser.T__35)
2460
2461
2462                 self.state = 346
2463                 self.direct_declarator()
2464                 pass
2465
2466             elif la_ == 2:
2467                 self.enterOuterAlt(localctx, 2)
2468                 self.state = 347
2469                 self.pointer()
2470                 pass
2471
2472
2473         except RecognitionException as re:
2474             localctx.exception = re
2475             self._errHandler.reportError(self, re)
2476             self._errHandler.recover(self, re)
2477         finally:
2478             self.exitRule()
2479         return localctx
2480
2481     class Direct_declaratorContext(ParserRuleContext):
2482
2483         # @param  parent=None Type: ParserRuleContext
2484         # @param  invokingState=-1 Type: int
2485         def __init__(self,parser,parent=None,invokingState=-1):
2486             super().__init__(parent, invokingState)
2487             self.parser = parser
2488
2489         def IDENTIFIER(self):
2490             return self.getToken(CParser.IDENTIFIER, 0)
2491
2492         # @param  i=None Type: int
2493         def declarator_suffix(self,i=None):
2494             if i is None:
2495                 return self.getTypedRuleContexts(CParser.Declarator_suffixContext)
2496             else:
2497                 return self.getTypedRuleContext(CParser.Declarator_suffixContext,i)
2498
2499
2500         def declarator(self):
2501             return self.getTypedRuleContext(CParser.DeclaratorContext,0)
2502
2503
2504         def getRuleIndex(self):
2505             return CParser.RULE_direct_declarator
2506
2507         # @param  listener Type: ParseTreeListener
2508         def enterRule(self,listener):
2509             if hasattr( listener, "enterDirect_declarator" ):
2510                 listener.enterDirect_declarator(self)
2511
2512         # @param  listener Type: ParseTreeListener
2513         def exitRule(self,listener):
2514             if hasattr( listener, "exitDirect_declarator" ):
2515                 listener.exitDirect_declarator(self)
2516
2517
2518
2519
2520     def direct_declarator(self):
2521
2522         localctx = CParser.Direct_declaratorContext(self, self._ctx, self.state)
2523         self.enterRule(localctx, 44, self.RULE_direct_declarator)
2524         try:
2525             self.state = 368
2526             self._errHandler.sync(self)
2527             token = self._input.LA(1)
2528             if token in [CParser.IDENTIFIER]:
2529                 self.enterOuterAlt(localctx, 1)
2530                 self.state = 350
2531                 self.match(CParser.IDENTIFIER)
2532                 self.state = 354
2533                 self._errHandler.sync(self)
2534                 _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
2535                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2536                     if _alt==1:
2537                         self.state = 351
2538                         self.declarator_suffix()
2539                     self.state = 356
2540                     self._errHandler.sync(self)
2541                     _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
2542
2543                 pass
2544             elif token in [CParser.T__37]:
2545                 self.enterOuterAlt(localctx, 2)
2546                 self.state = 357
2547                 self.match(CParser.T__37)
2548                 self.state = 359
2549                 self._errHandler.sync(self)
2550                 la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
2551                 if la_ == 1:
2552                     self.state = 358
2553                     self.match(CParser.T__33)
2554
2555
2556                 self.state = 361
2557                 self.declarator()
2558                 self.state = 362
2559                 self.match(CParser.T__38)
2560                 self.state = 364
2561                 self._errHandler.sync(self)
2562                 _alt = 1
2563                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2564                     if _alt == 1:
2565                         self.state = 363
2566                         self.declarator_suffix()
2567
2568                     else:
2569                         raise NoViableAltException(self)
2570                     self.state = 366
2571                     self._errHandler.sync(self)
2572                     _alt = self._interp.adaptivePredict(self._input,37,self._ctx)
2573
2574                 pass
2575             else:
2576                 raise NoViableAltException(self)
2577
2578         except RecognitionException as re:
2579             localctx.exception = re
2580             self._errHandler.reportError(self, re)
2581             self._errHandler.recover(self, re)
2582         finally:
2583             self.exitRule()
2584         return localctx
2585
2586     class Declarator_suffixContext(ParserRuleContext):
2587
2588         # @param  parent=None Type: ParserRuleContext
2589         # @param  invokingState=-1 Type: int
2590         def __init__(self,parser,parent=None,invokingState=-1):
2591             super().__init__(parent, invokingState)
2592             self.parser = parser
2593
2594         def constant_expression(self):
2595             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
2596
2597
2598         def parameter_type_list(self):
2599             return self.getTypedRuleContext(CParser.Parameter_type_listContext,0)
2600
2601
2602         def identifier_list(self):
2603             return self.getTypedRuleContext(CParser.Identifier_listContext,0)
2604
2605
2606         def getRuleIndex(self):
2607             return CParser.RULE_declarator_suffix
2608
2609         # @param  listener Type: ParseTreeListener
2610         def enterRule(self,listener):
2611             if hasattr( listener, "enterDeclarator_suffix" ):
2612                 listener.enterDeclarator_suffix(self)
2613
2614         # @param  listener Type: ParseTreeListener
2615         def exitRule(self,listener):
2616             if hasattr( listener, "exitDeclarator_suffix" ):
2617                 listener.exitDeclarator_suffix(self)
2618
2619
2620
2621
2622     def declarator_suffix(self):
2623
2624         localctx = CParser.Declarator_suffixContext(self, self._ctx, self.state)
2625         self.enterRule(localctx, 46, self.RULE_declarator_suffix)
2626         try:
2627             self.state = 386
2628             self._errHandler.sync(self)
2629             la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
2630             if la_ == 1:
2631                 self.enterOuterAlt(localctx, 1)
2632                 self.state = 370
2633                 self.match(CParser.T__39)
2634                 self.state = 371
2635                 self.constant_expression()
2636                 self.state = 372
2637                 self.match(CParser.T__40)
2638                 pass
2639
2640             elif la_ == 2:
2641                 self.enterOuterAlt(localctx, 2)
2642                 self.state = 374
2643                 self.match(CParser.T__39)
2644                 self.state = 375
2645                 self.match(CParser.T__40)
2646                 pass
2647
2648             elif la_ == 3:
2649                 self.enterOuterAlt(localctx, 3)
2650                 self.state = 376
2651                 self.match(CParser.T__37)
2652                 self.state = 377
2653                 self.parameter_type_list()
2654                 self.state = 378
2655                 self.match(CParser.T__38)
2656                 pass
2657
2658             elif la_ == 4:
2659                 self.enterOuterAlt(localctx, 4)
2660                 self.state = 380
2661                 self.match(CParser.T__37)
2662                 self.state = 381
2663                 self.identifier_list()
2664                 self.state = 382
2665                 self.match(CParser.T__38)
2666                 pass
2667
2668             elif la_ == 5:
2669                 self.enterOuterAlt(localctx, 5)
2670                 self.state = 384
2671                 self.match(CParser.T__37)
2672                 self.state = 385
2673                 self.match(CParser.T__38)
2674                 pass
2675
2676
2677         except RecognitionException as re:
2678             localctx.exception = re
2679             self._errHandler.reportError(self, re)
2680             self._errHandler.recover(self, re)
2681         finally:
2682             self.exitRule()
2683         return localctx
2684
2685     class PointerContext(ParserRuleContext):
2686
2687         # @param  parent=None Type: ParserRuleContext
2688         # @param  invokingState=-1 Type: int
2689         def __init__(self,parser,parent=None,invokingState=-1):
2690             super().__init__(parent, invokingState)
2691             self.parser = parser
2692
2693         # @param  i=None Type: int
2694         def type_qualifier(self,i=None):
2695             if i is None:
2696                 return self.getTypedRuleContexts(CParser.Type_qualifierContext)
2697             else:
2698                 return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
2699
2700
2701         def pointer(self):
2702             return self.getTypedRuleContext(CParser.PointerContext,0)
2703
2704
2705         def getRuleIndex(self):
2706             return CParser.RULE_pointer
2707
2708         # @param  listener Type: ParseTreeListener
2709         def enterRule(self,listener):
2710             if hasattr( listener, "enterPointer" ):
2711                 listener.enterPointer(self)
2712
2713         # @param  listener Type: ParseTreeListener
2714         def exitRule(self,listener):
2715             if hasattr( listener, "exitPointer" ):
2716                 listener.exitPointer(self)
2717
2718
2719
2720
2721     def pointer(self):
2722
2723         localctx = CParser.PointerContext(self, self._ctx, self.state)
2724         self.enterRule(localctx, 48, self.RULE_pointer)
2725         try:
2726             self.state = 400
2727             self._errHandler.sync(self)
2728             la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
2729             if la_ == 1:
2730                 self.enterOuterAlt(localctx, 1)
2731                 self.state = 388
2732                 self.match(CParser.T__41)
2733                 self.state = 390
2734                 self._errHandler.sync(self)
2735                 _alt = 1
2736                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2737                     if _alt == 1:
2738                         self.state = 389
2739                         self.type_qualifier()
2740
2741                     else:
2742                         raise NoViableAltException(self)
2743                     self.state = 392
2744                     self._errHandler.sync(self)
2745                     _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
2746
2747                 self.state = 395
2748                 self._errHandler.sync(self)
2749                 la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
2750                 if la_ == 1:
2751                     self.state = 394
2752                     self.pointer()
2753
2754
2755                 pass
2756
2757             elif la_ == 2:
2758                 self.enterOuterAlt(localctx, 2)
2759                 self.state = 397
2760                 self.match(CParser.T__41)
2761                 self.state = 398
2762                 self.pointer()
2763                 pass
2764
2765             elif la_ == 3:
2766                 self.enterOuterAlt(localctx, 3)
2767                 self.state = 399
2768                 self.match(CParser.T__41)
2769                 pass
2770
2771
2772         except RecognitionException as re:
2773             localctx.exception = re
2774             self._errHandler.reportError(self, re)
2775             self._errHandler.recover(self, re)
2776         finally:
2777             self.exitRule()
2778         return localctx
2779
2780     class Parameter_type_listContext(ParserRuleContext):
2781
2782         # @param  parent=None Type: ParserRuleContext
2783         # @param  invokingState=-1 Type: int
2784         def __init__(self,parser,parent=None,invokingState=-1):
2785             super().__init__(parent, invokingState)
2786             self.parser = parser
2787
2788         def parameter_list(self):
2789             return self.getTypedRuleContext(CParser.Parameter_listContext,0)
2790
2791
2792         def getRuleIndex(self):
2793             return CParser.RULE_parameter_type_list
2794
2795         # @param  listener Type: ParseTreeListener
2796         def enterRule(self,listener):
2797             if hasattr( listener, "enterParameter_type_list" ):
2798                 listener.enterParameter_type_list(self)
2799
2800         # @param  listener Type: ParseTreeListener
2801         def exitRule(self,listener):
2802             if hasattr( listener, "exitParameter_type_list" ):
2803                 listener.exitParameter_type_list(self)
2804
2805
2806
2807
2808     def parameter_type_list(self):
2809
2810         localctx = CParser.Parameter_type_listContext(self, self._ctx, self.state)
2811         self.enterRule(localctx, 50, self.RULE_parameter_type_list)
2812         self._la = 0 # Token type
2813         try:
2814             self.enterOuterAlt(localctx, 1)
2815             self.state = 402
2816             self.parameter_list()
2817             self.state = 408
2818             self._errHandler.sync(self)
2819             _la = self._input.LA(1)
2820             if _la==CParser.T__3:
2821                 self.state = 403
2822                 self.match(CParser.T__3)
2823                 self.state = 405
2824                 self._errHandler.sync(self)
2825                 _la = self._input.LA(1)
2826                 if _la==CParser.T__28:
2827                     self.state = 404
2828                     self.match(CParser.T__28)
2829
2830
2831                 self.state = 407
2832                 self.match(CParser.T__42)
2833
2834
2835         except RecognitionException as re:
2836             localctx.exception = re
2837             self._errHandler.reportError(self, re)
2838             self._errHandler.recover(self, re)
2839         finally:
2840             self.exitRule()
2841         return localctx
2842
2843     class Parameter_listContext(ParserRuleContext):
2844
2845         # @param  parent=None Type: ParserRuleContext
2846         # @param  invokingState=-1 Type: int
2847         def __init__(self,parser,parent=None,invokingState=-1):
2848             super().__init__(parent, invokingState)
2849             self.parser = parser
2850
2851         # @param  i=None Type: int
2852         def parameter_declaration(self,i=None):
2853             if i is None:
2854                 return self.getTypedRuleContexts(CParser.Parameter_declarationContext)
2855             else:
2856                 return self.getTypedRuleContext(CParser.Parameter_declarationContext,i)
2857
2858
2859         def getRuleIndex(self):
2860             return CParser.RULE_parameter_list
2861
2862         # @param  listener Type: ParseTreeListener
2863         def enterRule(self,listener):
2864             if hasattr( listener, "enterParameter_list" ):
2865                 listener.enterParameter_list(self)
2866
2867         # @param  listener Type: ParseTreeListener
2868         def exitRule(self,listener):
2869             if hasattr( listener, "exitParameter_list" ):
2870                 listener.exitParameter_list(self)
2871
2872
2873
2874
2875     def parameter_list(self):
2876
2877         localctx = CParser.Parameter_listContext(self, self._ctx, self.state)
2878         self.enterRule(localctx, 52, self.RULE_parameter_list)
2879         try:
2880             self.enterOuterAlt(localctx, 1)
2881             self.state = 410
2882             self.parameter_declaration()
2883             self.state = 418
2884             self._errHandler.sync(self)
2885             _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
2886             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2887                 if _alt==1:
2888                     self.state = 411
2889                     self.match(CParser.T__3)
2890                     self.state = 413
2891                     self._errHandler.sync(self)
2892                     la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
2893                     if la_ == 1:
2894                         self.state = 412
2895                         self.match(CParser.T__28)
2896
2897
2898                     self.state = 415
2899                     self.parameter_declaration()
2900                 self.state = 420
2901                 self._errHandler.sync(self)
2902                 _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
2903
2904         except RecognitionException as re:
2905             localctx.exception = re
2906             self._errHandler.reportError(self, re)
2907             self._errHandler.recover(self, re)
2908         finally:
2909             self.exitRule()
2910         return localctx
2911
2912     class Parameter_declarationContext(ParserRuleContext):
2913
2914         # @param  parent=None Type: ParserRuleContext
2915         # @param  invokingState=-1 Type: int
2916         def __init__(self,parser,parent=None,invokingState=-1):
2917             super().__init__(parent, invokingState)
2918             self.parser = parser
2919
2920         def declaration_specifiers(self):
2921             return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
2922
2923
2924         # @param  i=None Type: int
2925         def declarator(self,i=None):
2926             if i is None:
2927                 return self.getTypedRuleContexts(CParser.DeclaratorContext)
2928             else:
2929                 return self.getTypedRuleContext(CParser.DeclaratorContext,i)
2930
2931
2932         # @param  i=None Type: int
2933         def abstract_declarator(self,i=None):
2934             if i is None:
2935                 return self.getTypedRuleContexts(CParser.Abstract_declaratorContext)
2936             else:
2937                 return self.getTypedRuleContext(CParser.Abstract_declaratorContext,i)
2938
2939
2940         def IDENTIFIER(self):
2941             return self.getToken(CParser.IDENTIFIER, 0)
2942
2943         # @param  i=None Type: int
2944         def pointer(self,i=None):
2945             if i is None:
2946                 return self.getTypedRuleContexts(CParser.PointerContext)
2947             else:
2948                 return self.getTypedRuleContext(CParser.PointerContext,i)
2949
2950
2951         def getRuleIndex(self):
2952             return CParser.RULE_parameter_declaration
2953
2954         # @param  listener Type: ParseTreeListener
2955         def enterRule(self,listener):
2956             if hasattr( listener, "enterParameter_declaration" ):
2957                 listener.enterParameter_declaration(self)
2958
2959         # @param  listener Type: ParseTreeListener
2960         def exitRule(self,listener):
2961             if hasattr( listener, "exitParameter_declaration" ):
2962                 listener.exitParameter_declaration(self)
2963
2964
2965
2966
2967     def parameter_declaration(self):
2968
2969         localctx = CParser.Parameter_declarationContext(self, self._ctx, self.state)
2970         self.enterRule(localctx, 54, self.RULE_parameter_declaration)
2971         self._la = 0 # Token type
2972         try:
2973             self.state = 439
2974             self._errHandler.sync(self)
2975             la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
2976             if la_ == 1:
2977                 self.enterOuterAlt(localctx, 1)
2978                 self.state = 421
2979                 self.declaration_specifiers()
2980                 self.state = 426
2981                 self._errHandler.sync(self)
2982                 _la = self._input.LA(1)
2983                 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):
2984                     self.state = 424
2985                     self._errHandler.sync(self)
2986                     la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
2987                     if la_ == 1:
2988                         self.state = 422
2989                         self.declarator()
2990                         pass
2991
2992                     elif la_ == 2:
2993                         self.state = 423
2994                         self.abstract_declarator()
2995                         pass
2996
2997
2998                     self.state = 428
2999                     self._errHandler.sync(self)
3000                     _la = self._input.LA(1)
3001
3002                 self.state = 430
3003                 self._errHandler.sync(self)
3004                 _la = self._input.LA(1)
3005                 if _la==CParser.T__28:
3006                     self.state = 429
3007                     self.match(CParser.T__28)
3008
3009
3010                 pass
3011
3012             elif la_ == 2:
3013                 self.enterOuterAlt(localctx, 2)
3014                 self.state = 435
3015                 self._errHandler.sync(self)
3016                 _la = self._input.LA(1)
3017                 while _la==CParser.T__41:
3018                     self.state = 432
3019                     self.pointer()
3020                     self.state = 437
3021                     self._errHandler.sync(self)
3022                     _la = self._input.LA(1)
3023
3024                 self.state = 438
3025                 self.match(CParser.IDENTIFIER)
3026                 pass
3027
3028
3029         except RecognitionException as re:
3030             localctx.exception = re
3031             self._errHandler.reportError(self, re)
3032             self._errHandler.recover(self, re)
3033         finally:
3034             self.exitRule()
3035         return localctx
3036
3037     class Identifier_listContext(ParserRuleContext):
3038
3039         # @param  parent=None Type: ParserRuleContext
3040         # @param  invokingState=-1 Type: int
3041         def __init__(self,parser,parent=None,invokingState=-1):
3042             super().__init__(parent, invokingState)
3043             self.parser = parser
3044
3045         # @param  i=None Type: int
3046         def IDENTIFIER(self,i=None):
3047             if i is None:
3048                 return self.getTokens(CParser.IDENTIFIER)
3049             else:
3050                 return self.getToken(CParser.IDENTIFIER, i)
3051
3052         def getRuleIndex(self):
3053             return CParser.RULE_identifier_list
3054
3055         # @param  listener Type: ParseTreeListener
3056         def enterRule(self,listener):
3057             if hasattr( listener, "enterIdentifier_list" ):
3058                 listener.enterIdentifier_list(self)
3059
3060         # @param  listener Type: ParseTreeListener
3061         def exitRule(self,listener):
3062             if hasattr( listener, "exitIdentifier_list" ):
3063                 listener.exitIdentifier_list(self)
3064
3065
3066
3067
3068     def identifier_list(self):
3069
3070         localctx = CParser.Identifier_listContext(self, self._ctx, self.state)
3071         self.enterRule(localctx, 56, self.RULE_identifier_list)
3072         self._la = 0 # Token type
3073         try:
3074             self.enterOuterAlt(localctx, 1)
3075             self.state = 441
3076             self.match(CParser.IDENTIFIER)
3077             self.state = 446
3078             self._errHandler.sync(self)
3079             _la = self._input.LA(1)
3080             while _la==CParser.T__3:
3081                 self.state = 442
3082                 self.match(CParser.T__3)
3083                 self.state = 443
3084                 self.match(CParser.IDENTIFIER)
3085                 self.state = 448
3086                 self._errHandler.sync(self)
3087                 _la = self._input.LA(1)
3088
3089         except RecognitionException as re:
3090             localctx.exception = re
3091             self._errHandler.reportError(self, re)
3092             self._errHandler.recover(self, re)
3093         finally:
3094             self.exitRule()
3095         return localctx
3096
3097     class Type_nameContext(ParserRuleContext):
3098
3099         # @param  parent=None Type: ParserRuleContext
3100         # @param  invokingState=-1 Type: int
3101         def __init__(self,parser,parent=None,invokingState=-1):
3102             super().__init__(parent, invokingState)
3103             self.parser = parser
3104
3105         def specifier_qualifier_list(self):
3106             return self.getTypedRuleContext(CParser.Specifier_qualifier_listContext,0)
3107
3108
3109         def abstract_declarator(self):
3110             return self.getTypedRuleContext(CParser.Abstract_declaratorContext,0)
3111
3112
3113         def type_id(self):
3114             return self.getTypedRuleContext(CParser.Type_idContext,0)
3115
3116
3117         def getRuleIndex(self):
3118             return CParser.RULE_type_name
3119
3120         # @param  listener Type: ParseTreeListener
3121         def enterRule(self,listener):
3122             if hasattr( listener, "enterType_name" ):
3123                 listener.enterType_name(self)
3124
3125         # @param  listener Type: ParseTreeListener
3126         def exitRule(self,listener):
3127             if hasattr( listener, "exitType_name" ):
3128                 listener.exitType_name(self)
3129
3130
3131
3132
3133     def type_name(self):
3134
3135         localctx = CParser.Type_nameContext(self, self._ctx, self.state)
3136         self.enterRule(localctx, 58, self.RULE_type_name)
3137         self._la = 0 # Token type
3138         try:
3139             self.state = 454
3140             self._errHandler.sync(self)
3141             la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
3142             if la_ == 1:
3143                 self.enterOuterAlt(localctx, 1)
3144                 self.state = 449
3145                 self.specifier_qualifier_list()
3146                 self.state = 451
3147                 self._errHandler.sync(self)
3148                 _la = self._input.LA(1)
3149                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__37) | (1 << CParser.T__39) | (1 << CParser.T__41))) != 0):
3150                     self.state = 450
3151                     self.abstract_declarator()
3152
3153
3154                 pass
3155
3156             elif la_ == 2:
3157                 self.enterOuterAlt(localctx, 2)
3158                 self.state = 453
3159                 self.type_id()
3160                 pass
3161
3162
3163         except RecognitionException as re:
3164             localctx.exception = re
3165             self._errHandler.reportError(self, re)
3166             self._errHandler.recover(self, re)
3167         finally:
3168             self.exitRule()
3169         return localctx
3170
3171     class Abstract_declaratorContext(ParserRuleContext):
3172
3173         # @param  parent=None Type: ParserRuleContext
3174         # @param  invokingState=-1 Type: int
3175         def __init__(self,parser,parent=None,invokingState=-1):
3176             super().__init__(parent, invokingState)
3177             self.parser = parser
3178
3179         def pointer(self):
3180             return self.getTypedRuleContext(CParser.PointerContext,0)
3181
3182
3183         def direct_abstract_declarator(self):
3184             return self.getTypedRuleContext(CParser.Direct_abstract_declaratorContext,0)
3185
3186
3187         def getRuleIndex(self):
3188             return CParser.RULE_abstract_declarator
3189
3190         # @param  listener Type: ParseTreeListener
3191         def enterRule(self,listener):
3192             if hasattr( listener, "enterAbstract_declarator" ):
3193                 listener.enterAbstract_declarator(self)
3194
3195         # @param  listener Type: ParseTreeListener
3196         def exitRule(self,listener):
3197             if hasattr( listener, "exitAbstract_declarator" ):
3198                 listener.exitAbstract_declarator(self)
3199
3200
3201
3202
3203     def abstract_declarator(self):
3204
3205         localctx = CParser.Abstract_declaratorContext(self, self._ctx, self.state)
3206         self.enterRule(localctx, 60, self.RULE_abstract_declarator)
3207         try:
3208             self.state = 461
3209             self._errHandler.sync(self)
3210             token = self._input.LA(1)
3211             if token in [CParser.T__41]:
3212                 self.enterOuterAlt(localctx, 1)
3213                 self.state = 456
3214                 self.pointer()
3215                 self.state = 458
3216                 self._errHandler.sync(self)
3217                 la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
3218                 if la_ == 1:
3219                     self.state = 457
3220                     self.direct_abstract_declarator()
3221
3222
3223                 pass
3224             elif token in [CParser.T__37, CParser.T__39]:
3225                 self.enterOuterAlt(localctx, 2)
3226                 self.state = 460
3227                 self.direct_abstract_declarator()
3228                 pass
3229             else:
3230                 raise NoViableAltException(self)
3231
3232         except RecognitionException as re:
3233             localctx.exception = re
3234             self._errHandler.reportError(self, re)
3235             self._errHandler.recover(self, re)
3236         finally:
3237             self.exitRule()
3238         return localctx
3239
3240     class Direct_abstract_declaratorContext(ParserRuleContext):
3241
3242         # @param  parent=None Type: ParserRuleContext
3243         # @param  invokingState=-1 Type: int
3244         def __init__(self,parser,parent=None,invokingState=-1):
3245             super().__init__(parent, invokingState)
3246             self.parser = parser
3247
3248         def abstract_declarator(self):
3249             return self.getTypedRuleContext(CParser.Abstract_declaratorContext,0)
3250
3251
3252         # @param  i=None Type: int
3253         def abstract_declarator_suffix(self,i=None):
3254             if i is None:
3255                 return self.getTypedRuleContexts(CParser.Abstract_declarator_suffixContext)
3256             else:
3257                 return self.getTypedRuleContext(CParser.Abstract_declarator_suffixContext,i)
3258
3259
3260         def getRuleIndex(self):
3261             return CParser.RULE_direct_abstract_declarator
3262
3263         # @param  listener Type: ParseTreeListener
3264         def enterRule(self,listener):
3265             if hasattr( listener, "enterDirect_abstract_declarator" ):
3266                 listener.enterDirect_abstract_declarator(self)
3267
3268         # @param  listener Type: ParseTreeListener
3269         def exitRule(self,listener):
3270             if hasattr( listener, "exitDirect_abstract_declarator" ):
3271                 listener.exitDirect_abstract_declarator(self)
3272
3273
3274
3275     def direct_abstract_declarator(self):
3276
3277         localctx = CParser.Direct_abstract_declaratorContext(self, self._ctx, self.state)
3278         self.enterRule(localctx, 62, self.RULE_direct_abstract_declarator)
3279         try:
3280             self.enterOuterAlt(localctx, 1)
3281             self.state = 468
3282             self._errHandler.sync(self)
3283             la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
3284             if la_ == 1:
3285                 self.state = 463
3286                 self.match(CParser.T__37)
3287                 self.state = 464
3288                 self.abstract_declarator()
3289                 self.state = 465
3290                 self.match(CParser.T__38)
3291                 pass
3292
3293             elif la_ == 2:
3294                 self.state = 467
3295                 self.abstract_declarator_suffix()
3296                 pass
3297
3298
3299             self.state = 473
3300             self._errHandler.sync(self)
3301             _alt = self._interp.adaptivePredict(self._input,58,self._ctx)
3302             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
3303                 if _alt==1:
3304                     self.state = 470
3305                     self.abstract_declarator_suffix()
3306                 self.state = 475
3307                 self._errHandler.sync(self)
3308                 _alt = self._interp.adaptivePredict(self._input,58,self._ctx)
3309
3310         except RecognitionException as re:
3311             localctx.exception = re
3312             self._errHandler.reportError(self, re)
3313             self._errHandler.recover(self, re)
3314         finally:
3315             self.exitRule()
3316         return localctx
3317
3318     class Abstract_declarator_suffixContext(ParserRuleContext):
3319
3320         # @param  parent=None Type: ParserRuleContext
3321         # @param  invokingState=-1 Type: int
3322         def __init__(self,parser,parent=None,invokingState=-1):
3323             super().__init__(parent, invokingState)
3324             self.parser = parser
3325
3326         def constant_expression(self):
3327             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
3328
3329
3330         def parameter_type_list(self):
3331             return self.getTypedRuleContext(CParser.Parameter_type_listContext,0)
3332
3333
3334         def getRuleIndex(self):
3335             return CParser.RULE_abstract_declarator_suffix
3336
3337         # @param  listener Type: ParseTreeListener
3338         def enterRule(self,listener):
3339             if hasattr( listener, "enterAbstract_declarator_suffix" ):
3340                 listener.enterAbstract_declarator_suffix(self)
3341
3342         # @param  listener Type: ParseTreeListener
3343         def exitRule(self,listener):
3344             if hasattr( listener, "exitAbstract_declarator_suffix" ):
3345                 listener.exitAbstract_declarator_suffix(self)
3346
3347
3348
3349
3350     def abstract_declarator_suffix(self):
3351
3352         localctx = CParser.Abstract_declarator_suffixContext(self, self._ctx, self.state)
3353         self.enterRule(localctx, 64, self.RULE_abstract_declarator_suffix)
3354         try:
3355             self.state = 488
3356             self._errHandler.sync(self)
3357             la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
3358             if la_ == 1:
3359                 self.enterOuterAlt(localctx, 1)
3360                 self.state = 476
3361                 self.match(CParser.T__39)
3362                 self.state = 477
3363                 self.match(CParser.T__40)
3364                 pass
3365
3366             elif la_ == 2:
3367                 self.enterOuterAlt(localctx, 2)
3368                 self.state = 478
3369                 self.match(CParser.T__39)
3370                 self.state = 479
3371                 self.constant_expression()
3372                 self.state = 480
3373                 self.match(CParser.T__40)
3374                 pass
3375
3376             elif la_ == 3:
3377                 self.enterOuterAlt(localctx, 3)
3378                 self.state = 482
3379                 self.match(CParser.T__37)
3380                 self.state = 483
3381                 self.match(CParser.T__38)
3382                 pass
3383
3384             elif la_ == 4:
3385                 self.enterOuterAlt(localctx, 4)
3386                 self.state = 484
3387                 self.match(CParser.T__37)
3388                 self.state = 485
3389                 self.parameter_type_list()
3390                 self.state = 486
3391                 self.match(CParser.T__38)
3392                 pass
3393
3394
3395         except RecognitionException as re:
3396             localctx.exception = re
3397             self._errHandler.reportError(self, re)
3398             self._errHandler.recover(self, re)
3399         finally:
3400             self.exitRule()
3401         return localctx
3402
3403     class InitializerContext(ParserRuleContext):
3404
3405         # @param  parent=None Type: ParserRuleContext
3406         # @param  invokingState=-1 Type: int
3407         def __init__(self,parser,parent=None,invokingState=-1):
3408             super().__init__(parent, invokingState)
3409             self.parser = parser
3410
3411         def assignment_expression(self):
3412             return self.getTypedRuleContext(CParser.Assignment_expressionContext,0)
3413
3414
3415         def initializer_list(self):
3416             return self.getTypedRuleContext(CParser.Initializer_listContext,0)
3417
3418
3419         def getRuleIndex(self):
3420             return CParser.RULE_initializer
3421
3422         # @param  listener Type: ParseTreeListener
3423         def enterRule(self,listener):
3424             if hasattr( listener, "enterInitializer" ):
3425                 listener.enterInitializer(self)
3426
3427         # @param  listener Type: ParseTreeListener
3428         def exitRule(self,listener):
3429             if hasattr( listener, "exitInitializer" ):
3430                 listener.exitInitializer(self)
3431
3432
3433
3434
3435     def initializer(self):
3436
3437         localctx = CParser.InitializerContext(self, self._ctx, self.state)
3438         self.enterRule(localctx, 66, self.RULE_initializer)
3439         self._la = 0 # Token type
3440         try:
3441             self.state = 498
3442             self._errHandler.sync(self)
3443             token = self._input.LA(1)
3444             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]:
3445                 self.enterOuterAlt(localctx, 1)
3446                 self.state = 490
3447                 self.assignment_expression()
3448                 pass
3449             elif token in [CParser.T__0]:
3450                 self.enterOuterAlt(localctx, 2)
3451                 self.state = 491
3452                 self.match(CParser.T__0)
3453                 self.state = 492
3454                 self.initializer_list()
3455                 self.state = 494
3456                 self._errHandler.sync(self)
3457                 _la = self._input.LA(1)
3458                 if _la==CParser.T__3:
3459                     self.state = 493
3460                     self.match(CParser.T__3)
3461
3462
3463                 self.state = 496
3464                 self.match(CParser.T__19)
3465                 pass
3466             else:
3467                 raise NoViableAltException(self)
3468
3469         except RecognitionException as re:
3470             localctx.exception = re
3471             self._errHandler.reportError(self, re)
3472             self._errHandler.recover(self, re)
3473         finally:
3474             self.exitRule()
3475         return localctx
3476
3477     class Initializer_listContext(ParserRuleContext):
3478
3479         # @param  parent=None Type: ParserRuleContext
3480         # @param  invokingState=-1 Type: int
3481         def __init__(self,parser,parent=None,invokingState=-1):
3482             super().__init__(parent, invokingState)
3483             self.parser = parser
3484
3485         # @param  i=None Type: int
3486         def initializer(self,i=None):
3487             if i is None:
3488                 return self.getTypedRuleContexts(CParser.InitializerContext)
3489             else:
3490                 return self.getTypedRuleContext(CParser.InitializerContext,i)
3491
3492
3493         def getRuleIndex(self):
3494             return CParser.RULE_initializer_list
3495
3496         # @param  listener Type: ParseTreeListener
3497         def enterRule(self,listener):
3498             if hasattr( listener, "enterInitializer_list" ):
3499                 listener.enterInitializer_list(self)
3500
3501         # @param  listener Type: ParseTreeListener
3502         def exitRule(self,listener):
3503             if hasattr( listener, "exitInitializer_list" ):
3504                 listener.exitInitializer_list(self)
3505
3506
3507
3508
3509     def initializer_list(self):
3510
3511         localctx = CParser.Initializer_listContext(self, self._ctx, self.state)
3512         self.enterRule(localctx, 68, self.RULE_initializer_list)
3513         try:
3514             self.enterOuterAlt(localctx, 1)
3515             self.state = 500
3516             self.initializer()
3517             self.state = 505
3518             self._errHandler.sync(self)
3519             _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
3520             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
3521                 if _alt==1:
3522                     self.state = 501
3523                     self.match(CParser.T__3)
3524                     self.state = 502
3525                     self.initializer()
3526                 self.state = 507
3527                 self._errHandler.sync(self)
3528                 _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
3529
3530         except RecognitionException as re:
3531             localctx.exception = re
3532             self._errHandler.reportError(self, re)
3533             self._errHandler.recover(self, re)
3534         finally:
3535             self.exitRule()
3536         return localctx
3537
3538     class Argument_expression_listContext(ParserRuleContext):
3539
3540         # @param  parent=None Type: ParserRuleContext
3541         # @param  invokingState=-1 Type: int
3542         def __init__(self,parser,parent=None,invokingState=-1):
3543             super().__init__(parent, invokingState)
3544             self.parser = parser
3545
3546         # @param  i=None Type: int
3547         def assignment_expression(self,i=None):
3548             if i is None:
3549                 return self.getTypedRuleContexts(CParser.Assignment_expressionContext)
3550             else:
3551                 return self.getTypedRuleContext(CParser.Assignment_expressionContext,i)
3552
3553
3554         def getRuleIndex(self):
3555             return CParser.RULE_argument_expression_list
3556
3557         # @param  listener Type: ParseTreeListener
3558         def enterRule(self,listener):
3559             if hasattr( listener, "enterArgument_expression_list" ):
3560                 listener.enterArgument_expression_list(self)
3561
3562         # @param  listener Type: ParseTreeListener
3563         def exitRule(self,listener):
3564             if hasattr( listener, "exitArgument_expression_list" ):
3565                 listener.exitArgument_expression_list(self)
3566
3567
3568
3569
3570     def argument_expression_list(self):
3571
3572         localctx = CParser.Argument_expression_listContext(self, self._ctx, self.state)
3573         self.enterRule(localctx, 70, self.RULE_argument_expression_list)
3574         self._la = 0 # Token type
3575         try:
3576             self.enterOuterAlt(localctx, 1)
3577             self.state = 508
3578             self.assignment_expression()
3579             self.state = 510
3580             self._errHandler.sync(self)
3581             _la = self._input.LA(1)
3582             if _la==CParser.T__28:
3583                 self.state = 509
3584                 self.match(CParser.T__28)
3585
3586
3587             self.state = 519
3588             self._errHandler.sync(self)
3589             _la = self._input.LA(1)
3590             while _la==CParser.T__3:
3591                 self.state = 512
3592                 self.match(CParser.T__3)
3593                 self.state = 513
3594                 self.assignment_expression()
3595                 self.state = 515
3596                 self._errHandler.sync(self)
3597                 _la = self._input.LA(1)
3598                 if _la==CParser.T__28:
3599                     self.state = 514
3600                     self.match(CParser.T__28)
3601
3602
3603                 self.state = 521
3604                 self._errHandler.sync(self)
3605                 _la = self._input.LA(1)
3606
3607         except RecognitionException as re:
3608             localctx.exception = re
3609             self._errHandler.reportError(self, re)
3610             self._errHandler.recover(self, re)
3611         finally:
3612             self.exitRule()
3613         return localctx
3614
3615     class Additive_expressionContext(ParserRuleContext):
3616
3617         # @param  parent=None Type: ParserRuleContext
3618         # @param  invokingState=-1 Type: int
3619         def __init__(self,parser,parent=None,invokingState=-1):
3620             super().__init__(parent, invokingState)
3621             self.parser = parser
3622
3623         # @param  i=None Type: int
3624         def multiplicative_expression(self,i=None):
3625             if i is None:
3626                 return self.getTypedRuleContexts(CParser.Multiplicative_expressionContext)
3627             else:
3628                 return self.getTypedRuleContext(CParser.Multiplicative_expressionContext,i)
3629
3630
3631         def getRuleIndex(self):
3632             return CParser.RULE_additive_expression
3633
3634         # @param  listener Type: ParseTreeListener
3635         def enterRule(self,listener):
3636             if hasattr( listener, "enterAdditive_expression" ):
3637                 listener.enterAdditive_expression(self)
3638
3639         # @param  listener Type: ParseTreeListener
3640         def exitRule(self,listener):
3641             if hasattr( listener, "exitAdditive_expression" ):
3642                 listener.exitAdditive_expression(self)
3643
3644
3645
3646
3647     def additive_expression(self):
3648
3649         localctx = CParser.Additive_expressionContext(self, self._ctx, self.state)
3650         self.enterRule(localctx, 72, self.RULE_additive_expression)
3651         self._la = 0 # Token type
3652         try:
3653             self.enterOuterAlt(localctx, 1)
3654             self.state = 522
3655             self.multiplicative_expression()
3656             self.state = 529
3657             self._errHandler.sync(self)
3658             _la = self._input.LA(1)
3659             while _la==CParser.T__43 or _la==CParser.T__44:
3660                 self.state = 527
3661                 self._errHandler.sync(self)
3662                 token = self._input.LA(1)
3663                 if token in [CParser.T__43]:
3664                     self.state = 523
3665                     self.match(CParser.T__43)
3666                     self.state = 524
3667                     self.multiplicative_expression()
3668                     pass
3669                 elif token in [CParser.T__44]:
3670                     self.state = 525
3671                     self.match(CParser.T__44)
3672                     self.state = 526
3673                     self.multiplicative_expression()
3674                     pass
3675                 else:
3676                     raise NoViableAltException(self)
3677
3678                 self.state = 531
3679                 self._errHandler.sync(self)
3680                 _la = self._input.LA(1)
3681
3682         except RecognitionException as re:
3683             localctx.exception = re
3684             self._errHandler.reportError(self, re)
3685             self._errHandler.recover(self, re)
3686         finally:
3687             self.exitRule()
3688         return localctx
3689
3690     class Multiplicative_expressionContext(ParserRuleContext):
3691
3692         # @param  parent=None Type: ParserRuleContext
3693         # @param  invokingState=-1 Type: int
3694         def __init__(self,parser,parent=None,invokingState=-1):
3695             super().__init__(parent, invokingState)
3696             self.parser = parser
3697
3698         # @param  i=None Type: int
3699         def cast_expression(self,i=None):
3700             if i is None:
3701                 return self.getTypedRuleContexts(CParser.Cast_expressionContext)
3702             else:
3703                 return self.getTypedRuleContext(CParser.Cast_expressionContext,i)
3704
3705
3706         def getRuleIndex(self):
3707             return CParser.RULE_multiplicative_expression
3708
3709         # @param  listener Type: ParseTreeListener
3710         def enterRule(self,listener):
3711             if hasattr( listener, "enterMultiplicative_expression" ):
3712                 listener.enterMultiplicative_expression(self)
3713
3714         # @param  listener Type: ParseTreeListener
3715         def exitRule(self,listener):
3716             if hasattr( listener, "exitMultiplicative_expression" ):
3717                 listener.exitMultiplicative_expression(self)
3718
3719
3720
3721
3722     def multiplicative_expression(self):
3723
3724         localctx = CParser.Multiplicative_expressionContext(self, self._ctx, self.state)
3725         self.enterRule(localctx, 74, self.RULE_multiplicative_expression)
3726         self._la = 0 # Token type
3727         try:
3728             self.enterOuterAlt(localctx, 1)
3729             self.state = 532
3730             self.cast_expression()
3731             self.state = 541
3732             self._errHandler.sync(self)
3733             _la = self._input.LA(1)
3734             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__41) | (1 << CParser.T__45) | (1 << CParser.T__46))) != 0):
3735                 self.state = 539
3736                 self._errHandler.sync(self)
3737                 token = self._input.LA(1)
3738                 if token in [CParser.T__41]:
3739                     self.state = 533
3740                     self.match(CParser.T__41)
3741                     self.state = 534
3742                     self.cast_expression()
3743                     pass
3744                 elif token in [CParser.T__45]:
3745                     self.state = 535
3746                     self.match(CParser.T__45)
3747                     self.state = 536
3748                     self.cast_expression()
3749                     pass
3750                 elif token in [CParser.T__46]:
3751                     self.state = 537
3752                     self.match(CParser.T__46)
3753                     self.state = 538
3754                     self.cast_expression()
3755                     pass
3756                 else:
3757                     raise NoViableAltException(self)
3758
3759                 self.state = 543
3760                 self._errHandler.sync(self)
3761                 _la = self._input.LA(1)
3762
3763         except RecognitionException as re:
3764             localctx.exception = re
3765             self._errHandler.reportError(self, re)
3766             self._errHandler.recover(self, re)
3767         finally:
3768             self.exitRule()
3769         return localctx
3770
3771     class Cast_expressionContext(ParserRuleContext):
3772
3773         # @param  parent=None Type: ParserRuleContext
3774         # @param  invokingState=-1 Type: int
3775         def __init__(self,parser,parent=None,invokingState=-1):
3776             super().__init__(parent, invokingState)
3777             self.parser = parser
3778
3779         def type_name(self):
3780             return self.getTypedRuleContext(CParser.Type_nameContext,0)
3781
3782
3783         def cast_expression(self):
3784             return self.getTypedRuleContext(CParser.Cast_expressionContext,0)
3785
3786
3787         def unary_expression(self):
3788             return self.getTypedRuleContext(CParser.Unary_expressionContext,0)
3789
3790
3791         def getRuleIndex(self):
3792             return CParser.RULE_cast_expression
3793
3794         # @param  listener Type: ParseTreeListener
3795         def enterRule(self,listener):
3796             if hasattr( listener, "enterCast_expression" ):
3797                 listener.enterCast_expression(self)
3798
3799         # @param  listener Type: ParseTreeListener
3800         def exitRule(self,listener):
3801             if hasattr( listener, "exitCast_expression" ):
3802                 listener.exitCast_expression(self)
3803
3804
3805
3806
3807     def cast_expression(self):
3808
3809         localctx = CParser.Cast_expressionContext(self, self._ctx, self.state)
3810         self.enterRule(localctx, 76, self.RULE_cast_expression)
3811         try:
3812             self.state = 550
3813             self._errHandler.sync(self)
3814             la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
3815             if la_ == 1:
3816                 self.enterOuterAlt(localctx, 1)
3817                 self.state = 544
3818                 self.match(CParser.T__37)
3819                 self.state = 545
3820                 self.type_name()
3821                 self.state = 546
3822                 self.match(CParser.T__38)
3823                 self.state = 547
3824                 self.cast_expression()
3825                 pass
3826
3827             elif la_ == 2:
3828                 self.enterOuterAlt(localctx, 2)
3829                 self.state = 549
3830                 self.unary_expression()
3831                 pass
3832
3833
3834         except RecognitionException as re:
3835             localctx.exception = re
3836             self._errHandler.reportError(self, re)
3837             self._errHandler.recover(self, re)
3838         finally:
3839             self.exitRule()
3840         return localctx
3841
3842     class Unary_expressionContext(ParserRuleContext):
3843
3844         # @param  parent=None Type: ParserRuleContext
3845         # @param  invokingState=-1 Type: int
3846         def __init__(self,parser,parent=None,invokingState=-1):
3847             super().__init__(parent, invokingState)
3848             self.parser = parser
3849
3850         def postfix_expression(self):
3851             return self.getTypedRuleContext(CParser.Postfix_expressionContext,0)
3852
3853
3854         def unary_expression(self):
3855             return self.getTypedRuleContext(CParser.Unary_expressionContext,0)
3856
3857
3858         def unary_operator(self):
3859             return self.getTypedRuleContext(CParser.Unary_operatorContext,0)
3860
3861
3862         def cast_expression(self):
3863             return self.getTypedRuleContext(CParser.Cast_expressionContext,0)
3864
3865
3866         def type_name(self):
3867             return self.getTypedRuleContext(CParser.Type_nameContext,0)
3868
3869
3870         def getRuleIndex(self):
3871             return CParser.RULE_unary_expression
3872
3873         # @param  listener Type: ParseTreeListener
3874         def enterRule(self,listener):
3875             if hasattr( listener, "enterUnary_expression" ):
3876                 listener.enterUnary_expression(self)
3877
3878         # @param  listener Type: ParseTreeListener
3879         def exitRule(self,listener):
3880             if hasattr( listener, "exitUnary_expression" ):
3881                 listener.exitUnary_expression(self)
3882
3883
3884
3885
3886     def unary_expression(self):
3887
3888         localctx = CParser.Unary_expressionContext(self, self._ctx, self.state)
3889         self.enterRule(localctx, 78, self.RULE_unary_expression)
3890         try:
3891             self.state = 567
3892             self._errHandler.sync(self)
3893             la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
3894             if la_ == 1:
3895                 self.enterOuterAlt(localctx, 1)
3896                 self.state = 552
3897                 self.postfix_expression()
3898                 pass
3899
3900             elif la_ == 2:
3901                 self.enterOuterAlt(localctx, 2)
3902                 self.state = 553
3903                 self.match(CParser.T__47)
3904                 self.state = 554
3905                 self.unary_expression()
3906                 pass
3907
3908             elif la_ == 3:
3909                 self.enterOuterAlt(localctx, 3)
3910                 self.state = 555
3911                 self.match(CParser.T__48)
3912                 self.state = 556
3913                 self.unary_expression()
3914                 pass
3915
3916             elif la_ == 4:
3917                 self.enterOuterAlt(localctx, 4)
3918                 self.state = 557
3919                 self.unary_operator()
3920                 self.state = 558
3921                 self.cast_expression()
3922                 pass
3923
3924             elif la_ == 5:
3925                 self.enterOuterAlt(localctx, 5)
3926                 self.state = 560
3927                 self.match(CParser.T__49)
3928                 self.state = 561
3929                 self.unary_expression()
3930                 pass
3931
3932             elif la_ == 6:
3933                 self.enterOuterAlt(localctx, 6)
3934                 self.state = 562
3935                 self.match(CParser.T__49)
3936                 self.state = 563
3937                 self.match(CParser.T__37)
3938                 self.state = 564
3939                 self.type_name()
3940                 self.state = 565
3941                 self.match(CParser.T__38)
3942                 pass
3943
3944
3945         except RecognitionException as re:
3946             localctx.exception = re
3947             self._errHandler.reportError(self, re)
3948             self._errHandler.recover(self, re)
3949         finally:
3950             self.exitRule()
3951         return localctx
3952
3953     class Postfix_expressionContext(ParserRuleContext):
3954
3955         # @param  parent=None Type: ParserRuleContext
3956         # @param  invokingState=-1 Type: int
3957         def __init__(self,parser,parent=None,invokingState=-1):
3958             super().__init__(parent, invokingState)
3959             self.parser = parser
3960             self.FuncCallText = ''
3961             self.p = None # Primary_expressionContext
3962             self.a = None # Token
3963             self.c = None # Argument_expression_listContext
3964             self.b = None # Token
3965             self.x = None # Token
3966             self.y = None # Token
3967             self.z = None # Token
3968
3969         def primary_expression(self):
3970             return self.getTypedRuleContext(CParser.Primary_expressionContext,0)
3971
3972
3973         # @param  i=None Type: int
3974         def expression(self,i=None):
3975             if i is None:
3976                 return self.getTypedRuleContexts(CParser.ExpressionContext)
3977             else:
3978                 return self.getTypedRuleContext(CParser.ExpressionContext,i)
3979
3980
3981         # @param  i=None Type: int
3982         def macro_parameter_list(self,i=None):
3983             if i is None:
3984                 return self.getTypedRuleContexts(CParser.Macro_parameter_listContext)
3985             else:
3986                 return self.getTypedRuleContext(CParser.Macro_parameter_listContext,i)
3987
3988
3989         # @param  i=None Type: int
3990         def argument_expression_list(self,i=None):
3991             if i is None:
3992                 return self.getTypedRuleContexts(CParser.Argument_expression_listContext)
3993             else:
3994                 return self.getTypedRuleContext(CParser.Argument_expression_listContext,i)
3995
3996
3997         # @param  i=None Type: int
3998         def IDENTIFIER(self,i=None):
3999             if i is None:
4000                 return self.getTokens(CParser.IDENTIFIER)
4001             else:
4002                 return self.getToken(CParser.IDENTIFIER, i)
4003
4004         def getRuleIndex(self):
4005             return CParser.RULE_postfix_expression
4006
4007         # @param  listener Type: ParseTreeListener
4008         def enterRule(self,listener):
4009             if hasattr( listener, "enterPostfix_expression" ):
4010                 listener.enterPostfix_expression(self)
4011
4012         # @param  listener Type: ParseTreeListener
4013         def exitRule(self,listener):
4014             if hasattr( listener, "exitPostfix_expression" ):
4015                 listener.exitPostfix_expression(self)
4016
4017
4018
4019
4020     def postfix_expression(self):
4021
4022         localctx = CParser.Postfix_expressionContext(self, self._ctx, self.state)
4023         self.enterRule(localctx, 80, self.RULE_postfix_expression)
4024
4025         self.FuncCallText=''
4026
4027         try:
4028             self.enterOuterAlt(localctx, 1)
4029             self.state = 569
4030             localctx.p = self.primary_expression()
4031             self.FuncCallText += (None if localctx.p is None else self._input.getText((localctx.p.start,localctx.p.stop)))
4032             self.state = 600
4033             self._errHandler.sync(self)
4034             _alt = self._interp.adaptivePredict(self._input,73,self._ctx)
4035             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
4036                 if _alt==1:
4037                     self.state = 598
4038                     self._errHandler.sync(self)
4039                     la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
4040                     if la_ == 1:
4041                         self.state = 571
4042                         self.match(CParser.T__39)
4043                         self.state = 572
4044                         self.expression()
4045                         self.state = 573
4046                         self.match(CParser.T__40)
4047                         pass
4048
4049                     elif la_ == 2:
4050                         self.state = 575
4051                         self.match(CParser.T__37)
4052                         self.state = 576
4053                         localctx.a = self.match(CParser.T__38)
4054                         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, '')
4055                         pass
4056
4057                     elif la_ == 3:
4058                         self.state = 578
4059                         self.match(CParser.T__37)
4060                         self.state = 579
4061                         localctx.c = self.argument_expression_list()
4062                         self.state = 580
4063                         localctx.b = self.match(CParser.T__38)
4064                         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))))
4065                         pass
4066
4067                     elif la_ == 4:
4068                         self.state = 583
4069                         self.match(CParser.T__37)
4070                         self.state = 584
4071                         self.macro_parameter_list()
4072                         self.state = 585
4073                         self.match(CParser.T__38)
4074                         pass
4075
4076                     elif la_ == 5:
4077                         self.state = 587
4078                         self.match(CParser.T__50)
4079                         self.state = 588
4080                         localctx.x = self.match(CParser.IDENTIFIER)
4081                         self.FuncCallText += '.' + (None if localctx.x is None else localctx.x.text)
4082                         pass
4083
4084                     elif la_ == 6:
4085                         self.state = 590
4086                         self.match(CParser.T__41)
4087                         self.state = 591
4088                         localctx.y = self.match(CParser.IDENTIFIER)
4089                         self.FuncCallText = (None if localctx.y is None else localctx.y.text)
4090                         pass
4091
4092                     elif la_ == 7:
4093                         self.state = 593
4094                         self.match(CParser.T__51)
4095                         self.state = 594
4096                         localctx.z = self.match(CParser.IDENTIFIER)
4097                         self.FuncCallText += '->' + (None if localctx.z is None else localctx.z.text)
4098                         pass
4099
4100                     elif la_ == 8:
4101                         self.state = 596
4102                         self.match(CParser.T__47)
4103                         pass
4104
4105                     elif la_ == 9:
4106                         self.state = 597
4107                         self.match(CParser.T__48)
4108                         pass
4109
4110
4111                 self.state = 602
4112                 self._errHandler.sync(self)
4113                 _alt = self._interp.adaptivePredict(self._input,73,self._ctx)
4114
4115         except RecognitionException as re:
4116             localctx.exception = re
4117             self._errHandler.reportError(self, re)
4118             self._errHandler.recover(self, re)
4119         finally:
4120             self.exitRule()
4121         return localctx
4122
4123     class Macro_parameter_listContext(ParserRuleContext):
4124
4125         # @param  parent=None Type: ParserRuleContext
4126         # @param  invokingState=-1 Type: int
4127         def __init__(self,parser,parent=None,invokingState=-1):
4128             super().__init__(parent, invokingState)
4129             self.parser = parser
4130
4131         # @param  i=None Type: int
4132         def parameter_declaration(self,i=None):
4133             if i is None:
4134                 return self.getTypedRuleContexts(CParser.Parameter_declarationContext)
4135             else:
4136                 return self.getTypedRuleContext(CParser.Parameter_declarationContext,i)
4137
4138
4139         def getRuleIndex(self):
4140             return CParser.RULE_macro_parameter_list
4141
4142         # @param  listener Type: ParseTreeListener
4143         def enterRule(self,listener):
4144             if hasattr( listener, "enterMacro_parameter_list" ):
4145                 listener.enterMacro_parameter_list(self)
4146
4147         # @param  listener Type: ParseTreeListener
4148         def exitRule(self,listener):
4149             if hasattr( listener, "exitMacro_parameter_list" ):
4150                 listener.exitMacro_parameter_list(self)
4151
4152
4153
4154
4155     def macro_parameter_list(self):
4156
4157         localctx = CParser.Macro_parameter_listContext(self, self._ctx, self.state)
4158         self.enterRule(localctx, 82, self.RULE_macro_parameter_list)
4159         self._la = 0 # Token type
4160         try:
4161             self.enterOuterAlt(localctx, 1)
4162             self.state = 603
4163             self.parameter_declaration()
4164             self.state = 608
4165             self._errHandler.sync(self)
4166             _la = self._input.LA(1)
4167             while _la==CParser.T__3:
4168                 self.state = 604
4169                 self.match(CParser.T__3)
4170                 self.state = 605
4171                 self.parameter_declaration()
4172                 self.state = 610
4173                 self._errHandler.sync(self)
4174                 _la = self._input.LA(1)
4175
4176         except RecognitionException as re:
4177             localctx.exception = re
4178             self._errHandler.reportError(self, re)
4179             self._errHandler.recover(self, re)
4180         finally:
4181             self.exitRule()
4182         return localctx
4183
4184     class Unary_operatorContext(ParserRuleContext):
4185
4186         # @param  parent=None Type: ParserRuleContext
4187         # @param  invokingState=-1 Type: int
4188         def __init__(self,parser,parent=None,invokingState=-1):
4189             super().__init__(parent, invokingState)
4190             self.parser = parser
4191
4192
4193         def getRuleIndex(self):
4194             return CParser.RULE_unary_operator
4195
4196         # @param  listener Type: ParseTreeListener
4197         def enterRule(self,listener):
4198             if hasattr( listener, "enterUnary_operator" ):
4199                 listener.enterUnary_operator(self)
4200
4201         # @param  listener Type: ParseTreeListener
4202         def exitRule(self,listener):
4203             if hasattr( listener, "exitUnary_operator" ):
4204                 listener.exitUnary_operator(self)
4205
4206
4207
4208
4209     def unary_operator(self):
4210
4211         localctx = CParser.Unary_operatorContext(self, self._ctx, self.state)
4212         self.enterRule(localctx, 84, self.RULE_unary_operator)
4213         self._la = 0 # Token type
4214         try:
4215             self.enterOuterAlt(localctx, 1)
4216             self.state = 611
4217             _la = self._input.LA(1)
4218             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)):
4219                 self._errHandler.recoverInline(self)
4220             else:
4221                 self._errHandler.reportMatch(self)
4222                 self.consume()
4223         except RecognitionException as re:
4224             localctx.exception = re
4225             self._errHandler.reportError(self, re)
4226             self._errHandler.recover(self, re)
4227         finally:
4228             self.exitRule()
4229         return localctx
4230
4231     class Primary_expressionContext(ParserRuleContext):
4232
4233         # @param  parent=None Type: ParserRuleContext
4234         # @param  invokingState=-1 Type: int
4235         def __init__(self,parser,parent=None,invokingState=-1):
4236             super().__init__(parent, invokingState)
4237             self.parser = parser
4238
4239         def IDENTIFIER(self):
4240             return self.getToken(CParser.IDENTIFIER, 0)
4241
4242         def constant(self):
4243             return self.getTypedRuleContext(CParser.ConstantContext,0)
4244
4245
4246         def expression(self):
4247             return self.getTypedRuleContext(CParser.ExpressionContext,0)
4248
4249
4250         def getRuleIndex(self):
4251             return CParser.RULE_primary_expression
4252
4253         # @param  listener Type: ParseTreeListener
4254         def enterRule(self,listener):
4255             if hasattr( listener, "enterPrimary_expression" ):
4256                 listener.enterPrimary_expression(self)
4257
4258         # @param  listener Type: ParseTreeListener
4259         def exitRule(self,listener):
4260             if hasattr( listener, "exitPrimary_expression" ):
4261                 listener.exitPrimary_expression(self)
4262
4263
4264
4265
4266     def primary_expression(self):
4267
4268         localctx = CParser.Primary_expressionContext(self, self._ctx, self.state)
4269         self.enterRule(localctx, 86, self.RULE_primary_expression)
4270         try:
4271             self.state = 619
4272             self._errHandler.sync(self)
4273             la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
4274             if la_ == 1:
4275                 self.enterOuterAlt(localctx, 1)
4276                 self.state = 613
4277                 self.match(CParser.IDENTIFIER)
4278                 pass
4279
4280             elif la_ == 2:
4281                 self.enterOuterAlt(localctx, 2)
4282                 self.state = 614
4283                 self.constant()
4284                 pass
4285
4286             elif la_ == 3:
4287                 self.enterOuterAlt(localctx, 3)
4288                 self.state = 615
4289                 self.match(CParser.T__37)
4290                 self.state = 616
4291                 self.expression()
4292                 self.state = 617
4293                 self.match(CParser.T__38)
4294                 pass
4295
4296
4297         except RecognitionException as re:
4298             localctx.exception = re
4299             self._errHandler.reportError(self, re)
4300             self._errHandler.recover(self, re)
4301         finally:
4302             self.exitRule()
4303         return localctx
4304
4305     class ConstantContext(ParserRuleContext):
4306
4307         # @param  parent=None Type: ParserRuleContext
4308         # @param  invokingState=-1 Type: int
4309         def __init__(self,parser,parent=None,invokingState=-1):
4310             super().__init__(parent, invokingState)
4311             self.parser = parser
4312
4313         def HEX_LITERAL(self):
4314             return self.getToken(CParser.HEX_LITERAL, 0)
4315
4316         def OCTAL_LITERAL(self):
4317             return self.getToken(CParser.OCTAL_LITERAL, 0)
4318
4319         def DECIMAL_LITERAL(self):
4320             return self.getToken(CParser.DECIMAL_LITERAL, 0)
4321
4322         def CHARACTER_LITERAL(self):
4323             return self.getToken(CParser.CHARACTER_LITERAL, 0)
4324
4325         # @param  i=None Type: int
4326         def IDENTIFIER(self,i=None):
4327             if i is None:
4328                 return self.getTokens(CParser.IDENTIFIER)
4329             else:
4330                 return self.getToken(CParser.IDENTIFIER, i)
4331
4332         # @param  i=None Type: int
4333         def STRING_LITERAL(self,i=None):
4334             if i is None:
4335                 return self.getTokens(CParser.STRING_LITERAL)
4336             else:
4337                 return self.getToken(CParser.STRING_LITERAL, i)
4338
4339         def FLOATING_POINT_LITERAL(self):
4340             return self.getToken(CParser.FLOATING_POINT_LITERAL, 0)
4341
4342         def getRuleIndex(self):
4343             return CParser.RULE_constant
4344
4345         # @param  listener Type: ParseTreeListener
4346         def enterRule(self,listener):
4347             if hasattr( listener, "enterConstant" ):
4348                 listener.enterConstant(self)
4349
4350         # @param  listener Type: ParseTreeListener
4351         def exitRule(self,listener):
4352             if hasattr( listener, "exitConstant" ):
4353                 listener.exitConstant(self)
4354
4355
4356
4357
4358     def constant(self):
4359
4360         localctx = CParser.ConstantContext(self, self._ctx, self.state)
4361         self.enterRule(localctx, 88, self.RULE_constant)
4362         self._la = 0 # Token type
4363         try:
4364             self.state = 647
4365             self._errHandler.sync(self)
4366             token = self._input.LA(1)
4367             if token in [CParser.HEX_LITERAL]:
4368                 self.enterOuterAlt(localctx, 1)
4369                 self.state = 621
4370                 self.match(CParser.HEX_LITERAL)
4371                 pass
4372             elif token in [CParser.OCTAL_LITERAL]:
4373                 self.enterOuterAlt(localctx, 2)
4374                 self.state = 622
4375                 self.match(CParser.OCTAL_LITERAL)
4376                 pass
4377             elif token in [CParser.DECIMAL_LITERAL]:
4378                 self.enterOuterAlt(localctx, 3)
4379                 self.state = 623
4380                 self.match(CParser.DECIMAL_LITERAL)
4381                 pass
4382             elif token in [CParser.CHARACTER_LITERAL]:
4383                 self.enterOuterAlt(localctx, 4)
4384                 self.state = 624
4385                 self.match(CParser.CHARACTER_LITERAL)
4386                 pass
4387             elif token in [CParser.IDENTIFIER, CParser.STRING_LITERAL]:
4388                 self.enterOuterAlt(localctx, 5)
4389                 self.state = 636
4390                 self._errHandler.sync(self)
4391                 _alt = 1
4392                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
4393                     if _alt == 1:
4394                         self.state = 628
4395                         self._errHandler.sync(self)
4396                         _la = self._input.LA(1)
4397                         while _la==CParser.IDENTIFIER:
4398                             self.state = 625
4399                             self.match(CParser.IDENTIFIER)
4400                             self.state = 630
4401                             self._errHandler.sync(self)
4402                             _la = self._input.LA(1)
4403
4404                         self.state = 632
4405                         self._errHandler.sync(self)
4406                         _alt = 1
4407                         while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
4408                             if _alt == 1:
4409                                 self.state = 631
4410                                 self.match(CParser.STRING_LITERAL)
4411
4412                             else:
4413                                 raise NoViableAltException(self)
4414                             self.state = 634
4415                             self._errHandler.sync(self)
4416                             _alt = self._interp.adaptivePredict(self._input,77,self._ctx)
4417
4418
4419                     else:
4420                         raise NoViableAltException(self)
4421                     self.state = 638
4422                     self._errHandler.sync(self)
4423                     _alt = self._interp.adaptivePredict(self._input,78,self._ctx)
4424
4425                 self.state = 643
4426                 self._errHandler.sync(self)
4427                 _la = self._input.LA(1)
4428                 while _la==CParser.IDENTIFIER:
4429                     self.state = 640
4430                     self.match(CParser.IDENTIFIER)
4431                     self.state = 645
4432                     self._errHandler.sync(self)
4433                     _la = self._input.LA(1)
4434
4435                 pass
4436             elif token in [CParser.FLOATING_POINT_LITERAL]:
4437                 self.enterOuterAlt(localctx, 6)
4438                 self.state = 646
4439                 self.match(CParser.FLOATING_POINT_LITERAL)
4440                 pass
4441             else:
4442                 raise NoViableAltException(self)
4443
4444         except RecognitionException as re:
4445             localctx.exception = re
4446             self._errHandler.reportError(self, re)
4447             self._errHandler.recover(self, re)
4448         finally:
4449             self.exitRule()
4450         return localctx
4451
4452     class ExpressionContext(ParserRuleContext):
4453
4454         # @param  parent=None Type: ParserRuleContext
4455         # @param  invokingState=-1 Type: int
4456         def __init__(self,parser,parent=None,invokingState=-1):
4457             super().__init__(parent, invokingState)
4458             self.parser = parser
4459
4460         # @param  i=None Type: int
4461         def assignment_expression(self,i=None):
4462             if i is None:
4463                 return self.getTypedRuleContexts(CParser.Assignment_expressionContext)
4464             else:
4465                 return self.getTypedRuleContext(CParser.Assignment_expressionContext,i)
4466
4467
4468         def getRuleIndex(self):
4469             return CParser.RULE_expression
4470
4471         # @param  listener Type: ParseTreeListener
4472         def enterRule(self,listener):
4473             if hasattr( listener, "enterExpression" ):
4474                 listener.enterExpression(self)
4475
4476         # @param  listener Type: ParseTreeListener
4477         def exitRule(self,listener):
4478             if hasattr( listener, "exitExpression" ):
4479                 listener.exitExpression(self)
4480
4481
4482
4483
4484     def expression(self):
4485
4486         localctx = CParser.ExpressionContext(self, self._ctx, self.state)
4487         self.enterRule(localctx, 90, self.RULE_expression)
4488         self._la = 0 # Token type
4489         try:
4490             self.enterOuterAlt(localctx, 1)
4491             self.state = 649
4492             self.assignment_expression()
4493             self.state = 654
4494             self._errHandler.sync(self)
4495             _la = self._input.LA(1)
4496             while _la==CParser.T__3:
4497                 self.state = 650
4498                 self.match(CParser.T__3)
4499                 self.state = 651
4500                 self.assignment_expression()
4501                 self.state = 656
4502                 self._errHandler.sync(self)
4503                 _la = self._input.LA(1)
4504
4505         except RecognitionException as re:
4506             localctx.exception = re
4507             self._errHandler.reportError(self, re)
4508             self._errHandler.recover(self, re)
4509         finally:
4510             self.exitRule()
4511         return localctx
4512
4513     class Constant_expressionContext(ParserRuleContext):
4514
4515         # @param  parent=None Type: ParserRuleContext
4516         # @param  invokingState=-1 Type: int
4517         def __init__(self,parser,parent=None,invokingState=-1):
4518             super().__init__(parent, invokingState)
4519             self.parser = parser
4520
4521         def conditional_expression(self):
4522             return self.getTypedRuleContext(CParser.Conditional_expressionContext,0)
4523
4524
4525         def getRuleIndex(self):
4526             return CParser.RULE_constant_expression
4527
4528         # @param  listener Type: ParseTreeListener
4529         def enterRule(self,listener):
4530             if hasattr( listener, "enterConstant_expression" ):
4531                 listener.enterConstant_expression(self)
4532
4533         # @param  listener Type: ParseTreeListener
4534         def exitRule(self,listener):
4535             if hasattr( listener, "exitConstant_expression" ):
4536                 listener.exitConstant_expression(self)
4537
4538
4539
4540
4541     def constant_expression(self):
4542
4543         localctx = CParser.Constant_expressionContext(self, self._ctx, self.state)
4544         self.enterRule(localctx, 92, self.RULE_constant_expression)
4545         try:
4546             self.enterOuterAlt(localctx, 1)
4547             self.state = 657
4548             self.conditional_expression()
4549         except RecognitionException as re:
4550             localctx.exception = re
4551             self._errHandler.reportError(self, re)
4552             self._errHandler.recover(self, re)
4553         finally:
4554             self.exitRule()
4555         return localctx
4556
4557     class Assignment_expressionContext(ParserRuleContext):
4558
4559         # @param  parent=None Type: ParserRuleContext
4560         # @param  invokingState=-1 Type: int
4561         def __init__(self,parser,parent=None,invokingState=-1):
4562             super().__init__(parent, invokingState)
4563             self.parser = parser
4564
4565         def lvalue(self):
4566             return self.getTypedRuleContext(CParser.LvalueContext,0)
4567
4568
4569         def assignment_operator(self):
4570             return self.getTypedRuleContext(CParser.Assignment_operatorContext,0)
4571
4572
4573         def assignment_expression(self):
4574             return self.getTypedRuleContext(CParser.Assignment_expressionContext,0)
4575
4576
4577         def conditional_expression(self):
4578             return self.getTypedRuleContext(CParser.Conditional_expressionContext,0)
4579
4580
4581         def getRuleIndex(self):
4582             return CParser.RULE_assignment_expression
4583
4584         # @param  listener Type: ParseTreeListener
4585         def enterRule(self,listener):
4586             if hasattr( listener, "enterAssignment_expression" ):
4587                 listener.enterAssignment_expression(self)
4588
4589         # @param  listener Type: ParseTreeListener
4590         def exitRule(self,listener):
4591             if hasattr( listener, "exitAssignment_expression" ):
4592                 listener.exitAssignment_expression(self)
4593
4594
4595
4596
4597     def assignment_expression(self):
4598
4599         localctx = CParser.Assignment_expressionContext(self, self._ctx, self.state)
4600         self.enterRule(localctx, 94, self.RULE_assignment_expression)
4601         try:
4602             self.state = 664
4603             self._errHandler.sync(self)
4604             la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
4605             if la_ == 1:
4606                 self.enterOuterAlt(localctx, 1)
4607                 self.state = 659
4608                 self.lvalue()
4609                 self.state = 660
4610                 self.assignment_operator()
4611                 self.state = 661
4612                 self.assignment_expression()
4613                 pass
4614
4615             elif la_ == 2:
4616                 self.enterOuterAlt(localctx, 2)
4617                 self.state = 663
4618                 self.conditional_expression()
4619                 pass
4620
4621
4622         except RecognitionException as re:
4623             localctx.exception = re
4624             self._errHandler.reportError(self, re)
4625             self._errHandler.recover(self, re)
4626         finally:
4627             self.exitRule()
4628         return localctx
4629
4630     class LvalueContext(ParserRuleContext):
4631
4632         # @param  parent=None Type: ParserRuleContext
4633         # @param  invokingState=-1 Type: int
4634         def __init__(self,parser,parent=None,invokingState=-1):
4635             super().__init__(parent, invokingState)
4636             self.parser = parser
4637
4638         def unary_expression(self):
4639             return self.getTypedRuleContext(CParser.Unary_expressionContext,0)
4640
4641
4642         def getRuleIndex(self):
4643             return CParser.RULE_lvalue
4644
4645         # @param  listener Type: ParseTreeListener
4646         def enterRule(self,listener):
4647             if hasattr( listener, "enterLvalue" ):
4648                 listener.enterLvalue(self)
4649
4650         # @param  listener Type: ParseTreeListener
4651         def exitRule(self,listener):
4652             if hasattr( listener, "exitLvalue" ):
4653                 listener.exitLvalue(self)
4654
4655
4656
4657
4658     def lvalue(self):
4659
4660         localctx = CParser.LvalueContext(self, self._ctx, self.state)
4661         self.enterRule(localctx, 96, self.RULE_lvalue)
4662         try:
4663             self.enterOuterAlt(localctx, 1)
4664             self.state = 666
4665             self.unary_expression()
4666         except RecognitionException as re:
4667             localctx.exception = re
4668             self._errHandler.reportError(self, re)
4669             self._errHandler.recover(self, re)
4670         finally:
4671             self.exitRule()
4672         return localctx
4673
4674     class Assignment_operatorContext(ParserRuleContext):
4675
4676         # @param  parent=None Type: ParserRuleContext
4677         # @param  invokingState=-1 Type: int
4678         def __init__(self,parser,parent=None,invokingState=-1):
4679             super().__init__(parent, invokingState)
4680             self.parser = parser
4681
4682
4683         def getRuleIndex(self):
4684             return CParser.RULE_assignment_operator
4685
4686         # @param  listener Type: ParseTreeListener
4687         def enterRule(self,listener):
4688             if hasattr( listener, "enterAssignment_operator" ):
4689                 listener.enterAssignment_operator(self)
4690
4691         # @param  listener Type: ParseTreeListener
4692         def exitRule(self,listener):
4693             if hasattr( listener, "exitAssignment_operator" ):
4694                 listener.exitAssignment_operator(self)
4695
4696
4697
4698
4699     def assignment_operator(self):
4700
4701         localctx = CParser.Assignment_operatorContext(self, self._ctx, self.state)
4702         self.enterRule(localctx, 98, self.RULE_assignment_operator)
4703         self._la = 0 # Token type
4704         try:
4705             self.enterOuterAlt(localctx, 1)
4706             self.state = 668
4707             _la = self._input.LA(1)
4708             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)):
4709                 self._errHandler.recoverInline(self)
4710             else:
4711                 self._errHandler.reportMatch(self)
4712                 self.consume()
4713         except RecognitionException as re:
4714             localctx.exception = re
4715             self._errHandler.reportError(self, re)
4716             self._errHandler.recover(self, re)
4717         finally:
4718             self.exitRule()
4719         return localctx
4720
4721     class Conditional_expressionContext(ParserRuleContext):
4722
4723         # @param  parent=None Type: ParserRuleContext
4724         # @param  invokingState=-1 Type: int
4725         def __init__(self,parser,parent=None,invokingState=-1):
4726             super().__init__(parent, invokingState)
4727             self.parser = parser
4728             self.e = None # Logical_or_expressionContext
4729
4730         def logical_or_expression(self):
4731             return self.getTypedRuleContext(CParser.Logical_or_expressionContext,0)
4732
4733
4734         def expression(self):
4735             return self.getTypedRuleContext(CParser.ExpressionContext,0)
4736
4737
4738         def conditional_expression(self):
4739             return self.getTypedRuleContext(CParser.Conditional_expressionContext,0)
4740
4741
4742         def getRuleIndex(self):
4743             return CParser.RULE_conditional_expression
4744
4745         # @param  listener Type: ParseTreeListener
4746         def enterRule(self,listener):
4747             if hasattr( listener, "enterConditional_expression" ):
4748                 listener.enterConditional_expression(self)
4749
4750         # @param  listener Type: ParseTreeListener
4751         def exitRule(self,listener):
4752             if hasattr( listener, "exitConditional_expression" ):
4753                 listener.exitConditional_expression(self)
4754
4755
4756
4757
4758     def conditional_expression(self):
4759
4760         localctx = CParser.Conditional_expressionContext(self, self._ctx, self.state)
4761         self.enterRule(localctx, 100, self.RULE_conditional_expression)
4762         self._la = 0 # Token type
4763         try:
4764             self.enterOuterAlt(localctx, 1)
4765             self.state = 670
4766             localctx.e = self.logical_or_expression()
4767             self.state = 677
4768             self._errHandler.sync(self)
4769             _la = self._input.LA(1)
4770             if _la==CParser.T__65:
4771                 self.state = 671
4772                 self.match(CParser.T__65)
4773                 self.state = 672
4774                 self.expression()
4775                 self.state = 673
4776                 self.match(CParser.T__22)
4777                 self.state = 674
4778                 self.conditional_expression()
4779                 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))))
4780
4781
4782         except RecognitionException as re:
4783             localctx.exception = re
4784             self._errHandler.reportError(self, re)
4785             self._errHandler.recover(self, re)
4786         finally:
4787             self.exitRule()
4788         return localctx
4789
4790     class Logical_or_expressionContext(ParserRuleContext):
4791
4792         # @param  parent=None Type: ParserRuleContext
4793         # @param  invokingState=-1 Type: int
4794         def __init__(self,parser,parent=None,invokingState=-1):
4795             super().__init__(parent, invokingState)
4796             self.parser = parser
4797
4798         # @param  i=None Type: int
4799         def logical_and_expression(self,i=None):
4800             if i is None:
4801                 return self.getTypedRuleContexts(CParser.Logical_and_expressionContext)
4802             else:
4803                 return self.getTypedRuleContext(CParser.Logical_and_expressionContext,i)
4804
4805
4806         def getRuleIndex(self):
4807             return CParser.RULE_logical_or_expression
4808
4809         # @param  listener Type: ParseTreeListener
4810         def enterRule(self,listener):
4811             if hasattr( listener, "enterLogical_or_expression" ):
4812                 listener.enterLogical_or_expression(self)
4813
4814         # @param  listener Type: ParseTreeListener
4815         def exitRule(self,listener):
4816             if hasattr( listener, "exitLogical_or_expression" ):
4817                 listener.exitLogical_or_expression(self)
4818
4819
4820
4821
4822     def logical_or_expression(self):
4823
4824         localctx = CParser.Logical_or_expressionContext(self, self._ctx, self.state)
4825         self.enterRule(localctx, 102, self.RULE_logical_or_expression)
4826         self._la = 0 # Token type
4827         try:
4828             self.enterOuterAlt(localctx, 1)
4829             self.state = 679
4830             self.logical_and_expression()
4831             self.state = 684
4832             self._errHandler.sync(self)
4833             _la = self._input.LA(1)
4834             while _la==CParser.T__66:
4835                 self.state = 680
4836                 self.match(CParser.T__66)
4837                 self.state = 681
4838                 self.logical_and_expression()
4839                 self.state = 686
4840                 self._errHandler.sync(self)
4841                 _la = self._input.LA(1)
4842
4843         except RecognitionException as re:
4844             localctx.exception = re
4845             self._errHandler.reportError(self, re)
4846             self._errHandler.recover(self, re)
4847         finally:
4848             self.exitRule()
4849         return localctx
4850
4851     class Logical_and_expressionContext(ParserRuleContext):
4852
4853         # @param  parent=None Type: ParserRuleContext
4854         # @param  invokingState=-1 Type: int
4855         def __init__(self,parser,parent=None,invokingState=-1):
4856             super().__init__(parent, invokingState)
4857             self.parser = parser
4858
4859         # @param  i=None Type: int
4860         def inclusive_or_expression(self,i=None):
4861             if i is None:
4862                 return self.getTypedRuleContexts(CParser.Inclusive_or_expressionContext)
4863             else:
4864                 return self.getTypedRuleContext(CParser.Inclusive_or_expressionContext,i)
4865
4866
4867         def getRuleIndex(self):
4868             return CParser.RULE_logical_and_expression
4869
4870         # @param  listener Type: ParseTreeListener
4871         def enterRule(self,listener):
4872             if hasattr( listener, "enterLogical_and_expression" ):
4873                 listener.enterLogical_and_expression(self)
4874
4875         # @param  listener Type: ParseTreeListener
4876         def exitRule(self,listener):
4877             if hasattr( listener, "exitLogical_and_expression" ):
4878                 listener.exitLogical_and_expression(self)
4879
4880
4881
4882
4883     def logical_and_expression(self):
4884
4885         localctx = CParser.Logical_and_expressionContext(self, self._ctx, self.state)
4886         self.enterRule(localctx, 104, self.RULE_logical_and_expression)
4887         self._la = 0 # Token type
4888         try:
4889             self.enterOuterAlt(localctx, 1)
4890             self.state = 687
4891             self.inclusive_or_expression()
4892             self.state = 692
4893             self._errHandler.sync(self)
4894             _la = self._input.LA(1)
4895             while _la==CParser.T__67:
4896                 self.state = 688
4897                 self.match(CParser.T__67)
4898                 self.state = 689
4899                 self.inclusive_or_expression()
4900                 self.state = 694
4901                 self._errHandler.sync(self)
4902                 _la = self._input.LA(1)
4903
4904         except RecognitionException as re:
4905             localctx.exception = re
4906             self._errHandler.reportError(self, re)
4907             self._errHandler.recover(self, re)
4908         finally:
4909             self.exitRule()
4910         return localctx
4911
4912     class Inclusive_or_expressionContext(ParserRuleContext):
4913
4914         # @param  parent=None Type: ParserRuleContext
4915         # @param  invokingState=-1 Type: int
4916         def __init__(self,parser,parent=None,invokingState=-1):
4917             super().__init__(parent, invokingState)
4918             self.parser = parser
4919
4920         # @param  i=None Type: int
4921         def exclusive_or_expression(self,i=None):
4922             if i is None:
4923                 return self.getTypedRuleContexts(CParser.Exclusive_or_expressionContext)
4924             else:
4925                 return self.getTypedRuleContext(CParser.Exclusive_or_expressionContext,i)
4926
4927
4928         def getRuleIndex(self):
4929             return CParser.RULE_inclusive_or_expression
4930
4931         # @param  listener Type: ParseTreeListener
4932         def enterRule(self,listener):
4933             if hasattr( listener, "enterInclusive_or_expression" ):
4934                 listener.enterInclusive_or_expression(self)
4935
4936         # @param  listener Type: ParseTreeListener
4937         def exitRule(self,listener):
4938             if hasattr( listener, "exitInclusive_or_expression" ):
4939                 listener.exitInclusive_or_expression(self)
4940
4941
4942
4943
4944     def inclusive_or_expression(self):
4945
4946         localctx = CParser.Inclusive_or_expressionContext(self, self._ctx, self.state)
4947         self.enterRule(localctx, 106, self.RULE_inclusive_or_expression)
4948         self._la = 0 # Token type
4949         try:
4950             self.enterOuterAlt(localctx, 1)
4951             self.state = 695
4952             self.exclusive_or_expression()
4953             self.state = 700
4954             self._errHandler.sync(self)
4955             _la = self._input.LA(1)
4956             while _la==CParser.T__68:
4957                 self.state = 696
4958                 self.match(CParser.T__68)
4959                 self.state = 697
4960                 self.exclusive_or_expression()
4961                 self.state = 702
4962                 self._errHandler.sync(self)
4963                 _la = self._input.LA(1)
4964
4965         except RecognitionException as re:
4966             localctx.exception = re
4967             self._errHandler.reportError(self, re)
4968             self._errHandler.recover(self, re)
4969         finally:
4970             self.exitRule()
4971         return localctx
4972
4973     class Exclusive_or_expressionContext(ParserRuleContext):
4974
4975         # @param  parent=None Type: ParserRuleContext
4976         # @param  invokingState=-1 Type: int
4977         def __init__(self,parser,parent=None,invokingState=-1):
4978             super().__init__(parent, invokingState)
4979             self.parser = parser
4980
4981         # @param  i=None Type: int
4982         def and_expression(self,i=None):
4983             if i is None:
4984                 return self.getTypedRuleContexts(CParser.And_expressionContext)
4985             else:
4986                 return self.getTypedRuleContext(CParser.And_expressionContext,i)
4987
4988
4989         def getRuleIndex(self):
4990             return CParser.RULE_exclusive_or_expression
4991
4992         # @param  listener Type: ParseTreeListener
4993         def enterRule(self,listener):
4994             if hasattr( listener, "enterExclusive_or_expression" ):
4995                 listener.enterExclusive_or_expression(self)
4996
4997         # @param  listener Type: ParseTreeListener
4998         def exitRule(self,listener):
4999             if hasattr( listener, "exitExclusive_or_expression" ):
5000                 listener.exitExclusive_or_expression(self)
5001
5002
5003
5004
5005     def exclusive_or_expression(self):
5006
5007         localctx = CParser.Exclusive_or_expressionContext(self, self._ctx, self.state)
5008         self.enterRule(localctx, 108, self.RULE_exclusive_or_expression)
5009         self._la = 0 # Token type
5010         try:
5011             self.enterOuterAlt(localctx, 1)
5012             self.state = 703
5013             self.and_expression()
5014             self.state = 708
5015             self._errHandler.sync(self)
5016             _la = self._input.LA(1)
5017             while _la==CParser.T__69:
5018                 self.state = 704
5019                 self.match(CParser.T__69)
5020                 self.state = 705
5021                 self.and_expression()
5022                 self.state = 710
5023                 self._errHandler.sync(self)
5024                 _la = self._input.LA(1)
5025
5026         except RecognitionException as re:
5027             localctx.exception = re
5028             self._errHandler.reportError(self, re)
5029             self._errHandler.recover(self, re)
5030         finally:
5031             self.exitRule()
5032         return localctx
5033
5034     class And_expressionContext(ParserRuleContext):
5035
5036         # @param  parent=None Type: ParserRuleContext
5037         # @param  invokingState=-1 Type: int
5038         def __init__(self,parser,parent=None,invokingState=-1):
5039             super().__init__(parent, invokingState)
5040             self.parser = parser
5041
5042         # @param  i=None Type: int
5043         def equality_expression(self,i=None):
5044             if i is None:
5045                 return self.getTypedRuleContexts(CParser.Equality_expressionContext)
5046             else:
5047                 return self.getTypedRuleContext(CParser.Equality_expressionContext,i)
5048
5049
5050         def getRuleIndex(self):
5051             return CParser.RULE_and_expression
5052
5053         # @param  listener Type: ParseTreeListener
5054         def enterRule(self,listener):
5055             if hasattr( listener, "enterAnd_expression" ):
5056                 listener.enterAnd_expression(self)
5057
5058         # @param  listener Type: ParseTreeListener
5059         def exitRule(self,listener):
5060             if hasattr( listener, "exitAnd_expression" ):
5061                 listener.exitAnd_expression(self)
5062
5063
5064
5065
5066     def and_expression(self):
5067
5068         localctx = CParser.And_expressionContext(self, self._ctx, self.state)
5069         self.enterRule(localctx, 110, self.RULE_and_expression)
5070         self._la = 0 # Token type
5071         try:
5072             self.enterOuterAlt(localctx, 1)
5073             self.state = 711
5074             self.equality_expression()
5075             self.state = 716
5076             self._errHandler.sync(self)
5077             _la = self._input.LA(1)
5078             while _la==CParser.T__52:
5079                 self.state = 712
5080                 self.match(CParser.T__52)
5081                 self.state = 713
5082                 self.equality_expression()
5083                 self.state = 718
5084                 self._errHandler.sync(self)
5085                 _la = self._input.LA(1)
5086
5087         except RecognitionException as re:
5088             localctx.exception = re
5089             self._errHandler.reportError(self, re)
5090             self._errHandler.recover(self, re)
5091         finally:
5092             self.exitRule()
5093         return localctx
5094
5095     class Equality_expressionContext(ParserRuleContext):
5096
5097         # @param  parent=None Type: ParserRuleContext
5098         # @param  invokingState=-1 Type: int
5099         def __init__(self,parser,parent=None,invokingState=-1):
5100             super().__init__(parent, invokingState)
5101             self.parser = parser
5102
5103         # @param  i=None Type: int
5104         def relational_expression(self,i=None):
5105             if i is None:
5106                 return self.getTypedRuleContexts(CParser.Relational_expressionContext)
5107             else:
5108                 return self.getTypedRuleContext(CParser.Relational_expressionContext,i)
5109
5110
5111         def getRuleIndex(self):
5112             return CParser.RULE_equality_expression
5113
5114         # @param  listener Type: ParseTreeListener
5115         def enterRule(self,listener):
5116             if hasattr( listener, "enterEquality_expression" ):
5117                 listener.enterEquality_expression(self)
5118
5119         # @param  listener Type: ParseTreeListener
5120         def exitRule(self,listener):
5121             if hasattr( listener, "exitEquality_expression" ):
5122                 listener.exitEquality_expression(self)
5123
5124
5125
5126
5127     def equality_expression(self):
5128
5129         localctx = CParser.Equality_expressionContext(self, self._ctx, self.state)
5130         self.enterRule(localctx, 112, self.RULE_equality_expression)
5131         self._la = 0 # Token type
5132         try:
5133             self.enterOuterAlt(localctx, 1)
5134             self.state = 719
5135             self.relational_expression()
5136             self.state = 724
5137             self._errHandler.sync(self)
5138             _la = self._input.LA(1)
5139             while _la==CParser.T__70 or _la==CParser.T__71:
5140                 self.state = 720
5141                 _la = self._input.LA(1)
5142                 if not(_la==CParser.T__70 or _la==CParser.T__71):
5143                     self._errHandler.recoverInline(self)
5144                 else:
5145                     self._errHandler.reportMatch(self)
5146                     self.consume()
5147                 self.state = 721
5148                 self.relational_expression()
5149                 self.state = 726
5150                 self._errHandler.sync(self)
5151                 _la = self._input.LA(1)
5152
5153         except RecognitionException as re:
5154             localctx.exception = re
5155             self._errHandler.reportError(self, re)
5156             self._errHandler.recover(self, re)
5157         finally:
5158             self.exitRule()
5159         return localctx
5160
5161     class Relational_expressionContext(ParserRuleContext):
5162
5163         # @param  parent=None Type: ParserRuleContext
5164         # @param  invokingState=-1 Type: int
5165         def __init__(self,parser,parent=None,invokingState=-1):
5166             super().__init__(parent, invokingState)
5167             self.parser = parser
5168
5169         # @param  i=None Type: int
5170         def shift_expression(self,i=None):
5171             if i is None:
5172                 return self.getTypedRuleContexts(CParser.Shift_expressionContext)
5173             else:
5174                 return self.getTypedRuleContext(CParser.Shift_expressionContext,i)
5175
5176
5177         def getRuleIndex(self):
5178             return CParser.RULE_relational_expression
5179
5180         # @param  listener Type: ParseTreeListener
5181         def enterRule(self,listener):
5182             if hasattr( listener, "enterRelational_expression" ):
5183                 listener.enterRelational_expression(self)
5184
5185         # @param  listener Type: ParseTreeListener
5186         def exitRule(self,listener):
5187             if hasattr( listener, "exitRelational_expression" ):
5188                 listener.exitRelational_expression(self)
5189
5190
5191
5192
5193     def relational_expression(self):
5194
5195         localctx = CParser.Relational_expressionContext(self, self._ctx, self.state)
5196         self.enterRule(localctx, 114, self.RULE_relational_expression)
5197         self._la = 0 # Token type
5198         try:
5199             self.enterOuterAlt(localctx, 1)
5200             self.state = 727
5201             self.shift_expression()
5202             self.state = 732
5203             self._errHandler.sync(self)
5204             _la = self._input.LA(1)
5205             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):
5206                 self.state = 728
5207                 _la = self._input.LA(1)
5208                 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)):
5209                     self._errHandler.recoverInline(self)
5210                 else:
5211                     self._errHandler.reportMatch(self)
5212                     self.consume()
5213                 self.state = 729
5214                 self.shift_expression()
5215                 self.state = 734
5216                 self._errHandler.sync(self)
5217                 _la = self._input.LA(1)
5218
5219         except RecognitionException as re:
5220             localctx.exception = re
5221             self._errHandler.reportError(self, re)
5222             self._errHandler.recover(self, re)
5223         finally:
5224             self.exitRule()
5225         return localctx
5226
5227     class Shift_expressionContext(ParserRuleContext):
5228
5229         # @param  parent=None Type: ParserRuleContext
5230         # @param  invokingState=-1 Type: int
5231         def __init__(self,parser,parent=None,invokingState=-1):
5232             super().__init__(parent, invokingState)
5233             self.parser = parser
5234
5235         # @param  i=None Type: int
5236         def additive_expression(self,i=None):
5237             if i is None:
5238                 return self.getTypedRuleContexts(CParser.Additive_expressionContext)
5239             else:
5240                 return self.getTypedRuleContext(CParser.Additive_expressionContext,i)
5241
5242
5243         def getRuleIndex(self):
5244             return CParser.RULE_shift_expression
5245
5246         # @param  listener Type: ParseTreeListener
5247         def enterRule(self,listener):
5248             if hasattr( listener, "enterShift_expression" ):
5249                 listener.enterShift_expression(self)
5250
5251         # @param  listener Type: ParseTreeListener
5252         def exitRule(self,listener):
5253             if hasattr( listener, "exitShift_expression" ):
5254                 listener.exitShift_expression(self)
5255
5256
5257
5258
5259     def shift_expression(self):
5260
5261         localctx = CParser.Shift_expressionContext(self, self._ctx, self.state)
5262         self.enterRule(localctx, 116, self.RULE_shift_expression)
5263         self._la = 0 # Token type
5264         try:
5265             self.enterOuterAlt(localctx, 1)
5266             self.state = 735
5267             self.additive_expression()
5268             self.state = 740
5269             self._errHandler.sync(self)
5270             _la = self._input.LA(1)
5271             while _la==CParser.T__76 or _la==CParser.T__77:
5272                 self.state = 736
5273                 _la = self._input.LA(1)
5274                 if not(_la==CParser.T__76 or _la==CParser.T__77):
5275                     self._errHandler.recoverInline(self)
5276                 else:
5277                     self._errHandler.reportMatch(self)
5278                     self.consume()
5279                 self.state = 737
5280                 self.additive_expression()
5281                 self.state = 742
5282                 self._errHandler.sync(self)
5283                 _la = self._input.LA(1)
5284
5285         except RecognitionException as re:
5286             localctx.exception = re
5287             self._errHandler.reportError(self, re)
5288             self._errHandler.recover(self, re)
5289         finally:
5290             self.exitRule()
5291         return localctx
5292
5293     class StatementContext(ParserRuleContext):
5294
5295         # @param  parent=None Type: ParserRuleContext
5296         # @param  invokingState=-1 Type: int
5297         def __init__(self,parser,parent=None,invokingState=-1):
5298             super().__init__(parent, invokingState)
5299             self.parser = parser
5300
5301         def labeled_statement(self):
5302             return self.getTypedRuleContext(CParser.Labeled_statementContext,0)
5303
5304
5305         def compound_statement(self):
5306             return self.getTypedRuleContext(CParser.Compound_statementContext,0)
5307
5308
5309         def expression_statement(self):
5310             return self.getTypedRuleContext(CParser.Expression_statementContext,0)
5311
5312
5313         def selection_statement(self):
5314             return self.getTypedRuleContext(CParser.Selection_statementContext,0)
5315
5316
5317         def iteration_statement(self):
5318             return self.getTypedRuleContext(CParser.Iteration_statementContext,0)
5319
5320
5321         def jump_statement(self):
5322             return self.getTypedRuleContext(CParser.Jump_statementContext,0)
5323
5324
5325         def macro_statement(self):
5326             return self.getTypedRuleContext(CParser.Macro_statementContext,0)
5327
5328
5329         def asm2_statement(self):
5330             return self.getTypedRuleContext(CParser.Asm2_statementContext,0)
5331
5332
5333         def asm1_statement(self):
5334             return self.getTypedRuleContext(CParser.Asm1_statementContext,0)
5335
5336
5337         def asm_statement(self):
5338             return self.getTypedRuleContext(CParser.Asm_statementContext,0)
5339
5340
5341         def declaration(self):
5342             return self.getTypedRuleContext(CParser.DeclarationContext,0)
5343
5344
5345         def getRuleIndex(self):
5346             return CParser.RULE_statement
5347
5348         # @param  listener Type: ParseTreeListener
5349         def enterRule(self,listener):
5350             if hasattr( listener, "enterStatement" ):
5351                 listener.enterStatement(self)
5352
5353         # @param  listener Type: ParseTreeListener
5354         def exitRule(self,listener):
5355             if hasattr( listener, "exitStatement" ):
5356                 listener.exitStatement(self)
5357
5358
5359
5360
5361     def statement(self):
5362
5363         localctx = CParser.StatementContext(self, self._ctx, self.state)
5364         self.enterRule(localctx, 118, self.RULE_statement)
5365         try:
5366             self.state = 754
5367             self._errHandler.sync(self)
5368             la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
5369             if la_ == 1:
5370                 self.enterOuterAlt(localctx, 1)
5371                 self.state = 743
5372                 self.labeled_statement()
5373                 pass
5374
5375             elif la_ == 2:
5376                 self.enterOuterAlt(localctx, 2)
5377                 self.state = 744
5378                 self.compound_statement()
5379                 pass
5380
5381             elif la_ == 3:
5382                 self.enterOuterAlt(localctx, 3)
5383                 self.state = 745
5384                 self.expression_statement()
5385                 pass
5386
5387             elif la_ == 4:
5388                 self.enterOuterAlt(localctx, 4)
5389                 self.state = 746
5390                 self.selection_statement()
5391                 pass
5392
5393             elif la_ == 5:
5394                 self.enterOuterAlt(localctx, 5)
5395                 self.state = 747
5396                 self.iteration_statement()
5397                 pass
5398
5399             elif la_ == 6:
5400                 self.enterOuterAlt(localctx, 6)
5401                 self.state = 748
5402                 self.jump_statement()
5403                 pass
5404
5405             elif la_ == 7:
5406                 self.enterOuterAlt(localctx, 7)
5407                 self.state = 749
5408                 self.macro_statement()
5409                 pass
5410
5411             elif la_ == 8:
5412                 self.enterOuterAlt(localctx, 8)
5413                 self.state = 750
5414                 self.asm2_statement()
5415                 pass
5416
5417             elif la_ == 9:
5418                 self.enterOuterAlt(localctx, 9)
5419                 self.state = 751
5420                 self.asm1_statement()
5421                 pass
5422
5423             elif la_ == 10:
5424                 self.enterOuterAlt(localctx, 10)
5425                 self.state = 752
5426                 self.asm_statement()
5427                 pass
5428
5429             elif la_ == 11:
5430                 self.enterOuterAlt(localctx, 11)
5431                 self.state = 753
5432                 self.declaration()
5433                 pass
5434
5435
5436         except RecognitionException as re:
5437             localctx.exception = re
5438             self._errHandler.reportError(self, re)
5439             self._errHandler.recover(self, re)
5440         finally:
5441             self.exitRule()
5442         return localctx
5443
5444     class Asm2_statementContext(ParserRuleContext):
5445
5446         # @param  parent=None Type: ParserRuleContext
5447         # @param  invokingState=-1 Type: int
5448         def __init__(self,parser,parent=None,invokingState=-1):
5449             super().__init__(parent, invokingState)
5450             self.parser = parser
5451
5452         def IDENTIFIER(self):
5453             return self.getToken(CParser.IDENTIFIER, 0)
5454
5455         def getRuleIndex(self):
5456             return CParser.RULE_asm2_statement
5457
5458         # @param  listener Type: ParseTreeListener
5459         def enterRule(self,listener):
5460             if hasattr( listener, "enterAsm2_statement" ):
5461                 listener.enterAsm2_statement(self)
5462
5463         # @param  listener Type: ParseTreeListener
5464         def exitRule(self,listener):
5465             if hasattr( listener, "exitAsm2_statement" ):
5466                 listener.exitAsm2_statement(self)
5467
5468
5469
5470
5471     def asm2_statement(self):
5472
5473         localctx = CParser.Asm2_statementContext(self, self._ctx, self.state)
5474         self.enterRule(localctx, 120, self.RULE_asm2_statement)
5475         self._la = 0 # Token type
5476         try:
5477             self.enterOuterAlt(localctx, 1)
5478             self.state = 757
5479             self._errHandler.sync(self)
5480             _la = self._input.LA(1)
5481             if _la==CParser.T__78:
5482                 self.state = 756
5483                 self.match(CParser.T__78)
5484
5485
5486             self.state = 759
5487             self.match(CParser.IDENTIFIER)
5488             self.state = 760
5489             self.match(CParser.T__37)
5490             self.state = 764
5491             self._errHandler.sync(self)
5492             _alt = self._interp.adaptivePredict(self._input,94,self._ctx)
5493             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
5494                 if _alt==1:
5495                     self.state = 761
5496                     _la = self._input.LA(1)
5497                     if _la <= 0 or _la==CParser.T__1:
5498                         self._errHandler.recoverInline(self)
5499                     else:
5500                         self._errHandler.reportMatch(self)
5501                         self.consume()
5502                 self.state = 766
5503                 self._errHandler.sync(self)
5504                 _alt = self._interp.adaptivePredict(self._input,94,self._ctx)
5505
5506             self.state = 767
5507             self.match(CParser.T__38)
5508             self.state = 768
5509             self.match(CParser.T__1)
5510         except RecognitionException as re:
5511             localctx.exception = re
5512             self._errHandler.reportError(self, re)
5513             self._errHandler.recover(self, re)
5514         finally:
5515             self.exitRule()
5516         return localctx
5517
5518     class Asm1_statementContext(ParserRuleContext):
5519
5520         # @param  parent=None Type: ParserRuleContext
5521         # @param  invokingState=-1 Type: int
5522         def __init__(self,parser,parent=None,invokingState=-1):
5523             super().__init__(parent, invokingState)
5524             self.parser = parser
5525
5526
5527         def getRuleIndex(self):
5528             return CParser.RULE_asm1_statement
5529
5530         # @param  listener Type: ParseTreeListener
5531         def enterRule(self,listener):
5532             if hasattr( listener, "enterAsm1_statement" ):
5533                 listener.enterAsm1_statement(self)
5534
5535         # @param  listener Type: ParseTreeListener
5536         def exitRule(self,listener):
5537             if hasattr( listener, "exitAsm1_statement" ):
5538                 listener.exitAsm1_statement(self)
5539
5540
5541
5542
5543     def asm1_statement(self):
5544
5545         localctx = CParser.Asm1_statementContext(self, self._ctx, self.state)
5546         self.enterRule(localctx, 122, self.RULE_asm1_statement)
5547         self._la = 0 # Token type
5548         try:
5549             self.enterOuterAlt(localctx, 1)
5550             self.state = 770
5551             self.match(CParser.T__79)
5552             self.state = 771
5553             self.match(CParser.T__0)
5554             self.state = 775
5555             self._errHandler.sync(self)
5556             _la = self._input.LA(1)
5557             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):
5558                 self.state = 772
5559                 _la = self._input.LA(1)
5560                 if _la <= 0 or _la==CParser.T__19:
5561                     self._errHandler.recoverInline(self)
5562                 else:
5563                     self._errHandler.reportMatch(self)
5564                     self.consume()
5565                 self.state = 777
5566                 self._errHandler.sync(self)
5567                 _la = self._input.LA(1)
5568
5569             self.state = 778
5570             self.match(CParser.T__19)
5571         except RecognitionException as re:
5572             localctx.exception = re
5573             self._errHandler.reportError(self, re)
5574             self._errHandler.recover(self, re)
5575         finally:
5576             self.exitRule()
5577         return localctx
5578
5579     class Asm_statementContext(ParserRuleContext):
5580
5581         # @param  parent=None Type: ParserRuleContext
5582         # @param  invokingState=-1 Type: int
5583         def __init__(self,parser,parent=None,invokingState=-1):
5584             super().__init__(parent, invokingState)
5585             self.parser = parser
5586
5587
5588         def getRuleIndex(self):
5589             return CParser.RULE_asm_statement
5590
5591         # @param  listener Type: ParseTreeListener
5592         def enterRule(self,listener):
5593             if hasattr( listener, "enterAsm_statement" ):
5594                 listener.enterAsm_statement(self)
5595
5596         # @param  listener Type: ParseTreeListener
5597         def exitRule(self,listener):
5598             if hasattr( listener, "exitAsm_statement" ):
5599                 listener.exitAsm_statement(self)
5600
5601
5602
5603
5604     def asm_statement(self):
5605
5606         localctx = CParser.Asm_statementContext(self, self._ctx, self.state)
5607         self.enterRule(localctx, 124, self.RULE_asm_statement)
5608         self._la = 0 # Token type
5609         try:
5610             self.enterOuterAlt(localctx, 1)
5611             self.state = 780
5612             self.match(CParser.T__80)
5613             self.state = 781
5614             self.match(CParser.T__0)
5615             self.state = 785
5616             self._errHandler.sync(self)
5617             _la = self._input.LA(1)
5618             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):
5619                 self.state = 782
5620                 _la = self._input.LA(1)
5621                 if _la <= 0 or _la==CParser.T__19:
5622                     self._errHandler.recoverInline(self)
5623                 else:
5624                     self._errHandler.reportMatch(self)
5625                     self.consume()
5626                 self.state = 787
5627                 self._errHandler.sync(self)
5628                 _la = self._input.LA(1)
5629
5630             self.state = 788
5631             self.match(CParser.T__19)
5632         except RecognitionException as re:
5633             localctx.exception = re
5634             self._errHandler.reportError(self, re)
5635             self._errHandler.recover(self, re)
5636         finally:
5637             self.exitRule()
5638         return localctx
5639
5640     class Macro_statementContext(ParserRuleContext):
5641
5642         # @param  parent=None Type: ParserRuleContext
5643         # @param  invokingState=-1 Type: int
5644         def __init__(self,parser,parent=None,invokingState=-1):
5645             super().__init__(parent, invokingState)
5646             self.parser = parser
5647
5648         def IDENTIFIER(self):
5649             return self.getToken(CParser.IDENTIFIER, 0)
5650
5651         # @param  i=None Type: int
5652         def declaration(self,i=None):
5653             if i is None:
5654                 return self.getTypedRuleContexts(CParser.DeclarationContext)
5655             else:
5656                 return self.getTypedRuleContext(CParser.DeclarationContext,i)
5657
5658
5659         def statement_list(self):
5660             return self.getTypedRuleContext(CParser.Statement_listContext,0)
5661
5662
5663         def expression(self):
5664             return self.getTypedRuleContext(CParser.ExpressionContext,0)
5665
5666
5667         def getRuleIndex(self):
5668             return CParser.RULE_macro_statement
5669
5670         # @param  listener Type: ParseTreeListener
5671         def enterRule(self,listener):
5672             if hasattr( listener, "enterMacro_statement" ):
5673                 listener.enterMacro_statement(self)
5674
5675         # @param  listener Type: ParseTreeListener
5676         def exitRule(self,listener):
5677             if hasattr( listener, "exitMacro_statement" ):
5678                 listener.exitMacro_statement(self)
5679
5680
5681
5682
5683     def macro_statement(self):
5684
5685         localctx = CParser.Macro_statementContext(self, self._ctx, self.state)
5686         self.enterRule(localctx, 126, self.RULE_macro_statement)
5687         self._la = 0 # Token type
5688         try:
5689             self.enterOuterAlt(localctx, 1)
5690             self.state = 790
5691             self.match(CParser.IDENTIFIER)
5692             self.state = 791
5693             self.match(CParser.T__37)
5694             self.state = 795
5695             self._errHandler.sync(self)
5696             _alt = self._interp.adaptivePredict(self._input,97,self._ctx)
5697             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
5698                 if _alt==1:
5699                     self.state = 792
5700                     self.declaration()
5701                 self.state = 797
5702                 self._errHandler.sync(self)
5703                 _alt = self._interp.adaptivePredict(self._input,97,self._ctx)
5704
5705             self.state = 799
5706             self._errHandler.sync(self)
5707             la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
5708             if la_ == 1:
5709                 self.state = 798
5710                 self.statement_list()
5711
5712
5713             self.state = 802
5714             self._errHandler.sync(self)
5715             _la = self._input.LA(1)
5716             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):
5717                 self.state = 801
5718                 self.expression()
5719
5720
5721             self.state = 804
5722             self.match(CParser.T__38)
5723         except RecognitionException as re:
5724             localctx.exception = re
5725             self._errHandler.reportError(self, re)
5726             self._errHandler.recover(self, re)
5727         finally:
5728             self.exitRule()
5729         return localctx
5730
5731     class Labeled_statementContext(ParserRuleContext):
5732
5733         # @param  parent=None Type: ParserRuleContext
5734         # @param  invokingState=-1 Type: int
5735         def __init__(self,parser,parent=None,invokingState=-1):
5736             super().__init__(parent, invokingState)
5737             self.parser = parser
5738
5739         def IDENTIFIER(self):
5740             return self.getToken(CParser.IDENTIFIER, 0)
5741
5742         def statement(self):
5743             return self.getTypedRuleContext(CParser.StatementContext,0)
5744
5745
5746         def constant_expression(self):
5747             return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
5748
5749
5750         def getRuleIndex(self):
5751             return CParser.RULE_labeled_statement
5752
5753         # @param  listener Type: ParseTreeListener
5754         def enterRule(self,listener):
5755             if hasattr( listener, "enterLabeled_statement" ):
5756                 listener.enterLabeled_statement(self)
5757
5758         # @param  listener Type: ParseTreeListener
5759         def exitRule(self,listener):
5760             if hasattr( listener, "exitLabeled_statement" ):
5761                 listener.exitLabeled_statement(self)
5762
5763
5764
5765
5766     def labeled_statement(self):
5767
5768         localctx = CParser.Labeled_statementContext(self, self._ctx, self.state)
5769         self.enterRule(localctx, 128, self.RULE_labeled_statement)
5770         try:
5771             self.state = 817
5772             self._errHandler.sync(self)
5773             token = self._input.LA(1)
5774             if token in [CParser.IDENTIFIER]:
5775                 self.enterOuterAlt(localctx, 1)
5776                 self.state = 806
5777                 self.match(CParser.IDENTIFIER)
5778                 self.state = 807
5779                 self.match(CParser.T__22)
5780                 self.state = 808
5781                 self.statement()
5782                 pass
5783             elif token in [CParser.T__81]:
5784                 self.enterOuterAlt(localctx, 2)
5785                 self.state = 809
5786                 self.match(CParser.T__81)
5787                 self.state = 810
5788                 self.constant_expression()
5789                 self.state = 811
5790                 self.match(CParser.T__22)
5791                 self.state = 812
5792                 self.statement()
5793                 pass
5794             elif token in [CParser.T__82]:
5795                 self.enterOuterAlt(localctx, 3)
5796                 self.state = 814
5797                 self.match(CParser.T__82)
5798                 self.state = 815
5799                 self.match(CParser.T__22)
5800                 self.state = 816
5801                 self.statement()
5802                 pass
5803             else:
5804                 raise NoViableAltException(self)
5805
5806         except RecognitionException as re:
5807             localctx.exception = re
5808             self._errHandler.reportError(self, re)
5809             self._errHandler.recover(self, re)
5810         finally:
5811             self.exitRule()
5812         return localctx
5813
5814     class Compound_statementContext(ParserRuleContext):
5815
5816         # @param  parent=None Type: ParserRuleContext
5817         # @param  invokingState=-1 Type: int
5818         def __init__(self,parser,parent=None,invokingState=-1):
5819             super().__init__(parent, invokingState)
5820             self.parser = parser
5821
5822         # @param  i=None Type: int
5823         def declaration(self,i=None):
5824             if i is None:
5825                 return self.getTypedRuleContexts(CParser.DeclarationContext)
5826             else:
5827                 return self.getTypedRuleContext(CParser.DeclarationContext,i)
5828
5829
5830         def statement_list(self):
5831             return self.getTypedRuleContext(CParser.Statement_listContext,0)
5832
5833
5834         def getRuleIndex(self):
5835             return CParser.RULE_compound_statement
5836
5837         # @param  listener Type: ParseTreeListener
5838         def enterRule(self,listener):
5839             if hasattr( listener, "enterCompound_statement" ):
5840                 listener.enterCompound_statement(self)
5841
5842         # @param  listener Type: ParseTreeListener
5843         def exitRule(self,listener):
5844             if hasattr( listener, "exitCompound_statement" ):
5845                 listener.exitCompound_statement(self)
5846
5847
5848
5849
5850     def compound_statement(self):
5851
5852         localctx = CParser.Compound_statementContext(self, self._ctx, self.state)
5853         self.enterRule(localctx, 130, self.RULE_compound_statement)
5854         self._la = 0 # Token type
5855         try:
5856             self.enterOuterAlt(localctx, 1)
5857             self.state = 819
5858             self.match(CParser.T__0)
5859             self.state = 823
5860             self._errHandler.sync(self)
5861             _alt = self._interp.adaptivePredict(self._input,101,self._ctx)
5862             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
5863                 if _alt==1:
5864                     self.state = 820
5865                     self.declaration()
5866                 self.state = 825
5867                 self._errHandler.sync(self)
5868                 _alt = self._interp.adaptivePredict(self._input,101,self._ctx)
5869
5870             self.state = 827
5871             self._errHandler.sync(self)
5872             _la = self._input.LA(1)
5873             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):
5874                 self.state = 826
5875                 self.statement_list()
5876
5877
5878             self.state = 829
5879             self.match(CParser.T__19)
5880         except RecognitionException as re:
5881             localctx.exception = re
5882             self._errHandler.reportError(self, re)
5883             self._errHandler.recover(self, re)
5884         finally:
5885             self.exitRule()
5886         return localctx
5887
5888     class Statement_listContext(ParserRuleContext):
5889
5890         # @param  parent=None Type: ParserRuleContext
5891         # @param  invokingState=-1 Type: int
5892         def __init__(self,parser,parent=None,invokingState=-1):
5893             super().__init__(parent, invokingState)
5894             self.parser = parser
5895
5896         # @param  i=None Type: int
5897         def statement(self,i=None):
5898             if i is None:
5899                 return self.getTypedRuleContexts(CParser.StatementContext)
5900             else:
5901                 return self.getTypedRuleContext(CParser.StatementContext,i)
5902
5903
5904         def getRuleIndex(self):
5905             return CParser.RULE_statement_list
5906
5907         # @param  listener Type: ParseTreeListener
5908         def enterRule(self,listener):
5909             if hasattr( listener, "enterStatement_list" ):
5910                 listener.enterStatement_list(self)
5911
5912         # @param  listener Type: ParseTreeListener
5913         def exitRule(self,listener):
5914             if hasattr( listener, "exitStatement_list" ):
5915                 listener.exitStatement_list(self)
5916
5917
5918
5919
5920     def statement_list(self):
5921
5922         localctx = CParser.Statement_listContext(self, self._ctx, self.state)
5923         self.enterRule(localctx, 132, self.RULE_statement_list)
5924         try:
5925             self.enterOuterAlt(localctx, 1)
5926             self.state = 832
5927             self._errHandler.sync(self)
5928             _alt = 1
5929             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
5930                 if _alt == 1:
5931                     self.state = 831
5932                     self.statement()
5933
5934                 else:
5935                     raise NoViableAltException(self)
5936                 self.state = 834
5937                 self._errHandler.sync(self)
5938                 _alt = self._interp.adaptivePredict(self._input,103,self._ctx)
5939
5940         except RecognitionException as re:
5941             localctx.exception = re
5942             self._errHandler.reportError(self, re)
5943             self._errHandler.recover(self, re)
5944         finally:
5945             self.exitRule()
5946         return localctx
5947
5948     class Expression_statementContext(ParserRuleContext):
5949
5950         # @param  parent=None Type: ParserRuleContext
5951         # @param  invokingState=-1 Type: int
5952         def __init__(self,parser,parent=None,invokingState=-1):
5953             super().__init__(parent, invokingState)
5954             self.parser = parser
5955
5956         def expression(self):
5957             return self.getTypedRuleContext(CParser.ExpressionContext,0)
5958
5959
5960         def getRuleIndex(self):
5961             return CParser.RULE_expression_statement
5962
5963         # @param  listener Type: ParseTreeListener
5964         def enterRule(self,listener):
5965             if hasattr( listener, "enterExpression_statement" ):
5966                 listener.enterExpression_statement(self)
5967
5968         # @param  listener Type: ParseTreeListener
5969         def exitRule(self,listener):
5970             if hasattr( listener, "exitExpression_statement" ):
5971                 listener.exitExpression_statement(self)
5972
5973
5974
5975
5976     def expression_statement(self):
5977
5978         localctx = CParser.Expression_statementContext(self, self._ctx, self.state)
5979         self.enterRule(localctx, 134, self.RULE_expression_statement)
5980         try:
5981             self.state = 840
5982             self._errHandler.sync(self)
5983             token = self._input.LA(1)
5984             if token in [CParser.T__1]:
5985                 self.enterOuterAlt(localctx, 1)
5986                 self.state = 836
5987                 self.match(CParser.T__1)
5988                 pass
5989             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]:
5990                 self.enterOuterAlt(localctx, 2)
5991                 self.state = 837
5992                 self.expression()
5993                 self.state = 838
5994                 self.match(CParser.T__1)
5995                 pass
5996             else:
5997                 raise NoViableAltException(self)
5998
5999         except RecognitionException as re:
6000             localctx.exception = re
6001             self._errHandler.reportError(self, re)
6002             self._errHandler.recover(self, re)
6003         finally:
6004             self.exitRule()
6005         return localctx
6006
6007     class Selection_statementContext(ParserRuleContext):
6008
6009         # @param  parent=None Type: ParserRuleContext
6010         # @param  invokingState=-1 Type: int
6011         def __init__(self,parser,parent=None,invokingState=-1):
6012             super().__init__(parent, invokingState)
6013             self.parser = parser
6014             self.e = None # ExpressionContext
6015
6016         # @param  i=None Type: int
6017         def statement(self,i=None):
6018             if i is None:
6019                 return self.getTypedRuleContexts(CParser.StatementContext)
6020             else:
6021                 return self.getTypedRuleContext(CParser.StatementContext,i)
6022
6023
6024         def expression(self):
6025             return self.getTypedRuleContext(CParser.ExpressionContext,0)
6026
6027
6028         def getRuleIndex(self):
6029             return CParser.RULE_selection_statement
6030
6031         # @param  listener Type: ParseTreeListener
6032         def enterRule(self,listener):
6033             if hasattr( listener, "enterSelection_statement" ):
6034                 listener.enterSelection_statement(self)
6035
6036         # @param  listener Type: ParseTreeListener
6037         def exitRule(self,listener):
6038             if hasattr( listener, "exitSelection_statement" ):
6039                 listener.exitSelection_statement(self)
6040
6041
6042
6043
6044     def selection_statement(self):
6045
6046         localctx = CParser.Selection_statementContext(self, self._ctx, self.state)
6047         self.enterRule(localctx, 136, self.RULE_selection_statement)
6048         try:
6049             self.state = 858
6050             self._errHandler.sync(self)
6051             token = self._input.LA(1)
6052             if token in [CParser.T__83]:
6053                 self.enterOuterAlt(localctx, 1)
6054                 self.state = 842
6055                 self.match(CParser.T__83)
6056                 self.state = 843
6057                 self.match(CParser.T__37)
6058                 self.state = 844
6059                 localctx.e = self.expression()
6060                 self.state = 845
6061                 self.match(CParser.T__38)
6062                 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))))
6063                 self.state = 847
6064                 self.statement()
6065                 self.state = 850
6066                 self._errHandler.sync(self)
6067                 la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
6068                 if la_ == 1:
6069                     self.state = 848
6070                     self.match(CParser.T__84)
6071                     self.state = 849
6072                     self.statement()
6073
6074
6075                 pass
6076             elif token in [CParser.T__85]:
6077                 self.enterOuterAlt(localctx, 2)
6078                 self.state = 852
6079                 self.match(CParser.T__85)
6080                 self.state = 853
6081                 self.match(CParser.T__37)
6082                 self.state = 854
6083                 self.expression()
6084                 self.state = 855
6085                 self.match(CParser.T__38)
6086                 self.state = 856
6087                 self.statement()
6088                 pass
6089             else:
6090                 raise NoViableAltException(self)
6091
6092         except RecognitionException as re:
6093             localctx.exception = re
6094             self._errHandler.reportError(self, re)
6095             self._errHandler.recover(self, re)
6096         finally:
6097             self.exitRule()
6098         return localctx
6099
6100     class Iteration_statementContext(ParserRuleContext):
6101
6102         # @param  parent=None Type: ParserRuleContext
6103         # @param  invokingState=-1 Type: int
6104         def __init__(self,parser,parent=None,invokingState=-1):
6105             super().__init__(parent, invokingState)
6106             self.parser = parser
6107             self.e = None # ExpressionContext
6108
6109         def statement(self):
6110             return self.getTypedRuleContext(CParser.StatementContext,0)
6111
6112
6113         def expression(self):
6114             return self.getTypedRuleContext(CParser.ExpressionContext,0)
6115
6116
6117         def getRuleIndex(self):
6118             return CParser.RULE_iteration_statement
6119
6120         # @param  listener Type: ParseTreeListener
6121         def enterRule(self,listener):
6122             if hasattr( listener, "enterIteration_statement" ):
6123                 listener.enterIteration_statement(self)
6124
6125         # @param  listener Type: ParseTreeListener
6126         def exitRule(self,listener):
6127             if hasattr( listener, "exitIteration_statement" ):
6128                 listener.exitIteration_statement(self)
6129
6130
6131
6132
6133     def iteration_statement(self):
6134
6135         localctx = CParser.Iteration_statementContext(self, self._ctx, self.state)
6136         self.enterRule(localctx, 138, self.RULE_iteration_statement)
6137         try:
6138             self.state = 876
6139             self._errHandler.sync(self)
6140             token = self._input.LA(1)
6141             if token in [CParser.T__86]:
6142                 self.enterOuterAlt(localctx, 1)
6143                 self.state = 860
6144                 self.match(CParser.T__86)
6145                 self.state = 861
6146                 self.match(CParser.T__37)
6147                 self.state = 862
6148                 localctx.e = self.expression()
6149                 self.state = 863
6150                 self.match(CParser.T__38)
6151                 self.state = 864
6152                 self.statement()
6153                 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))))
6154                 pass
6155             elif token in [CParser.T__87]:
6156                 self.enterOuterAlt(localctx, 2)
6157                 self.state = 867
6158                 self.match(CParser.T__87)
6159                 self.state = 868
6160                 self.statement()
6161                 self.state = 869
6162                 self.match(CParser.T__86)
6163                 self.state = 870
6164                 self.match(CParser.T__37)
6165                 self.state = 871
6166                 localctx.e = self.expression()
6167                 self.state = 872
6168                 self.match(CParser.T__38)
6169                 self.state = 873
6170                 self.match(CParser.T__1)
6171                 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))))
6172                 pass
6173             else:
6174                 raise NoViableAltException(self)
6175
6176         except RecognitionException as re:
6177             localctx.exception = re
6178             self._errHandler.reportError(self, re)
6179             self._errHandler.recover(self, re)
6180         finally:
6181             self.exitRule()
6182         return localctx
6183
6184     class Jump_statementContext(ParserRuleContext):
6185
6186         # @param  parent=None Type: ParserRuleContext
6187         # @param  invokingState=-1 Type: int
6188         def __init__(self,parser,parent=None,invokingState=-1):
6189             super().__init__(parent, invokingState)
6190             self.parser = parser
6191
6192         def IDENTIFIER(self):
6193             return self.getToken(CParser.IDENTIFIER, 0)
6194
6195         def expression(self):
6196             return self.getTypedRuleContext(CParser.ExpressionContext,0)
6197
6198
6199         def getRuleIndex(self):
6200             return CParser.RULE_jump_statement
6201
6202         # @param  listener Type: ParseTreeListener
6203         def enterRule(self,listener):
6204             if hasattr( listener, "enterJump_statement" ):
6205                 listener.enterJump_statement(self)
6206
6207         # @param  listener Type: ParseTreeListener
6208         def exitRule(self,listener):
6209             if hasattr( listener, "exitJump_statement" ):
6210                 listener.exitJump_statement(self)
6211
6212
6213
6214
6215     def jump_statement(self):
6216
6217         localctx = CParser.Jump_statementContext(self, self._ctx, self.state)
6218         self.enterRule(localctx, 140, self.RULE_jump_statement)
6219         try:
6220             self.state = 891
6221             self._errHandler.sync(self)
6222             la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
6223             if la_ == 1:
6224                 self.enterOuterAlt(localctx, 1)
6225                 self.state = 878
6226                 self.match(CParser.T__88)
6227                 self.state = 879
6228                 self.match(CParser.IDENTIFIER)
6229                 self.state = 880
6230                 self.match(CParser.T__1)
6231                 pass
6232
6233             elif la_ == 2:
6234                 self.enterOuterAlt(localctx, 2)
6235                 self.state = 881
6236                 self.match(CParser.T__89)
6237                 self.state = 882
6238                 self.match(CParser.T__1)
6239                 pass
6240
6241             elif la_ == 3:
6242                 self.enterOuterAlt(localctx, 3)
6243                 self.state = 883
6244                 self.match(CParser.T__90)
6245                 self.state = 884
6246                 self.match(CParser.T__1)
6247                 pass
6248
6249             elif la_ == 4:
6250                 self.enterOuterAlt(localctx, 4)
6251                 self.state = 885
6252                 self.match(CParser.T__91)
6253                 self.state = 886
6254                 self.match(CParser.T__1)
6255                 pass
6256
6257             elif la_ == 5:
6258                 self.enterOuterAlt(localctx, 5)
6259                 self.state = 887
6260                 self.match(CParser.T__91)
6261                 self.state = 888
6262                 self.expression()
6263                 self.state = 889
6264                 self.match(CParser.T__1)
6265                 pass
6266
6267
6268         except RecognitionException as re:
6269             localctx.exception = re
6270             self._errHandler.reportError(self, re)
6271             self._errHandler.recover(self, re)
6272         finally:
6273             self.exitRule()
6274         return localctx
6275
6276
6277
6278
6279