mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-19 15:37:40 +01:00
6274 lines
251 KiB
Python
Executable File
6274 lines
251 KiB
Python
Executable File
# Generated from C.g4 by ANTLR 4.7.1
|
|
# encoding: utf-8
|
|
from antlr4 import *
|
|
from io import StringIO
|
|
from typing.io import TextIO
|
|
import sys
|
|
|
|
|
|
## @file
|
|
# The file defines the parser for C source files.
|
|
#
|
|
# THIS FILE IS AUTO-GENENERATED. PLEASE DON NOT MODIFY THIS FILE.
|
|
# This file is generated by running:
|
|
# java org.antlr.Tool C.g
|
|
#
|
|
# Copyright (c) 2009 - 2010, Intel Corporation All rights reserved.
|
|
#
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
#
|
|
##
|
|
|
|
import Ecc.CodeFragment as CodeFragment
|
|
import Ecc.FileProfile as FileProfile
|
|
|
|
def serializedATN():
|
|
with StringIO() as buf:
|
|
buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3k")
|
|
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")
|
|
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")
|
|
buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
|
|
buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
|
|
buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
|
|
buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
|
|
buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
|
|
buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
|
|
buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
|
|
buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
|
|
buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\3\2\7\2\u0092\n\2\f\2\16\2\u0095")
|
|
buf.write("\13\2\3\3\5\3\u0098\n\3\3\3\3\3\7\3\u009c\n\3\f\3\16\3")
|
|
buf.write("\u009f\13\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00a7\n\3\5\3")
|
|
buf.write("\u00a9\n\3\3\4\5\4\u00ac\n\4\3\4\3\4\6\4\u00b0\n\4\r\4")
|
|
buf.write("\16\4\u00b1\3\4\3\4\3\4\5\4\u00b7\n\4\3\4\3\4\3\5\3\5")
|
|
buf.write("\3\5\6\5\u00be\n\5\r\5\16\5\u00bf\3\6\3\6\5\6\u00c4\n")
|
|
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")
|
|
buf.write("\6\u00d1\n\6\3\7\3\7\3\7\7\7\u00d6\n\7\f\7\16\7\u00d9")
|
|
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")
|
|
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")
|
|
buf.write("\7\n\u00f3\n\n\f\n\16\n\u00f6\13\n\3\n\3\n\5\n\u00fa\n")
|
|
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")
|
|
buf.write("\3\f\3\f\5\f\u0109\n\f\3\r\3\r\3\16\6\16\u010e\n\16\r")
|
|
buf.write("\16\16\16\u010f\3\17\3\17\3\17\3\17\3\20\3\20\6\20\u0118")
|
|
buf.write("\n\20\r\20\16\20\u0119\3\21\3\21\3\21\7\21\u011f\n\21")
|
|
buf.write("\f\21\16\21\u0122\13\21\3\22\3\22\3\22\5\22\u0127\n\22")
|
|
buf.write("\3\22\3\22\5\22\u012b\n\22\3\23\3\23\3\23\3\23\5\23\u0131")
|
|
buf.write("\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u013a\n")
|
|
buf.write("\23\3\23\3\23\3\23\3\23\5\23\u0140\n\23\3\24\3\24\3\24")
|
|
buf.write("\7\24\u0145\n\24\f\24\16\24\u0148\13\24\3\25\3\25\3\25")
|
|
buf.write("\5\25\u014d\n\25\3\26\3\26\3\27\5\27\u0152\n\27\3\27\5")
|
|
buf.write("\27\u0155\n\27\3\27\5\27\u0158\n\27\3\27\5\27\u015b\n")
|
|
buf.write("\27\3\27\3\27\5\27\u015f\n\27\3\30\3\30\7\30\u0163\n\30")
|
|
buf.write("\f\30\16\30\u0166\13\30\3\30\3\30\5\30\u016a\n\30\3\30")
|
|
buf.write("\3\30\3\30\6\30\u016f\n\30\r\30\16\30\u0170\5\30\u0173")
|
|
buf.write("\n\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
|
|
buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0185\n\31\3\32\3")
|
|
buf.write("\32\6\32\u0189\n\32\r\32\16\32\u018a\3\32\5\32\u018e\n")
|
|
buf.write("\32\3\32\3\32\3\32\5\32\u0193\n\32\3\33\3\33\3\33\5\33")
|
|
buf.write("\u0198\n\33\3\33\5\33\u019b\n\33\3\34\3\34\3\34\5\34\u01a0")
|
|
buf.write("\n\34\3\34\7\34\u01a3\n\34\f\34\16\34\u01a6\13\34\3\35")
|
|
buf.write("\3\35\3\35\7\35\u01ab\n\35\f\35\16\35\u01ae\13\35\3\35")
|
|
buf.write("\5\35\u01b1\n\35\3\35\7\35\u01b4\n\35\f\35\16\35\u01b7")
|
|
buf.write("\13\35\3\35\5\35\u01ba\n\35\3\36\3\36\3\36\7\36\u01bf")
|
|
buf.write("\n\36\f\36\16\36\u01c2\13\36\3\37\3\37\5\37\u01c6\n\37")
|
|
buf.write("\3\37\5\37\u01c9\n\37\3 \3 \5 \u01cd\n \3 \5 \u01d0\n")
|
|
buf.write(" \3!\3!\3!\3!\3!\5!\u01d7\n!\3!\7!\u01da\n!\f!\16!\u01dd")
|
|
buf.write("\13!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5")
|
|
buf.write("\"\u01eb\n\"\3#\3#\3#\3#\5#\u01f1\n#\3#\3#\5#\u01f5\n")
|
|
buf.write("#\3$\3$\3$\7$\u01fa\n$\f$\16$\u01fd\13$\3%\3%\5%\u0201")
|
|
buf.write("\n%\3%\3%\3%\5%\u0206\n%\7%\u0208\n%\f%\16%\u020b\13%")
|
|
buf.write("\3&\3&\3&\3&\3&\7&\u0212\n&\f&\16&\u0215\13&\3\'\3\'\3")
|
|
buf.write("\'\3\'\3\'\3\'\3\'\7\'\u021e\n\'\f\'\16\'\u0221\13\'\3")
|
|
buf.write("(\3(\3(\3(\3(\3(\5(\u0229\n(\3)\3)\3)\3)\3)\3)\3)\3)\3")
|
|
buf.write(")\3)\3)\3)\3)\3)\3)\5)\u023a\n)\3*\3*\3*\3*\3*\3*\3*\3")
|
|
buf.write("*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3")
|
|
buf.write("*\3*\3*\3*\7*\u0259\n*\f*\16*\u025c\13*\3+\3+\3+\7+\u0261")
|
|
buf.write("\n+\f+\16+\u0264\13+\3,\3,\3-\3-\3-\3-\3-\3-\5-\u026e")
|
|
buf.write("\n-\3.\3.\3.\3.\3.\7.\u0275\n.\f.\16.\u0278\13.\3.\6.")
|
|
buf.write("\u027b\n.\r.\16.\u027c\6.\u027f\n.\r.\16.\u0280\3.\7.")
|
|
buf.write("\u0284\n.\f.\16.\u0287\13.\3.\5.\u028a\n.\3/\3/\3/\7/")
|
|
buf.write("\u028f\n/\f/\16/\u0292\13/\3\60\3\60\3\61\3\61\3\61\3")
|
|
buf.write("\61\3\61\5\61\u029b\n\61\3\62\3\62\3\63\3\63\3\64\3\64")
|
|
buf.write("\3\64\3\64\3\64\3\64\3\64\5\64\u02a8\n\64\3\65\3\65\3")
|
|
buf.write("\65\7\65\u02ad\n\65\f\65\16\65\u02b0\13\65\3\66\3\66\3")
|
|
buf.write("\66\7\66\u02b5\n\66\f\66\16\66\u02b8\13\66\3\67\3\67\3")
|
|
buf.write("\67\7\67\u02bd\n\67\f\67\16\67\u02c0\13\67\38\38\38\7")
|
|
buf.write("8\u02c5\n8\f8\168\u02c8\138\39\39\39\79\u02cd\n9\f9\16")
|
|
buf.write("9\u02d0\139\3:\3:\3:\7:\u02d5\n:\f:\16:\u02d8\13:\3;\3")
|
|
buf.write(";\3;\7;\u02dd\n;\f;\16;\u02e0\13;\3<\3<\3<\7<\u02e5\n")
|
|
buf.write("<\f<\16<\u02e8\13<\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\5")
|
|
buf.write("=\u02f5\n=\3>\5>\u02f8\n>\3>\3>\3>\7>\u02fd\n>\f>\16>")
|
|
buf.write("\u0300\13>\3>\3>\3>\3?\3?\3?\7?\u0308\n?\f?\16?\u030b")
|
|
buf.write("\13?\3?\3?\3@\3@\3@\7@\u0312\n@\f@\16@\u0315\13@\3@\3")
|
|
buf.write("@\3A\3A\3A\7A\u031c\nA\fA\16A\u031f\13A\3A\5A\u0322\n")
|
|
buf.write("A\3A\5A\u0325\nA\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3")
|
|
buf.write("B\5B\u0334\nB\3C\3C\7C\u0338\nC\fC\16C\u033b\13C\3C\5")
|
|
buf.write("C\u033e\nC\3C\3C\3D\6D\u0343\nD\rD\16D\u0344\3E\3E\3E")
|
|
buf.write("\3E\5E\u034b\nE\3F\3F\3F\3F\3F\3F\3F\3F\5F\u0355\nF\3")
|
|
buf.write("F\3F\3F\3F\3F\3F\5F\u035d\nF\3G\3G\3G\3G\3G\3G\3G\3G\3")
|
|
buf.write("G\3G\3G\3G\3G\3G\3G\3G\5G\u036f\nG\3H\3H\3H\3H\3H\3H\3")
|
|
buf.write("H\3H\3H\3H\3H\3H\3H\5H\u037e\nH\3H\2\2I\2\4\6\b\n\f\16")
|
|
buf.write("\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDF")
|
|
buf.write("HJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086")
|
|
buf.write("\u0088\u008a\u008c\u008e\2\f\3\2\b\f\3\2\27\30\3\2\33")
|
|
buf.write("\'\5\2,,./\679\4\2\7\7:C\3\2IJ\3\2KN\3\2OP\3\2\4\4\3\2")
|
|
buf.write("\26\26\2\u03d8\2\u0093\3\2\2\2\4\u00a8\3\2\2\2\6\u00ab")
|
|
buf.write("\3\2\2\2\b\u00bd\3\2\2\2\n\u00d0\3\2\2\2\f\u00d2\3\2\2")
|
|
buf.write("\2\16\u00da\3\2\2\2\20\u00df\3\2\2\2\22\u00f9\3\2\2\2")
|
|
buf.write("\24\u00fb\3\2\2\2\26\u0108\3\2\2\2\30\u010a\3\2\2\2\32")
|
|
buf.write("\u010d\3\2\2\2\34\u0111\3\2\2\2\36\u0117\3\2\2\2 \u011b")
|
|
buf.write("\3\2\2\2\"\u012a\3\2\2\2$\u013f\3\2\2\2&\u0141\3\2\2\2")
|
|
buf.write("(\u0149\3\2\2\2*\u014e\3\2\2\2,\u015e\3\2\2\2.\u0172\3")
|
|
buf.write("\2\2\2\60\u0184\3\2\2\2\62\u0192\3\2\2\2\64\u0194\3\2")
|
|
buf.write("\2\2\66\u019c\3\2\2\28\u01b9\3\2\2\2:\u01bb\3\2\2\2<\u01c8")
|
|
buf.write("\3\2\2\2>\u01cf\3\2\2\2@\u01d6\3\2\2\2B\u01ea\3\2\2\2")
|
|
buf.write("D\u01f4\3\2\2\2F\u01f6\3\2\2\2H\u01fe\3\2\2\2J\u020c\3")
|
|
buf.write("\2\2\2L\u0216\3\2\2\2N\u0228\3\2\2\2P\u0239\3\2\2\2R\u023b")
|
|
buf.write("\3\2\2\2T\u025d\3\2\2\2V\u0265\3\2\2\2X\u026d\3\2\2\2")
|
|
buf.write("Z\u0289\3\2\2\2\\\u028b\3\2\2\2^\u0293\3\2\2\2`\u029a")
|
|
buf.write("\3\2\2\2b\u029c\3\2\2\2d\u029e\3\2\2\2f\u02a0\3\2\2\2")
|
|
buf.write("h\u02a9\3\2\2\2j\u02b1\3\2\2\2l\u02b9\3\2\2\2n\u02c1\3")
|
|
buf.write("\2\2\2p\u02c9\3\2\2\2r\u02d1\3\2\2\2t\u02d9\3\2\2\2v\u02e1")
|
|
buf.write("\3\2\2\2x\u02f4\3\2\2\2z\u02f7\3\2\2\2|\u0304\3\2\2\2")
|
|
buf.write("~\u030e\3\2\2\2\u0080\u0318\3\2\2\2\u0082\u0333\3\2\2")
|
|
buf.write("\2\u0084\u0335\3\2\2\2\u0086\u0342\3\2\2\2\u0088\u034a")
|
|
buf.write("\3\2\2\2\u008a\u035c\3\2\2\2\u008c\u036e\3\2\2\2\u008e")
|
|
buf.write("\u037d\3\2\2\2\u0090\u0092\5\4\3\2\u0091\u0090\3\2\2\2")
|
|
buf.write("\u0092\u0095\3\2\2\2\u0093\u0091\3\2\2\2\u0093\u0094\3")
|
|
buf.write("\2\2\2\u0094\3\3\2\2\2\u0095\u0093\3\2\2\2\u0096\u0098")
|
|
buf.write("\5\b\5\2\u0097\u0096\3\2\2\2\u0097\u0098\3\2\2\2\u0098")
|
|
buf.write("\u0099\3\2\2\2\u0099\u009d\5,\27\2\u009a\u009c\5\n\6\2")
|
|
buf.write("\u009b\u009a\3\2\2\2\u009c\u009f\3\2\2\2\u009d\u009b\3")
|
|
buf.write("\2\2\2\u009d\u009e\3\2\2\2\u009e\u00a0\3\2\2\2\u009f\u009d")
|
|
buf.write("\3\2\2\2\u00a0\u00a1\7\3\2\2\u00a1\u00a9\3\2\2\2\u00a2")
|
|
buf.write("\u00a9\5\6\4\2\u00a3\u00a9\5\n\6\2\u00a4\u00a6\5\u0080")
|
|
buf.write("A\2\u00a5\u00a7\7\4\2\2\u00a6\u00a5\3\2\2\2\u00a6\u00a7")
|
|
buf.write("\3\2\2\2\u00a7\u00a9\3\2\2\2\u00a8\u0097\3\2\2\2\u00a8")
|
|
buf.write("\u00a2\3\2\2\2\u00a8\u00a3\3\2\2\2\u00a8\u00a4\3\2\2\2")
|
|
buf.write("\u00a9\5\3\2\2\2\u00aa\u00ac\5\b\5\2\u00ab\u00aa\3\2\2")
|
|
buf.write("\2\u00ab\u00ac\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00b6")
|
|
buf.write("\5,\27\2\u00ae\u00b0\5\n\6\2\u00af\u00ae\3\2\2\2\u00b0")
|
|
buf.write("\u00b1\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2\2\2")
|
|
buf.write("\u00b2\u00b3\3\2\2\2\u00b3\u00b4\5\u0084C\2\u00b4\u00b7")
|
|
buf.write("\3\2\2\2\u00b5\u00b7\5\u0084C\2\u00b6\u00af\3\2\2\2\u00b6")
|
|
buf.write("\u00b5\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\b\4\1\2")
|
|
buf.write("\u00b9\7\3\2\2\2\u00ba\u00be\5\20\t\2\u00bb\u00be\5\22")
|
|
buf.write("\n\2\u00bc\u00be\5*\26\2\u00bd\u00ba\3\2\2\2\u00bd\u00bb")
|
|
buf.write("\3\2\2\2\u00bd\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf")
|
|
buf.write("\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\t\3\2\2\2\u00c1")
|
|
buf.write("\u00c3\7\5\2\2\u00c2\u00c4\5\b\5\2\u00c3\u00c2\3\2\2\2")
|
|
buf.write("\u00c3\u00c4\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c6\5")
|
|
buf.write("\f\7\2\u00c6\u00c7\7\4\2\2\u00c7\u00c8\b\6\1\2\u00c8\u00d1")
|
|
buf.write("\3\2\2\2\u00c9\u00cb\5\b\5\2\u00ca\u00cc\5\f\7\2\u00cb")
|
|
buf.write("\u00ca\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2")
|
|
buf.write("\u00cd\u00ce\7\4\2\2\u00ce\u00cf\b\6\1\2\u00cf\u00d1\3")
|
|
buf.write("\2\2\2\u00d0\u00c1\3\2\2\2\u00d0\u00c9\3\2\2\2\u00d1\13")
|
|
buf.write("\3\2\2\2\u00d2\u00d7\5\16\b\2\u00d3\u00d4\7\6\2\2\u00d4")
|
|
buf.write("\u00d6\5\16\b\2\u00d5\u00d3\3\2\2\2\u00d6\u00d9\3\2\2")
|
|
buf.write("\2\u00d7\u00d5\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\r\3\2")
|
|
buf.write("\2\2\u00d9\u00d7\3\2\2\2\u00da\u00dd\5,\27\2\u00db\u00dc")
|
|
buf.write("\7\7\2\2\u00dc\u00de\5D#\2\u00dd\u00db\3\2\2\2\u00dd\u00de")
|
|
buf.write("\3\2\2\2\u00de\17\3\2\2\2\u00df\u00e0\t\2\2\2\u00e0\21")
|
|
buf.write("\3\2\2\2\u00e1\u00fa\7\r\2\2\u00e2\u00fa\7\16\2\2\u00e3")
|
|
buf.write("\u00fa\7\17\2\2\u00e4\u00fa\7\20\2\2\u00e5\u00fa\7\21")
|
|
buf.write("\2\2\u00e6\u00fa\7\22\2\2\u00e7\u00fa\7\23\2\2\u00e8\u00fa")
|
|
buf.write("\7\24\2\2\u00e9\u00fa\7\25\2\2\u00ea\u00eb\5\26\f\2\u00eb")
|
|
buf.write("\u00ec\b\n\1\2\u00ec\u00fa\3\2\2\2\u00ed\u00ee\5$\23\2")
|
|
buf.write("\u00ee\u00ef\b\n\1\2\u00ef\u00fa\3\2\2\2\u00f0\u00f4\7")
|
|
buf.write("_\2\2\u00f1\u00f3\5*\26\2\u00f2\u00f1\3\2\2\2\u00f3\u00f6")
|
|
buf.write("\3\2\2\2\u00f4\u00f2\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5")
|
|
buf.write("\u00f7\3\2\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00fa\5,\27\2")
|
|
buf.write("\u00f8\u00fa\5\24\13\2\u00f9\u00e1\3\2\2\2\u00f9\u00e2")
|
|
buf.write("\3\2\2\2\u00f9\u00e3\3\2\2\2\u00f9\u00e4\3\2\2\2\u00f9")
|
|
buf.write("\u00e5\3\2\2\2\u00f9\u00e6\3\2\2\2\u00f9\u00e7\3\2\2\2")
|
|
buf.write("\u00f9\u00e8\3\2\2\2\u00f9\u00e9\3\2\2\2\u00f9\u00ea\3")
|
|
buf.write("\2\2\2\u00f9\u00ed\3\2\2\2\u00f9\u00f0\3\2\2\2\u00f9\u00f8")
|
|
buf.write("\3\2\2\2\u00fa\23\3\2\2\2\u00fb\u00fc\7_\2\2\u00fc\25")
|
|
buf.write("\3\2\2\2\u00fd\u00ff\5\30\r\2\u00fe\u0100\7_\2\2\u00ff")
|
|
buf.write("\u00fe\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101\3\2\2\2")
|
|
buf.write("\u0101\u0102\7\3\2\2\u0102\u0103\5\32\16\2\u0103\u0104")
|
|
buf.write("\7\26\2\2\u0104\u0109\3\2\2\2\u0105\u0106\5\30\r\2\u0106")
|
|
buf.write("\u0107\7_\2\2\u0107\u0109\3\2\2\2\u0108\u00fd\3\2\2\2")
|
|
buf.write("\u0108\u0105\3\2\2\2\u0109\27\3\2\2\2\u010a\u010b\t\3")
|
|
buf.write("\2\2\u010b\31\3\2\2\2\u010c\u010e\5\34\17\2\u010d\u010c")
|
|
buf.write("\3\2\2\2\u010e\u010f\3\2\2\2\u010f\u010d\3\2\2\2\u010f")
|
|
buf.write("\u0110\3\2\2\2\u0110\33\3\2\2\2\u0111\u0112\5\36\20\2")
|
|
buf.write("\u0112\u0113\5 \21\2\u0113\u0114\7\4\2\2\u0114\35\3\2")
|
|
buf.write("\2\2\u0115\u0118\5*\26\2\u0116\u0118\5\22\n\2\u0117\u0115")
|
|
buf.write("\3\2\2\2\u0117\u0116\3\2\2\2\u0118\u0119\3\2\2\2\u0119")
|
|
buf.write("\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a\37\3\2\2\2\u011b")
|
|
buf.write("\u0120\5\"\22\2\u011c\u011d\7\6\2\2\u011d\u011f\5\"\22")
|
|
buf.write("\2\u011e\u011c\3\2\2\2\u011f\u0122\3\2\2\2\u0120\u011e")
|
|
buf.write("\3\2\2\2\u0120\u0121\3\2\2\2\u0121!\3\2\2\2\u0122\u0120")
|
|
buf.write("\3\2\2\2\u0123\u0126\5,\27\2\u0124\u0125\7\31\2\2\u0125")
|
|
buf.write("\u0127\5^\60\2\u0126\u0124\3\2\2\2\u0126\u0127\3\2\2\2")
|
|
buf.write("\u0127\u012b\3\2\2\2\u0128\u0129\7\31\2\2\u0129\u012b")
|
|
buf.write("\5^\60\2\u012a\u0123\3\2\2\2\u012a\u0128\3\2\2\2\u012b")
|
|
buf.write("#\3\2\2\2\u012c\u012d\7\32\2\2\u012d\u012e\7\3\2\2\u012e")
|
|
buf.write("\u0130\5&\24\2\u012f\u0131\7\6\2\2\u0130\u012f\3\2\2\2")
|
|
buf.write("\u0130\u0131\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0133\7")
|
|
buf.write("\26\2\2\u0133\u0140\3\2\2\2\u0134\u0135\7\32\2\2\u0135")
|
|
buf.write("\u0136\7_\2\2\u0136\u0137\7\3\2\2\u0137\u0139\5&\24\2")
|
|
buf.write("\u0138\u013a\7\6\2\2\u0139\u0138\3\2\2\2\u0139\u013a\3")
|
|
buf.write("\2\2\2\u013a\u013b\3\2\2\2\u013b\u013c\7\26\2\2\u013c")
|
|
buf.write("\u0140\3\2\2\2\u013d\u013e\7\32\2\2\u013e\u0140\7_\2\2")
|
|
buf.write("\u013f\u012c\3\2\2\2\u013f\u0134\3\2\2\2\u013f\u013d\3")
|
|
buf.write("\2\2\2\u0140%\3\2\2\2\u0141\u0146\5(\25\2\u0142\u0143")
|
|
buf.write("\7\6\2\2\u0143\u0145\5(\25\2\u0144\u0142\3\2\2\2\u0145")
|
|
buf.write("\u0148\3\2\2\2\u0146\u0144\3\2\2\2\u0146\u0147\3\2\2\2")
|
|
buf.write("\u0147\'\3\2\2\2\u0148\u0146\3\2\2\2\u0149\u014c\7_\2")
|
|
buf.write("\2\u014a\u014b\7\7\2\2\u014b\u014d\5^\60\2\u014c\u014a")
|
|
buf.write("\3\2\2\2\u014c\u014d\3\2\2\2\u014d)\3\2\2\2\u014e\u014f")
|
|
buf.write("\t\4\2\2\u014f+\3\2\2\2\u0150\u0152\5\62\32\2\u0151\u0150")
|
|
buf.write("\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0154\3\2\2\2\u0153")
|
|
buf.write("\u0155\7$\2\2\u0154\u0153\3\2\2\2\u0154\u0155\3\2\2\2")
|
|
buf.write("\u0155\u0157\3\2\2\2\u0156\u0158\7%\2\2\u0157\u0156\3")
|
|
buf.write("\2\2\2\u0157\u0158\3\2\2\2\u0158\u015a\3\2\2\2\u0159\u015b")
|
|
buf.write("\7&\2\2\u015a\u0159\3\2\2\2\u015a\u015b\3\2\2\2\u015b")
|
|
buf.write("\u015c\3\2\2\2\u015c\u015f\5.\30\2\u015d\u015f\5\62\32")
|
|
buf.write("\2\u015e\u0151\3\2\2\2\u015e\u015d\3\2\2\2\u015f-\3\2")
|
|
buf.write("\2\2\u0160\u0164\7_\2\2\u0161\u0163\5\60\31\2\u0162\u0161")
|
|
buf.write("\3\2\2\2\u0163\u0166\3\2\2\2\u0164\u0162\3\2\2\2\u0164")
|
|
buf.write("\u0165\3\2\2\2\u0165\u0173\3\2\2\2\u0166\u0164\3\2\2\2")
|
|
buf.write("\u0167\u0169\7(\2\2\u0168\u016a\7$\2\2\u0169\u0168\3\2")
|
|
buf.write("\2\2\u0169\u016a\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u016c")
|
|
buf.write("\5,\27\2\u016c\u016e\7)\2\2\u016d\u016f\5\60\31\2\u016e")
|
|
buf.write("\u016d\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u016e\3\2\2\2")
|
|
buf.write("\u0170\u0171\3\2\2\2\u0171\u0173\3\2\2\2\u0172\u0160\3")
|
|
buf.write("\2\2\2\u0172\u0167\3\2\2\2\u0173/\3\2\2\2\u0174\u0175")
|
|
buf.write("\7*\2\2\u0175\u0176\5^\60\2\u0176\u0177\7+\2\2\u0177\u0185")
|
|
buf.write("\3\2\2\2\u0178\u0179\7*\2\2\u0179\u0185\7+\2\2\u017a\u017b")
|
|
buf.write("\7(\2\2\u017b\u017c\5\64\33\2\u017c\u017d\7)\2\2\u017d")
|
|
buf.write("\u0185\3\2\2\2\u017e\u017f\7(\2\2\u017f\u0180\5:\36\2")
|
|
buf.write("\u0180\u0181\7)\2\2\u0181\u0185\3\2\2\2\u0182\u0183\7")
|
|
buf.write("(\2\2\u0183\u0185\7)\2\2\u0184\u0174\3\2\2\2\u0184\u0178")
|
|
buf.write("\3\2\2\2\u0184\u017a\3\2\2\2\u0184\u017e\3\2\2\2\u0184")
|
|
buf.write("\u0182\3\2\2\2\u0185\61\3\2\2\2\u0186\u0188\7,\2\2\u0187")
|
|
buf.write("\u0189\5*\26\2\u0188\u0187\3\2\2\2\u0189\u018a\3\2\2\2")
|
|
buf.write("\u018a\u0188\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018d\3")
|
|
buf.write("\2\2\2\u018c\u018e\5\62\32\2\u018d\u018c\3\2\2\2\u018d")
|
|
buf.write("\u018e\3\2\2\2\u018e\u0193\3\2\2\2\u018f\u0190\7,\2\2")
|
|
buf.write("\u0190\u0193\5\62\32\2\u0191\u0193\7,\2\2\u0192\u0186")
|
|
buf.write("\3\2\2\2\u0192\u018f\3\2\2\2\u0192\u0191\3\2\2\2\u0193")
|
|
buf.write("\63\3\2\2\2\u0194\u019a\5\66\34\2\u0195\u0197\7\6\2\2")
|
|
buf.write("\u0196\u0198\7\37\2\2\u0197\u0196\3\2\2\2\u0197\u0198")
|
|
buf.write("\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019b\7-\2\2\u019a")
|
|
buf.write("\u0195\3\2\2\2\u019a\u019b\3\2\2\2\u019b\65\3\2\2\2\u019c")
|
|
buf.write("\u01a4\58\35\2\u019d\u019f\7\6\2\2\u019e\u01a0\7\37\2")
|
|
buf.write("\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1")
|
|
buf.write("\3\2\2\2\u01a1\u01a3\58\35\2\u01a2\u019d\3\2\2\2\u01a3")
|
|
buf.write("\u01a6\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2")
|
|
buf.write("\u01a5\67\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a7\u01ac\5\b")
|
|
buf.write("\5\2\u01a8\u01ab\5,\27\2\u01a9\u01ab\5> \2\u01aa\u01a8")
|
|
buf.write("\3\2\2\2\u01aa\u01a9\3\2\2\2\u01ab\u01ae\3\2\2\2\u01ac")
|
|
buf.write("\u01aa\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\u01b0\3\2\2\2")
|
|
buf.write("\u01ae\u01ac\3\2\2\2\u01af\u01b1\7\37\2\2\u01b0\u01af")
|
|
buf.write("\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01ba\3\2\2\2\u01b2")
|
|
buf.write("\u01b4\5\62\32\2\u01b3\u01b2\3\2\2\2\u01b4\u01b7\3\2\2")
|
|
buf.write("\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b8")
|
|
buf.write("\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01ba\7_\2\2\u01b9")
|
|
buf.write("\u01a7\3\2\2\2\u01b9\u01b5\3\2\2\2\u01ba9\3\2\2\2\u01bb")
|
|
buf.write("\u01c0\7_\2\2\u01bc\u01bd\7\6\2\2\u01bd\u01bf\7_\2\2\u01be")
|
|
buf.write("\u01bc\3\2\2\2\u01bf\u01c2\3\2\2\2\u01c0\u01be\3\2\2\2")
|
|
buf.write("\u01c0\u01c1\3\2\2\2\u01c1;\3\2\2\2\u01c2\u01c0\3\2\2")
|
|
buf.write("\2\u01c3\u01c5\5\36\20\2\u01c4\u01c6\5> \2\u01c5\u01c4")
|
|
buf.write("\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6\u01c9\3\2\2\2\u01c7")
|
|
buf.write("\u01c9\5\24\13\2\u01c8\u01c3\3\2\2\2\u01c8\u01c7\3\2\2")
|
|
buf.write("\2\u01c9=\3\2\2\2\u01ca\u01cc\5\62\32\2\u01cb\u01cd\5")
|
|
buf.write("@!\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01d0")
|
|
buf.write("\3\2\2\2\u01ce\u01d0\5@!\2\u01cf\u01ca\3\2\2\2\u01cf\u01ce")
|
|
buf.write("\3\2\2\2\u01d0?\3\2\2\2\u01d1\u01d2\7(\2\2\u01d2\u01d3")
|
|
buf.write("\5> \2\u01d3\u01d4\7)\2\2\u01d4\u01d7\3\2\2\2\u01d5\u01d7")
|
|
buf.write("\5B\"\2\u01d6\u01d1\3\2\2\2\u01d6\u01d5\3\2\2\2\u01d7")
|
|
buf.write("\u01db\3\2\2\2\u01d8\u01da\5B\"\2\u01d9\u01d8\3\2\2\2")
|
|
buf.write("\u01da\u01dd\3\2\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3")
|
|
buf.write("\2\2\2\u01dcA\3\2\2\2\u01dd\u01db\3\2\2\2\u01de\u01df")
|
|
buf.write("\7*\2\2\u01df\u01eb\7+\2\2\u01e0\u01e1\7*\2\2\u01e1\u01e2")
|
|
buf.write("\5^\60\2\u01e2\u01e3\7+\2\2\u01e3\u01eb\3\2\2\2\u01e4")
|
|
buf.write("\u01e5\7(\2\2\u01e5\u01eb\7)\2\2\u01e6\u01e7\7(\2\2\u01e7")
|
|
buf.write("\u01e8\5\64\33\2\u01e8\u01e9\7)\2\2\u01e9\u01eb\3\2\2")
|
|
buf.write("\2\u01ea\u01de\3\2\2\2\u01ea\u01e0\3\2\2\2\u01ea\u01e4")
|
|
buf.write("\3\2\2\2\u01ea\u01e6\3\2\2\2\u01ebC\3\2\2\2\u01ec\u01f5")
|
|
buf.write("\5`\61\2\u01ed\u01ee\7\3\2\2\u01ee\u01f0\5F$\2\u01ef\u01f1")
|
|
buf.write("\7\6\2\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1")
|
|
buf.write("\u01f2\3\2\2\2\u01f2\u01f3\7\26\2\2\u01f3\u01f5\3\2\2")
|
|
buf.write("\2\u01f4\u01ec\3\2\2\2\u01f4\u01ed\3\2\2\2\u01f5E\3\2")
|
|
buf.write("\2\2\u01f6\u01fb\5D#\2\u01f7\u01f8\7\6\2\2\u01f8\u01fa")
|
|
buf.write("\5D#\2\u01f9\u01f7\3\2\2\2\u01fa\u01fd\3\2\2\2\u01fb\u01f9")
|
|
buf.write("\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fcG\3\2\2\2\u01fd\u01fb")
|
|
buf.write("\3\2\2\2\u01fe\u0200\5`\61\2\u01ff\u0201\7\37\2\2\u0200")
|
|
buf.write("\u01ff\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0209\3\2\2\2")
|
|
buf.write("\u0202\u0203\7\6\2\2\u0203\u0205\5`\61\2\u0204\u0206\7")
|
|
buf.write("\37\2\2\u0205\u0204\3\2\2\2\u0205\u0206\3\2\2\2\u0206")
|
|
buf.write("\u0208\3\2\2\2\u0207\u0202\3\2\2\2\u0208\u020b\3\2\2\2")
|
|
buf.write("\u0209\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020aI\3\2\2")
|
|
buf.write("\2\u020b\u0209\3\2\2\2\u020c\u0213\5L\'\2\u020d\u020e")
|
|
buf.write("\7.\2\2\u020e\u0212\5L\'\2\u020f\u0210\7/\2\2\u0210\u0212")
|
|
buf.write("\5L\'\2\u0211\u020d\3\2\2\2\u0211\u020f\3\2\2\2\u0212")
|
|
buf.write("\u0215\3\2\2\2\u0213\u0211\3\2\2\2\u0213\u0214\3\2\2\2")
|
|
buf.write("\u0214K\3\2\2\2\u0215\u0213\3\2\2\2\u0216\u021f\5N(\2")
|
|
buf.write("\u0217\u0218\7,\2\2\u0218\u021e\5N(\2\u0219\u021a\7\60")
|
|
buf.write("\2\2\u021a\u021e\5N(\2\u021b\u021c\7\61\2\2\u021c\u021e")
|
|
buf.write("\5N(\2\u021d\u0217\3\2\2\2\u021d\u0219\3\2\2\2\u021d\u021b")
|
|
buf.write("\3\2\2\2\u021e\u0221\3\2\2\2\u021f\u021d\3\2\2\2\u021f")
|
|
buf.write("\u0220\3\2\2\2\u0220M\3\2\2\2\u0221\u021f\3\2\2\2\u0222")
|
|
buf.write("\u0223\7(\2\2\u0223\u0224\5<\37\2\u0224\u0225\7)\2\2\u0225")
|
|
buf.write("\u0226\5N(\2\u0226\u0229\3\2\2\2\u0227\u0229\5P)\2\u0228")
|
|
buf.write("\u0222\3\2\2\2\u0228\u0227\3\2\2\2\u0229O\3\2\2\2\u022a")
|
|
buf.write("\u023a\5R*\2\u022b\u022c\7\62\2\2\u022c\u023a\5P)\2\u022d")
|
|
buf.write("\u022e\7\63\2\2\u022e\u023a\5P)\2\u022f\u0230\5V,\2\u0230")
|
|
buf.write("\u0231\5N(\2\u0231\u023a\3\2\2\2\u0232\u0233\7\64\2\2")
|
|
buf.write("\u0233\u023a\5P)\2\u0234\u0235\7\64\2\2\u0235\u0236\7")
|
|
buf.write("(\2\2\u0236\u0237\5<\37\2\u0237\u0238\7)\2\2\u0238\u023a")
|
|
buf.write("\3\2\2\2\u0239\u022a\3\2\2\2\u0239\u022b\3\2\2\2\u0239")
|
|
buf.write("\u022d\3\2\2\2\u0239\u022f\3\2\2\2\u0239\u0232\3\2\2\2")
|
|
buf.write("\u0239\u0234\3\2\2\2\u023aQ\3\2\2\2\u023b\u023c\5X-\2")
|
|
buf.write("\u023c\u025a\b*\1\2\u023d\u023e\7*\2\2\u023e\u023f\5\\")
|
|
buf.write("/\2\u023f\u0240\7+\2\2\u0240\u0259\3\2\2\2\u0241\u0242")
|
|
buf.write("\7(\2\2\u0242\u0243\7)\2\2\u0243\u0259\b*\1\2\u0244\u0245")
|
|
buf.write("\7(\2\2\u0245\u0246\5H%\2\u0246\u0247\7)\2\2\u0247\u0248")
|
|
buf.write("\b*\1\2\u0248\u0259\3\2\2\2\u0249\u024a\7(\2\2\u024a\u024b")
|
|
buf.write("\5T+\2\u024b\u024c\7)\2\2\u024c\u0259\3\2\2\2\u024d\u024e")
|
|
buf.write("\7\65\2\2\u024e\u024f\7_\2\2\u024f\u0259\b*\1\2\u0250")
|
|
buf.write("\u0251\7,\2\2\u0251\u0252\7_\2\2\u0252\u0259\b*\1\2\u0253")
|
|
buf.write("\u0254\7\66\2\2\u0254\u0255\7_\2\2\u0255\u0259\b*\1\2")
|
|
buf.write("\u0256\u0259\7\62\2\2\u0257\u0259\7\63\2\2\u0258\u023d")
|
|
buf.write("\3\2\2\2\u0258\u0241\3\2\2\2\u0258\u0244\3\2\2\2\u0258")
|
|
buf.write("\u0249\3\2\2\2\u0258\u024d\3\2\2\2\u0258\u0250\3\2\2\2")
|
|
buf.write("\u0258\u0253\3\2\2\2\u0258\u0256\3\2\2\2\u0258\u0257\3")
|
|
buf.write("\2\2\2\u0259\u025c\3\2\2\2\u025a\u0258\3\2\2\2\u025a\u025b")
|
|
buf.write("\3\2\2\2\u025bS\3\2\2\2\u025c\u025a\3\2\2\2\u025d\u0262")
|
|
buf.write("\58\35\2\u025e\u025f\7\6\2\2\u025f\u0261\58\35\2\u0260")
|
|
buf.write("\u025e\3\2\2\2\u0261\u0264\3\2\2\2\u0262\u0260\3\2\2\2")
|
|
buf.write("\u0262\u0263\3\2\2\2\u0263U\3\2\2\2\u0264\u0262\3\2\2")
|
|
buf.write("\2\u0265\u0266\t\5\2\2\u0266W\3\2\2\2\u0267\u026e\7_\2")
|
|
buf.write("\2\u0268\u026e\5Z.\2\u0269\u026a\7(\2\2\u026a\u026b\5")
|
|
buf.write("\\/\2\u026b\u026c\7)\2\2\u026c\u026e\3\2\2\2\u026d\u0267")
|
|
buf.write("\3\2\2\2\u026d\u0268\3\2\2\2\u026d\u0269\3\2\2\2\u026e")
|
|
buf.write("Y\3\2\2\2\u026f\u028a\7b\2\2\u0270\u028a\7d\2\2\u0271")
|
|
buf.write("\u028a\7c\2\2\u0272\u028a\7`\2\2\u0273\u0275\7_\2\2\u0274")
|
|
buf.write("\u0273\3\2\2\2\u0275\u0278\3\2\2\2\u0276\u0274\3\2\2\2")
|
|
buf.write("\u0276\u0277\3\2\2\2\u0277\u027a\3\2\2\2\u0278\u0276\3")
|
|
buf.write("\2\2\2\u0279\u027b\7a\2\2\u027a\u0279\3\2\2\2\u027b\u027c")
|
|
buf.write("\3\2\2\2\u027c\u027a\3\2\2\2\u027c\u027d\3\2\2\2\u027d")
|
|
buf.write("\u027f\3\2\2\2\u027e\u0276\3\2\2\2\u027f\u0280\3\2\2\2")
|
|
buf.write("\u0280\u027e\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0285\3")
|
|
buf.write("\2\2\2\u0282\u0284\7_\2\2\u0283\u0282\3\2\2\2\u0284\u0287")
|
|
buf.write("\3\2\2\2\u0285\u0283\3\2\2\2\u0285\u0286\3\2\2\2\u0286")
|
|
buf.write("\u028a\3\2\2\2\u0287\u0285\3\2\2\2\u0288\u028a\7e\2\2")
|
|
buf.write("\u0289\u026f\3\2\2\2\u0289\u0270\3\2\2\2\u0289\u0271\3")
|
|
buf.write("\2\2\2\u0289\u0272\3\2\2\2\u0289\u027e\3\2\2\2\u0289\u0288")
|
|
buf.write("\3\2\2\2\u028a[\3\2\2\2\u028b\u0290\5`\61\2\u028c\u028d")
|
|
buf.write("\7\6\2\2\u028d\u028f\5`\61\2\u028e\u028c\3\2\2\2\u028f")
|
|
buf.write("\u0292\3\2\2\2\u0290\u028e\3\2\2\2\u0290\u0291\3\2\2\2")
|
|
buf.write("\u0291]\3\2\2\2\u0292\u0290\3\2\2\2\u0293\u0294\5f\64")
|
|
buf.write("\2\u0294_\3\2\2\2\u0295\u0296\5b\62\2\u0296\u0297\5d\63")
|
|
buf.write("\2\u0297\u0298\5`\61\2\u0298\u029b\3\2\2\2\u0299\u029b")
|
|
buf.write("\5f\64\2\u029a\u0295\3\2\2\2\u029a\u0299\3\2\2\2\u029b")
|
|
buf.write("a\3\2\2\2\u029c\u029d\5P)\2\u029dc\3\2\2\2\u029e\u029f")
|
|
buf.write("\t\6\2\2\u029fe\3\2\2\2\u02a0\u02a7\5h\65\2\u02a1\u02a2")
|
|
buf.write("\7D\2\2\u02a2\u02a3\5\\/\2\u02a3\u02a4\7\31\2\2\u02a4")
|
|
buf.write("\u02a5\5f\64\2\u02a5\u02a6\b\64\1\2\u02a6\u02a8\3\2\2")
|
|
buf.write("\2\u02a7\u02a1\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8g\3\2")
|
|
buf.write("\2\2\u02a9\u02ae\5j\66\2\u02aa\u02ab\7E\2\2\u02ab\u02ad")
|
|
buf.write("\5j\66\2\u02ac\u02aa\3\2\2\2\u02ad\u02b0\3\2\2\2\u02ae")
|
|
buf.write("\u02ac\3\2\2\2\u02ae\u02af\3\2\2\2\u02afi\3\2\2\2\u02b0")
|
|
buf.write("\u02ae\3\2\2\2\u02b1\u02b6\5l\67\2\u02b2\u02b3\7F\2\2")
|
|
buf.write("\u02b3\u02b5\5l\67\2\u02b4\u02b2\3\2\2\2\u02b5\u02b8\3")
|
|
buf.write("\2\2\2\u02b6\u02b4\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7k")
|
|
buf.write("\3\2\2\2\u02b8\u02b6\3\2\2\2\u02b9\u02be\5n8\2\u02ba\u02bb")
|
|
buf.write("\7G\2\2\u02bb\u02bd\5n8\2\u02bc\u02ba\3\2\2\2\u02bd\u02c0")
|
|
buf.write("\3\2\2\2\u02be\u02bc\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf")
|
|
buf.write("m\3\2\2\2\u02c0\u02be\3\2\2\2\u02c1\u02c6\5p9\2\u02c2")
|
|
buf.write("\u02c3\7H\2\2\u02c3\u02c5\5p9\2\u02c4\u02c2\3\2\2\2\u02c5")
|
|
buf.write("\u02c8\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c6\u02c7\3\2\2\2")
|
|
buf.write("\u02c7o\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c9\u02ce\5r:\2")
|
|
buf.write("\u02ca\u02cb\7\67\2\2\u02cb\u02cd\5r:\2\u02cc\u02ca\3")
|
|
buf.write("\2\2\2\u02cd\u02d0\3\2\2\2\u02ce\u02cc\3\2\2\2\u02ce\u02cf")
|
|
buf.write("\3\2\2\2\u02cfq\3\2\2\2\u02d0\u02ce\3\2\2\2\u02d1\u02d6")
|
|
buf.write("\5t;\2\u02d2\u02d3\t\7\2\2\u02d3\u02d5\5t;\2\u02d4\u02d2")
|
|
buf.write("\3\2\2\2\u02d5\u02d8\3\2\2\2\u02d6\u02d4\3\2\2\2\u02d6")
|
|
buf.write("\u02d7\3\2\2\2\u02d7s\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d9")
|
|
buf.write("\u02de\5v<\2\u02da\u02db\t\b\2\2\u02db\u02dd\5v<\2\u02dc")
|
|
buf.write("\u02da\3\2\2\2\u02dd\u02e0\3\2\2\2\u02de\u02dc\3\2\2\2")
|
|
buf.write("\u02de\u02df\3\2\2\2\u02dfu\3\2\2\2\u02e0\u02de\3\2\2")
|
|
buf.write("\2\u02e1\u02e6\5J&\2\u02e2\u02e3\t\t\2\2\u02e3\u02e5\5")
|
|
buf.write("J&\2\u02e4\u02e2\3\2\2\2\u02e5\u02e8\3\2\2\2\u02e6\u02e4")
|
|
buf.write("\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7w\3\2\2\2\u02e8\u02e6")
|
|
buf.write("\3\2\2\2\u02e9\u02f5\5\u0082B\2\u02ea\u02f5\5\u0084C\2")
|
|
buf.write("\u02eb\u02f5\5\u0088E\2\u02ec\u02f5\5\u008aF\2\u02ed\u02f5")
|
|
buf.write("\5\u008cG\2\u02ee\u02f5\5\u008eH\2\u02ef\u02f5\5\u0080")
|
|
buf.write("A\2\u02f0\u02f5\5z>\2\u02f1\u02f5\5|?\2\u02f2\u02f5\5")
|
|
buf.write("~@\2\u02f3\u02f5\5\n\6\2\u02f4\u02e9\3\2\2\2\u02f4\u02ea")
|
|
buf.write("\3\2\2\2\u02f4\u02eb\3\2\2\2\u02f4\u02ec\3\2\2\2\u02f4")
|
|
buf.write("\u02ed\3\2\2\2\u02f4\u02ee\3\2\2\2\u02f4\u02ef\3\2\2\2")
|
|
buf.write("\u02f4\u02f0\3\2\2\2\u02f4\u02f1\3\2\2\2\u02f4\u02f2\3")
|
|
buf.write("\2\2\2\u02f4\u02f3\3\2\2\2\u02f5y\3\2\2\2\u02f6\u02f8")
|
|
buf.write("\7Q\2\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8")
|
|
buf.write("\u02f9\3\2\2\2\u02f9\u02fa\7_\2\2\u02fa\u02fe\7(\2\2\u02fb")
|
|
buf.write("\u02fd\n\n\2\2\u02fc\u02fb\3\2\2\2\u02fd\u0300\3\2\2\2")
|
|
buf.write("\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0301\3")
|
|
buf.write("\2\2\2\u0300\u02fe\3\2\2\2\u0301\u0302\7)\2\2\u0302\u0303")
|
|
buf.write("\7\4\2\2\u0303{\3\2\2\2\u0304\u0305\7R\2\2\u0305\u0309")
|
|
buf.write("\7\3\2\2\u0306\u0308\n\13\2\2\u0307\u0306\3\2\2\2\u0308")
|
|
buf.write("\u030b\3\2\2\2\u0309\u0307\3\2\2\2\u0309\u030a\3\2\2\2")
|
|
buf.write("\u030a\u030c\3\2\2\2\u030b\u0309\3\2\2\2\u030c\u030d\7")
|
|
buf.write("\26\2\2\u030d}\3\2\2\2\u030e\u030f\7S\2\2\u030f\u0313")
|
|
buf.write("\7\3\2\2\u0310\u0312\n\13\2\2\u0311\u0310\3\2\2\2\u0312")
|
|
buf.write("\u0315\3\2\2\2\u0313\u0311\3\2\2\2\u0313\u0314\3\2\2\2")
|
|
buf.write("\u0314\u0316\3\2\2\2\u0315\u0313\3\2\2\2\u0316\u0317\7")
|
|
buf.write("\26\2\2\u0317\177\3\2\2\2\u0318\u0319\7_\2\2\u0319\u031d")
|
|
buf.write("\7(\2\2\u031a\u031c\5\n\6\2\u031b\u031a\3\2\2\2\u031c")
|
|
buf.write("\u031f\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031e\3\2\2\2")
|
|
buf.write("\u031e\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u0320\u0322\5")
|
|
buf.write("\u0086D\2\u0321\u0320\3\2\2\2\u0321\u0322\3\2\2\2\u0322")
|
|
buf.write("\u0324\3\2\2\2\u0323\u0325\5\\/\2\u0324\u0323\3\2\2\2")
|
|
buf.write("\u0324\u0325\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u0327\7")
|
|
buf.write(")\2\2\u0327\u0081\3\2\2\2\u0328\u0329\7_\2\2\u0329\u032a")
|
|
buf.write("\7\31\2\2\u032a\u0334\5x=\2\u032b\u032c\7T\2\2\u032c\u032d")
|
|
buf.write("\5^\60\2\u032d\u032e\7\31\2\2\u032e\u032f\5x=\2\u032f")
|
|
buf.write("\u0334\3\2\2\2\u0330\u0331\7U\2\2\u0331\u0332\7\31\2\2")
|
|
buf.write("\u0332\u0334\5x=\2\u0333\u0328\3\2\2\2\u0333\u032b\3\2")
|
|
buf.write("\2\2\u0333\u0330\3\2\2\2\u0334\u0083\3\2\2\2\u0335\u0339")
|
|
buf.write("\7\3\2\2\u0336\u0338\5\n\6\2\u0337\u0336\3\2\2\2\u0338")
|
|
buf.write("\u033b\3\2\2\2\u0339\u0337\3\2\2\2\u0339\u033a\3\2\2\2")
|
|
buf.write("\u033a\u033d\3\2\2\2\u033b\u0339\3\2\2\2\u033c\u033e\5")
|
|
buf.write("\u0086D\2\u033d\u033c\3\2\2\2\u033d\u033e\3\2\2\2\u033e")
|
|
buf.write("\u033f\3\2\2\2\u033f\u0340\7\26\2\2\u0340\u0085\3\2\2")
|
|
buf.write("\2\u0341\u0343\5x=\2\u0342\u0341\3\2\2\2\u0343\u0344\3")
|
|
buf.write("\2\2\2\u0344\u0342\3\2\2\2\u0344\u0345\3\2\2\2\u0345\u0087")
|
|
buf.write("\3\2\2\2\u0346\u034b\7\4\2\2\u0347\u0348\5\\/\2\u0348")
|
|
buf.write("\u0349\7\4\2\2\u0349\u034b\3\2\2\2\u034a\u0346\3\2\2\2")
|
|
buf.write("\u034a\u0347\3\2\2\2\u034b\u0089\3\2\2\2\u034c\u034d\7")
|
|
buf.write("V\2\2\u034d\u034e\7(\2\2\u034e\u034f\5\\/\2\u034f\u0350")
|
|
buf.write("\7)\2\2\u0350\u0351\bF\1\2\u0351\u0354\5x=\2\u0352\u0353")
|
|
buf.write("\7W\2\2\u0353\u0355\5x=\2\u0354\u0352\3\2\2\2\u0354\u0355")
|
|
buf.write("\3\2\2\2\u0355\u035d\3\2\2\2\u0356\u0357\7X\2\2\u0357")
|
|
buf.write("\u0358\7(\2\2\u0358\u0359\5\\/\2\u0359\u035a\7)\2\2\u035a")
|
|
buf.write("\u035b\5x=\2\u035b\u035d\3\2\2\2\u035c\u034c\3\2\2\2\u035c")
|
|
buf.write("\u0356\3\2\2\2\u035d\u008b\3\2\2\2\u035e\u035f\7Y\2\2")
|
|
buf.write("\u035f\u0360\7(\2\2\u0360\u0361\5\\/\2\u0361\u0362\7)")
|
|
buf.write("\2\2\u0362\u0363\5x=\2\u0363\u0364\bG\1\2\u0364\u036f")
|
|
buf.write("\3\2\2\2\u0365\u0366\7Z\2\2\u0366\u0367\5x=\2\u0367\u0368")
|
|
buf.write("\7Y\2\2\u0368\u0369\7(\2\2\u0369\u036a\5\\/\2\u036a\u036b")
|
|
buf.write("\7)\2\2\u036b\u036c\7\4\2\2\u036c\u036d\bG\1\2\u036d\u036f")
|
|
buf.write("\3\2\2\2\u036e\u035e\3\2\2\2\u036e\u0365\3\2\2\2\u036f")
|
|
buf.write("\u008d\3\2\2\2\u0370\u0371\7[\2\2\u0371\u0372\7_\2\2\u0372")
|
|
buf.write("\u037e\7\4\2\2\u0373\u0374\7\\\2\2\u0374\u037e\7\4\2\2")
|
|
buf.write("\u0375\u0376\7]\2\2\u0376\u037e\7\4\2\2\u0377\u0378\7")
|
|
buf.write("^\2\2\u0378\u037e\7\4\2\2\u0379\u037a\7^\2\2\u037a\u037b")
|
|
buf.write("\5\\/\2\u037b\u037c\7\4\2\2\u037c\u037e\3\2\2\2\u037d")
|
|
buf.write("\u0370\3\2\2\2\u037d\u0373\3\2\2\2\u037d\u0375\3\2\2\2")
|
|
buf.write("\u037d\u0377\3\2\2\2\u037d\u0379\3\2\2\2\u037e\u008f\3")
|
|
buf.write("\2\2\2o\u0093\u0097\u009d\u00a6\u00a8\u00ab\u00b1\u00b6")
|
|
buf.write("\u00bd\u00bf\u00c3\u00cb\u00d0\u00d7\u00dd\u00f4\u00f9")
|
|
buf.write("\u00ff\u0108\u010f\u0117\u0119\u0120\u0126\u012a\u0130")
|
|
buf.write("\u0139\u013f\u0146\u014c\u0151\u0154\u0157\u015a\u015e")
|
|
buf.write("\u0164\u0169\u0170\u0172\u0184\u018a\u018d\u0192\u0197")
|
|
buf.write("\u019a\u019f\u01a4\u01aa\u01ac\u01b0\u01b5\u01b9\u01c0")
|
|
buf.write("\u01c5\u01c8\u01cc\u01cf\u01d6\u01db\u01ea\u01f0\u01f4")
|
|
buf.write("\u01fb\u0200\u0205\u0209\u0211\u0213\u021d\u021f\u0228")
|
|
buf.write("\u0239\u0258\u025a\u0262\u026d\u0276\u027c\u0280\u0285")
|
|
buf.write("\u0289\u0290\u029a\u02a7\u02ae\u02b6\u02be\u02c6\u02ce")
|
|
buf.write("\u02d6\u02de\u02e6\u02f4\u02f7\u02fe\u0309\u0313\u031d")
|
|
buf.write("\u0321\u0324\u0333\u0339\u033d\u0344\u034a\u0354\u035c")
|
|
buf.write("\u036e\u037d")
|
|
return buf.getvalue()
|
|
|
|
|
|
class CParser ( Parser ):
|
|
|
|
grammarFileName = "C.g4"
|
|
|
|
atn = ATNDeserializer().deserialize(serializedATN())
|
|
|
|
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
|
|
|
|
sharedContextCache = PredictionContextCache()
|
|
|
|
literalNames = [ "<INVALID>", "'{'", "';'", "'typedef'", "','", "'='",
|
|
"'extern'", "'static'", "'auto'", "'register'", "'STATIC'",
|
|
"'void'", "'char'", "'short'", "'int'", "'long'", "'float'",
|
|
"'double'", "'signed'", "'unsigned'", "'}'", "'struct'",
|
|
"'union'", "':'", "'enum'", "'const'", "'volatile'",
|
|
"'IN'", "'OUT'", "'OPTIONAL'", "'CONST'", "'UNALIGNED'",
|
|
"'VOLATILE'", "'GLOBAL_REMOVE_IF_UNREFERENCED'", "'EFIAPI'",
|
|
"'EFI_BOOTSERVICE'", "'EFI_RUNTIMESERVICE'", "'PACKED'",
|
|
"'('", "')'", "'['", "']'", "'*'", "'...'", "'+'",
|
|
"'-'", "'/'", "'%'", "'++'", "'--'", "'sizeof'", "'.'",
|
|
"'->'", "'&'", "'~'", "'!'", "'*='", "'/='", "'%='",
|
|
"'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", "'|='",
|
|
"'?'", "'||'", "'&&'", "'|'", "'^'", "'=='", "'!='",
|
|
"'<'", "'>'", "'<='", "'>='", "'<<'", "'>>'", "'__asm__'",
|
|
"'_asm'", "'__asm'", "'case'", "'default'", "'if'",
|
|
"'else'", "'switch'", "'while'", "'do'", "'goto'",
|
|
"'continue'", "'break'", "'return'" ]
|
|
|
|
symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "IDENTIFIER", "CHARACTER_LITERAL", "STRING_LITERAL",
|
|
"HEX_LITERAL", "DECIMAL_LITERAL", "OCTAL_LITERAL",
|
|
"FLOATING_POINT_LITERAL", "WS", "BS", "UnicodeVocabulary",
|
|
"COMMENT", "LINE_COMMENT", "LINE_COMMAND" ]
|
|
|
|
RULE_translation_unit = 0
|
|
RULE_external_declaration = 1
|
|
RULE_function_definition = 2
|
|
RULE_declaration_specifiers = 3
|
|
RULE_declaration = 4
|
|
RULE_init_declarator_list = 5
|
|
RULE_init_declarator = 6
|
|
RULE_storage_class_specifier = 7
|
|
RULE_type_specifier = 8
|
|
RULE_type_id = 9
|
|
RULE_struct_or_union_specifier = 10
|
|
RULE_struct_or_union = 11
|
|
RULE_struct_declaration_list = 12
|
|
RULE_struct_declaration = 13
|
|
RULE_specifier_qualifier_list = 14
|
|
RULE_struct_declarator_list = 15
|
|
RULE_struct_declarator = 16
|
|
RULE_enum_specifier = 17
|
|
RULE_enumerator_list = 18
|
|
RULE_enumerator = 19
|
|
RULE_type_qualifier = 20
|
|
RULE_declarator = 21
|
|
RULE_direct_declarator = 22
|
|
RULE_declarator_suffix = 23
|
|
RULE_pointer = 24
|
|
RULE_parameter_type_list = 25
|
|
RULE_parameter_list = 26
|
|
RULE_parameter_declaration = 27
|
|
RULE_identifier_list = 28
|
|
RULE_type_name = 29
|
|
RULE_abstract_declarator = 30
|
|
RULE_direct_abstract_declarator = 31
|
|
RULE_abstract_declarator_suffix = 32
|
|
RULE_initializer = 33
|
|
RULE_initializer_list = 34
|
|
RULE_argument_expression_list = 35
|
|
RULE_additive_expression = 36
|
|
RULE_multiplicative_expression = 37
|
|
RULE_cast_expression = 38
|
|
RULE_unary_expression = 39
|
|
RULE_postfix_expression = 40
|
|
RULE_macro_parameter_list = 41
|
|
RULE_unary_operator = 42
|
|
RULE_primary_expression = 43
|
|
RULE_constant = 44
|
|
RULE_expression = 45
|
|
RULE_constant_expression = 46
|
|
RULE_assignment_expression = 47
|
|
RULE_lvalue = 48
|
|
RULE_assignment_operator = 49
|
|
RULE_conditional_expression = 50
|
|
RULE_logical_or_expression = 51
|
|
RULE_logical_and_expression = 52
|
|
RULE_inclusive_or_expression = 53
|
|
RULE_exclusive_or_expression = 54
|
|
RULE_and_expression = 55
|
|
RULE_equality_expression = 56
|
|
RULE_relational_expression = 57
|
|
RULE_shift_expression = 58
|
|
RULE_statement = 59
|
|
RULE_asm2_statement = 60
|
|
RULE_asm1_statement = 61
|
|
RULE_asm_statement = 62
|
|
RULE_macro_statement = 63
|
|
RULE_labeled_statement = 64
|
|
RULE_compound_statement = 65
|
|
RULE_statement_list = 66
|
|
RULE_expression_statement = 67
|
|
RULE_selection_statement = 68
|
|
RULE_iteration_statement = 69
|
|
RULE_jump_statement = 70
|
|
|
|
ruleNames = [ "translation_unit", "external_declaration", "function_definition",
|
|
"declaration_specifiers", "declaration", "init_declarator_list",
|
|
"init_declarator", "storage_class_specifier", "type_specifier",
|
|
"type_id", "struct_or_union_specifier", "struct_or_union",
|
|
"struct_declaration_list", "struct_declaration", "specifier_qualifier_list",
|
|
"struct_declarator_list", "struct_declarator", "enum_specifier",
|
|
"enumerator_list", "enumerator", "type_qualifier", "declarator",
|
|
"direct_declarator", "declarator_suffix", "pointer",
|
|
"parameter_type_list", "parameter_list", "parameter_declaration",
|
|
"identifier_list", "type_name", "abstract_declarator",
|
|
"direct_abstract_declarator", "abstract_declarator_suffix",
|
|
"initializer", "initializer_list", "argument_expression_list",
|
|
"additive_expression", "multiplicative_expression", "cast_expression",
|
|
"unary_expression", "postfix_expression", "macro_parameter_list",
|
|
"unary_operator", "primary_expression", "constant", "expression",
|
|
"constant_expression", "assignment_expression", "lvalue",
|
|
"assignment_operator", "conditional_expression", "logical_or_expression",
|
|
"logical_and_expression", "inclusive_or_expression",
|
|
"exclusive_or_expression", "and_expression", "equality_expression",
|
|
"relational_expression", "shift_expression", "statement",
|
|
"asm2_statement", "asm1_statement", "asm_statement",
|
|
"macro_statement", "labeled_statement", "compound_statement",
|
|
"statement_list", "expression_statement", "selection_statement",
|
|
"iteration_statement", "jump_statement" ]
|
|
|
|
EOF = Token.EOF
|
|
T__0=1
|
|
T__1=2
|
|
T__2=3
|
|
T__3=4
|
|
T__4=5
|
|
T__5=6
|
|
T__6=7
|
|
T__7=8
|
|
T__8=9
|
|
T__9=10
|
|
T__10=11
|
|
T__11=12
|
|
T__12=13
|
|
T__13=14
|
|
T__14=15
|
|
T__15=16
|
|
T__16=17
|
|
T__17=18
|
|
T__18=19
|
|
T__19=20
|
|
T__20=21
|
|
T__21=22
|
|
T__22=23
|
|
T__23=24
|
|
T__24=25
|
|
T__25=26
|
|
T__26=27
|
|
T__27=28
|
|
T__28=29
|
|
T__29=30
|
|
T__30=31
|
|
T__31=32
|
|
T__32=33
|
|
T__33=34
|
|
T__34=35
|
|
T__35=36
|
|
T__36=37
|
|
T__37=38
|
|
T__38=39
|
|
T__39=40
|
|
T__40=41
|
|
T__41=42
|
|
T__42=43
|
|
T__43=44
|
|
T__44=45
|
|
T__45=46
|
|
T__46=47
|
|
T__47=48
|
|
T__48=49
|
|
T__49=50
|
|
T__50=51
|
|
T__51=52
|
|
T__52=53
|
|
T__53=54
|
|
T__54=55
|
|
T__55=56
|
|
T__56=57
|
|
T__57=58
|
|
T__58=59
|
|
T__59=60
|
|
T__60=61
|
|
T__61=62
|
|
T__62=63
|
|
T__63=64
|
|
T__64=65
|
|
T__65=66
|
|
T__66=67
|
|
T__67=68
|
|
T__68=69
|
|
T__69=70
|
|
T__70=71
|
|
T__71=72
|
|
T__72=73
|
|
T__73=74
|
|
T__74=75
|
|
T__75=76
|
|
T__76=77
|
|
T__77=78
|
|
T__78=79
|
|
T__79=80
|
|
T__80=81
|
|
T__81=82
|
|
T__82=83
|
|
T__83=84
|
|
T__84=85
|
|
T__85=86
|
|
T__86=87
|
|
T__87=88
|
|
T__88=89
|
|
T__89=90
|
|
T__90=91
|
|
T__91=92
|
|
IDENTIFIER=93
|
|
CHARACTER_LITERAL=94
|
|
STRING_LITERAL=95
|
|
HEX_LITERAL=96
|
|
DECIMAL_LITERAL=97
|
|
OCTAL_LITERAL=98
|
|
FLOATING_POINT_LITERAL=99
|
|
WS=100
|
|
BS=101
|
|
UnicodeVocabulary=102
|
|
COMMENT=103
|
|
LINE_COMMENT=104
|
|
LINE_COMMAND=105
|
|
|
|
# @param input Type: TokenStream
|
|
# @param output= sys.stdout Type: TextIO
|
|
def __init__(self,input,output= sys.stdout):
|
|
super().__init__(input, output)
|
|
self.checkVersion("4.7.1")
|
|
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
|
|
self._predicates = None
|
|
|
|
|
|
|
|
|
|
def printTokenInfo(self,line,offset,tokenText):
|
|
print(str(line)+ ',' + str(offset) + ':' + str(tokenText))
|
|
|
|
def StorePredicateExpression(self,StartLine,StartOffset,EndLine,EndOffset,Text):
|
|
PredExp = CodeFragment.PredicateExpression(Text, (StartLine, StartOffset), (EndLine, EndOffset))
|
|
FileProfile.PredicateExpressionList.append(PredExp)
|
|
|
|
def StoreEnumerationDefinition(self,StartLine,StartOffset,EndLine,EndOffset,Text):
|
|
EnumDef = CodeFragment.EnumerationDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset))
|
|
FileProfile.EnumerationDefinitionList.append(EnumDef)
|
|
|
|
def StoreStructUnionDefinition(self,StartLine,StartOffset,EndLine,EndOffset,Text):
|
|
SUDef = CodeFragment.StructUnionDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset))
|
|
FileProfile.StructUnionDefinitionList.append(SUDef)
|
|
|
|
def StoreTypedefDefinition(self,StartLine,StartOffset,EndLine,EndOffset,FromText,ToText):
|
|
Tdef = CodeFragment.TypedefDefinition(FromText, ToText, (StartLine, StartOffset), (EndLine, EndOffset))
|
|
FileProfile.TypedefDefinitionList.append(Tdef)
|
|
|
|
def StoreFunctionDefinition(self,StartLine,StartOffset,EndLine,EndOffset,ModifierText,DeclText,LeftBraceLine,LeftBraceOffset,DeclLine,DeclOffset):
|
|
FuncDef = CodeFragment.FunctionDefinition(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset), (LeftBraceLine, LeftBraceOffset), (DeclLine, DeclOffset))
|
|
FileProfile.FunctionDefinitionList.append(FuncDef)
|
|
|
|
def StoreVariableDeclaration(self,StartLine,StartOffset,EndLine,EndOffset,ModifierText,DeclText):
|
|
VarDecl = CodeFragment.VariableDeclaration(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset))
|
|
FileProfile.VariableDeclarationList.append(VarDecl)
|
|
|
|
def StoreFunctionCalling(self,StartLine,StartOffset,EndLine,EndOffset,FuncName,ParamList):
|
|
FuncCall = CodeFragment.FunctionCalling(FuncName, ParamList, (StartLine, StartOffset), (EndLine, EndOffset))
|
|
FileProfile.FunctionCallingList.append(FuncCall)
|
|
|
|
|
|
|
|
class Translation_unitContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def external_declaration(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.External_declarationContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.External_declarationContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_translation_unit
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterTranslation_unit" ):
|
|
listener.enterTranslation_unit(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitTranslation_unit" ):
|
|
listener.exitTranslation_unit(self)
|
|
|
|
|
|
|
|
|
|
def translation_unit(self):
|
|
|
|
localctx = CParser.Translation_unitContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 0, self.RULE_translation_unit)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 145
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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:
|
|
self.state = 142
|
|
self.external_declaration()
|
|
self.state = 147
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class External_declarationContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def declarator(self):
|
|
return self.getTypedRuleContext(CParser.DeclaratorContext,0)
|
|
|
|
|
|
def declaration_specifiers(self):
|
|
return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def declaration(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.DeclarationContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.DeclarationContext,i)
|
|
|
|
|
|
def function_definition(self):
|
|
return self.getTypedRuleContext(CParser.Function_definitionContext,0)
|
|
|
|
|
|
def macro_statement(self):
|
|
return self.getTypedRuleContext(CParser.Macro_statementContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_external_declaration
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterExternal_declaration" ):
|
|
listener.enterExternal_declaration(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitExternal_declaration" ):
|
|
listener.exitExternal_declaration(self)
|
|
|
|
|
|
|
|
|
|
def external_declaration(self):
|
|
|
|
localctx = CParser.External_declarationContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 2, self.RULE_external_declaration)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 166
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 149
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 148
|
|
self.declaration_specifiers()
|
|
|
|
|
|
self.state = 151
|
|
self.declarator()
|
|
self.state = 155
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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:
|
|
self.state = 152
|
|
self.declaration()
|
|
self.state = 157
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 158
|
|
self.match(CParser.T__0)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 160
|
|
self.function_definition()
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 161
|
|
self.declaration()
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 162
|
|
self.macro_statement()
|
|
self.state = 164
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__1:
|
|
self.state = 163
|
|
self.match(CParser.T__1)
|
|
|
|
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Function_definitionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.ModifierText = ''
|
|
self.DeclText = ''
|
|
self.LBLine = 0
|
|
self.LBOffset = 0
|
|
self.DeclLine = 0
|
|
self.DeclOffset = 0
|
|
self.d = None # Declaration_specifiersContext
|
|
self._declaration_specifiers = None # Declaration_specifiersContext
|
|
self._declarator = None # DeclaratorContext
|
|
self.a = None # Compound_statementContext
|
|
self.b = None # Compound_statementContext
|
|
|
|
def declarator(self):
|
|
return self.getTypedRuleContext(CParser.DeclaratorContext,0)
|
|
|
|
|
|
def compound_statement(self):
|
|
return self.getTypedRuleContext(CParser.Compound_statementContext,0)
|
|
|
|
|
|
def declaration_specifiers(self):
|
|
return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def declaration(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.DeclarationContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.DeclarationContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_function_definition
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterFunction_definition" ):
|
|
listener.enterFunction_definition(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitFunction_definition" ):
|
|
listener.exitFunction_definition(self)
|
|
|
|
|
|
|
|
|
|
def function_definition(self):
|
|
|
|
localctx = CParser.Function_definitionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 4, self.RULE_function_definition)
|
|
|
|
ModifierText = '';
|
|
DeclText = '';
|
|
LBLine = 0;
|
|
LBOffset = 0;
|
|
DeclLine = 0;
|
|
DeclOffset = 0;
|
|
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 169
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 168
|
|
localctx.d = localctx._declaration_specifiers = self.declaration_specifiers()
|
|
|
|
|
|
self.state = 171
|
|
localctx._declarator = self.declarator()
|
|
self.state = 180
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
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]:
|
|
self.state = 173
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while True:
|
|
self.state = 172
|
|
self.declaration()
|
|
self.state = 175
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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):
|
|
break
|
|
|
|
self.state = 177
|
|
localctx.a = self.compound_statement()
|
|
pass
|
|
elif token in [CParser.T__0]:
|
|
self.state = 179
|
|
localctx.b = self.compound_statement()
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
|
|
if localctx.d != None:
|
|
ModifierText = (None if localctx._declaration_specifiers is None else self._input.getText((localctx._declaration_specifiers.start,localctx._declaration_specifiers.stop)))
|
|
else:
|
|
ModifierText = ''
|
|
DeclText = (None if localctx._declarator is None else self._input.getText((localctx._declarator.start,localctx._declarator.stop)))
|
|
DeclLine = (None if localctx._declarator is None else localctx._declarator.start).line
|
|
DeclOffset = (None if localctx._declarator is None else localctx._declarator.start).column
|
|
if localctx.a != None:
|
|
LBLine = (None if localctx.a is None else localctx.a.start).line
|
|
LBOffset = (None if localctx.a is None else localctx.a.start).column
|
|
else:
|
|
LBLine = (None if localctx.b is None else localctx.b.start).line
|
|
LBOffset = (None if localctx.b is None else localctx.b.start).column
|
|
|
|
self._ctx.stop = self._input.LT(-1)
|
|
|
|
self.StoreFunctionDefinition(localctx.start.line, localctx.start.column, localctx.stop.line, localctx.stop.column, ModifierText, DeclText, LBLine, LBOffset, DeclLine, DeclOffset)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Declaration_specifiersContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def storage_class_specifier(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Storage_class_specifierContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Storage_class_specifierContext,i)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def type_specifier(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Type_specifierContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Type_specifierContext,i)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def type_qualifier(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Type_qualifierContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_declaration_specifiers
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterDeclaration_specifiers" ):
|
|
listener.enterDeclaration_specifiers(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitDeclaration_specifiers" ):
|
|
listener.exitDeclaration_specifiers(self)
|
|
|
|
|
|
|
|
|
|
def declaration_specifiers(self):
|
|
|
|
localctx = CParser.Declaration_specifiersContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 6, self.RULE_declaration_specifiers)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 187
|
|
self._errHandler.sync(self)
|
|
_alt = 1
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt == 1:
|
|
self.state = 187
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9]:
|
|
self.state = 184
|
|
self.storage_class_specifier()
|
|
pass
|
|
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]:
|
|
self.state = 185
|
|
self.type_specifier()
|
|
pass
|
|
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]:
|
|
self.state = 186
|
|
self.type_qualifier()
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
|
|
else:
|
|
raise NoViableAltException(self)
|
|
self.state = 189
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,9,self._ctx)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class DeclarationContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.a = None # Token
|
|
self.b = None # Declaration_specifiersContext
|
|
self.c = None # Init_declarator_listContext
|
|
self.d = None # Token
|
|
self.s = None # Declaration_specifiersContext
|
|
self.t = None # Init_declarator_listContext
|
|
self.e = None # Token
|
|
|
|
def init_declarator_list(self):
|
|
return self.getTypedRuleContext(CParser.Init_declarator_listContext,0)
|
|
|
|
|
|
def declaration_specifiers(self):
|
|
return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_declaration
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterDeclaration" ):
|
|
listener.enterDeclaration(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitDeclaration" ):
|
|
listener.exitDeclaration(self)
|
|
|
|
|
|
|
|
|
|
def declaration(self):
|
|
|
|
localctx = CParser.DeclarationContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 8, self.RULE_declaration)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 206
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.T__2]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 191
|
|
localctx.a = self.match(CParser.T__2)
|
|
self.state = 193
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 192
|
|
localctx.b = self.declaration_specifiers()
|
|
|
|
|
|
self.state = 195
|
|
localctx.c = self.init_declarator_list()
|
|
self.state = 196
|
|
localctx.d = self.match(CParser.T__1)
|
|
|
|
if localctx.b is not None:
|
|
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))))
|
|
else:
|
|
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))))
|
|
|
|
pass
|
|
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]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 199
|
|
localctx.s = self.declaration_specifiers()
|
|
self.state = 201
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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):
|
|
self.state = 200
|
|
localctx.t = self.init_declarator_list()
|
|
|
|
|
|
self.state = 203
|
|
localctx.e = self.match(CParser.T__1)
|
|
|
|
if localctx.t is not None:
|
|
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))))
|
|
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Init_declarator_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def init_declarator(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Init_declaratorContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Init_declaratorContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_init_declarator_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterInit_declarator_list" ):
|
|
listener.enterInit_declarator_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitInit_declarator_list" ):
|
|
listener.exitInit_declarator_list(self)
|
|
|
|
|
|
|
|
|
|
def init_declarator_list(self):
|
|
|
|
localctx = CParser.Init_declarator_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 10, self.RULE_init_declarator_list)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 208
|
|
self.init_declarator()
|
|
self.state = 213
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__3:
|
|
self.state = 209
|
|
self.match(CParser.T__3)
|
|
self.state = 210
|
|
self.init_declarator()
|
|
self.state = 215
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Init_declaratorContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def declarator(self):
|
|
return self.getTypedRuleContext(CParser.DeclaratorContext,0)
|
|
|
|
|
|
def initializer(self):
|
|
return self.getTypedRuleContext(CParser.InitializerContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_init_declarator
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterInit_declarator" ):
|
|
listener.enterInit_declarator(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitInit_declarator" ):
|
|
listener.exitInit_declarator(self)
|
|
|
|
|
|
|
|
|
|
def init_declarator(self):
|
|
|
|
localctx = CParser.Init_declaratorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 12, self.RULE_init_declarator)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 216
|
|
self.declarator()
|
|
self.state = 219
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__4:
|
|
self.state = 217
|
|
self.match(CParser.T__4)
|
|
self.state = 218
|
|
self.initializer()
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Storage_class_specifierContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_storage_class_specifier
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterStorage_class_specifier" ):
|
|
listener.enterStorage_class_specifier(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitStorage_class_specifier" ):
|
|
listener.exitStorage_class_specifier(self)
|
|
|
|
|
|
|
|
|
|
def storage_class_specifier(self):
|
|
|
|
localctx = CParser.Storage_class_specifierContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 14, self.RULE_storage_class_specifier)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 221
|
|
_la = self._input.LA(1)
|
|
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)):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Type_specifierContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.s = None # Struct_or_union_specifierContext
|
|
self.e = None # Enum_specifierContext
|
|
|
|
def struct_or_union_specifier(self):
|
|
return self.getTypedRuleContext(CParser.Struct_or_union_specifierContext,0)
|
|
|
|
|
|
def enum_specifier(self):
|
|
return self.getTypedRuleContext(CParser.Enum_specifierContext,0)
|
|
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
def declarator(self):
|
|
return self.getTypedRuleContext(CParser.DeclaratorContext,0)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def type_qualifier(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Type_qualifierContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
|
|
|
|
|
|
def type_id(self):
|
|
return self.getTypedRuleContext(CParser.Type_idContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_type_specifier
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterType_specifier" ):
|
|
listener.enterType_specifier(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitType_specifier" ):
|
|
listener.exitType_specifier(self)
|
|
|
|
|
|
|
|
|
|
def type_specifier(self):
|
|
|
|
localctx = CParser.Type_specifierContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 16, self.RULE_type_specifier)
|
|
try:
|
|
self.state = 247
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 223
|
|
self.match(CParser.T__10)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 224
|
|
self.match(CParser.T__11)
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 225
|
|
self.match(CParser.T__12)
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 226
|
|
self.match(CParser.T__13)
|
|
pass
|
|
|
|
elif la_ == 5:
|
|
self.enterOuterAlt(localctx, 5)
|
|
self.state = 227
|
|
self.match(CParser.T__14)
|
|
pass
|
|
|
|
elif la_ == 6:
|
|
self.enterOuterAlt(localctx, 6)
|
|
self.state = 228
|
|
self.match(CParser.T__15)
|
|
pass
|
|
|
|
elif la_ == 7:
|
|
self.enterOuterAlt(localctx, 7)
|
|
self.state = 229
|
|
self.match(CParser.T__16)
|
|
pass
|
|
|
|
elif la_ == 8:
|
|
self.enterOuterAlt(localctx, 8)
|
|
self.state = 230
|
|
self.match(CParser.T__17)
|
|
pass
|
|
|
|
elif la_ == 9:
|
|
self.enterOuterAlt(localctx, 9)
|
|
self.state = 231
|
|
self.match(CParser.T__18)
|
|
pass
|
|
|
|
elif la_ == 10:
|
|
self.enterOuterAlt(localctx, 10)
|
|
self.state = 232
|
|
localctx.s = self.struct_or_union_specifier()
|
|
|
|
if localctx.s.stop is not None:
|
|
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))))
|
|
|
|
pass
|
|
|
|
elif la_ == 11:
|
|
self.enterOuterAlt(localctx, 11)
|
|
self.state = 235
|
|
localctx.e = self.enum_specifier()
|
|
|
|
if localctx.e.stop is not None:
|
|
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))))
|
|
|
|
pass
|
|
|
|
elif la_ == 12:
|
|
self.enterOuterAlt(localctx, 12)
|
|
self.state = 238
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 242
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,15,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 239
|
|
self.type_qualifier()
|
|
self.state = 244
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,15,self._ctx)
|
|
|
|
self.state = 245
|
|
self.declarator()
|
|
pass
|
|
|
|
elif la_ == 13:
|
|
self.enterOuterAlt(localctx, 13)
|
|
self.state = 246
|
|
self.type_id()
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Type_idContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_type_id
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterType_id" ):
|
|
listener.enterType_id(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitType_id" ):
|
|
listener.exitType_id(self)
|
|
|
|
|
|
|
|
|
|
def type_id(self):
|
|
|
|
localctx = CParser.Type_idContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 18, self.RULE_type_id)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 249
|
|
self.match(CParser.IDENTIFIER)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Struct_or_union_specifierContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def struct_or_union(self):
|
|
return self.getTypedRuleContext(CParser.Struct_or_unionContext,0)
|
|
|
|
|
|
def struct_declaration_list(self):
|
|
return self.getTypedRuleContext(CParser.Struct_declaration_listContext,0)
|
|
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_struct_or_union_specifier
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterStruct_or_union_specifier" ):
|
|
listener.enterStruct_or_union_specifier(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitStruct_or_union_specifier" ):
|
|
listener.exitStruct_or_union_specifier(self)
|
|
|
|
|
|
|
|
|
|
def struct_or_union_specifier(self):
|
|
|
|
localctx = CParser.Struct_or_union_specifierContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 20, self.RULE_struct_or_union_specifier)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 262
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 251
|
|
self.struct_or_union()
|
|
self.state = 253
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.IDENTIFIER:
|
|
self.state = 252
|
|
self.match(CParser.IDENTIFIER)
|
|
|
|
|
|
self.state = 255
|
|
self.match(CParser.T__0)
|
|
self.state = 256
|
|
self.struct_declaration_list()
|
|
self.state = 257
|
|
self.match(CParser.T__19)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 259
|
|
self.struct_or_union()
|
|
self.state = 260
|
|
self.match(CParser.IDENTIFIER)
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Struct_or_unionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_struct_or_union
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterStruct_or_union" ):
|
|
listener.enterStruct_or_union(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitStruct_or_union" ):
|
|
listener.exitStruct_or_union(self)
|
|
|
|
|
|
|
|
|
|
def struct_or_union(self):
|
|
|
|
localctx = CParser.Struct_or_unionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 22, self.RULE_struct_or_union)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 264
|
|
_la = self._input.LA(1)
|
|
if not(_la==CParser.T__20 or _la==CParser.T__21):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Struct_declaration_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def struct_declaration(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Struct_declarationContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Struct_declarationContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_struct_declaration_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterStruct_declaration_list" ):
|
|
listener.enterStruct_declaration_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitStruct_declaration_list" ):
|
|
listener.exitStruct_declaration_list(self)
|
|
|
|
|
|
|
|
|
|
def struct_declaration_list(self):
|
|
|
|
localctx = CParser.Struct_declaration_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 24, self.RULE_struct_declaration_list)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 267
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while True:
|
|
self.state = 266
|
|
self.struct_declaration()
|
|
self.state = 269
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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):
|
|
break
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Struct_declarationContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def specifier_qualifier_list(self):
|
|
return self.getTypedRuleContext(CParser.Specifier_qualifier_listContext,0)
|
|
|
|
|
|
def struct_declarator_list(self):
|
|
return self.getTypedRuleContext(CParser.Struct_declarator_listContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_struct_declaration
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterStruct_declaration" ):
|
|
listener.enterStruct_declaration(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitStruct_declaration" ):
|
|
listener.exitStruct_declaration(self)
|
|
|
|
|
|
|
|
|
|
def struct_declaration(self):
|
|
|
|
localctx = CParser.Struct_declarationContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 26, self.RULE_struct_declaration)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 271
|
|
self.specifier_qualifier_list()
|
|
self.state = 272
|
|
self.struct_declarator_list()
|
|
self.state = 273
|
|
self.match(CParser.T__1)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Specifier_qualifier_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def type_qualifier(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Type_qualifierContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def type_specifier(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Type_specifierContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Type_specifierContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_specifier_qualifier_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterSpecifier_qualifier_list" ):
|
|
listener.enterSpecifier_qualifier_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitSpecifier_qualifier_list" ):
|
|
listener.exitSpecifier_qualifier_list(self)
|
|
|
|
|
|
|
|
|
|
def specifier_qualifier_list(self):
|
|
|
|
localctx = CParser.Specifier_qualifier_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 28, self.RULE_specifier_qualifier_list)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 277
|
|
self._errHandler.sync(self)
|
|
_alt = 1
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt == 1:
|
|
self.state = 277
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
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]:
|
|
self.state = 275
|
|
self.type_qualifier()
|
|
pass
|
|
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]:
|
|
self.state = 276
|
|
self.type_specifier()
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
|
|
else:
|
|
raise NoViableAltException(self)
|
|
self.state = 279
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,21,self._ctx)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Struct_declarator_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def struct_declarator(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Struct_declaratorContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Struct_declaratorContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_struct_declarator_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterStruct_declarator_list" ):
|
|
listener.enterStruct_declarator_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitStruct_declarator_list" ):
|
|
listener.exitStruct_declarator_list(self)
|
|
|
|
|
|
|
|
|
|
def struct_declarator_list(self):
|
|
|
|
localctx = CParser.Struct_declarator_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 30, self.RULE_struct_declarator_list)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 281
|
|
self.struct_declarator()
|
|
self.state = 286
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__3:
|
|
self.state = 282
|
|
self.match(CParser.T__3)
|
|
self.state = 283
|
|
self.struct_declarator()
|
|
self.state = 288
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Struct_declaratorContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def declarator(self):
|
|
return self.getTypedRuleContext(CParser.DeclaratorContext,0)
|
|
|
|
|
|
def constant_expression(self):
|
|
return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_struct_declarator
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterStruct_declarator" ):
|
|
listener.enterStruct_declarator(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitStruct_declarator" ):
|
|
listener.exitStruct_declarator(self)
|
|
|
|
|
|
|
|
|
|
def struct_declarator(self):
|
|
|
|
localctx = CParser.Struct_declaratorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 32, self.RULE_struct_declarator)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 296
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.T__33, CParser.T__34, CParser.T__35, CParser.T__37, CParser.T__41, CParser.IDENTIFIER]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 289
|
|
self.declarator()
|
|
self.state = 292
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__22:
|
|
self.state = 290
|
|
self.match(CParser.T__22)
|
|
self.state = 291
|
|
self.constant_expression()
|
|
|
|
|
|
pass
|
|
elif token in [CParser.T__22]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 294
|
|
self.match(CParser.T__22)
|
|
self.state = 295
|
|
self.constant_expression()
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Enum_specifierContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def enumerator_list(self):
|
|
return self.getTypedRuleContext(CParser.Enumerator_listContext,0)
|
|
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_enum_specifier
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterEnum_specifier" ):
|
|
listener.enterEnum_specifier(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitEnum_specifier" ):
|
|
listener.exitEnum_specifier(self)
|
|
|
|
|
|
|
|
|
|
def enum_specifier(self):
|
|
|
|
localctx = CParser.Enum_specifierContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 34, self.RULE_enum_specifier)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 317
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 298
|
|
self.match(CParser.T__23)
|
|
self.state = 299
|
|
self.match(CParser.T__0)
|
|
self.state = 300
|
|
self.enumerator_list()
|
|
self.state = 302
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__3:
|
|
self.state = 301
|
|
self.match(CParser.T__3)
|
|
|
|
|
|
self.state = 304
|
|
self.match(CParser.T__19)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 306
|
|
self.match(CParser.T__23)
|
|
self.state = 307
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 308
|
|
self.match(CParser.T__0)
|
|
self.state = 309
|
|
self.enumerator_list()
|
|
self.state = 311
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__3:
|
|
self.state = 310
|
|
self.match(CParser.T__3)
|
|
|
|
|
|
self.state = 313
|
|
self.match(CParser.T__19)
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 315
|
|
self.match(CParser.T__23)
|
|
self.state = 316
|
|
self.match(CParser.IDENTIFIER)
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Enumerator_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def enumerator(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.EnumeratorContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.EnumeratorContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_enumerator_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterEnumerator_list" ):
|
|
listener.enterEnumerator_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitEnumerator_list" ):
|
|
listener.exitEnumerator_list(self)
|
|
|
|
|
|
|
|
|
|
def enumerator_list(self):
|
|
|
|
localctx = CParser.Enumerator_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 36, self.RULE_enumerator_list)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 319
|
|
self.enumerator()
|
|
self.state = 324
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,28,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 320
|
|
self.match(CParser.T__3)
|
|
self.state = 321
|
|
self.enumerator()
|
|
self.state = 326
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,28,self._ctx)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class EnumeratorContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
def constant_expression(self):
|
|
return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_enumerator
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterEnumerator" ):
|
|
listener.enterEnumerator(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitEnumerator" ):
|
|
listener.exitEnumerator(self)
|
|
|
|
|
|
|
|
|
|
def enumerator(self):
|
|
|
|
localctx = CParser.EnumeratorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 38, self.RULE_enumerator)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 327
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 330
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__4:
|
|
self.state = 328
|
|
self.match(CParser.T__4)
|
|
self.state = 329
|
|
self.constant_expression()
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Type_qualifierContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_type_qualifier
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterType_qualifier" ):
|
|
listener.enterType_qualifier(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitType_qualifier" ):
|
|
listener.exitType_qualifier(self)
|
|
|
|
|
|
|
|
|
|
def type_qualifier(self):
|
|
|
|
localctx = CParser.Type_qualifierContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 40, self.RULE_type_qualifier)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 332
|
|
_la = self._input.LA(1)
|
|
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)):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class DeclaratorContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def direct_declarator(self):
|
|
return self.getTypedRuleContext(CParser.Direct_declaratorContext,0)
|
|
|
|
|
|
def pointer(self):
|
|
return self.getTypedRuleContext(CParser.PointerContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_declarator
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterDeclarator" ):
|
|
listener.enterDeclarator(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitDeclarator" ):
|
|
listener.exitDeclarator(self)
|
|
|
|
|
|
|
|
|
|
def declarator(self):
|
|
|
|
localctx = CParser.DeclaratorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 42, self.RULE_declarator)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 348
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 335
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__41:
|
|
self.state = 334
|
|
self.pointer()
|
|
|
|
|
|
self.state = 338
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__33:
|
|
self.state = 337
|
|
self.match(CParser.T__33)
|
|
|
|
|
|
self.state = 341
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__34:
|
|
self.state = 340
|
|
self.match(CParser.T__34)
|
|
|
|
|
|
self.state = 344
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__35:
|
|
self.state = 343
|
|
self.match(CParser.T__35)
|
|
|
|
|
|
self.state = 346
|
|
self.direct_declarator()
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 347
|
|
self.pointer()
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Direct_declaratorContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
# @param i=None Type: int
|
|
def declarator_suffix(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Declarator_suffixContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Declarator_suffixContext,i)
|
|
|
|
|
|
def declarator(self):
|
|
return self.getTypedRuleContext(CParser.DeclaratorContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_direct_declarator
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterDirect_declarator" ):
|
|
listener.enterDirect_declarator(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitDirect_declarator" ):
|
|
listener.exitDirect_declarator(self)
|
|
|
|
|
|
|
|
|
|
def direct_declarator(self):
|
|
|
|
localctx = CParser.Direct_declaratorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 44, self.RULE_direct_declarator)
|
|
try:
|
|
self.state = 368
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.IDENTIFIER]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 350
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 354
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,35,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 351
|
|
self.declarator_suffix()
|
|
self.state = 356
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,35,self._ctx)
|
|
|
|
pass
|
|
elif token in [CParser.T__37]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 357
|
|
self.match(CParser.T__37)
|
|
self.state = 359
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 358
|
|
self.match(CParser.T__33)
|
|
|
|
|
|
self.state = 361
|
|
self.declarator()
|
|
self.state = 362
|
|
self.match(CParser.T__38)
|
|
self.state = 364
|
|
self._errHandler.sync(self)
|
|
_alt = 1
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt == 1:
|
|
self.state = 363
|
|
self.declarator_suffix()
|
|
|
|
else:
|
|
raise NoViableAltException(self)
|
|
self.state = 366
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,37,self._ctx)
|
|
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Declarator_suffixContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def constant_expression(self):
|
|
return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
|
|
|
|
|
|
def parameter_type_list(self):
|
|
return self.getTypedRuleContext(CParser.Parameter_type_listContext,0)
|
|
|
|
|
|
def identifier_list(self):
|
|
return self.getTypedRuleContext(CParser.Identifier_listContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_declarator_suffix
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterDeclarator_suffix" ):
|
|
listener.enterDeclarator_suffix(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitDeclarator_suffix" ):
|
|
listener.exitDeclarator_suffix(self)
|
|
|
|
|
|
|
|
|
|
def declarator_suffix(self):
|
|
|
|
localctx = CParser.Declarator_suffixContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 46, self.RULE_declarator_suffix)
|
|
try:
|
|
self.state = 386
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 370
|
|
self.match(CParser.T__39)
|
|
self.state = 371
|
|
self.constant_expression()
|
|
self.state = 372
|
|
self.match(CParser.T__40)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 374
|
|
self.match(CParser.T__39)
|
|
self.state = 375
|
|
self.match(CParser.T__40)
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 376
|
|
self.match(CParser.T__37)
|
|
self.state = 377
|
|
self.parameter_type_list()
|
|
self.state = 378
|
|
self.match(CParser.T__38)
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 380
|
|
self.match(CParser.T__37)
|
|
self.state = 381
|
|
self.identifier_list()
|
|
self.state = 382
|
|
self.match(CParser.T__38)
|
|
pass
|
|
|
|
elif la_ == 5:
|
|
self.enterOuterAlt(localctx, 5)
|
|
self.state = 384
|
|
self.match(CParser.T__37)
|
|
self.state = 385
|
|
self.match(CParser.T__38)
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class PointerContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def type_qualifier(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Type_qualifierContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
|
|
|
|
|
|
def pointer(self):
|
|
return self.getTypedRuleContext(CParser.PointerContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_pointer
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterPointer" ):
|
|
listener.enterPointer(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitPointer" ):
|
|
listener.exitPointer(self)
|
|
|
|
|
|
|
|
|
|
def pointer(self):
|
|
|
|
localctx = CParser.PointerContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 48, self.RULE_pointer)
|
|
try:
|
|
self.state = 400
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 388
|
|
self.match(CParser.T__41)
|
|
self.state = 390
|
|
self._errHandler.sync(self)
|
|
_alt = 1
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt == 1:
|
|
self.state = 389
|
|
self.type_qualifier()
|
|
|
|
else:
|
|
raise NoViableAltException(self)
|
|
self.state = 392
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,40,self._ctx)
|
|
|
|
self.state = 395
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 394
|
|
self.pointer()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 397
|
|
self.match(CParser.T__41)
|
|
self.state = 398
|
|
self.pointer()
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 399
|
|
self.match(CParser.T__41)
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Parameter_type_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def parameter_list(self):
|
|
return self.getTypedRuleContext(CParser.Parameter_listContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_parameter_type_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterParameter_type_list" ):
|
|
listener.enterParameter_type_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitParameter_type_list" ):
|
|
listener.exitParameter_type_list(self)
|
|
|
|
|
|
|
|
|
|
def parameter_type_list(self):
|
|
|
|
localctx = CParser.Parameter_type_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 50, self.RULE_parameter_type_list)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 402
|
|
self.parameter_list()
|
|
self.state = 408
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__3:
|
|
self.state = 403
|
|
self.match(CParser.T__3)
|
|
self.state = 405
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__28:
|
|
self.state = 404
|
|
self.match(CParser.T__28)
|
|
|
|
|
|
self.state = 407
|
|
self.match(CParser.T__42)
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Parameter_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def parameter_declaration(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Parameter_declarationContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Parameter_declarationContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_parameter_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterParameter_list" ):
|
|
listener.enterParameter_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitParameter_list" ):
|
|
listener.exitParameter_list(self)
|
|
|
|
|
|
|
|
|
|
def parameter_list(self):
|
|
|
|
localctx = CParser.Parameter_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 52, self.RULE_parameter_list)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 410
|
|
self.parameter_declaration()
|
|
self.state = 418
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,46,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 411
|
|
self.match(CParser.T__3)
|
|
self.state = 413
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 412
|
|
self.match(CParser.T__28)
|
|
|
|
|
|
self.state = 415
|
|
self.parameter_declaration()
|
|
self.state = 420
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,46,self._ctx)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Parameter_declarationContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def declaration_specifiers(self):
|
|
return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def declarator(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.DeclaratorContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.DeclaratorContext,i)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def abstract_declarator(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Abstract_declaratorContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Abstract_declaratorContext,i)
|
|
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
# @param i=None Type: int
|
|
def pointer(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.PointerContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.PointerContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_parameter_declaration
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterParameter_declaration" ):
|
|
listener.enterParameter_declaration(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitParameter_declaration" ):
|
|
listener.exitParameter_declaration(self)
|
|
|
|
|
|
|
|
|
|
def parameter_declaration(self):
|
|
|
|
localctx = CParser.Parameter_declarationContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 54, self.RULE_parameter_declaration)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 439
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 421
|
|
self.declaration_specifiers()
|
|
self.state = 426
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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):
|
|
self.state = 424
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 422
|
|
self.declarator()
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.state = 423
|
|
self.abstract_declarator()
|
|
pass
|
|
|
|
|
|
self.state = 428
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 430
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__28:
|
|
self.state = 429
|
|
self.match(CParser.T__28)
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 435
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__41:
|
|
self.state = 432
|
|
self.pointer()
|
|
self.state = 437
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 438
|
|
self.match(CParser.IDENTIFIER)
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Identifier_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def IDENTIFIER(self,i=None):
|
|
if i is None:
|
|
return self.getTokens(CParser.IDENTIFIER)
|
|
else:
|
|
return self.getToken(CParser.IDENTIFIER, i)
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_identifier_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterIdentifier_list" ):
|
|
listener.enterIdentifier_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitIdentifier_list" ):
|
|
listener.exitIdentifier_list(self)
|
|
|
|
|
|
|
|
|
|
def identifier_list(self):
|
|
|
|
localctx = CParser.Identifier_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 56, self.RULE_identifier_list)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 441
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 446
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__3:
|
|
self.state = 442
|
|
self.match(CParser.T__3)
|
|
self.state = 443
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 448
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Type_nameContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def specifier_qualifier_list(self):
|
|
return self.getTypedRuleContext(CParser.Specifier_qualifier_listContext,0)
|
|
|
|
|
|
def abstract_declarator(self):
|
|
return self.getTypedRuleContext(CParser.Abstract_declaratorContext,0)
|
|
|
|
|
|
def type_id(self):
|
|
return self.getTypedRuleContext(CParser.Type_idContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_type_name
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterType_name" ):
|
|
listener.enterType_name(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitType_name" ):
|
|
listener.exitType_name(self)
|
|
|
|
|
|
|
|
|
|
def type_name(self):
|
|
|
|
localctx = CParser.Type_nameContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 58, self.RULE_type_name)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 454
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 449
|
|
self.specifier_qualifier_list()
|
|
self.state = 451
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__37) | (1 << CParser.T__39) | (1 << CParser.T__41))) != 0):
|
|
self.state = 450
|
|
self.abstract_declarator()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 453
|
|
self.type_id()
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Abstract_declaratorContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def pointer(self):
|
|
return self.getTypedRuleContext(CParser.PointerContext,0)
|
|
|
|
|
|
def direct_abstract_declarator(self):
|
|
return self.getTypedRuleContext(CParser.Direct_abstract_declaratorContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_abstract_declarator
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterAbstract_declarator" ):
|
|
listener.enterAbstract_declarator(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitAbstract_declarator" ):
|
|
listener.exitAbstract_declarator(self)
|
|
|
|
|
|
|
|
|
|
def abstract_declarator(self):
|
|
|
|
localctx = CParser.Abstract_declaratorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 60, self.RULE_abstract_declarator)
|
|
try:
|
|
self.state = 461
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.T__41]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 456
|
|
self.pointer()
|
|
self.state = 458
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 457
|
|
self.direct_abstract_declarator()
|
|
|
|
|
|
pass
|
|
elif token in [CParser.T__37, CParser.T__39]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 460
|
|
self.direct_abstract_declarator()
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Direct_abstract_declaratorContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def abstract_declarator(self):
|
|
return self.getTypedRuleContext(CParser.Abstract_declaratorContext,0)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def abstract_declarator_suffix(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Abstract_declarator_suffixContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Abstract_declarator_suffixContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_direct_abstract_declarator
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterDirect_abstract_declarator" ):
|
|
listener.enterDirect_abstract_declarator(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitDirect_abstract_declarator" ):
|
|
listener.exitDirect_abstract_declarator(self)
|
|
|
|
|
|
|
|
def direct_abstract_declarator(self):
|
|
|
|
localctx = CParser.Direct_abstract_declaratorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 62, self.RULE_direct_abstract_declarator)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 468
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 463
|
|
self.match(CParser.T__37)
|
|
self.state = 464
|
|
self.abstract_declarator()
|
|
self.state = 465
|
|
self.match(CParser.T__38)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.state = 467
|
|
self.abstract_declarator_suffix()
|
|
pass
|
|
|
|
|
|
self.state = 473
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,58,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 470
|
|
self.abstract_declarator_suffix()
|
|
self.state = 475
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,58,self._ctx)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Abstract_declarator_suffixContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def constant_expression(self):
|
|
return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
|
|
|
|
|
|
def parameter_type_list(self):
|
|
return self.getTypedRuleContext(CParser.Parameter_type_listContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_abstract_declarator_suffix
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterAbstract_declarator_suffix" ):
|
|
listener.enterAbstract_declarator_suffix(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitAbstract_declarator_suffix" ):
|
|
listener.exitAbstract_declarator_suffix(self)
|
|
|
|
|
|
|
|
|
|
def abstract_declarator_suffix(self):
|
|
|
|
localctx = CParser.Abstract_declarator_suffixContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 64, self.RULE_abstract_declarator_suffix)
|
|
try:
|
|
self.state = 488
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 476
|
|
self.match(CParser.T__39)
|
|
self.state = 477
|
|
self.match(CParser.T__40)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 478
|
|
self.match(CParser.T__39)
|
|
self.state = 479
|
|
self.constant_expression()
|
|
self.state = 480
|
|
self.match(CParser.T__40)
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 482
|
|
self.match(CParser.T__37)
|
|
self.state = 483
|
|
self.match(CParser.T__38)
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 484
|
|
self.match(CParser.T__37)
|
|
self.state = 485
|
|
self.parameter_type_list()
|
|
self.state = 486
|
|
self.match(CParser.T__38)
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class InitializerContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def assignment_expression(self):
|
|
return self.getTypedRuleContext(CParser.Assignment_expressionContext,0)
|
|
|
|
|
|
def initializer_list(self):
|
|
return self.getTypedRuleContext(CParser.Initializer_listContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_initializer
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterInitializer" ):
|
|
listener.enterInitializer(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitInitializer" ):
|
|
listener.exitInitializer(self)
|
|
|
|
|
|
|
|
|
|
def initializer(self):
|
|
|
|
localctx = CParser.InitializerContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 66, self.RULE_initializer)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 498
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
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]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 490
|
|
self.assignment_expression()
|
|
pass
|
|
elif token in [CParser.T__0]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 491
|
|
self.match(CParser.T__0)
|
|
self.state = 492
|
|
self.initializer_list()
|
|
self.state = 494
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__3:
|
|
self.state = 493
|
|
self.match(CParser.T__3)
|
|
|
|
|
|
self.state = 496
|
|
self.match(CParser.T__19)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Initializer_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def initializer(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.InitializerContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.InitializerContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_initializer_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterInitializer_list" ):
|
|
listener.enterInitializer_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitInitializer_list" ):
|
|
listener.exitInitializer_list(self)
|
|
|
|
|
|
|
|
|
|
def initializer_list(self):
|
|
|
|
localctx = CParser.Initializer_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 68, self.RULE_initializer_list)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 500
|
|
self.initializer()
|
|
self.state = 505
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,62,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 501
|
|
self.match(CParser.T__3)
|
|
self.state = 502
|
|
self.initializer()
|
|
self.state = 507
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,62,self._ctx)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Argument_expression_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def assignment_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Assignment_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Assignment_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_argument_expression_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterArgument_expression_list" ):
|
|
listener.enterArgument_expression_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitArgument_expression_list" ):
|
|
listener.exitArgument_expression_list(self)
|
|
|
|
|
|
|
|
|
|
def argument_expression_list(self):
|
|
|
|
localctx = CParser.Argument_expression_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 70, self.RULE_argument_expression_list)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 508
|
|
self.assignment_expression()
|
|
self.state = 510
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__28:
|
|
self.state = 509
|
|
self.match(CParser.T__28)
|
|
|
|
|
|
self.state = 519
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__3:
|
|
self.state = 512
|
|
self.match(CParser.T__3)
|
|
self.state = 513
|
|
self.assignment_expression()
|
|
self.state = 515
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__28:
|
|
self.state = 514
|
|
self.match(CParser.T__28)
|
|
|
|
|
|
self.state = 521
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Additive_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def multiplicative_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Multiplicative_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Multiplicative_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_additive_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterAdditive_expression" ):
|
|
listener.enterAdditive_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitAdditive_expression" ):
|
|
listener.exitAdditive_expression(self)
|
|
|
|
|
|
|
|
|
|
def additive_expression(self):
|
|
|
|
localctx = CParser.Additive_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 72, self.RULE_additive_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 522
|
|
self.multiplicative_expression()
|
|
self.state = 529
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__43 or _la==CParser.T__44:
|
|
self.state = 527
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.T__43]:
|
|
self.state = 523
|
|
self.match(CParser.T__43)
|
|
self.state = 524
|
|
self.multiplicative_expression()
|
|
pass
|
|
elif token in [CParser.T__44]:
|
|
self.state = 525
|
|
self.match(CParser.T__44)
|
|
self.state = 526
|
|
self.multiplicative_expression()
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
self.state = 531
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Multiplicative_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def cast_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Cast_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Cast_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_multiplicative_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterMultiplicative_expression" ):
|
|
listener.enterMultiplicative_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitMultiplicative_expression" ):
|
|
listener.exitMultiplicative_expression(self)
|
|
|
|
|
|
|
|
|
|
def multiplicative_expression(self):
|
|
|
|
localctx = CParser.Multiplicative_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 74, self.RULE_multiplicative_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 532
|
|
self.cast_expression()
|
|
self.state = 541
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__41) | (1 << CParser.T__45) | (1 << CParser.T__46))) != 0):
|
|
self.state = 539
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.T__41]:
|
|
self.state = 533
|
|
self.match(CParser.T__41)
|
|
self.state = 534
|
|
self.cast_expression()
|
|
pass
|
|
elif token in [CParser.T__45]:
|
|
self.state = 535
|
|
self.match(CParser.T__45)
|
|
self.state = 536
|
|
self.cast_expression()
|
|
pass
|
|
elif token in [CParser.T__46]:
|
|
self.state = 537
|
|
self.match(CParser.T__46)
|
|
self.state = 538
|
|
self.cast_expression()
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
self.state = 543
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Cast_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def type_name(self):
|
|
return self.getTypedRuleContext(CParser.Type_nameContext,0)
|
|
|
|
|
|
def cast_expression(self):
|
|
return self.getTypedRuleContext(CParser.Cast_expressionContext,0)
|
|
|
|
|
|
def unary_expression(self):
|
|
return self.getTypedRuleContext(CParser.Unary_expressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_cast_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterCast_expression" ):
|
|
listener.enterCast_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitCast_expression" ):
|
|
listener.exitCast_expression(self)
|
|
|
|
|
|
|
|
|
|
def cast_expression(self):
|
|
|
|
localctx = CParser.Cast_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 76, self.RULE_cast_expression)
|
|
try:
|
|
self.state = 550
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 544
|
|
self.match(CParser.T__37)
|
|
self.state = 545
|
|
self.type_name()
|
|
self.state = 546
|
|
self.match(CParser.T__38)
|
|
self.state = 547
|
|
self.cast_expression()
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 549
|
|
self.unary_expression()
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Unary_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def postfix_expression(self):
|
|
return self.getTypedRuleContext(CParser.Postfix_expressionContext,0)
|
|
|
|
|
|
def unary_expression(self):
|
|
return self.getTypedRuleContext(CParser.Unary_expressionContext,0)
|
|
|
|
|
|
def unary_operator(self):
|
|
return self.getTypedRuleContext(CParser.Unary_operatorContext,0)
|
|
|
|
|
|
def cast_expression(self):
|
|
return self.getTypedRuleContext(CParser.Cast_expressionContext,0)
|
|
|
|
|
|
def type_name(self):
|
|
return self.getTypedRuleContext(CParser.Type_nameContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_unary_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterUnary_expression" ):
|
|
listener.enterUnary_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitUnary_expression" ):
|
|
listener.exitUnary_expression(self)
|
|
|
|
|
|
|
|
|
|
def unary_expression(self):
|
|
|
|
localctx = CParser.Unary_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 78, self.RULE_unary_expression)
|
|
try:
|
|
self.state = 567
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 552
|
|
self.postfix_expression()
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 553
|
|
self.match(CParser.T__47)
|
|
self.state = 554
|
|
self.unary_expression()
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 555
|
|
self.match(CParser.T__48)
|
|
self.state = 556
|
|
self.unary_expression()
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 557
|
|
self.unary_operator()
|
|
self.state = 558
|
|
self.cast_expression()
|
|
pass
|
|
|
|
elif la_ == 5:
|
|
self.enterOuterAlt(localctx, 5)
|
|
self.state = 560
|
|
self.match(CParser.T__49)
|
|
self.state = 561
|
|
self.unary_expression()
|
|
pass
|
|
|
|
elif la_ == 6:
|
|
self.enterOuterAlt(localctx, 6)
|
|
self.state = 562
|
|
self.match(CParser.T__49)
|
|
self.state = 563
|
|
self.match(CParser.T__37)
|
|
self.state = 564
|
|
self.type_name()
|
|
self.state = 565
|
|
self.match(CParser.T__38)
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Postfix_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.FuncCallText = ''
|
|
self.p = None # Primary_expressionContext
|
|
self.a = None # Token
|
|
self.c = None # Argument_expression_listContext
|
|
self.b = None # Token
|
|
self.x = None # Token
|
|
self.y = None # Token
|
|
self.z = None # Token
|
|
|
|
def primary_expression(self):
|
|
return self.getTypedRuleContext(CParser.Primary_expressionContext,0)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.ExpressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.ExpressionContext,i)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def macro_parameter_list(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Macro_parameter_listContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Macro_parameter_listContext,i)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def argument_expression_list(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Argument_expression_listContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Argument_expression_listContext,i)
|
|
|
|
|
|
# @param i=None Type: int
|
|
def IDENTIFIER(self,i=None):
|
|
if i is None:
|
|
return self.getTokens(CParser.IDENTIFIER)
|
|
else:
|
|
return self.getToken(CParser.IDENTIFIER, i)
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_postfix_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterPostfix_expression" ):
|
|
listener.enterPostfix_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitPostfix_expression" ):
|
|
listener.exitPostfix_expression(self)
|
|
|
|
|
|
|
|
|
|
def postfix_expression(self):
|
|
|
|
localctx = CParser.Postfix_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 80, self.RULE_postfix_expression)
|
|
|
|
self.FuncCallText=''
|
|
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 569
|
|
localctx.p = self.primary_expression()
|
|
self.FuncCallText += (None if localctx.p is None else self._input.getText((localctx.p.start,localctx.p.stop)))
|
|
self.state = 600
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,73,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 598
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 571
|
|
self.match(CParser.T__39)
|
|
self.state = 572
|
|
self.expression()
|
|
self.state = 573
|
|
self.match(CParser.T__40)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.state = 575
|
|
self.match(CParser.T__37)
|
|
self.state = 576
|
|
localctx.a = self.match(CParser.T__38)
|
|
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, '')
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.state = 578
|
|
self.match(CParser.T__37)
|
|
self.state = 579
|
|
localctx.c = self.argument_expression_list()
|
|
self.state = 580
|
|
localctx.b = self.match(CParser.T__38)
|
|
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))))
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
self.state = 583
|
|
self.match(CParser.T__37)
|
|
self.state = 584
|
|
self.macro_parameter_list()
|
|
self.state = 585
|
|
self.match(CParser.T__38)
|
|
pass
|
|
|
|
elif la_ == 5:
|
|
self.state = 587
|
|
self.match(CParser.T__50)
|
|
self.state = 588
|
|
localctx.x = self.match(CParser.IDENTIFIER)
|
|
self.FuncCallText += '.' + (None if localctx.x is None else localctx.x.text)
|
|
pass
|
|
|
|
elif la_ == 6:
|
|
self.state = 590
|
|
self.match(CParser.T__41)
|
|
self.state = 591
|
|
localctx.y = self.match(CParser.IDENTIFIER)
|
|
self.FuncCallText = (None if localctx.y is None else localctx.y.text)
|
|
pass
|
|
|
|
elif la_ == 7:
|
|
self.state = 593
|
|
self.match(CParser.T__51)
|
|
self.state = 594
|
|
localctx.z = self.match(CParser.IDENTIFIER)
|
|
self.FuncCallText += '->' + (None if localctx.z is None else localctx.z.text)
|
|
pass
|
|
|
|
elif la_ == 8:
|
|
self.state = 596
|
|
self.match(CParser.T__47)
|
|
pass
|
|
|
|
elif la_ == 9:
|
|
self.state = 597
|
|
self.match(CParser.T__48)
|
|
pass
|
|
|
|
|
|
self.state = 602
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,73,self._ctx)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Macro_parameter_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def parameter_declaration(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Parameter_declarationContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Parameter_declarationContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_macro_parameter_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterMacro_parameter_list" ):
|
|
listener.enterMacro_parameter_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitMacro_parameter_list" ):
|
|
listener.exitMacro_parameter_list(self)
|
|
|
|
|
|
|
|
|
|
def macro_parameter_list(self):
|
|
|
|
localctx = CParser.Macro_parameter_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 82, self.RULE_macro_parameter_list)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 603
|
|
self.parameter_declaration()
|
|
self.state = 608
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__3:
|
|
self.state = 604
|
|
self.match(CParser.T__3)
|
|
self.state = 605
|
|
self.parameter_declaration()
|
|
self.state = 610
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Unary_operatorContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_unary_operator
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterUnary_operator" ):
|
|
listener.enterUnary_operator(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitUnary_operator" ):
|
|
listener.exitUnary_operator(self)
|
|
|
|
|
|
|
|
|
|
def unary_operator(self):
|
|
|
|
localctx = CParser.Unary_operatorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 84, self.RULE_unary_operator)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 611
|
|
_la = self._input.LA(1)
|
|
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)):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Primary_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
def constant(self):
|
|
return self.getTypedRuleContext(CParser.ConstantContext,0)
|
|
|
|
|
|
def expression(self):
|
|
return self.getTypedRuleContext(CParser.ExpressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_primary_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterPrimary_expression" ):
|
|
listener.enterPrimary_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitPrimary_expression" ):
|
|
listener.exitPrimary_expression(self)
|
|
|
|
|
|
|
|
|
|
def primary_expression(self):
|
|
|
|
localctx = CParser.Primary_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 86, self.RULE_primary_expression)
|
|
try:
|
|
self.state = 619
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 613
|
|
self.match(CParser.IDENTIFIER)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 614
|
|
self.constant()
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 615
|
|
self.match(CParser.T__37)
|
|
self.state = 616
|
|
self.expression()
|
|
self.state = 617
|
|
self.match(CParser.T__38)
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class ConstantContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def HEX_LITERAL(self):
|
|
return self.getToken(CParser.HEX_LITERAL, 0)
|
|
|
|
def OCTAL_LITERAL(self):
|
|
return self.getToken(CParser.OCTAL_LITERAL, 0)
|
|
|
|
def DECIMAL_LITERAL(self):
|
|
return self.getToken(CParser.DECIMAL_LITERAL, 0)
|
|
|
|
def CHARACTER_LITERAL(self):
|
|
return self.getToken(CParser.CHARACTER_LITERAL, 0)
|
|
|
|
# @param i=None Type: int
|
|
def IDENTIFIER(self,i=None):
|
|
if i is None:
|
|
return self.getTokens(CParser.IDENTIFIER)
|
|
else:
|
|
return self.getToken(CParser.IDENTIFIER, i)
|
|
|
|
# @param i=None Type: int
|
|
def STRING_LITERAL(self,i=None):
|
|
if i is None:
|
|
return self.getTokens(CParser.STRING_LITERAL)
|
|
else:
|
|
return self.getToken(CParser.STRING_LITERAL, i)
|
|
|
|
def FLOATING_POINT_LITERAL(self):
|
|
return self.getToken(CParser.FLOATING_POINT_LITERAL, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_constant
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterConstant" ):
|
|
listener.enterConstant(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitConstant" ):
|
|
listener.exitConstant(self)
|
|
|
|
|
|
|
|
|
|
def constant(self):
|
|
|
|
localctx = CParser.ConstantContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 88, self.RULE_constant)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 647
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.HEX_LITERAL]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 621
|
|
self.match(CParser.HEX_LITERAL)
|
|
pass
|
|
elif token in [CParser.OCTAL_LITERAL]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 622
|
|
self.match(CParser.OCTAL_LITERAL)
|
|
pass
|
|
elif token in [CParser.DECIMAL_LITERAL]:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 623
|
|
self.match(CParser.DECIMAL_LITERAL)
|
|
pass
|
|
elif token in [CParser.CHARACTER_LITERAL]:
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 624
|
|
self.match(CParser.CHARACTER_LITERAL)
|
|
pass
|
|
elif token in [CParser.IDENTIFIER, CParser.STRING_LITERAL]:
|
|
self.enterOuterAlt(localctx, 5)
|
|
self.state = 636
|
|
self._errHandler.sync(self)
|
|
_alt = 1
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt == 1:
|
|
self.state = 628
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.IDENTIFIER:
|
|
self.state = 625
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 630
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 632
|
|
self._errHandler.sync(self)
|
|
_alt = 1
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt == 1:
|
|
self.state = 631
|
|
self.match(CParser.STRING_LITERAL)
|
|
|
|
else:
|
|
raise NoViableAltException(self)
|
|
self.state = 634
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,77,self._ctx)
|
|
|
|
|
|
else:
|
|
raise NoViableAltException(self)
|
|
self.state = 638
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,78,self._ctx)
|
|
|
|
self.state = 643
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.IDENTIFIER:
|
|
self.state = 640
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 645
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
pass
|
|
elif token in [CParser.FLOATING_POINT_LITERAL]:
|
|
self.enterOuterAlt(localctx, 6)
|
|
self.state = 646
|
|
self.match(CParser.FLOATING_POINT_LITERAL)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class ExpressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def assignment_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Assignment_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Assignment_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterExpression" ):
|
|
listener.enterExpression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitExpression" ):
|
|
listener.exitExpression(self)
|
|
|
|
|
|
|
|
|
|
def expression(self):
|
|
|
|
localctx = CParser.ExpressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 90, self.RULE_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 649
|
|
self.assignment_expression()
|
|
self.state = 654
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__3:
|
|
self.state = 650
|
|
self.match(CParser.T__3)
|
|
self.state = 651
|
|
self.assignment_expression()
|
|
self.state = 656
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Constant_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def conditional_expression(self):
|
|
return self.getTypedRuleContext(CParser.Conditional_expressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_constant_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterConstant_expression" ):
|
|
listener.enterConstant_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitConstant_expression" ):
|
|
listener.exitConstant_expression(self)
|
|
|
|
|
|
|
|
|
|
def constant_expression(self):
|
|
|
|
localctx = CParser.Constant_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 92, self.RULE_constant_expression)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 657
|
|
self.conditional_expression()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Assignment_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def lvalue(self):
|
|
return self.getTypedRuleContext(CParser.LvalueContext,0)
|
|
|
|
|
|
def assignment_operator(self):
|
|
return self.getTypedRuleContext(CParser.Assignment_operatorContext,0)
|
|
|
|
|
|
def assignment_expression(self):
|
|
return self.getTypedRuleContext(CParser.Assignment_expressionContext,0)
|
|
|
|
|
|
def conditional_expression(self):
|
|
return self.getTypedRuleContext(CParser.Conditional_expressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_assignment_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterAssignment_expression" ):
|
|
listener.enterAssignment_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitAssignment_expression" ):
|
|
listener.exitAssignment_expression(self)
|
|
|
|
|
|
|
|
|
|
def assignment_expression(self):
|
|
|
|
localctx = CParser.Assignment_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 94, self.RULE_assignment_expression)
|
|
try:
|
|
self.state = 664
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 659
|
|
self.lvalue()
|
|
self.state = 660
|
|
self.assignment_operator()
|
|
self.state = 661
|
|
self.assignment_expression()
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 663
|
|
self.conditional_expression()
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class LvalueContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def unary_expression(self):
|
|
return self.getTypedRuleContext(CParser.Unary_expressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_lvalue
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterLvalue" ):
|
|
listener.enterLvalue(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitLvalue" ):
|
|
listener.exitLvalue(self)
|
|
|
|
|
|
|
|
|
|
def lvalue(self):
|
|
|
|
localctx = CParser.LvalueContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 96, self.RULE_lvalue)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 666
|
|
self.unary_expression()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Assignment_operatorContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_assignment_operator
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterAssignment_operator" ):
|
|
listener.enterAssignment_operator(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitAssignment_operator" ):
|
|
listener.exitAssignment_operator(self)
|
|
|
|
|
|
|
|
|
|
def assignment_operator(self):
|
|
|
|
localctx = CParser.Assignment_operatorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 98, self.RULE_assignment_operator)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 668
|
|
_la = self._input.LA(1)
|
|
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)):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Conditional_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.e = None # Logical_or_expressionContext
|
|
|
|
def logical_or_expression(self):
|
|
return self.getTypedRuleContext(CParser.Logical_or_expressionContext,0)
|
|
|
|
|
|
def expression(self):
|
|
return self.getTypedRuleContext(CParser.ExpressionContext,0)
|
|
|
|
|
|
def conditional_expression(self):
|
|
return self.getTypedRuleContext(CParser.Conditional_expressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_conditional_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterConditional_expression" ):
|
|
listener.enterConditional_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitConditional_expression" ):
|
|
listener.exitConditional_expression(self)
|
|
|
|
|
|
|
|
|
|
def conditional_expression(self):
|
|
|
|
localctx = CParser.Conditional_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 100, self.RULE_conditional_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 670
|
|
localctx.e = self.logical_or_expression()
|
|
self.state = 677
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__65:
|
|
self.state = 671
|
|
self.match(CParser.T__65)
|
|
self.state = 672
|
|
self.expression()
|
|
self.state = 673
|
|
self.match(CParser.T__22)
|
|
self.state = 674
|
|
self.conditional_expression()
|
|
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))))
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Logical_or_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def logical_and_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Logical_and_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Logical_and_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_logical_or_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterLogical_or_expression" ):
|
|
listener.enterLogical_or_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitLogical_or_expression" ):
|
|
listener.exitLogical_or_expression(self)
|
|
|
|
|
|
|
|
|
|
def logical_or_expression(self):
|
|
|
|
localctx = CParser.Logical_or_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 102, self.RULE_logical_or_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 679
|
|
self.logical_and_expression()
|
|
self.state = 684
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__66:
|
|
self.state = 680
|
|
self.match(CParser.T__66)
|
|
self.state = 681
|
|
self.logical_and_expression()
|
|
self.state = 686
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Logical_and_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def inclusive_or_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Inclusive_or_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Inclusive_or_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_logical_and_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterLogical_and_expression" ):
|
|
listener.enterLogical_and_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitLogical_and_expression" ):
|
|
listener.exitLogical_and_expression(self)
|
|
|
|
|
|
|
|
|
|
def logical_and_expression(self):
|
|
|
|
localctx = CParser.Logical_and_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 104, self.RULE_logical_and_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 687
|
|
self.inclusive_or_expression()
|
|
self.state = 692
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__67:
|
|
self.state = 688
|
|
self.match(CParser.T__67)
|
|
self.state = 689
|
|
self.inclusive_or_expression()
|
|
self.state = 694
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Inclusive_or_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def exclusive_or_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Exclusive_or_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Exclusive_or_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_inclusive_or_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterInclusive_or_expression" ):
|
|
listener.enterInclusive_or_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitInclusive_or_expression" ):
|
|
listener.exitInclusive_or_expression(self)
|
|
|
|
|
|
|
|
|
|
def inclusive_or_expression(self):
|
|
|
|
localctx = CParser.Inclusive_or_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 106, self.RULE_inclusive_or_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 695
|
|
self.exclusive_or_expression()
|
|
self.state = 700
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__68:
|
|
self.state = 696
|
|
self.match(CParser.T__68)
|
|
self.state = 697
|
|
self.exclusive_or_expression()
|
|
self.state = 702
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Exclusive_or_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def and_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.And_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.And_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_exclusive_or_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterExclusive_or_expression" ):
|
|
listener.enterExclusive_or_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitExclusive_or_expression" ):
|
|
listener.exitExclusive_or_expression(self)
|
|
|
|
|
|
|
|
|
|
def exclusive_or_expression(self):
|
|
|
|
localctx = CParser.Exclusive_or_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 108, self.RULE_exclusive_or_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 703
|
|
self.and_expression()
|
|
self.state = 708
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__69:
|
|
self.state = 704
|
|
self.match(CParser.T__69)
|
|
self.state = 705
|
|
self.and_expression()
|
|
self.state = 710
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class And_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def equality_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Equality_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Equality_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_and_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterAnd_expression" ):
|
|
listener.enterAnd_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitAnd_expression" ):
|
|
listener.exitAnd_expression(self)
|
|
|
|
|
|
|
|
|
|
def and_expression(self):
|
|
|
|
localctx = CParser.And_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 110, self.RULE_and_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 711
|
|
self.equality_expression()
|
|
self.state = 716
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__52:
|
|
self.state = 712
|
|
self.match(CParser.T__52)
|
|
self.state = 713
|
|
self.equality_expression()
|
|
self.state = 718
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Equality_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def relational_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Relational_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Relational_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_equality_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterEquality_expression" ):
|
|
listener.enterEquality_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitEquality_expression" ):
|
|
listener.exitEquality_expression(self)
|
|
|
|
|
|
|
|
|
|
def equality_expression(self):
|
|
|
|
localctx = CParser.Equality_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 112, self.RULE_equality_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 719
|
|
self.relational_expression()
|
|
self.state = 724
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__70 or _la==CParser.T__71:
|
|
self.state = 720
|
|
_la = self._input.LA(1)
|
|
if not(_la==CParser.T__70 or _la==CParser.T__71):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
self.state = 721
|
|
self.relational_expression()
|
|
self.state = 726
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Relational_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def shift_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Shift_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Shift_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_relational_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterRelational_expression" ):
|
|
listener.enterRelational_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitRelational_expression" ):
|
|
listener.exitRelational_expression(self)
|
|
|
|
|
|
|
|
|
|
def relational_expression(self):
|
|
|
|
localctx = CParser.Relational_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 114, self.RULE_relational_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 727
|
|
self.shift_expression()
|
|
self.state = 732
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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):
|
|
self.state = 728
|
|
_la = self._input.LA(1)
|
|
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)):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
self.state = 729
|
|
self.shift_expression()
|
|
self.state = 734
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Shift_expressionContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def additive_expression(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.Additive_expressionContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.Additive_expressionContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_shift_expression
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterShift_expression" ):
|
|
listener.enterShift_expression(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitShift_expression" ):
|
|
listener.exitShift_expression(self)
|
|
|
|
|
|
|
|
|
|
def shift_expression(self):
|
|
|
|
localctx = CParser.Shift_expressionContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 116, self.RULE_shift_expression)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 735
|
|
self.additive_expression()
|
|
self.state = 740
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CParser.T__76 or _la==CParser.T__77:
|
|
self.state = 736
|
|
_la = self._input.LA(1)
|
|
if not(_la==CParser.T__76 or _la==CParser.T__77):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
self.state = 737
|
|
self.additive_expression()
|
|
self.state = 742
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class StatementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def labeled_statement(self):
|
|
return self.getTypedRuleContext(CParser.Labeled_statementContext,0)
|
|
|
|
|
|
def compound_statement(self):
|
|
return self.getTypedRuleContext(CParser.Compound_statementContext,0)
|
|
|
|
|
|
def expression_statement(self):
|
|
return self.getTypedRuleContext(CParser.Expression_statementContext,0)
|
|
|
|
|
|
def selection_statement(self):
|
|
return self.getTypedRuleContext(CParser.Selection_statementContext,0)
|
|
|
|
|
|
def iteration_statement(self):
|
|
return self.getTypedRuleContext(CParser.Iteration_statementContext,0)
|
|
|
|
|
|
def jump_statement(self):
|
|
return self.getTypedRuleContext(CParser.Jump_statementContext,0)
|
|
|
|
|
|
def macro_statement(self):
|
|
return self.getTypedRuleContext(CParser.Macro_statementContext,0)
|
|
|
|
|
|
def asm2_statement(self):
|
|
return self.getTypedRuleContext(CParser.Asm2_statementContext,0)
|
|
|
|
|
|
def asm1_statement(self):
|
|
return self.getTypedRuleContext(CParser.Asm1_statementContext,0)
|
|
|
|
|
|
def asm_statement(self):
|
|
return self.getTypedRuleContext(CParser.Asm_statementContext,0)
|
|
|
|
|
|
def declaration(self):
|
|
return self.getTypedRuleContext(CParser.DeclarationContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterStatement" ):
|
|
listener.enterStatement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitStatement" ):
|
|
listener.exitStatement(self)
|
|
|
|
|
|
|
|
|
|
def statement(self):
|
|
|
|
localctx = CParser.StatementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 118, self.RULE_statement)
|
|
try:
|
|
self.state = 754
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 743
|
|
self.labeled_statement()
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 744
|
|
self.compound_statement()
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 745
|
|
self.expression_statement()
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 746
|
|
self.selection_statement()
|
|
pass
|
|
|
|
elif la_ == 5:
|
|
self.enterOuterAlt(localctx, 5)
|
|
self.state = 747
|
|
self.iteration_statement()
|
|
pass
|
|
|
|
elif la_ == 6:
|
|
self.enterOuterAlt(localctx, 6)
|
|
self.state = 748
|
|
self.jump_statement()
|
|
pass
|
|
|
|
elif la_ == 7:
|
|
self.enterOuterAlt(localctx, 7)
|
|
self.state = 749
|
|
self.macro_statement()
|
|
pass
|
|
|
|
elif la_ == 8:
|
|
self.enterOuterAlt(localctx, 8)
|
|
self.state = 750
|
|
self.asm2_statement()
|
|
pass
|
|
|
|
elif la_ == 9:
|
|
self.enterOuterAlt(localctx, 9)
|
|
self.state = 751
|
|
self.asm1_statement()
|
|
pass
|
|
|
|
elif la_ == 10:
|
|
self.enterOuterAlt(localctx, 10)
|
|
self.state = 752
|
|
self.asm_statement()
|
|
pass
|
|
|
|
elif la_ == 11:
|
|
self.enterOuterAlt(localctx, 11)
|
|
self.state = 753
|
|
self.declaration()
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Asm2_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_asm2_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterAsm2_statement" ):
|
|
listener.enterAsm2_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitAsm2_statement" ):
|
|
listener.exitAsm2_statement(self)
|
|
|
|
|
|
|
|
|
|
def asm2_statement(self):
|
|
|
|
localctx = CParser.Asm2_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 120, self.RULE_asm2_statement)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 757
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CParser.T__78:
|
|
self.state = 756
|
|
self.match(CParser.T__78)
|
|
|
|
|
|
self.state = 759
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 760
|
|
self.match(CParser.T__37)
|
|
self.state = 764
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,94,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 761
|
|
_la = self._input.LA(1)
|
|
if _la <= 0 or _la==CParser.T__1:
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
self.state = 766
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,94,self._ctx)
|
|
|
|
self.state = 767
|
|
self.match(CParser.T__38)
|
|
self.state = 768
|
|
self.match(CParser.T__1)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Asm1_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_asm1_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterAsm1_statement" ):
|
|
listener.enterAsm1_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitAsm1_statement" ):
|
|
listener.exitAsm1_statement(self)
|
|
|
|
|
|
|
|
|
|
def asm1_statement(self):
|
|
|
|
localctx = CParser.Asm1_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 122, self.RULE_asm1_statement)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 770
|
|
self.match(CParser.T__79)
|
|
self.state = 771
|
|
self.match(CParser.T__0)
|
|
self.state = 775
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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):
|
|
self.state = 772
|
|
_la = self._input.LA(1)
|
|
if _la <= 0 or _la==CParser.T__19:
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
self.state = 777
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 778
|
|
self.match(CParser.T__19)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Asm_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_asm_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterAsm_statement" ):
|
|
listener.enterAsm_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitAsm_statement" ):
|
|
listener.exitAsm_statement(self)
|
|
|
|
|
|
|
|
|
|
def asm_statement(self):
|
|
|
|
localctx = CParser.Asm_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 124, self.RULE_asm_statement)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 780
|
|
self.match(CParser.T__80)
|
|
self.state = 781
|
|
self.match(CParser.T__0)
|
|
self.state = 785
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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):
|
|
self.state = 782
|
|
_la = self._input.LA(1)
|
|
if _la <= 0 or _la==CParser.T__19:
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
self.state = 787
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 788
|
|
self.match(CParser.T__19)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Macro_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
# @param i=None Type: int
|
|
def declaration(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.DeclarationContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.DeclarationContext,i)
|
|
|
|
|
|
def statement_list(self):
|
|
return self.getTypedRuleContext(CParser.Statement_listContext,0)
|
|
|
|
|
|
def expression(self):
|
|
return self.getTypedRuleContext(CParser.ExpressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_macro_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterMacro_statement" ):
|
|
listener.enterMacro_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitMacro_statement" ):
|
|
listener.exitMacro_statement(self)
|
|
|
|
|
|
|
|
|
|
def macro_statement(self):
|
|
|
|
localctx = CParser.Macro_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 126, self.RULE_macro_statement)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 790
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 791
|
|
self.match(CParser.T__37)
|
|
self.state = 795
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,97,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 792
|
|
self.declaration()
|
|
self.state = 797
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,97,self._ctx)
|
|
|
|
self.state = 799
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 798
|
|
self.statement_list()
|
|
|
|
|
|
self.state = 802
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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):
|
|
self.state = 801
|
|
self.expression()
|
|
|
|
|
|
self.state = 804
|
|
self.match(CParser.T__38)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Labeled_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
def statement(self):
|
|
return self.getTypedRuleContext(CParser.StatementContext,0)
|
|
|
|
|
|
def constant_expression(self):
|
|
return self.getTypedRuleContext(CParser.Constant_expressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_labeled_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterLabeled_statement" ):
|
|
listener.enterLabeled_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitLabeled_statement" ):
|
|
listener.exitLabeled_statement(self)
|
|
|
|
|
|
|
|
|
|
def labeled_statement(self):
|
|
|
|
localctx = CParser.Labeled_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 128, self.RULE_labeled_statement)
|
|
try:
|
|
self.state = 817
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.IDENTIFIER]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 806
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 807
|
|
self.match(CParser.T__22)
|
|
self.state = 808
|
|
self.statement()
|
|
pass
|
|
elif token in [CParser.T__81]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 809
|
|
self.match(CParser.T__81)
|
|
self.state = 810
|
|
self.constant_expression()
|
|
self.state = 811
|
|
self.match(CParser.T__22)
|
|
self.state = 812
|
|
self.statement()
|
|
pass
|
|
elif token in [CParser.T__82]:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 814
|
|
self.match(CParser.T__82)
|
|
self.state = 815
|
|
self.match(CParser.T__22)
|
|
self.state = 816
|
|
self.statement()
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Compound_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def declaration(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.DeclarationContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.DeclarationContext,i)
|
|
|
|
|
|
def statement_list(self):
|
|
return self.getTypedRuleContext(CParser.Statement_listContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_compound_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterCompound_statement" ):
|
|
listener.enterCompound_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitCompound_statement" ):
|
|
listener.exitCompound_statement(self)
|
|
|
|
|
|
|
|
|
|
def compound_statement(self):
|
|
|
|
localctx = CParser.Compound_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 130, self.RULE_compound_statement)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 819
|
|
self.match(CParser.T__0)
|
|
self.state = 823
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,101,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 820
|
|
self.declaration()
|
|
self.state = 825
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,101,self._ctx)
|
|
|
|
self.state = 827
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
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):
|
|
self.state = 826
|
|
self.statement_list()
|
|
|
|
|
|
self.state = 829
|
|
self.match(CParser.T__19)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Statement_listContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
# @param i=None Type: int
|
|
def statement(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.StatementContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.StatementContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_statement_list
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterStatement_list" ):
|
|
listener.enterStatement_list(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitStatement_list" ):
|
|
listener.exitStatement_list(self)
|
|
|
|
|
|
|
|
|
|
def statement_list(self):
|
|
|
|
localctx = CParser.Statement_listContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 132, self.RULE_statement_list)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 832
|
|
self._errHandler.sync(self)
|
|
_alt = 1
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt == 1:
|
|
self.state = 831
|
|
self.statement()
|
|
|
|
else:
|
|
raise NoViableAltException(self)
|
|
self.state = 834
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,103,self._ctx)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Expression_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def expression(self):
|
|
return self.getTypedRuleContext(CParser.ExpressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_expression_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterExpression_statement" ):
|
|
listener.enterExpression_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitExpression_statement" ):
|
|
listener.exitExpression_statement(self)
|
|
|
|
|
|
|
|
|
|
def expression_statement(self):
|
|
|
|
localctx = CParser.Expression_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 134, self.RULE_expression_statement)
|
|
try:
|
|
self.state = 840
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.T__1]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 836
|
|
self.match(CParser.T__1)
|
|
pass
|
|
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]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 837
|
|
self.expression()
|
|
self.state = 838
|
|
self.match(CParser.T__1)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Selection_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.e = None # ExpressionContext
|
|
|
|
# @param i=None Type: int
|
|
def statement(self,i=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CParser.StatementContext)
|
|
else:
|
|
return self.getTypedRuleContext(CParser.StatementContext,i)
|
|
|
|
|
|
def expression(self):
|
|
return self.getTypedRuleContext(CParser.ExpressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_selection_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterSelection_statement" ):
|
|
listener.enterSelection_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitSelection_statement" ):
|
|
listener.exitSelection_statement(self)
|
|
|
|
|
|
|
|
|
|
def selection_statement(self):
|
|
|
|
localctx = CParser.Selection_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 136, self.RULE_selection_statement)
|
|
try:
|
|
self.state = 858
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.T__83]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 842
|
|
self.match(CParser.T__83)
|
|
self.state = 843
|
|
self.match(CParser.T__37)
|
|
self.state = 844
|
|
localctx.e = self.expression()
|
|
self.state = 845
|
|
self.match(CParser.T__38)
|
|
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))))
|
|
self.state = 847
|
|
self.statement()
|
|
self.state = 850
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 848
|
|
self.match(CParser.T__84)
|
|
self.state = 849
|
|
self.statement()
|
|
|
|
|
|
pass
|
|
elif token in [CParser.T__85]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 852
|
|
self.match(CParser.T__85)
|
|
self.state = 853
|
|
self.match(CParser.T__37)
|
|
self.state = 854
|
|
self.expression()
|
|
self.state = 855
|
|
self.match(CParser.T__38)
|
|
self.state = 856
|
|
self.statement()
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Iteration_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.e = None # ExpressionContext
|
|
|
|
def statement(self):
|
|
return self.getTypedRuleContext(CParser.StatementContext,0)
|
|
|
|
|
|
def expression(self):
|
|
return self.getTypedRuleContext(CParser.ExpressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_iteration_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterIteration_statement" ):
|
|
listener.enterIteration_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitIteration_statement" ):
|
|
listener.exitIteration_statement(self)
|
|
|
|
|
|
|
|
|
|
def iteration_statement(self):
|
|
|
|
localctx = CParser.Iteration_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 138, self.RULE_iteration_statement)
|
|
try:
|
|
self.state = 876
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CParser.T__86]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 860
|
|
self.match(CParser.T__86)
|
|
self.state = 861
|
|
self.match(CParser.T__37)
|
|
self.state = 862
|
|
localctx.e = self.expression()
|
|
self.state = 863
|
|
self.match(CParser.T__38)
|
|
self.state = 864
|
|
self.statement()
|
|
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))))
|
|
pass
|
|
elif token in [CParser.T__87]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 867
|
|
self.match(CParser.T__87)
|
|
self.state = 868
|
|
self.statement()
|
|
self.state = 869
|
|
self.match(CParser.T__86)
|
|
self.state = 870
|
|
self.match(CParser.T__37)
|
|
self.state = 871
|
|
localctx.e = self.expression()
|
|
self.state = 872
|
|
self.match(CParser.T__38)
|
|
self.state = 873
|
|
self.match(CParser.T__1)
|
|
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))))
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class Jump_statementContext(ParserRuleContext):
|
|
|
|
# @param parent=None Type: ParserRuleContext
|
|
# @param invokingState=-1 Type: int
|
|
def __init__(self,parser,parent=None,invokingState=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def IDENTIFIER(self):
|
|
return self.getToken(CParser.IDENTIFIER, 0)
|
|
|
|
def expression(self):
|
|
return self.getTypedRuleContext(CParser.ExpressionContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CParser.RULE_jump_statement
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def enterRule(self,listener):
|
|
if hasattr( listener, "enterJump_statement" ):
|
|
listener.enterJump_statement(self)
|
|
|
|
# @param listener Type: ParseTreeListener
|
|
def exitRule(self,listener):
|
|
if hasattr( listener, "exitJump_statement" ):
|
|
listener.exitJump_statement(self)
|
|
|
|
|
|
|
|
|
|
def jump_statement(self):
|
|
|
|
localctx = CParser.Jump_statementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 140, self.RULE_jump_statement)
|
|
try:
|
|
self.state = 891
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
|
|
if la_ == 1:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 878
|
|
self.match(CParser.T__88)
|
|
self.state = 879
|
|
self.match(CParser.IDENTIFIER)
|
|
self.state = 880
|
|
self.match(CParser.T__1)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 881
|
|
self.match(CParser.T__89)
|
|
self.state = 882
|
|
self.match(CParser.T__1)
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 883
|
|
self.match(CParser.T__90)
|
|
self.state = 884
|
|
self.match(CParser.T__1)
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 885
|
|
self.match(CParser.T__91)
|
|
self.state = 886
|
|
self.match(CParser.T__1)
|
|
pass
|
|
|
|
elif la_ == 5:
|
|
self.enterOuterAlt(localctx, 5)
|
|
self.state = 887
|
|
self.match(CParser.T__91)
|
|
self.state = 888
|
|
self.expression()
|
|
self.state = 889
|
|
self.match(CParser.T__1)
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
|
|
|
|
|