# Generated from Documents\THESE\pycropml_pheno\src\pycropml\antlr_grammarV4\cpp\CPP14.g4 by ANTLR 4.8
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
from typing import TextIO
else:
from typing.io import TextIO
[docs]
def serializedATN():
with StringIO() as buf:
buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0098")
buf.write("\u09b1\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\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080")
buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084")
buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087")
buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b")
buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e")
buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092")
buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095")
buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099")
buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c")
buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0")
buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3")
buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7")
buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa")
buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae")
buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1")
buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5")
buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8")
buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc")
buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf")
buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3")
buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6")
buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca")
buf.write("\t\u00ca\4\u00cb\t\u00cb\3\2\5\2\u0198\n\2\3\2\3\2\3\3")
buf.write("\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u01a4\n\3\3\4\3\4\5\4")
buf.write("\u01a8\n\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u01b3")
buf.write("\n\5\3\6\3\6\5\6\u01b7\n\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7")
buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u01c6\n\7\3\7\3\7\3\7\3\7")
buf.write("\3\7\5\7\u01cd\n\7\3\7\3\7\3\7\7\7\u01d2\n\7\f\7\16\7")
buf.write("\u01d5\13\7\3\b\3\b\5\b\u01d9\n\b\3\b\3\b\3\t\3\t\5\t")
buf.write("\u01df\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u01e9\n")
buf.write("\n\3\13\3\13\3\f\3\f\3\f\5\f\u01f0\n\f\3\f\3\f\3\f\3\f")
buf.write("\5\f\u01f6\n\f\7\f\u01f8\n\f\f\f\16\f\u01fb\13\f\3\r\3")
buf.write("\r\5\r\u01ff\n\r\3\16\3\16\3\16\3\16\5\16\u0205\n\16\3")
buf.write("\17\3\17\3\17\3\17\3\17\5\17\u020c\n\17\3\20\3\20\3\20")
buf.write("\3\20\5\20\u0212\n\20\3\20\5\20\u0215\n\20\3\20\5\20\u0218")
buf.write("\n\20\3\20\5\20\u021b\n\20\3\21\3\21\3\21\3\21\3\21\5")
buf.write("\21\u0222\n\21\3\21\3\21\3\21\3\21\3\21\5\21\u0229\n\21")
buf.write("\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21")
buf.write("\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21")
buf.write("\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21")
buf.write("\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21")
buf.write("\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u025d\n\21\3\21\3")
buf.write("\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21")
buf.write("\3\21\5\21\u026c\n\21\3\21\3\21\3\21\3\21\5\21\u0272\n")
buf.write("\21\3\21\3\21\3\21\3\21\5\21\u0278\n\21\3\21\3\21\3\21")
buf.write("\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u0285\n")
buf.write("\21\f\21\16\21\u0288\13\21\3\22\3\22\3\23\3\23\3\24\3")
buf.write("\24\3\25\5\25\u0291\n\25\3\25\3\25\3\25\3\25\3\25\3\25")
buf.write("\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u02a0\n\25\3")
buf.write("\25\3\25\3\25\3\25\5\25\u02a6\n\25\3\26\3\26\3\26\3\26")
buf.write("\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26")
buf.write("\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26")
buf.write("\3\26\3\26\5\26\u02c4\n\26\3\27\3\27\3\30\5\30\u02c9\n")
buf.write("\30\3\30\3\30\5\30\u02cd\n\30\3\30\3\30\5\30\u02d1\n\30")
buf.write("\3\30\5\30\u02d4\n\30\3\30\3\30\5\30\u02d8\n\30\3\30\3")
buf.write("\30\3\30\3\30\5\30\u02de\n\30\5\30\u02e0\n\30\3\31\3\31")
buf.write("\3\31\3\31\3\32\3\32\5\32\u02e8\n\32\3\33\3\33\5\33\u02ec")
buf.write("\n\33\3\33\5\33\u02ef\n\33\3\34\3\34\3\34\3\34\3\34\5")
buf.write("\34\u02f6\n\34\3\34\3\34\3\34\3\34\3\34\5\34\u02fd\n\34")
buf.write("\7\34\u02ff\n\34\f\34\16\34\u0302\13\34\3\35\3\35\5\35")
buf.write("\u0306\n\35\3\35\3\35\5\35\u030a\n\35\3\36\5\36\u030d")
buf.write("\n\36\3\36\3\36\3\36\5\36\u0312\n\36\3\36\3\36\3\36\3")
buf.write("\36\5\36\u0318\n\36\3\37\3\37\3\37\3\37\3\37\3 \3 \3 ")
buf.write("\3 \3 \3 \5 \u0325\n \3!\3!\3!\3!\3!\3!\3!\3!\3!\7!\u0330")
buf.write("\n!\f!\16!\u0333\13!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3")
buf.write("\"\3\"\3\"\3\"\7\"\u0341\n\"\f\"\16\"\u0344\13\"\3#\3")
buf.write("#\3#\3#\3#\3#\3#\3#\3#\7#\u034f\n#\f#\16#\u0352\13#\3")
buf.write("$\3$\3$\3$\3$\3$\3$\7$\u035b\n$\f$\16$\u035e\13$\3%\3")
buf.write("%\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\7&\u0371")
buf.write("\n&\f&\16&\u0374\13&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3")
buf.write("\'\7\'\u037f\n\'\f\'\16\'\u0382\13\'\3(\3(\3(\3(\3(\3")
buf.write("(\7(\u038a\n(\f(\16(\u038d\13(\3)\3)\3)\3)\3)\3)\7)\u0395")
buf.write("\n)\f)\16)\u0398\13)\3*\3*\3*\3*\3*\3*\7*\u03a0\n*\f*")
buf.write("\16*\u03a3\13*\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u03ae\n+")
buf.write("\f+\16+\u03b1\13+\3,\3,\3,\3,\3,\3,\3,\3,\3,\7,\u03bc")
buf.write("\n,\f,\16,\u03bf\13,\3-\3-\3-\3-\3-\3-\3-\5-\u03c8\n-")
buf.write("\3.\3.\3.\3.\3.\3.\5.\u03d0\n.\3/\3/\3\60\3\60\3\60\3")
buf.write("\60\3\60\3\60\7\60\u03da\n\60\f\60\16\60\u03dd\13\60\3")
buf.write("\61\3\61\3\62\3\62\5\62\u03e3\n\62\3\62\3\62\5\62\u03e7")
buf.write("\n\62\3\62\3\62\5\62\u03eb\n\62\3\62\3\62\5\62\u03ef\n")
buf.write("\62\3\62\3\62\5\62\u03f3\n\62\3\62\3\62\3\62\5\62\u03f8")
buf.write("\n\62\3\62\5\62\u03fb\n\62\3\63\5\63\u03fe\n\63\3\63\3")
buf.write("\63\3\63\3\63\5\63\u0404\n\63\3\63\3\63\3\63\3\63\3\63")
buf.write("\3\63\5\63\u040c\n\63\3\63\3\63\3\63\5\63\u0411\n\63\3")
buf.write("\64\5\64\u0414\n\64\3\64\3\64\3\65\3\65\5\65\u041a\n\65")
buf.write("\3\65\3\65\3\66\3\66\3\66\3\66\3\66\7\66\u0423\n\66\f")
buf.write("\66\16\66\u0426\13\66\3\67\3\67\3\67\3\67\3\67\3\67\3")
buf.write("\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67")
buf.write("\3\67\3\67\3\67\5\67\u043c\n\67\38\38\58\u0440\n8\38\3")
buf.write("8\38\38\38\38\58\u0448\n8\38\38\38\38\58\u044e\n8\39\3")
buf.write("9\39\39\39\39\39\39\39\39\39\39\39\39\39\39\39\39\59\u0462")
buf.write("\n9\39\39\59\u0466\n9\39\39\39\39\39\39\39\39\39\39\3")
buf.write("9\59\u0473\n9\3:\3:\5:\u0477\n:\3;\5;\u047a\n;\3;\3;\3")
buf.write(";\3<\3<\5<\u0481\n<\3=\3=\3=\3=\3=\3=\5=\u0489\n=\3=\3")
buf.write("=\3=\3=\3=\3=\3=\3=\5=\u0493\n=\3>\3>\3?\3?\3?\3?\3?\7")
buf.write("?\u049c\n?\f?\16?\u049f\13?\3@\3@\3@\3@\3@\3@\3@\3@\3")
buf.write("@\5@\u04aa\n@\3A\3A\3A\3A\3A\3A\3A\3A\5A\u04b4\nA\3B\3")
buf.write("B\3B\5B\u04b9\nB\3B\3B\3B\3B\3C\5C\u04c0\nC\3C\5C\u04c3")
buf.write("\nC\3C\3C\3C\5C\u04c8\nC\3C\3C\3C\5C\u04cd\nC\3D\3D\3")
buf.write("D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3G\3G\3G\3G\3G\3G\5G\u04e2")
buf.write("\nG\3H\3H\5H\u04e6\nH\3H\3H\3H\5H\u04eb\nH\3I\3I\3J\3")
buf.write("J\3K\3K\3L\3L\3L\5L\u04f6\nL\3M\3M\3M\3M\5M\u04fc\nM\3")
buf.write("N\3N\5N\u0500\nN\3N\3N\3N\5N\u0505\nN\3O\3O\5O\u0509\n")
buf.write("O\3O\3O\3O\5O\u050e\nO\3P\5P\u0511\nP\3P\3P\3P\3P\3P\3")
buf.write("P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\5P\u0527\n")
buf.write("P\3Q\3Q\3Q\3Q\5Q\u052d\nQ\3R\3R\3R\3R\3R\3R\3R\3R\3R\5")
buf.write("R\u0538\nR\3S\3S\5S\u053c\nS\3S\5S\u053f\nS\3S\3S\3S\3")
buf.write("S\3S\3S\3S\3S\5S\u0549\nS\3S\3S\3S\3S\5S\u054f\nS\3S\5")
buf.write("S\u0552\nS\3T\3T\3U\3U\3U\5U\u0559\nU\3U\3U\3U\3U\3U\3")
buf.write("U\3U\3U\5U\u0563\nU\3V\3V\5V\u0567\nV\3V\5V\u056a\nV\3")
buf.write("V\5V\u056d\nV\3V\3V\5V\u0571\nV\3V\3V\3V\5V\u0576\nV\5")
buf.write("V\u0578\nV\3W\3W\5W\u057c\nW\3W\3W\5W\u0580\nW\3W\3W\3")
buf.write("X\3X\3X\3X\3X\5X\u0589\nX\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\7")
buf.write("Z\u0594\nZ\fZ\16Z\u0597\13Z\3[\3[\3[\3[\3[\5[\u059e\n")
buf.write("[\3\\\3\\\3]\3]\5]\u05a4\n]\3^\3^\3_\3_\5_\u05aa\n_\3")
buf.write("`\3`\5`\u05ae\n`\3a\5a\u05b1\na\3a\3a\3a\3a\3a\3a\3b\5")
buf.write("b\u05ba\nb\3b\3b\3b\3b\3b\3b\3c\5c\u05c3\nc\3c\3c\3c\3")
buf.write("c\3c\3d\5d\u05cb\nd\3e\3e\3f\3f\3f\3f\3f\3f\3g\5g\u05d6")
buf.write("\ng\3g\3g\3h\3h\5h\u05dc\nh\3h\3h\3h\3h\3h\3h\3h\3h\3")
buf.write("h\5h\u05e7\nh\3i\5i\u05ea\ni\3i\3i\3i\5i\u05ef\ni\3i\3")
buf.write("i\3i\3j\3j\3j\3j\3j\3j\3k\3k\3k\3k\5k\u05fe\nk\3k\3k\3")
buf.write("k\3k\5k\u0604\nk\3l\3l\3l\3l\3l\7l\u060b\nl\fl\16l\u060e")
buf.write("\13l\3m\3m\3m\3m\3m\3m\3m\5m\u0617\nm\3n\3n\3n\3n\5n\u061d")
buf.write("\nn\3n\3n\3n\3n\3n\3n\5n\u0625\nn\3n\3n\5n\u0629\nn\3")
buf.write("o\3o\5o\u062d\no\3o\3o\3o\5o\u0632\no\3o\3o\3o\5o\u0637")
buf.write("\no\3o\3o\3o\3o\3o\7o\u063e\no\fo\16o\u0641\13o\3p\3p")
buf.write("\5p\u0645\np\3q\3q\5q\u0649\nq\3r\3r\3r\3r\3s\3s\3t\3")
buf.write("t\3t\3t\3u\3u\5u\u0657\nu\3u\3u\7u\u065b\nu\fu\16u\u065e")
buf.write("\13u\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\6v\u066d\n")
buf.write("v\rv\16v\u066e\5v\u0671\nv\3w\3w\3w\3w\3w\3w\7w\u0679")
buf.write("\nw\fw\16w\u067c\13w\3x\3x\5x\u0680\nx\3y\3y\3y\3y\3y")
buf.write("\5y\u0687\ny\3z\3z\3z\3z\5z\u068d\nz\3{\3{\3{\5{\u0692")
buf.write("\n{\3{\3{\3{\3{\5{\u0698\n{\3{\3{\3{\3{\3{\5{\u069f\n")
buf.write("{\3{\3{\5{\u06a3\n{\7{\u06a5\n{\f{\16{\u06a8\13{\3|\3")
buf.write("|\3|\3|\5|\u06ae\n|\3|\5|\u06b1\n|\3|\5|\u06b4\n|\3|\5")
buf.write("|\u06b7\n|\3}\3}\3}\5}\u06bc\n}\3~\3~\5~\u06c0\n~\3~\5")
buf.write("~\u06c3\n~\3~\3~\5~\u06c7\n~\3~\3~\5~\u06cb\n~\3~\3~\3")
buf.write("~\5~\u06d0\n~\3~\5~\u06d3\n~\5~\u06d5\n~\3\177\3\177\5")
buf.write("\177\u06d9\n\177\3\u0080\3\u0080\3\u0081\3\u0081\3\u0082")
buf.write("\5\u0082\u06e0\n\u0082\3\u0082\3\u0082\3\u0083\3\u0083")
buf.write("\5\u0083\u06e6\n\u0083\3\u0084\3\u0084\5\u0084\u06ea\n")
buf.write("\u0084\3\u0084\3\u0084\3\u0084\3\u0084\5\u0084\u06f0\n")
buf.write("\u0084\3\u0085\3\u0085\3\u0085\5\u0085\u06f5\n\u0085\5")
buf.write("\u0085\u06f7\n\u0085\3\u0086\3\u0086\3\u0086\3\u0086\5")
buf.write("\u0086\u06fd\n\u0086\3\u0086\3\u0086\5\u0086\u0701\n\u0086")
buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u0707\n\u0086")
buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u070e")
buf.write("\n\u0086\3\u0086\3\u0086\5\u0086\u0712\n\u0086\7\u0086")
buf.write("\u0714\n\u0086\f\u0086\16\u0086\u0717\13\u0086\3\u0087")
buf.write("\3\u0087\3\u0087\3\u0087\5\u0087\u071d\n\u0087\3\u0088")
buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088")
buf.write("\5\u0088\u0727\n\u0088\3\u0088\3\u0088\5\u0088\u072b\n")
buf.write("\u0088\7\u0088\u072d\n\u0088\f\u0088\16\u0088\u0730\13")
buf.write("\u0088\3\u0089\5\u0089\u0733\n\u0089\3\u0089\5\u0089\u0736")
buf.write("\n\u0089\3\u0089\3\u0089\3\u0089\3\u0089\5\u0089\u073c")
buf.write("\n\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
buf.write("\7\u008a\u0744\n\u008a\f\u008a\16\u008a\u0747\13\u008a")
buf.write("\3\u008b\5\u008b\u074a\n\u008b\3\u008b\3\u008b\3\u008b")
buf.write("\3\u008b\5\u008b\u0750\n\u008b\3\u008b\3\u008b\3\u008b")
buf.write("\3\u008b\3\u008b\3\u008b\5\u008b\u0758\n\u008b\3\u008b")
buf.write("\3\u008b\5\u008b\u075c\n\u008b\3\u008b\5\u008b\u075f\n")
buf.write("\u008b\3\u008b\3\u008b\5\u008b\u0763\n\u008b\3\u008b\3")
buf.write("\u008b\3\u008b\5\u008b\u0768\n\u008b\3\u008c\5\u008c\u076b")
buf.write("\n\u008c\3\u008c\5\u008c\u076e\n\u008c\3\u008c\3\u008c")
buf.write("\5\u008c\u0772\n\u008c\3\u008c\3\u008c\3\u008d\5\u008d")
buf.write("\u0777\n\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d")
buf.write("\3\u008d\3\u008d\3\u008d\5\u008d\u0781\n\u008d\3\u008e")
buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e\u0788\n\u008e")
buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u078d\n\u008f\3\u0090")
buf.write("\3\u0090\5\u0090\u0791\n\u0090\3\u0091\3\u0091\3\u0091")
buf.write("\5\u0091\u0796\n\u0091\3\u0091\3\u0091\3\u0091\3\u0091")
buf.write("\5\u0091\u079c\n\u0091\7\u0091\u079e\n\u0091\f\u0091\16")
buf.write("\u0091\u07a1\13\u0091\3\u0092\3\u0092\3\u0092\5\u0092")
buf.write("\u07a6\n\u0092\3\u0092\3\u0092\3\u0092\3\u0092\5\u0092")
buf.write("\u07ac\n\u0092\3\u0093\3\u0093\5\u0093\u07b0\n\u0093\3")
buf.write("\u0094\3\u0094\3\u0094\5\u0094\u07b5\n\u0094\3\u0094\3")
buf.write("\u0094\3\u0095\3\u0095\5\u0095\u07bb\n\u0095\3\u0095\3")
buf.write("\u0095\5\u0095\u07bf\n\u0095\3\u0095\5\u0095\u07c2\n\u0095")
buf.write("\3\u0095\3\u0095\5\u0095\u07c6\n\u0095\3\u0095\5\u0095")
buf.write("\u07c9\n\u0095\5\u0095\u07cb\n\u0095\3\u0096\5\u0096\u07ce")
buf.write("\n\u0096\3\u0096\3\u0096\3\u0097\3\u0097\3\u0098\3\u0098")
buf.write("\3\u0099\3\u0099\5\u0099\u07d8\n\u0099\3\u0099\3\u0099")
buf.write("\3\u0099\5\u0099\u07dd\n\u0099\5\u0099\u07df\n\u0099\3")
buf.write("\u009a\5\u009a\u07e2\n\u009a\3\u009a\5\u009a\u07e5\n\u009a")
buf.write("\3\u009a\5\u009a\u07e8\n\u009a\3\u009a\3\u009a\3\u009a")
buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\5\u009a\u07f1\n\u009a")
buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\7\u009b")
buf.write("\u07f9\n\u009b\f\u009b\16\u009b\u07fc\13\u009b\3\u009c")
buf.write("\3\u009c\5\u009c\u0800\n\u009c\3\u009c\5\u009c\u0803\n")
buf.write("\u009c\3\u009c\3\u009c\5\u009c\u0807\n\u009c\3\u009c\5")
buf.write("\u009c\u080a\n\u009c\3\u009c\5\u009c\u080d\n\u009c\3\u009c")
buf.write("\3\u009c\5\u009c\u0811\n\u009c\3\u009d\3\u009d\3\u009d")
buf.write("\3\u009d\3\u009d\7\u009d\u0818\n\u009d\f\u009d\16\u009d")
buf.write("\u081b\13\u009d\3\u009e\3\u009e\3\u009f\3\u009f\3\u009f")
buf.write("\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1")
buf.write("\5\u00a1\u0829\n\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1")
buf.write("\5\u00a1\u082f\n\u00a1\7\u00a1\u0831\n\u00a1\f\u00a1\16")
buf.write("\u00a1\u0834\13\u00a1\3\u00a2\5\u00a2\u0837\n\u00a2\3")
buf.write("\u00a2\3\u00a2\5\u00a2\u083b\n\u00a2\3\u00a2\3\u00a2\5")
buf.write("\u00a2\u083f\n\u00a2\3\u00a2\3\u00a2\5\u00a2\u0843\n\u00a2")
buf.write("\3\u00a2\3\u00a2\5\u00a2\u0847\n\u00a2\3\u00a2\3\u00a2")
buf.write("\5\u00a2\u084b\n\u00a2\3\u00a3\5\u00a3\u084e\n\u00a3\3")
buf.write("\u00a3\3\u00a3\5\u00a3\u0852\n\u00a3\3\u00a4\3\u00a4\3")
buf.write("\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7")
buf.write("\5\u00a7\u085d\n\u00a7\3\u00a8\3\u00a8\5\u00a8\u0861\n")
buf.write("\u00a8\3\u00a9\3\u00a9\3\u00a9\3\u00aa\3\u00aa\5\u00aa")
buf.write("\u0868\n\u00aa\3\u00aa\3\u00aa\5\u00aa\u086c\n\u00aa\3")
buf.write("\u00aa\3\u00aa\3\u00aa\5\u00aa\u0871\n\u00aa\3\u00ab\3")
buf.write("\u00ab\3\u00ab\5\u00ab\u0876\n\u00ab\3\u00ab\3\u00ab\3")
buf.write("\u00ab\3\u00ab\3\u00ab\5\u00ab\u087d\n\u00ab\3\u00ac\3")
buf.write("\u00ac\5\u00ac\u0881\n\u00ac\3\u00ad\3\u00ad\3\u00ad\3")
buf.write("\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u088b\n")
buf.write("\u00ae\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af")
buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\7\u00b0")
buf.write("\u0899\n\u00b0\f\u00b0\16\u00b0\u089c\13\u00b0\3\u00b1")
buf.write("\3\u00b1\5\u00b1\u08a0\n\u00b1\3\u00b2\3\u00b2\5\u00b2")
buf.write("\u08a4\n\u00b2\3\u00b2\5\u00b2\u08a7\n\u00b2\3\u00b2\3")
buf.write("\u00b2\5\u00b2\u08ab\n\u00b2\3\u00b2\3\u00b2\3\u00b2\3")
buf.write("\u00b2\5\u00b2\u08b1\n\u00b2\3\u00b2\5\u00b2\u08b4\n\u00b2")
buf.write("\3\u00b2\3\u00b2\5\u00b2\u08b8\n\u00b2\3\u00b2\3\u00b2")
buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2")
buf.write("\u08c2\n\u00b2\3\u00b2\5\u00b2\u08c5\n\u00b2\3\u00b2\3")
buf.write("\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u08cd\n")
buf.write("\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u08d2\n\u00b2\3")
buf.write("\u00b3\3\u00b3\3\u00b3\5\u00b3\u08d7\n\u00b3\3\u00b3\3")
buf.write("\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4\5\u00b4\u08df\n")
buf.write("\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\5\u00b4")
buf.write("\u08e6\n\u00b4\3\u00b4\3\u00b4\5\u00b4\u08ea\n\u00b4\3")
buf.write("\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u08f1\n")
buf.write("\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u08f7\n")
buf.write("\u00b6\7\u00b6\u08f9\n\u00b6\f\u00b6\16\u00b6\u08fc\13")
buf.write("\u00b6\3\u00b7\3\u00b7\3\u00b7\5\u00b7\u0901\n\u00b7\3")
buf.write("\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
buf.write("\5\u00b8\u090a\n\u00b8\3\u00b8\3\u00b8\5\u00b8\u090e\n")
buf.write("\u00b8\3\u00b9\5\u00b9\u0911\n\u00b9\3\u00b9\3\u00b9\3")
buf.write("\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb")
buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bc\3\u00bc\5\u00bc\u0921")
buf.write("\n\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bd\3\u00bd\5\u00bd")
buf.write("\u0928\n\u00bd\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
buf.write("\3\u00be\3\u00bf\5\u00bf\u0931\n\u00bf\3\u00bf\3\u00bf")
buf.write("\3\u00bf\3\u00bf\5\u00bf\u0937\n\u00bf\3\u00bf\3\u00bf")
buf.write("\5\u00bf\u093b\n\u00bf\3\u00bf\5\u00bf\u093e\n\u00bf\3")
buf.write("\u00c0\3\u00c0\5\u00c0\u0942\n\u00c0\3\u00c1\3\u00c1\5")
buf.write("\u00c1\u0946\n\u00c1\3\u00c2\3\u00c2\3\u00c2\5\u00c2\u094b")
buf.write("\n\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\5\u00c3")
buf.write("\u0952\n\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\5\u00c3")
buf.write("\u0958\n\u00c3\7\u00c3\u095a\n\u00c3\f\u00c3\16\u00c3")
buf.write("\u095d\13\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4")
buf.write("\3\u00c4\5\u00c4\u0965\n\u00c4\3\u00c5\3\u00c5\3\u00c6")
buf.write("\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
buf.write("\3\u00c7\3\u00c7\3\u00c7\5\u00c7\u099e\n\u00c7\3\u00c8")
buf.write("\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8")
buf.write("\u09a7\n\u00c8\3\u00c9\3\u00c9\5\u00c9\u09ab\n\u00c9\3")
buf.write("\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cb\2$\f\26 \66@BD")
buf.write("FJLNPRTV^j|\u00b2\u00d6\u00dc\u00e8\u00ec\u00f4\u010a")
buf.write("\u010e\u0112\u0120\u0134\u0138\u0140\u015e\u016a\u0184")
buf.write("\u00cc\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,")
buf.write(".\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080")
buf.write("\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092")
buf.write("\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4")
buf.write("\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6")
buf.write("\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8")
buf.write("\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da")
buf.write("\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec")
buf.write("\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe")
buf.write("\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110")
buf.write("\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122")
buf.write("\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134")
buf.write("\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146")
buf.write("\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158")
buf.write("\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a")
buf.write("\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c")
buf.write("\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e")
buf.write("\u0190\u0192\u0194\2\17\4\2bbff\5\2\3\4\\^bd\3\2qr\5\2")
buf.write("ffipst\7\2\'\'\61\61;;AAHH\5\2%%..QQ\3\2V[\4\2\31\31S")
buf.write("S\4\2\5\5bb\5\2\30\30DDNN\4\2((\67\67\3\28:\3\2\u0091")
buf.write("\u0094\2\u0acc\2\u0197\3\2\2\2\4\u01a3\3\2\2\2\6\u01a7")
buf.write("\3\2\2\2\b\u01b2\3\2\2\2\n\u01b4\3\2\2\2\f\u01c5\3\2\2")
buf.write("\2\16\u01d6\3\2\2\2\20\u01dc\3\2\2\2\22\u01e8\3\2\2\2")
buf.write("\24\u01ea\3\2\2\2\26\u01ec\3\2\2\2\30\u01fe\3\2\2\2\32")
buf.write("\u0204\3\2\2\2\34\u020b\3\2\2\2\36\u020d\3\2\2\2 \u025c")
buf.write("\3\2\2\2\"\u0289\3\2\2\2$\u028b\3\2\2\2&\u028d\3\2\2\2")
buf.write("(\u02a5\3\2\2\2*\u02c3\3\2\2\2,\u02c5\3\2\2\2.\u02df\3")
buf.write("\2\2\2\60\u02e1\3\2\2\2\62\u02e5\3\2\2\2\64\u02ee\3\2")
buf.write("\2\2\66\u02f0\3\2\2\28\u0309\3\2\2\2:\u0317\3\2\2\2<\u0319")
buf.write("\3\2\2\2>\u0324\3\2\2\2@\u0326\3\2\2\2B\u0334\3\2\2\2")
buf.write("D\u0345\3\2\2\2F\u0353\3\2\2\2H\u035f\3\2\2\2J\u0361\3")
buf.write("\2\2\2L\u0375\3\2\2\2N\u0383\3\2\2\2P\u038e\3\2\2\2R\u0399")
buf.write("\3\2\2\2T\u03a4\3\2\2\2V\u03b2\3\2\2\2X\u03c7\3\2\2\2")
buf.write("Z\u03cf\3\2\2\2\\\u03d1\3\2\2\2^\u03d3\3\2\2\2`\u03de")
buf.write("\3\2\2\2b\u03fa\3\2\2\2d\u0410\3\2\2\2f\u0413\3\2\2\2")
buf.write("h\u0417\3\2\2\2j\u041d\3\2\2\2l\u043b\3\2\2\2n\u044d\3")
buf.write("\2\2\2p\u0472\3\2\2\2r\u0476\3\2\2\2t\u0479\3\2\2\2v\u0480")
buf.write("\3\2\2\2x\u0492\3\2\2\2z\u0494\3\2\2\2|\u0496\3\2\2\2")
buf.write("~\u04a9\3\2\2\2\u0080\u04b3\3\2\2\2\u0082\u04b5\3\2\2")
buf.write("\2\u0084\u04cc\3\2\2\2\u0086\u04ce\3\2\2\2\u0088\u04d6")
buf.write("\3\2\2\2\u008a\u04d8\3\2\2\2\u008c\u04e1\3\2\2\2\u008e")
buf.write("\u04ea\3\2\2\2\u0090\u04ec\3\2\2\2\u0092\u04ee\3\2\2\2")
buf.write("\u0094\u04f0\3\2\2\2\u0096\u04f5\3\2\2\2\u0098\u04fb\3")
buf.write("\2\2\2\u009a\u0504\3\2\2\2\u009c\u050d\3\2\2\2\u009e\u0526")
buf.write("\3\2\2\2\u00a0\u052c\3\2\2\2\u00a2\u0537\3\2\2\2\u00a4")
buf.write("\u0551\3\2\2\2\u00a6\u0553\3\2\2\2\u00a8\u0562\3\2\2\2")
buf.write("\u00aa\u0577\3\2\2\2\u00ac\u0579\3\2\2\2\u00ae\u0588\3")
buf.write("\2\2\2\u00b0\u058a\3\2\2\2\u00b2\u058d\3\2\2\2\u00b4\u059d")
buf.write("\3\2\2\2\u00b6\u059f\3\2\2\2\u00b8\u05a3\3\2\2\2\u00ba")
buf.write("\u05a5\3\2\2\2\u00bc\u05a9\3\2\2\2\u00be\u05ad\3\2\2\2")
buf.write("\u00c0\u05b0\3\2\2\2\u00c2\u05b9\3\2\2\2\u00c4\u05c2\3")
buf.write("\2\2\2\u00c6\u05ca\3\2\2\2\u00c8\u05cc\3\2\2\2\u00ca\u05ce")
buf.write("\3\2\2\2\u00cc\u05d5\3\2\2\2\u00ce\u05e6\3\2\2\2\u00d0")
buf.write("\u05e9\3\2\2\2\u00d2\u05f3\3\2\2\2\u00d4\u0603\3\2\2\2")
buf.write("\u00d6\u0605\3\2\2\2\u00d8\u0616\3\2\2\2\u00da\u0628\3")
buf.write("\2\2\2\u00dc\u0631\3\2\2\2\u00de\u0642\3\2\2\2\u00e0\u0648")
buf.write("\3\2\2\2\u00e2\u064a\3\2\2\2\u00e4\u064e\3\2\2\2\u00e6")
buf.write("\u0650\3\2\2\2\u00e8\u0654\3\2\2\2\u00ea\u0670\3\2\2\2")
buf.write("\u00ec\u0672\3\2\2\2\u00ee\u067d\3\2\2\2\u00f0\u0686\3")
buf.write("\2\2\2\u00f2\u068c\3\2\2\2\u00f4\u0697\3\2\2\2\u00f6\u06a9")
buf.write("\3\2\2\2\u00f8\u06b8\3\2\2\2\u00fa\u06d4\3\2\2\2\u00fc")
buf.write("\u06d6\3\2\2\2\u00fe\u06da\3\2\2\2\u0100\u06dc\3\2\2\2")
buf.write("\u0102\u06df\3\2\2\2\u0104\u06e3\3\2\2\2\u0106\u06ef\3")
buf.write("\2\2\2\u0108\u06f6\3\2\2\2\u010a\u0706\3\2\2\2\u010c\u071c")
buf.write("\3\2\2\2\u010e\u071e\3\2\2\2\u0110\u073b\3\2\2\2\u0112")
buf.write("\u073d\3\2\2\2\u0114\u0767\3\2\2\2\u0116\u076a\3\2\2\2")
buf.write("\u0118\u0780\3\2\2\2\u011a\u0787\3\2\2\2\u011c\u078c\3")
buf.write("\2\2\2\u011e\u0790\3\2\2\2\u0120\u0792\3\2\2\2\u0122\u07ab")
buf.write("\3\2\2\2\u0124\u07af\3\2\2\2\u0126\u07b1\3\2\2\2\u0128")
buf.write("\u07ca\3\2\2\2\u012a\u07cd\3\2\2\2\u012c\u07d1\3\2\2\2")
buf.write("\u012e\u07d3\3\2\2\2\u0130\u07de\3\2\2\2\u0132\u07f0\3")
buf.write("\2\2\2\u0134\u07f2\3\2\2\2\u0136\u0810\3\2\2\2\u0138\u0812")
buf.write("\3\2\2\2\u013a\u081c\3\2\2\2\u013c\u081e\3\2\2\2\u013e")
buf.write("\u0822\3\2\2\2\u0140\u0825\3\2\2\2\u0142\u084a\3\2\2\2")
buf.write("\u0144\u0851\3\2\2\2\u0146\u0853\3\2\2\2\u0148\u0855\3")
buf.write("\2\2\2\u014a\u0857\3\2\2\2\u014c\u085a\3\2\2\2\u014e\u085e")
buf.write("\3\2\2\2\u0150\u0862\3\2\2\2\u0152\u0870\3\2\2\2\u0154")
buf.write("\u087c\3\2\2\2\u0156\u0880\3\2\2\2\u0158\u0882\3\2\2\2")
buf.write("\u015a\u088a\3\2\2\2\u015c\u088c\3\2\2\2\u015e\u0892\3")
buf.write("\2\2\2\u0160\u089f\3\2\2\2\u0162\u08d1\3\2\2\2\u0164\u08d3")
buf.write("\3\2\2\2\u0166\u08e9\3\2\2\2\u0168\u08eb\3\2\2\2\u016a")
buf.write("\u08ed\3\2\2\2\u016c\u0900\3\2\2\2\u016e\u090d\3\2\2\2")
buf.write("\u0170\u0910\3\2\2\2\u0172\u0915\3\2\2\2\u0174\u091a\3")
buf.write("\2\2\2\u0176\u091e\3\2\2\2\u0178\u0925\3\2\2\2\u017a\u0929")
buf.write("\3\2\2\2\u017c\u093d\3\2\2\2\u017e\u093f\3\2\2\2\u0180")
buf.write("\u0945\3\2\2\2\u0182\u0947\3\2\2\2\u0184\u094e\3\2\2\2")
buf.write("\u0186\u0964\3\2\2\2\u0188\u0966\3\2\2\2\u018a\u0968\3")
buf.write("\2\2\2\u018c\u099d\3\2\2\2\u018e\u09a6\3\2\2\2\u0190\u09aa")
buf.write("\3\2\2\2\u0192\u09ac\3\2\2\2\u0194\u09ae\3\2\2\2\u0196")
buf.write("\u0198\5|?\2\u0197\u0196\3\2\2\2\u0197\u0198\3\2\2\2\u0198")
buf.write("\u0199\3\2\2\2\u0199\u019a\7\2\2\3\u019a\3\3\2\2\2\u019b")
buf.write("\u01a4\5\u018e\u00c8\2\u019c\u01a4\7G\2\2\u019d\u019e")
buf.write("\7V\2\2\u019e\u019f\5^\60\2\u019f\u01a0\7W\2\2\u01a0\u01a4")
buf.write("\3\2\2\2\u01a1\u01a4\5\6\4\2\u01a2\u01a4\5\16\b\2\u01a3")
buf.write("\u019b\3\2\2\2\u01a3\u019c\3\2\2\2\u01a3\u019d\3\2\2\2")
buf.write("\u01a3\u01a1\3\2\2\2\u01a3\u01a2\3\2\2\2\u01a4\5\3\2\2")
buf.write("\2\u01a5\u01a8\5\b\5\2\u01a6\u01a8\5\n\6\2\u01a7\u01a5")
buf.write("\3\2\2\2\u01a7\u01a6\3\2\2\2\u01a8\7\3\2\2\2\u01a9\u01b3")
buf.write("\7\u0087\2\2\u01aa\u01b3\5\u0158\u00ad\2\u01ab\u01b3\5")
buf.write("\u014a\u00a6\2\u01ac\u01b3\5\u015a\u00ae\2\u01ad\u01ae")
buf.write("\7d\2\2\u01ae\u01b3\5\u0124\u0093\2\u01af\u01b0\7d\2\2")
buf.write("\u01b0\u01b3\5\u00a2R\2\u01b1\u01b3\5\u0166\u00b4\2\u01b2")
buf.write("\u01a9\3\2\2\2\u01b2\u01aa\3\2\2\2\u01b2\u01ab\3\2\2\2")
buf.write("\u01b2\u01ac\3\2\2\2\u01b2\u01ad\3\2\2\2\u01b2\u01af\3")
buf.write("\2\2\2\u01b2\u01b1\3\2\2\2\u01b3\t\3\2\2\2\u01b4\u01b6")
buf.write("\5\f\7\2\u01b5\u01b7\7F\2\2\u01b6\u01b5\3\2\2\2\u01b6")
buf.write("\u01b7\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8\u01b9\5\b\5\2")
buf.write("\u01b9\13\3\2\2\2\u01ba\u01bb\b\7\1\2\u01bb\u01c6\7\u0082")
buf.write("\2\2\u01bc\u01bd\5\u00a0Q\2\u01bd\u01be\7\u0082\2\2\u01be")
buf.write("\u01c6\3\2\2\2\u01bf\u01c0\5\u00b8]\2\u01c0\u01c1\7\u0082")
buf.write("\2\2\u01c1\u01c6\3\2\2\2\u01c2\u01c3\5\u00a2R\2\u01c3")
buf.write("\u01c4\7\u0082\2\2\u01c4\u01c6\3\2\2\2\u01c5\u01ba\3\2")
buf.write("\2\2\u01c5\u01bc\3\2\2\2\u01c5\u01bf\3\2\2\2\u01c5\u01c2")
buf.write("\3\2\2\2\u01c6\u01d3\3\2\2\2\u01c7\u01c8\f\4\2\2\u01c8")
buf.write("\u01c9\7\u0087\2\2\u01c9\u01d2\7\u0082\2\2\u01ca\u01cc")
buf.write("\f\3\2\2\u01cb\u01cd\7F\2\2\u01cc\u01cb\3\2\2\2\u01cc")
buf.write("\u01cd\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01cf\5\u0164")
buf.write("\u00b3\2\u01cf\u01d0\7\u0082\2\2\u01d0\u01d2\3\2\2\2\u01d1")
buf.write("\u01c7\3\2\2\2\u01d1\u01ca\3\2\2\2\u01d2\u01d5\3\2\2\2")
buf.write("\u01d3\u01d1\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\r\3\2\2")
buf.write("\2\u01d5\u01d3\3\2\2\2\u01d6\u01d8\5\20\t\2\u01d7\u01d9")
buf.write("\5\36\20\2\u01d8\u01d7\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9")
buf.write("\u01da\3\2\2\2\u01da\u01db\5h\65\2\u01db\17\3\2\2\2\u01dc")
buf.write("\u01de\7X\2\2\u01dd\u01df\5\22\n\2\u01de\u01dd\3\2\2\2")
buf.write("\u01de\u01df\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0\u01e1\7")
buf.write("Y\2\2\u01e1\21\3\2\2\2\u01e2\u01e9\5\24\13\2\u01e3\u01e9")
buf.write("\5\26\f\2\u01e4\u01e5\5\24\13\2\u01e5\u01e6\7}\2\2\u01e6")
buf.write("\u01e7\5\26\f\2\u01e7\u01e9\3\2\2\2\u01e8\u01e2\3\2\2")
buf.write("\2\u01e8\u01e3\3\2\2\2\u01e8\u01e4\3\2\2\2\u01e9\23\3")
buf.write("\2\2\2\u01ea\u01eb\t\2\2\2\u01eb\25\3\2\2\2\u01ec\u01ed")
buf.write("\b\f\1\2\u01ed\u01ef\5\30\r\2\u01ee\u01f0\7\u0086\2\2")
buf.write("\u01ef\u01ee\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f9\3")
buf.write("\2\2\2\u01f1\u01f2\f\3\2\2\u01f2\u01f3\7}\2\2\u01f3\u01f5")
buf.write("\5\30\r\2\u01f4\u01f6\7\u0086\2\2\u01f5\u01f4\3\2\2\2")
buf.write("\u01f5\u01f6\3\2\2\2\u01f6\u01f8\3\2\2\2\u01f7\u01f1\3")
buf.write("\2\2\2\u01f8\u01fb\3\2\2\2\u01f9\u01f7\3\2\2\2\u01f9\u01fa")
buf.write("\3\2\2\2\u01fa\27\3\2\2\2\u01fb\u01f9\3\2\2\2\u01fc\u01ff")
buf.write("\5\32\16\2\u01fd\u01ff\5\34\17\2\u01fe\u01fc\3\2\2\2\u01fe")
buf.write("\u01fd\3\2\2\2\u01ff\31\3\2\2\2\u0200\u0205\7\u0087\2")
buf.write("\2\u0201\u0202\7b\2\2\u0202\u0205\7\u0087\2\2\u0203\u0205")
buf.write("\7G\2\2\u0204\u0200\3\2\2\2\u0204\u0201\3\2\2\2\u0204")
buf.write("\u0203\3\2\2\2\u0205\33\3\2\2\2\u0206\u0207\7\u0087\2")
buf.write("\2\u0207\u020c\5\u011a\u008e\2\u0208\u0209\7b\2\2\u0209")
buf.write("\u020a\7\u0087\2\2\u020a\u020c\5\u011a\u008e\2\u020b\u0206")
buf.write("\3\2\2\2\u020b\u0208\3\2\2\2\u020c\35\3\2\2\2\u020d\u020e")
buf.write("\7V\2\2\u020e\u020f\5\u0110\u0089\2\u020f\u0211\7W\2\2")
buf.write("\u0210\u0212\7\61\2\2\u0211\u0210\3\2\2\2\u0211\u0212")
buf.write("\3\2\2\2\u0212\u0214\3\2\2\2\u0213\u0215\5\u0180\u00c1")
buf.write("\2\u0214\u0213\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0217")
buf.write("\3\2\2\2\u0216\u0218\5\u00d6l\2\u0217\u0216\3\2\2\2\u0217")
buf.write("\u0218\3\2\2\2\u0218\u021a\3\2\2\2\u0219\u021b\5\u00f8")
buf.write("}\2\u021a\u0219\3\2\2\2\u021a\u021b\3\2\2\2\u021b\37\3")
buf.write("\2\2\2\u021c\u021d\b\21\1\2\u021d\u025d\5\4\3\2\u021e")
buf.write("\u021f\5\u009eP\2\u021f\u0221\7V\2\2\u0220\u0222\5&\24")
buf.write("\2\u0221\u0220\3\2\2\2\u0221\u0222\3\2\2\2\u0222\u0223")
buf.write("\3\2\2\2\u0223\u0224\7W\2\2\u0224\u025d\3\2\2\2\u0225")
buf.write("\u0226\5\u016e\u00b8\2\u0226\u0228\7V\2\2\u0227\u0229")
buf.write("\5&\24\2\u0228\u0227\3\2\2\2\u0228\u0229\3\2\2\2\u0229")
buf.write("\u022a\3\2\2\2\u022a\u022b\7W\2\2\u022b\u025d\3\2\2\2")
buf.write("\u022c\u022d\5\u009eP\2\u022d\u022e\5\u0122\u0092\2\u022e")
buf.write("\u025d\3\2\2\2\u022f\u0230\5\u016e\u00b8\2\u0230\u0231")
buf.write("\5\u0122\u0092\2\u0231\u025d\3\2\2\2\u0232\u0233\7\"\2")
buf.write("\2\u0233\u0234\7g\2\2\u0234\u0235\5\u0104\u0083\2\u0235")
buf.write("\u0236\7h\2\2\u0236\u0237\7V\2\2\u0237\u0238\5^\60\2\u0238")
buf.write("\u0239\7W\2\2\u0239\u025d\3\2\2\2\u023a\u023b\7C\2\2\u023b")
buf.write("\u023c\7g\2\2\u023c\u023d\5\u0104\u0083\2\u023d\u023e")
buf.write("\7h\2\2\u023e\u023f\7V\2\2\u023f\u0240\5^\60\2\u0240\u0241")
buf.write("\7W\2\2\u0241\u025d\3\2\2\2\u0242\u0243\7<\2\2\u0243\u0244")
buf.write("\7g\2\2\u0244\u0245\5\u0104\u0083\2\u0245\u0246\7h\2\2")
buf.write("\u0246\u0247\7V\2\2\u0247\u0248\5^\60\2\u0248\u0249\7")
buf.write("W\2\2\u0249\u025d\3\2\2\2\u024a\u024b\7\33\2\2\u024b\u024c")
buf.write("\7g\2\2\u024c\u024d\5\u0104\u0083\2\u024d\u024e\7h\2\2")
buf.write("\u024e\u024f\7V\2\2\u024f\u0250\5^\60\2\u0250\u0251\7")
buf.write("W\2\2\u0251\u025d\3\2\2\2\u0252\u0253\5$\23\2\u0253\u0254")
buf.write("\7V\2\2\u0254\u0255\5^\60\2\u0255\u0256\7W\2\2\u0256\u025d")
buf.write("\3\2\2\2\u0257\u0258\5$\23\2\u0258\u0259\7V\2\2\u0259")
buf.write("\u025a\5\u0104\u0083\2\u025a\u025b\7W\2\2\u025b\u025d")
buf.write("\3\2\2\2\u025c\u021c\3\2\2\2\u025c\u021e\3\2\2\2\u025c")
buf.write("\u0225\3\2\2\2\u025c\u022c\3\2\2\2\u025c\u022f\3\2\2\2")
buf.write("\u025c\u0232\3\2\2\2\u025c\u023a\3\2\2\2\u025c\u0242\3")
buf.write("\2\2\2\u025c\u024a\3\2\2\2\u025c\u0252\3\2\2\2\u025c\u0257")
buf.write("\3\2\2\2\u025d\u0286\3\2\2\2\u025e\u025f\f\25\2\2\u025f")
buf.write("\u0260\7X\2\2\u0260\u0261\5^\60\2\u0261\u0262\7Y\2\2\u0262")
buf.write("\u0285\3\2\2\2\u0263\u0264\f\24\2\2\u0264\u0265\7X\2\2")
buf.write("\u0265\u0266\5\u0122\u0092\2\u0266\u0267\7Y\2\2\u0267")
buf.write("\u0285\3\2\2\2\u0268\u0269\f\23\2\2\u0269\u026b\7V\2\2")
buf.write("\u026a\u026c\5&\24\2\u026b\u026a\3\2\2\2\u026b\u026c\3")
buf.write("\2\2\2\u026c\u026d\3\2\2\2\u026d\u0285\7W\2\2\u026e\u026f")
buf.write("\f\16\2\2\u026f\u0271\7\u0084\2\2\u0270\u0272\7F\2\2\u0271")
buf.write("\u0270\3\2\2\2\u0271\u0272\3\2\2\2\u0272\u0273\3\2\2\2")
buf.write("\u0273\u0285\5\6\4\2\u0274\u0275\f\r\2\2\u0275\u0277\7")
buf.write("\177\2\2\u0276\u0278\7F\2\2\u0277\u0276\3\2\2\2\u0277")
buf.write("\u0278\3\2\2\2\u0278\u0279\3\2\2\2\u0279\u0285\5\6\4\2")
buf.write("\u027a\u027b\f\f\2\2\u027b\u027c\7\u0084\2\2\u027c\u0285")
buf.write("\5(\25\2\u027d\u027e\f\13\2\2\u027e\u027f\7\177\2\2\u027f")
buf.write("\u0285\5(\25\2\u0280\u0281\f\n\2\2\u0281\u0285\7{\2\2")
buf.write("\u0282\u0283\f\t\2\2\u0283\u0285\7|\2\2\u0284\u025e\3")
buf.write("\2\2\2\u0284\u0263\3\2\2\2\u0284\u0268\3\2\2\2\u0284\u026e")
buf.write("\3\2\2\2\u0284\u0274\3\2\2\2\u0284\u027a\3\2\2\2\u0284")
buf.write("\u027d\3\2\2\2\u0284\u0280\3\2\2\2\u0284\u0282\3\2\2\2")
buf.write("\u0285\u0288\3\2\2\2\u0286\u0284\3\2\2\2\u0286\u0287\3")
buf.write("\2\2\2\u0287!\3\2\2\2\u0288\u0286\3\2\2\2\u0289\u028a")
buf.write("\7L\2\2\u028a#\3\2\2\2\u028b\u028c\7L\2\2\u028c%\3\2\2")
buf.write("\2\u028d\u028e\5\u0120\u0091\2\u028e\'\3\2\2\2\u028f\u0291")
buf.write("\5\f\7\2\u0290\u028f\3\2\2\2\u0290\u0291\3\2\2\2\u0291")
buf.write("\u0292\3\2\2\2\u0292\u0293\5\u00a0Q\2\u0293\u0294\7\u0082")
buf.write("\2\2\u0294\u0295\7d\2\2\u0295\u0296\5\u00a0Q\2\u0296\u02a6")
buf.write("\3\2\2\2\u0297\u0298\5\f\7\2\u0298\u0299\7F\2\2\u0299")
buf.write("\u029a\5\u0164\u00b3\2\u029a\u029b\7\u0082\2\2\u029b\u029c")
buf.write("\7d\2\2\u029c\u029d\5\u00a0Q\2\u029d\u02a6\3\2\2\2\u029e")
buf.write("\u02a0\5\f\7\2\u029f\u029e\3\2\2\2\u029f\u02a0\3\2\2\2")
buf.write("\u02a0\u02a1\3\2\2\2\u02a1\u02a2\7d\2\2\u02a2\u02a6\5")
buf.write("\u00a0Q\2\u02a3\u02a4\7d\2\2\u02a4\u02a6\5\u00a2R\2\u02a5")
buf.write("\u0290\3\2\2\2\u02a5\u0297\3\2\2\2\u02a5\u029f\3\2\2\2")
buf.write("\u02a5\u02a3\3\2\2\2\u02a6)\3\2\2\2\u02a7\u02c4\5 \21")
buf.write("\2\u02a8\u02a9\7{\2\2\u02a9\u02c4\5> \2\u02aa\u02ab\7")
buf.write("|\2\2\u02ab\u02c4\5> \2\u02ac\u02ad\5,\27\2\u02ad\u02ae")
buf.write("\5> \2\u02ae\u02c4\3\2\2\2\u02af\u02b0\7@\2\2\u02b0\u02c4")
buf.write("\5*\26\2\u02b1\u02b2\7@\2\2\u02b2\u02b3\7V\2\2\u02b3\u02b4")
buf.write("\5\u0104\u0083\2\u02b4\u02b5\7W\2\2\u02b5\u02c4\3\2\2")
buf.write("\2\u02b6\u02b7\7@\2\2\u02b7\u02b8\7\u0086\2\2\u02b8\u02b9")
buf.write("\7V\2\2\u02b9\u02ba\7\u0087\2\2\u02ba\u02c4\7W\2\2\u02bb")
buf.write("\u02bc\7\16\2\2\u02bc\u02bd\7V\2\2\u02bd\u02be\5\u0104")
buf.write("\u0083\2\u02be\u02bf\7W\2\2\u02bf\u02c4\3\2\2\2\u02c0")
buf.write("\u02c4\5<\37\2\u02c1\u02c4\5.\30\2\u02c2\u02c4\5:\36\2")
buf.write("\u02c3\u02a7\3\2\2\2\u02c3\u02a8\3\2\2\2\u02c3\u02aa\3")
buf.write("\2\2\2\u02c3\u02ac\3\2\2\2\u02c3\u02af\3\2\2\2\u02c3\u02b1")
buf.write("\3\2\2\2\u02c3\u02b6\3\2\2\2\u02c3\u02bb\3\2\2\2\u02c3")
buf.write("\u02c0\3\2\2\2\u02c3\u02c1\3\2\2\2\u02c3\u02c2\3\2\2\2")
buf.write("\u02c4+\3\2\2\2\u02c5\u02c6\t\3\2\2\u02c6-\3\2\2\2\u02c7")
buf.write("\u02c9\7\u0082\2\2\u02c8\u02c7\3\2\2\2\u02c8\u02c9\3\2")
buf.write("\2\2\u02c9\u02ca\3\2\2\2\u02ca\u02cc\7\63\2\2\u02cb\u02cd")
buf.write("\5\60\31\2\u02cc\u02cb\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd")
buf.write("\u02ce\3\2\2\2\u02ce\u02d0\5\62\32\2\u02cf\u02d1\58\35")
buf.write("\2\u02d0\u02cf\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02e0")
buf.write("\3\2\2\2\u02d2\u02d4\7\u0082\2\2\u02d3\u02d2\3\2\2\2\u02d3")
buf.write("\u02d4\3\2\2\2\u02d4\u02d5\3\2\2\2\u02d5\u02d7\7\63\2")
buf.write("\2\u02d6\u02d8\5\60\31\2\u02d7\u02d6\3\2\2\2\u02d7\u02d8")
buf.write("\3\2\2\2\u02d8\u02d9\3\2\2\2\u02d9\u02da\7V\2\2\u02da")
buf.write("\u02db\5\u0104\u0083\2\u02db\u02dd\7W\2\2\u02dc\u02de")
buf.write("\58\35\2\u02dd\u02dc\3\2\2\2\u02dd\u02de\3\2\2\2\u02de")
buf.write("\u02e0\3\2\2\2\u02df\u02c8\3\2\2\2\u02df\u02d3\3\2\2\2")
buf.write("\u02e0/\3\2\2\2\u02e1\u02e2\7V\2\2\u02e2\u02e3\5&\24\2")
buf.write("\u02e3\u02e4\7W\2\2\u02e4\61\3\2\2\2\u02e5\u02e7\5\u009a")
buf.write("N\2\u02e6\u02e8\5\64\33\2\u02e7\u02e6\3\2\2\2\u02e7\u02e8")
buf.write("\3\2\2\2\u02e8\63\3\2\2\2\u02e9\u02eb\5\u00fa~\2\u02ea")
buf.write("\u02ec\5\64\33\2\u02eb\u02ea\3\2\2\2\u02eb\u02ec\3\2\2")
buf.write("\2\u02ec\u02ef\3\2\2\2\u02ed\u02ef\5\66\34\2\u02ee\u02e9")
buf.write("\3\2\2\2\u02ee\u02ed\3\2\2\2\u02ef\65\3\2\2\2\u02f0\u02f1")
buf.write("\b\34\1\2\u02f1\u02f2\7X\2\2\u02f2\u02f3\5^\60\2\u02f3")
buf.write("\u02f5\7Y\2\2\u02f4\u02f6\5\u00d6l\2\u02f5\u02f4\3\2\2")
buf.write("\2\u02f5\u02f6\3\2\2\2\u02f6\u0300\3\2\2\2\u02f7\u02f8")
buf.write("\f\3\2\2\u02f8\u02f9\7X\2\2\u02f9\u02fa\5`\61\2\u02fa")
buf.write("\u02fc\7Y\2\2\u02fb\u02fd\5\u00d6l\2\u02fc\u02fb\3\2\2")
buf.write("\2\u02fc\u02fd\3\2\2\2\u02fd\u02ff\3\2\2\2\u02fe\u02f7")
buf.write("\3\2\2\2\u02ff\u0302\3\2\2\2\u0300\u02fe\3\2\2\2\u0300")
buf.write("\u0301\3\2\2\2\u0301\67\3\2\2\2\u0302\u0300\3\2\2\2\u0303")
buf.write("\u0305\7V\2\2\u0304\u0306\5&\24\2\u0305\u0304\3\2\2\2")
buf.write("\u0305\u0306\3\2\2\2\u0306\u0307\3\2\2\2\u0307\u030a\7")
buf.write("W\2\2\u0308\u030a\5\u0122\u0092\2\u0309\u0303\3\2\2\2")
buf.write("\u0309\u0308\3\2\2\2\u030a9\3\2\2\2\u030b\u030d\7\u0082")
buf.write("\2\2\u030c\u030b\3\2\2\2\u030c\u030d\3\2\2\2\u030d\u030e")
buf.write("\3\2\2\2\u030e\u030f\7\37\2\2\u030f\u0318\5> \2\u0310")
buf.write("\u0312\7\u0082\2\2\u0311\u0310\3\2\2\2\u0311\u0312\3\2")
buf.write("\2\2\u0312\u0313\3\2\2\2\u0313\u0314\7\37\2\2\u0314\u0315")
buf.write("\7X\2\2\u0315\u0316\7Y\2\2\u0316\u0318\5> \2\u0317\u030c")
buf.write("\3\2\2\2\u0317\u0311\3\2\2\2\u0318;\3\2\2\2\u0319\u031a")
buf.write("\7\64\2\2\u031a\u031b\7V\2\2\u031b\u031c\5^\60\2\u031c")
buf.write("\u031d\7W\2\2\u031d=\3\2\2\2\u031e\u0325\5*\26\2\u031f")
buf.write("\u0320\7V\2\2\u0320\u0321\5\u0104\u0083\2\u0321\u0322")
buf.write("\7W\2\2\u0322\u0323\5> \2\u0323\u0325\3\2\2\2\u0324\u031e")
buf.write("\3\2\2\2\u0324\u031f\3\2\2\2\u0325?\3\2\2\2\u0326\u0327")
buf.write("\b!\1\2\u0327\u0328\5> \2\u0328\u0331\3\2\2\2\u0329\u032a")
buf.write("\f\4\2\2\u032a\u032b\7\u0085\2\2\u032b\u0330\5> \2\u032c")
buf.write("\u032d\f\3\2\2\u032d\u032e\7~\2\2\u032e\u0330\5> \2\u032f")
buf.write("\u0329\3\2\2\2\u032f\u032c\3\2\2\2\u0330\u0333\3\2\2\2")
buf.write("\u0331\u032f\3\2\2\2\u0331\u0332\3\2\2\2\u0332A\3\2\2")
buf.write("\2\u0333\u0331\3\2\2\2\u0334\u0335\b\"\1\2\u0335\u0336")
buf.write("\5@!\2\u0336\u0342\3\2\2\2\u0337\u0338\f\5\2\2\u0338\u0339")
buf.write("\7^\2\2\u0339\u0341\5@!\2\u033a\u033b\f\4\2\2\u033b\u033c")
buf.write("\7_\2\2\u033c\u0341\5@!\2\u033d\u033e\f\3\2\2\u033e\u033f")
buf.write("\7`\2\2\u033f\u0341\5@!\2\u0340\u0337\3\2\2\2\u0340\u033a")
buf.write("\3\2\2\2\u0340\u033d\3\2\2\2\u0341\u0344\3\2\2\2\u0342")
buf.write("\u0340\3\2\2\2\u0342\u0343\3\2\2\2\u0343C\3\2\2\2\u0344")
buf.write("\u0342\3\2\2\2\u0345\u0346\b#\1\2\u0346\u0347\5B\"\2\u0347")
buf.write("\u0350\3\2\2\2\u0348\u0349\f\4\2\2\u0349\u034a\7\\\2\2")
buf.write("\u034a\u034f\5B\"\2\u034b\u034c\f\3\2\2\u034c\u034d\7")
buf.write("]\2\2\u034d\u034f\5B\"\2\u034e\u0348\3\2\2\2\u034e\u034b")
buf.write("\3\2\2\2\u034f\u0352\3\2\2\2\u0350\u034e\3\2\2\2\u0350")
buf.write("\u0351\3\2\2\2\u0351E\3\2\2\2\u0352\u0350\3\2\2\2\u0353")
buf.write("\u0354\b$\1\2\u0354\u0355\5D#\2\u0355\u035c\3\2\2\2\u0356")
buf.write("\u0357\f\3\2\2\u0357\u0358\5H%\2\u0358\u0359\5D#\2\u0359")
buf.write("\u035b\3\2\2\2\u035a\u0356\3\2\2\2\u035b\u035e\3\2\2\2")
buf.write("\u035c\u035a\3\2\2\2\u035c\u035d\3\2\2\2\u035dG\3\2\2")
buf.write("\2\u035e\u035c\3\2\2\2\u035f\u0360\t\4\2\2\u0360I\3\2")
buf.write("\2\2\u0361\u0362\b&\1\2\u0362\u0363\5F$\2\u0363\u0372")
buf.write("\3\2\2\2\u0364\u0365\f\6\2\2\u0365\u0366\7g\2\2\u0366")
buf.write("\u0371\5F$\2\u0367\u0368\f\5\2\2\u0368\u0369\7h\2\2\u0369")
buf.write("\u0371\5F$\2\u036a\u036b\f\4\2\2\u036b\u036c\7w\2\2\u036c")
buf.write("\u0371\5F$\2\u036d\u036e\f\3\2\2\u036e\u036f\7x\2\2\u036f")
buf.write("\u0371\5F$\2\u0370\u0364\3\2\2\2\u0370\u0367\3\2\2\2\u0370")
buf.write("\u036a\3\2\2\2\u0370\u036d\3\2\2\2\u0371\u0374\3\2\2\2")
buf.write("\u0372\u0370\3\2\2\2\u0372\u0373\3\2\2\2\u0373K\3\2\2")
buf.write("\2\u0374\u0372\3\2\2\2\u0375\u0376\b\'\1\2\u0376\u0377")
buf.write("\5J&\2\u0377\u0380\3\2\2\2\u0378\u0379\f\4\2\2\u0379\u037a")
buf.write("\7u\2\2\u037a\u037f\5J&\2\u037b\u037c\f\3\2\2\u037c\u037d")
buf.write("\7v\2\2\u037d\u037f\5J&\2\u037e\u0378\3\2\2\2\u037e\u037b")
buf.write("\3\2\2\2\u037f\u0382\3\2\2\2\u0380\u037e\3\2\2\2\u0380")
buf.write("\u0381\3\2\2\2\u0381M\3\2\2\2\u0382\u0380\3\2\2\2\u0383")
buf.write("\u0384\b(\1\2\u0384\u0385\5L\'\2\u0385\u038b\3\2\2\2\u0386")
buf.write("\u0387\f\3\2\2\u0387\u0388\7b\2\2\u0388\u038a\5L\'\2\u0389")
buf.write("\u0386\3\2\2\2\u038a\u038d\3\2\2\2\u038b\u0389\3\2\2\2")
buf.write("\u038b\u038c\3\2\2\2\u038cO\3\2\2\2\u038d\u038b\3\2\2")
buf.write("\2\u038e\u038f\b)\1\2\u038f\u0390\5N(\2\u0390\u0396\3")
buf.write("\2\2\2\u0391\u0392\f\3\2\2\u0392\u0393\7a\2\2\u0393\u0395")
buf.write("\5N(\2\u0394\u0391\3\2\2\2\u0395\u0398\3\2\2\2\u0396\u0394")
buf.write("\3\2\2\2\u0396\u0397\3\2\2\2\u0397Q\3\2\2\2\u0398\u0396")
buf.write("\3\2\2\2\u0399\u039a\b*\1\2\u039a\u039b\5P)\2\u039b\u03a1")
buf.write("\3\2\2\2\u039c\u039d\f\3\2\2\u039d\u039e\7c\2\2\u039e")
buf.write("\u03a0\5P)\2\u039f\u039c\3\2\2\2\u03a0\u03a3\3\2\2\2\u03a1")
buf.write("\u039f\3\2\2\2\u03a1\u03a2\3\2\2\2\u03a2S\3\2\2\2\u03a3")
buf.write("\u03a1\3\2\2\2\u03a4\u03a5\b+\1\2\u03a5\u03a6\5R*\2\u03a6")
buf.write("\u03af\3\2\2\2\u03a7\u03a8\f\4\2\2\u03a8\u03a9\7\5\2\2")
buf.write("\u03a9\u03ae\5R*\2\u03aa\u03ab\f\3\2\2\u03ab\u03ac\7\6")
buf.write("\2\2\u03ac\u03ae\5R*\2\u03ad\u03a7\3\2\2\2\u03ad\u03aa")
buf.write("\3\2\2\2\u03ae\u03b1\3\2\2\2\u03af\u03ad\3\2\2\2\u03af")
buf.write("\u03b0\3\2\2\2\u03b0U\3\2\2\2\u03b1\u03af\3\2\2\2\u03b2")
buf.write("\u03b3\b,\1\2\u03b3\u03b4\5T+\2\u03b4\u03bd\3\2\2\2\u03b5")
buf.write("\u03b6\f\4\2\2\u03b6\u03b7\7\7\2\2\u03b7\u03bc\5T+\2\u03b8")
buf.write("\u03b9\f\3\2\2\u03b9\u03ba\7\b\2\2\u03ba\u03bc\5T+\2\u03bb")
buf.write("\u03b5\3\2\2\2\u03bb\u03b8\3\2\2\2\u03bc\u03bf\3\2\2\2")
buf.write("\u03bd\u03bb\3\2\2\2\u03bd\u03be\3\2\2\2\u03beW\3\2\2")
buf.write("\2\u03bf\u03bd\3\2\2\2\u03c0\u03c8\5V,\2\u03c1\u03c2\5")
buf.write("V,\2\u03c2\u03c3\7\u0080\2\2\u03c3\u03c4\5^\60\2\u03c4")
buf.write("\u03c5\7\u0081\2\2\u03c5\u03c6\5Z.\2\u03c6\u03c8\3\2\2")
buf.write("\2\u03c7\u03c0\3\2\2\2\u03c7\u03c1\3\2\2\2\u03c8Y\3\2")
buf.write("\2\2\u03c9\u03d0\5X-\2\u03ca\u03cb\5V,\2\u03cb\u03cc\5")
buf.write("\\/\2\u03cc\u03cd\5\u011e\u0090\2\u03cd\u03d0\3\2\2\2")
buf.write("\u03ce\u03d0\5\u017e\u00c0\2\u03cf\u03c9\3\2\2\2\u03cf")
buf.write("\u03ca\3\2\2\2\u03cf\u03ce\3\2\2\2\u03d0[\3\2\2\2\u03d1")
buf.write("\u03d2\t\5\2\2\u03d2]\3\2\2\2\u03d3\u03d4\b\60\1\2\u03d4")
buf.write("\u03d5\5Z.\2\u03d5\u03db\3\2\2\2\u03d6\u03d7\f\3\2\2\u03d7")
buf.write("\u03d8\7}\2\2\u03d8\u03da\5Z.\2\u03d9\u03d6\3\2\2\2\u03da")
buf.write("\u03dd\3\2\2\2\u03db\u03d9\3\2\2\2\u03db\u03dc\3\2\2\2")
buf.write("\u03dc_\3\2\2\2\u03dd\u03db\3\2\2\2\u03de\u03df\5X-\2")
buf.write("\u03dfa\3\2\2\2\u03e0\u03fb\5d\63\2\u03e1\u03e3\5\u00d6")
buf.write("l\2\u03e2\u03e1\3\2\2\2\u03e2\u03e3\3\2\2\2\u03e3\u03e4")
buf.write("\3\2\2\2\u03e4\u03fb\5f\64\2\u03e5\u03e7\5\u00d6l\2\u03e6")
buf.write("\u03e5\3\2\2\2\u03e6\u03e7\3\2\2\2\u03e7\u03e8\3\2\2\2")
buf.write("\u03e8\u03fb\5h\65\2\u03e9\u03eb\5\u00d6l\2\u03ea\u03e9")
buf.write("\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec\3\2\2\2\u03ec")
buf.write("\u03fb\5l\67\2\u03ed\u03ef\5\u00d6l\2\u03ee\u03ed\3\2")
buf.write("\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f0\3\2\2\2\u03f0\u03fb")
buf.write("\5p9\2\u03f1\u03f3\5\u00d6l\2\u03f2\u03f1\3\2\2\2\u03f2")
buf.write("\u03f3\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u03fb\5x=\2\u03f5")
buf.write("\u03fb\5z>\2\u03f6\u03f8\5\u00d6l\2\u03f7\u03f6\3\2\2")
buf.write("\2\u03f7\u03f8\3\2\2\2\u03f8\u03f9\3\2\2\2\u03f9\u03fb")
buf.write("\5\u0174\u00bb\2\u03fa\u03e0\3\2\2\2\u03fa\u03e2\3\2\2")
buf.write("\2\u03fa\u03e6\3\2\2\2\u03fa\u03ea\3\2\2\2\u03fa\u03ee")
buf.write("\3\2\2\2\u03fa\u03f2\3\2\2\2\u03fa\u03f5\3\2\2\2\u03fa")
buf.write("\u03f7\3\2\2\2\u03fbc\3\2\2\2\u03fc\u03fe\5\u00d6l\2\u03fd")
buf.write("\u03fc\3\2\2\2\u03fd\u03fe\3\2\2\2\u03fe\u03ff\3\2\2\2")
buf.write("\u03ff\u0400\7\u0087\2\2\u0400\u0401\7\u0081\2\2\u0401")
buf.write("\u0411\5b\62\2\u0402\u0404\5\u00d6l\2\u0403\u0402\3\2")
buf.write("\2\2\u0403\u0404\3\2\2\2\u0404\u0405\3\2\2\2\u0405\u0406")
buf.write("\7\23\2\2\u0406\u0407\5`\61\2\u0407\u0408\7\u0081\2\2")
buf.write("\u0408\u0409\5b\62\2\u0409\u0411\3\2\2\2\u040a\u040c\5")
buf.write("\u00d6l\2\u040b\u040a\3\2\2\2\u040b\u040c\3\2\2\2\u040c")
buf.write("\u040d\3\2\2\2\u040d\u040e\7\36\2\2\u040e\u040f\7\u0081")
buf.write("\2\2\u040f\u0411\5b\62\2\u0410\u03fd\3\2\2\2\u0410\u0403")
buf.write("\3\2\2\2\u0410\u040b\3\2\2\2\u0411e\3\2\2\2\u0412\u0414")
buf.write("\5^\60\2\u0413\u0412\3\2\2\2\u0413\u0414\3\2\2\2\u0414")
buf.write("\u0415\3\2\2\2\u0415\u0416\7\u0083\2\2\u0416g\3\2\2\2")
buf.write("\u0417\u0419\7Z\2\2\u0418\u041a\5j\66\2\u0419\u0418\3")
buf.write("\2\2\2\u0419\u041a\3\2\2\2\u041a\u041b\3\2\2\2\u041b\u041c")
buf.write("\7[\2\2\u041ci\3\2\2\2\u041d\u041e\b\66\1\2\u041e\u041f")
buf.write("\5b\62\2\u041f\u0424\3\2\2\2\u0420\u0421\f\3\2\2\u0421")
buf.write("\u0423\5b\62\2\u0422\u0420\3\2\2\2\u0423\u0426\3\2\2\2")
buf.write("\u0424\u0422\3\2\2\2\u0424\u0425\3\2\2\2\u0425k\3\2\2")
buf.write("\2\u0426\u0424\3\2\2\2\u0427\u0428\7-\2\2\u0428\u0429")
buf.write("\7V\2\2\u0429\u042a\5n8\2\u042a\u042b\7W\2\2\u042b\u042c")
buf.write("\5b\62\2\u042c\u043c\3\2\2\2\u042d\u042e\7-\2\2\u042e")
buf.write("\u042f\7V\2\2\u042f\u0430\5n8\2\u0430\u0431\7W\2\2\u0431")
buf.write("\u0432\5b\62\2\u0432\u0433\7#\2\2\u0433\u0434\5b\62\2")
buf.write("\u0434\u043c\3\2\2\2\u0435\u0436\7E\2\2\u0436\u0437\7")
buf.write("V\2\2\u0437\u0438\5n8\2\u0438\u0439\7W\2\2\u0439\u043a")
buf.write("\5b\62\2\u043a\u043c\3\2\2\2\u043b\u0427\3\2\2\2\u043b")
buf.write("\u042d\3\2\2\2\u043b\u0435\3\2\2\2\u043cm\3\2\2\2\u043d")
buf.write("\u044e\5^\60\2\u043e\u0440\5\u00d6l\2\u043f\u043e\3\2")
buf.write("\2\2\u043f\u0440\3\2\2\2\u0440\u0441\3\2\2\2\u0441\u0442")
buf.write("\5\u008eH\2\u0442\u0443\5\u00f0y\2\u0443\u0444\7f\2\2")
buf.write("\u0444\u0445\5\u011e\u0090\2\u0445\u044e\3\2\2\2\u0446")
buf.write("\u0448\5\u00d6l\2\u0447\u0446\3\2\2\2\u0447\u0448\3\2")
buf.write("\2\2\u0448\u0449\3\2\2\2\u0449\u044a\5\u008eH\2\u044a")
buf.write("\u044b\5\u00f0y\2\u044b\u044c\5\u0122\u0092\2\u044c\u044e")
buf.write("\3\2\2\2\u044d\u043d\3\2\2\2\u044d\u043f\3\2\2\2\u044d")
buf.write("\u0447\3\2\2\2\u044eo\3\2\2\2\u044f\u0450\7U\2\2\u0450")
buf.write("\u0451\7V\2\2\u0451\u0452\5n8\2\u0452\u0453\7W\2\2\u0453")
buf.write("\u0454\5b\62\2\u0454\u0473\3\2\2\2\u0455\u0456\7 \2\2")
buf.write("\u0456\u0457\5b\62\2\u0457\u0458\7U\2\2\u0458\u0459\7")
buf.write("V\2\2\u0459\u045a\5^\60\2\u045a\u045b\7W\2\2\u045b\u045c")
buf.write("\7\u0083\2\2\u045c\u0473\3\2\2\2\u045d\u045e\7*\2\2\u045e")
buf.write("\u045f\7V\2\2\u045f\u0461\5r:\2\u0460\u0462\5n8\2\u0461")
buf.write("\u0460\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0463\3\2\2\2")
buf.write("\u0463\u0465\7\u0083\2\2\u0464\u0466\5^\60\2\u0465\u0464")
buf.write("\3\2\2\2\u0465\u0466\3\2\2\2\u0466\u0467\3\2\2\2\u0467")
buf.write("\u0468\7W\2\2\u0468\u0469\5b\62\2\u0469\u0473\3\2\2\2")
buf.write("\u046a\u046b\7*\2\2\u046b\u046c\7V\2\2\u046c\u046d\5t")
buf.write(";\2\u046d\u046e\7\u0081\2\2\u046e\u046f\5v<\2\u046f\u0470")
buf.write("\7W\2\2\u0470\u0471\5b\62\2\u0471\u0473\3\2\2\2\u0472")
buf.write("\u044f\3\2\2\2\u0472\u0455\3\2\2\2\u0472\u045d\3\2\2\2")
buf.write("\u0472\u046a\3\2\2\2\u0473q\3\2\2\2\u0474\u0477\5f\64")
buf.write("\2\u0475\u0477\5\u0084C\2\u0476\u0474\3\2\2\2\u0476\u0475")
buf.write("\3\2\2\2\u0477s\3\2\2\2\u0478\u047a\5\u00d6l\2\u0479\u0478")
buf.write("\3\2\2\2\u0479\u047a\3\2\2\2\u047a\u047b\3\2\2\2\u047b")
buf.write("\u047c\5\u008eH\2\u047c\u047d\5\u00f0y\2\u047du\3\2\2")
buf.write("\2\u047e\u0481\5^\60\2\u047f\u0481\5\u0122\u0092\2\u0480")
buf.write("\u047e\3\2\2\2\u0480\u047f\3\2\2\2\u0481w\3\2\2\2\u0482")
buf.write("\u0483\7\22\2\2\u0483\u0493\7\u0083\2\2\u0484\u0485\7")
buf.write("\34\2\2\u0485\u0493\7\u0083\2\2\u0486\u0488\7=\2\2\u0487")
buf.write("\u0489\5^\60\2\u0488\u0487\3\2\2\2\u0488\u0489\3\2\2\2")
buf.write("\u0489\u048a\3\2\2\2\u048a\u0493\7\u0083\2\2\u048b\u048c")
buf.write("\7=\2\2\u048c\u048d\5\u0122\u0092\2\u048d\u048e\7\u0083")
buf.write("\2\2\u048e\u0493\3\2\2\2\u048f\u0490\7,\2\2\u0490\u0491")
buf.write("\7\u0087\2\2\u0491\u0493\7\u0083\2\2\u0492\u0482\3\2\2")
buf.write("\2\u0492\u0484\3\2\2\2\u0492\u0486\3\2\2\2\u0492\u048b")
buf.write("\3\2\2\2\u0492\u048f\3\2\2\2\u0493y\3\2\2\2\u0494\u0495")
buf.write("\5\u0080A\2\u0495{\3\2\2\2\u0496\u0497\b?\1\2\u0497\u0498")
buf.write("\5~@\2\u0498\u049d\3\2\2\2\u0499\u049a\f\3\2\2\u049a\u049c")
buf.write("\5~@\2\u049b\u0499\3\2\2\2\u049c\u049f\3\2\2\2\u049d\u049b")
buf.write("\3\2\2\2\u049d\u049e\3\2\2\2\u049e}\3\2\2\2\u049f\u049d")
buf.write("\3\2\2\2\u04a0\u04aa\5\u0080A\2\u04a1\u04aa\5\u0116\u008c")
buf.write("\2\u04a2\u04aa\5\u015c\u00af\2\u04a3\u04aa\5\u0170\u00b9")
buf.write("\2\u04a4\u04aa\5\u0172\u00ba\2\u04a5\u04aa\5\u00d4k\2")
buf.write("\u04a6\u04aa\5\u00bc_\2\u04a7\u04aa\5\u0088E\2\u04a8\u04aa")
buf.write("\5\u008aF\2\u04a9\u04a0\3\2\2\2\u04a9\u04a1\3\2\2\2\u04a9")
buf.write("\u04a2\3\2\2\2\u04a9\u04a3\3\2\2\2\u04a9\u04a4\3\2\2\2")
buf.write("\u04a9\u04a5\3\2\2\2\u04a9\u04a6\3\2\2\2\u04a9\u04a7\3")
buf.write("\2\2\2\u04a9\u04a8\3\2\2\2\u04aa\177\3\2\2\2\u04ab\u04b4")
buf.write("\5\u0084C\2\u04ac\u04b4\5\u00d2j\2\u04ad\u04b4\5\u00ca")
buf.write("f\2\u04ae\u04b4\5\u00ceh\2\u04af\u04b4\5\u00d0i\2\u04b0")
buf.write("\u04b4\5\u0086D\2\u04b1\u04b4\5\u0082B\2\u04b2\u04b4\5")
buf.write("\u00acW\2\u04b3\u04ab\3\2\2\2\u04b3\u04ac\3\2\2\2\u04b3")
buf.write("\u04ad\3\2\2\2\u04b3\u04ae\3\2\2\2\u04b3\u04af\3\2\2\2")
buf.write("\u04b3\u04b0\3\2\2\2\u04b3\u04b1\3\2\2\2\u04b3\u04b2\3")
buf.write("\2\2\2\u04b4\u0081\3\2\2\2\u04b5\u04b6\7P\2\2\u04b6\u04b8")
buf.write("\7\u0087\2\2\u04b7\u04b9\5\u00d6l\2\u04b8\u04b7\3\2\2")
buf.write("\2\u04b8\u04b9\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04bb")
buf.write("\7f\2\2\u04bb\u04bc\5\u0104\u0083\2\u04bc\u04bd\7\u0083")
buf.write("\2\2\u04bd\u0083\3\2\2\2\u04be\u04c0\5\u008eH\2\u04bf")
buf.write("\u04be\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c2\3\2\2\2")
buf.write("\u04c1\u04c3\5\u00ecw\2\u04c2\u04c1\3\2\2\2\u04c2\u04c3")
buf.write("\3\2\2\2\u04c3\u04c4\3\2\2\2\u04c4\u04cd\7\u0083\2\2\u04c5")
buf.write("\u04c7\5\u00d6l\2\u04c6\u04c8\5\u008eH\2\u04c7\u04c6\3")
buf.write("\2\2\2\u04c7\u04c8\3\2\2\2\u04c8\u04c9\3\2\2\2\u04c9\u04ca")
buf.write("\5\u00ecw\2\u04ca\u04cb\7\u0083\2\2\u04cb\u04cd\3\2\2")
buf.write("\2\u04cc\u04bf\3\2\2\2\u04cc\u04c5\3\2\2\2\u04cd\u0085")
buf.write("\3\2\2\2\u04ce\u04cf\7B\2\2\u04cf\u04d0\7V\2\2\u04d0\u04d1")
buf.write("\5`\61\2\u04d1\u04d2\7}\2\2\u04d2\u04d3\7\u0090\2\2\u04d3")
buf.write("\u04d4\7W\2\2\u04d4\u04d5\7\u0083\2\2\u04d5\u0087\3\2")
buf.write("\2\2\u04d6\u04d7\7\u0083\2\2\u04d7\u0089\3\2\2\2\u04d8")
buf.write("\u04d9\5\u00d6l\2\u04d9\u04da\7\u0083\2\2\u04da\u008b")
buf.write("\3\2\2\2\u04db\u04e2\5\u0090I\2\u04dc\u04e2\5\u0096L\2")
buf.write("\u04dd\u04e2\5\u0092J\2\u04de\u04e2\7+\2\2\u04df\u04e2")
buf.write("\7K\2\2\u04e0\u04e2\7\32\2\2\u04e1\u04db\3\2\2\2\u04e1")
buf.write("\u04dc\3\2\2\2\u04e1\u04dd\3\2\2\2\u04e1\u04de\3\2\2\2")
buf.write("\u04e1\u04df\3\2\2\2\u04e1\u04e0\3\2\2\2\u04e2\u008d\3")
buf.write("\2\2\2\u04e3\u04e5\5\u008cG\2\u04e4\u04e6\5\u00d6l\2\u04e5")
buf.write("\u04e4\3\2\2\2\u04e5\u04e6\3\2\2\2\u04e6\u04eb\3\2\2\2")
buf.write("\u04e7\u04e8\5\u008cG\2\u04e8\u04e9\5\u008eH\2\u04e9\u04eb")
buf.write("\3\2\2\2\u04ea\u04e3\3\2\2\2\u04ea\u04e7\3\2\2\2\u04eb")
buf.write("\u008f\3\2\2\2\u04ec\u04ed\t\6\2\2\u04ed\u0091\3\2\2\2")
buf.write("\u04ee\u04ef\t\7\2\2\u04ef\u0093\3\2\2\2\u04f0\u04f1\7")
buf.write("\u0087\2\2\u04f1\u0095\3\2\2\2\u04f2\u04f6\5\u0098M\2")
buf.write("\u04f3\u04f6\5\u0126\u0094\2\u04f4\u04f6\5\u00a8U\2\u04f5")
buf.write("\u04f2\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f4\3\2\2\2")
buf.write("\u04f6\u0097\3\2\2\2\u04f7\u04fc\5\u009eP\2\u04f8\u04fc")
buf.write("\5\u00a4S\2\u04f9\u04fc\5\u016e\u00b8\2\u04fa\u04fc\5")
buf.write("\u00fe\u0080\2\u04fb\u04f7\3\2\2\2\u04fb\u04f8\3\2\2\2")
buf.write("\u04fb\u04f9\3\2\2\2\u04fb\u04fa\3\2\2\2\u04fc\u0099\3")
buf.write("\2\2\2\u04fd\u04ff\5\u0096L\2\u04fe\u0500\5\u00d6l\2\u04ff")
buf.write("\u04fe\3\2\2\2\u04ff\u0500\3\2\2\2\u0500\u0505\3\2\2\2")
buf.write("\u0501\u0502\5\u0096L\2\u0502\u0503\5\u009aN\2\u0503\u0505")
buf.write("\3\2\2\2\u0504\u04fd\3\2\2\2\u0504\u0501\3\2\2\2\u0505")
buf.write("\u009b\3\2\2\2\u0506\u0508\5\u0098M\2\u0507\u0509\5\u00d6")
buf.write("l\2\u0508\u0507\3\2\2\2\u0508\u0509\3\2\2\2\u0509\u050e")
buf.write("\3\2\2\2\u050a\u050b\5\u0098M\2\u050b\u050c\5\u009cO\2")
buf.write("\u050c\u050e\3\2\2\2\u050d\u0506\3\2\2\2\u050d\u050a\3")
buf.write("\2\2\2\u050e\u009d\3\2\2\2\u050f\u0511\5\f\7\2\u0510\u050f")
buf.write("\3\2\2\2\u0510\u0511\3\2\2\2\u0511\u0512\3\2\2\2\u0512")
buf.write("\u0527\5\u00a0Q\2\u0513\u0514\5\f\7\2\u0514\u0515\7F\2")
buf.write("\2\u0515\u0516\5\u0164\u00b3\2\u0516\u0527\3\2\2\2\u0517")
buf.write("\u0527\7\25\2\2\u0518\u0527\7\26\2\2\u0519\u0527\7\27")
buf.write("\2\2\u051a\u0527\7T\2\2\u051b\u0527\7\21\2\2\u051c\u0527")
buf.write("\7>\2\2\u051d\u0527\7/\2\2\u051e\u0527\7\60\2\2\u051f")
buf.write("\u0527\7?\2\2\u0520\u0527\7O\2\2\u0521\u0527\7)\2\2\u0522")
buf.write("\u0527\7!\2\2\u0523\u0527\7R\2\2\u0524\u0527\7\20\2\2")
buf.write("\u0525\u0527\5\u00a2R\2\u0526\u0510\3\2\2\2\u0526\u0513")
buf.write("\3\2\2\2\u0526\u0517\3\2\2\2\u0526\u0518\3\2\2\2\u0526")
buf.write("\u0519\3\2\2\2\u0526\u051a\3\2\2\2\u0526\u051b\3\2\2\2")
buf.write("\u0526\u051c\3\2\2\2\u0526\u051d\3\2\2\2\u0526\u051e\3")
buf.write("\2\2\2\u0526\u051f\3\2\2\2\u0526\u0520\3\2\2\2\u0526\u0521")
buf.write("\3\2\2\2\u0526\u0522\3\2\2\2\u0526\u0523\3\2\2\2\u0526")
buf.write("\u0524\3\2\2\2\u0526\u0525\3\2\2\2\u0527\u009f\3\2\2\2")
buf.write("\u0528\u052d\5\u0124\u0093\2\u0529\u052d\5\u00a6T\2\u052a")
buf.write("\u052d\5\u0094K\2\u052b\u052d\5\u0164\u00b3\2\u052c\u0528")
buf.write("\3\2\2\2\u052c\u0529\3\2\2\2\u052c\u052a\3\2\2\2\u052c")
buf.write("\u052b\3\2\2\2\u052d\u00a1\3\2\2\2\u052e\u052f\7\35\2")
buf.write("\2\u052f\u0530\7V\2\2\u0530\u0531\5^\60\2\u0531\u0532")
buf.write("\7W\2\2\u0532\u0538\3\2\2\2\u0533\u0534\7\35\2\2\u0534")
buf.write("\u0535\7V\2\2\u0535\u0536\7\20\2\2\u0536\u0538\7W\2\2")
buf.write("\u0537\u052e\3\2\2\2\u0537\u0533\3\2\2\2\u0538\u00a3\3")
buf.write("\2\2\2\u0539\u053b\5\u012e\u0098\2\u053a\u053c\5\u00d6")
buf.write("l\2\u053b\u053a\3\2\2\2\u053b\u053c\3\2\2\2\u053c\u053e")
buf.write("\3\2\2\2\u053d\u053f\5\f\7\2\u053e\u053d\3\2\2\2\u053e")
buf.write("\u053f\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0541\7\u0087")
buf.write("\2\2\u0541\u0552\3\2\2\2\u0542\u0543\5\u012e\u0098\2\u0543")
buf.write("\u0544\5\u0164\u00b3\2\u0544\u0552\3\2\2\2\u0545\u0546")
buf.write("\5\u012e\u0098\2\u0546\u0548\5\f\7\2\u0547\u0549\7F\2")
buf.write("\2\u0548\u0547\3\2\2\2\u0548\u0549\3\2\2\2\u0549\u054a")
buf.write("\3\2\2\2\u054a\u054b\5\u0164\u00b3\2\u054b\u0552\3\2\2")
buf.write("\2\u054c\u054e\7$\2\2\u054d\u054f\5\f\7\2\u054e\u054d")
buf.write("\3\2\2\2\u054e\u054f\3\2\2\2\u054f\u0550\3\2\2\2\u0550")
buf.write("\u0552\7\u0087\2\2\u0551\u0539\3\2\2\2\u0551\u0542\3\2")
buf.write("\2\2\u0551\u0545\3\2\2\2\u0551\u054c\3\2\2\2\u0552\u00a5")
buf.write("\3\2\2\2\u0553\u0554\7\u0087\2\2\u0554\u00a7\3\2\2\2\u0555")
buf.write("\u0556\5\u00aaV\2\u0556\u0558\7Z\2\2\u0557\u0559\5\u00b2")
buf.write("Z\2\u0558\u0557\3\2\2\2\u0558\u0559\3\2\2\2\u0559\u055a")
buf.write("\3\2\2\2\u055a\u055b\7[\2\2\u055b\u0563\3\2\2\2\u055c")
buf.write("\u055d\5\u00aaV\2\u055d\u055e\7Z\2\2\u055e\u055f\5\u00b2")
buf.write("Z\2\u055f\u0560\7}\2\2\u0560\u0561\7[\2\2\u0561\u0563")
buf.write("\3\2\2\2\u0562\u0555\3\2\2\2\u0562\u055c\3\2\2\2\u0563")
buf.write("\u00a9\3\2\2\2\u0564\u0566\5\u00aeX\2\u0565\u0567\5\u00d6")
buf.write("l\2\u0566\u0565\3\2\2\2\u0566\u0567\3\2\2\2\u0567\u0569")
buf.write("\3\2\2\2\u0568\u056a\7\u0087\2\2\u0569\u0568\3\2\2\2\u0569")
buf.write("\u056a\3\2\2\2\u056a\u056c\3\2\2\2\u056b\u056d\5\u00b0")
buf.write("Y\2\u056c\u056b\3\2\2\2\u056c\u056d\3\2\2\2\u056d\u0578")
buf.write("\3\2\2\2\u056e\u0570\5\u00aeX\2\u056f\u0571\5\u00d6l\2")
buf.write("\u0570\u056f\3\2\2\2\u0570\u0571\3\2\2\2\u0571\u0572\3")
buf.write("\2\2\2\u0572\u0573\5\f\7\2\u0573\u0575\7\u0087\2\2\u0574")
buf.write("\u0576\5\u00b0Y\2\u0575\u0574\3\2\2\2\u0575\u0576\3\2")
buf.write("\2\2\u0576\u0578\3\2\2\2\u0577\u0564\3\2\2\2\u0577\u056e")
buf.write("\3\2\2\2\u0578\u00ab\3\2\2\2\u0579\u057b\5\u00aeX\2\u057a")
buf.write("\u057c\5\u00d6l\2\u057b\u057a\3\2\2\2\u057b\u057c\3\2")
buf.write("\2\2\u057c\u057d\3\2\2\2\u057d\u057f\7\u0087\2\2\u057e")
buf.write("\u0580\5\u00b0Y\2\u057f\u057e\3\2\2\2\u057f\u0580\3\2")
buf.write("\2\2\u0580\u0581\3\2\2\2\u0581\u0582\7\u0083\2\2\u0582")
buf.write("\u00ad\3\2\2\2\u0583\u0589\7$\2\2\u0584\u0585\7$\2\2\u0585")
buf.write("\u0589\7\30\2\2\u0586\u0587\7$\2\2\u0587\u0589\7D\2\2")
buf.write("\u0588\u0583\3\2\2\2\u0588\u0584\3\2\2\2\u0588\u0586\3")
buf.write("\2\2\2\u0589\u00af\3\2\2\2\u058a\u058b\7\u0081\2\2\u058b")
buf.write("\u058c\5\u009aN\2\u058c\u00b1\3\2\2\2\u058d\u058e\bZ\1")
buf.write("\2\u058e\u058f\5\u00b4[\2\u058f\u0595\3\2\2\2\u0590\u0591")
buf.write("\f\3\2\2\u0591\u0592\7}\2\2\u0592\u0594\5\u00b4[\2\u0593")
buf.write("\u0590\3\2\2\2\u0594\u0597\3\2\2\2\u0595\u0593\3\2\2\2")
buf.write("\u0595\u0596\3\2\2\2\u0596\u00b3\3\2\2\2\u0597\u0595\3")
buf.write("\2\2\2\u0598\u059e\5\u00b6\\\2\u0599\u059a\5\u00b6\\\2")
buf.write("\u059a\u059b\7f\2\2\u059b\u059c\5`\61\2\u059c\u059e\3")
buf.write("\2\2\2\u059d\u0598\3\2\2\2\u059d\u0599\3\2\2\2\u059e\u00b5")
buf.write("\3\2\2\2\u059f\u05a0\7\u0087\2\2\u05a0\u00b7\3\2\2\2\u05a1")
buf.write("\u05a4\5\u00ba^\2\u05a2\u05a4\5\u00c8e\2\u05a3\u05a1\3")
buf.write("\2\2\2\u05a3\u05a2\3\2\2\2\u05a4\u00b9\3\2\2\2\u05a5\u05a6")
buf.write("\7\u0087\2\2\u05a6\u00bb\3\2\2\2\u05a7\u05aa\5\u00be`")
buf.write("\2\u05a8\u05aa\5\u00c4c\2\u05a9\u05a7\3\2\2\2\u05a9\u05a8")
buf.write("\3\2\2\2\u05aa\u00bd\3\2\2\2\u05ab\u05ae\5\u00c0a\2\u05ac")
buf.write("\u05ae\5\u00c2b\2\u05ad\u05ab\3\2\2\2\u05ad\u05ac\3\2")
buf.write("\2\2\u05ae\u00bf\3\2\2\2\u05af\u05b1\7.\2\2\u05b0\u05af")
buf.write("\3\2\2\2\u05b0\u05b1\3\2\2\2\u05b1\u05b2\3\2\2\2\u05b2")
buf.write("\u05b3\7\62\2\2\u05b3\u05b4\7\u0087\2\2\u05b4\u05b5\7")
buf.write("Z\2\2\u05b5\u05b6\5\u00c6d\2\u05b6\u05b7\7[\2\2\u05b7")
buf.write("\u00c1\3\2\2\2\u05b8\u05ba\7.\2\2\u05b9\u05b8\3\2\2\2")
buf.write("\u05b9\u05ba\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb\u05bc\7")
buf.write("\62\2\2\u05bc\u05bd\5\u00ba^\2\u05bd\u05be\7Z\2\2\u05be")
buf.write("\u05bf\5\u00c6d\2\u05bf\u05c0\7[\2\2\u05c0\u00c3\3\2\2")
buf.write("\2\u05c1\u05c3\7.\2\2\u05c2\u05c1\3\2\2\2\u05c2\u05c3")
buf.write("\3\2\2\2\u05c3\u05c4\3\2\2\2\u05c4\u05c5\7\62\2\2\u05c5")
buf.write("\u05c6\7Z\2\2\u05c6\u05c7\5\u00c6d\2\u05c7\u05c8\7[\2")
buf.write("\2\u05c8\u00c5\3\2\2\2\u05c9\u05cb\5|?\2\u05ca\u05c9\3")
buf.write("\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u00c7\3\2\2\2\u05cc\u05cd")
buf.write("\7\u0087\2\2\u05cd\u00c9\3\2\2\2\u05ce\u05cf\7\62\2\2")
buf.write("\u05cf\u05d0\7\u0087\2\2\u05d0\u05d1\7f\2\2\u05d1\u05d2")
buf.write("\5\u00ccg\2\u05d2\u05d3\7\u0083\2\2\u05d3\u00cb\3\2\2")
buf.write("\2\u05d4\u05d6\5\f\7\2\u05d5\u05d4\3\2\2\2\u05d5\u05d6")
buf.write("\3\2\2\2\u05d6\u05d7\3\2\2\2\u05d7\u05d8\5\u00b8]\2\u05d8")
buf.write("\u00cd\3\2\2\2\u05d9\u05db\7P\2\2\u05da\u05dc\7M\2\2\u05db")
buf.write("\u05da\3\2\2\2\u05db\u05dc\3\2\2\2\u05dc\u05dd\3\2\2\2")
buf.write("\u05dd\u05de\5\f\7\2\u05de\u05df\5\b\5\2\u05df\u05e0\7")
buf.write("\u0083\2\2\u05e0\u05e7\3\2\2\2\u05e1\u05e2\7P\2\2\u05e2")
buf.write("\u05e3\7\u0082\2\2\u05e3\u05e4\5\b\5\2\u05e4\u05e5\7\u0083")
buf.write("\2\2\u05e5\u05e7\3\2\2\2\u05e6\u05d9\3\2\2\2\u05e6\u05e1")
buf.write("\3\2\2\2\u05e7\u00cf\3\2\2\2\u05e8\u05ea\5\u00d6l\2\u05e9")
buf.write("\u05e8\3\2\2\2\u05e9\u05ea\3\2\2\2\u05ea\u05eb\3\2\2\2")
buf.write("\u05eb\u05ec\7P\2\2\u05ec\u05ee\7\62\2\2\u05ed\u05ef\5")
buf.write("\f\7\2\u05ee\u05ed\3\2\2\2\u05ee\u05ef\3\2\2\2\u05ef\u05f0")
buf.write("\3\2\2\2\u05f0\u05f1\5\u00b8]\2\u05f1\u05f2\7\u0083\2")
buf.write("\2\u05f2\u00d1\3\2\2\2\u05f3\u05f4\7\17\2\2\u05f4\u05f5")
buf.write("\7V\2\2\u05f5\u05f6\7\u0090\2\2\u05f6\u05f7\7W\2\2\u05f7")
buf.write("\u05f8\7\u0083\2\2\u05f8\u00d3\3\2\2\2\u05f9\u05fa\7\'")
buf.write("\2\2\u05fa\u05fb\7\u0090\2\2\u05fb\u05fd\7Z\2\2\u05fc")
buf.write("\u05fe\5|?\2\u05fd\u05fc\3\2\2\2\u05fd\u05fe\3\2\2\2\u05fe")
buf.write("\u05ff\3\2\2\2\u05ff\u0604\7[\2\2\u0600\u0601\7\'\2\2")
buf.write("\u0601\u0602\7\u0090\2\2\u0602\u0604\5~@\2\u0603\u05f9")
buf.write("\3\2\2\2\u0603\u0600\3\2\2\2\u0604\u00d5\3\2\2\2\u0605")
buf.write("\u0606\bl\1\2\u0606\u0607\5\u00d8m\2\u0607\u060c\3\2\2")
buf.write("\2\u0608\u0609\f\3\2\2\u0609\u060b\5\u00d8m\2\u060a\u0608")
buf.write("\3\2\2\2\u060b\u060e\3\2\2\2\u060c\u060a\3\2\2\2\u060c")
buf.write("\u060d\3\2\2\2\u060d\u00d7\3\2\2\2\u060e\u060c\3\2\2\2")
buf.write("\u060f\u0610\7X\2\2\u0610\u0611\7X\2\2\u0611\u0612\5\u00dc")
buf.write("o\2\u0612\u0613\7Y\2\2\u0613\u0614\7Y\2\2\u0614\u0617")
buf.write("\3\2\2\2\u0615\u0617\5\u00dan\2\u0616\u060f\3\2\2\2\u0616")
buf.write("\u0615\3\2\2\2\u0617\u00d9\3\2\2\2\u0618\u0619\7\r\2\2")
buf.write("\u0619\u061a\7V\2\2\u061a\u061c\5\u0104\u0083\2\u061b")
buf.write("\u061d\7\u0086\2\2\u061c\u061b\3\2\2\2\u061c\u061d\3\2")
buf.write("\2\2\u061d\u061e\3\2\2\2\u061e\u061f\7W\2\2\u061f\u0629")
buf.write("\3\2\2\2\u0620\u0621\7\r\2\2\u0621\u0622\7V\2\2\u0622")
buf.write("\u0624\5`\61\2\u0623\u0625\7\u0086\2\2\u0624\u0623\3\2")
buf.write("\2\2\u0624\u0625\3\2\2\2\u0625\u0626\3\2\2\2\u0626\u0627")
buf.write("\7W\2\2\u0627\u0629\3\2\2\2\u0628\u0618\3\2\2\2\u0628")
buf.write("\u0620\3\2\2\2\u0629\u00db\3\2\2\2\u062a\u062c\bo\1\2")
buf.write("\u062b\u062d\5\u00dep\2\u062c\u062b\3\2\2\2\u062c\u062d")
buf.write("\3\2\2\2\u062d\u0632\3\2\2\2\u062e\u062f\5\u00dep\2\u062f")
buf.write("\u0630\7\u0086\2\2\u0630\u0632\3\2\2\2\u0631\u062a\3\2")
buf.write("\2\2\u0631\u062e\3\2\2\2\u0632\u063f\3\2\2\2\u0633\u0634")
buf.write("\f\5\2\2\u0634\u0636\7}\2\2\u0635\u0637\5\u00dep\2\u0636")
buf.write("\u0635\3\2\2\2\u0636\u0637\3\2\2\2\u0637\u063e\3\2\2\2")
buf.write("\u0638\u0639\f\3\2\2\u0639\u063a\7}\2\2\u063a\u063b\5")
buf.write("\u00dep\2\u063b\u063c\7\u0086\2\2\u063c\u063e\3\2\2\2")
buf.write("\u063d\u0633\3\2\2\2\u063d\u0638\3\2\2\2\u063e\u0641\3")
buf.write("\2\2\2\u063f\u063d\3\2\2\2\u063f\u0640\3\2\2\2\u0640\u00dd")
buf.write("\3\2\2\2\u0641\u063f\3\2\2\2\u0642\u0644\5\u00e0q\2\u0643")
buf.write("\u0645\5\u00e6t\2\u0644\u0643\3\2\2\2\u0644\u0645\3\2")
buf.write("\2\2\u0645\u00df\3\2\2\2\u0646\u0649\7\u0087\2\2\u0647")
buf.write("\u0649\5\u00e2r\2\u0648\u0646\3\2\2\2\u0648\u0647\3\2")
buf.write("\2\2\u0649\u00e1\3\2\2\2\u064a\u064b\5\u00e4s\2\u064b")
buf.write("\u064c\7\u0082\2\2\u064c\u064d\7\u0087\2\2\u064d\u00e3")
buf.write("\3\2\2\2\u064e\u064f\7\u0087\2\2\u064f\u00e5\3\2\2\2\u0650")
buf.write("\u0651\7V\2\2\u0651\u0652\5\u00e8u\2\u0652\u0653\7W\2")
buf.write("\2\u0653\u00e7\3\2\2\2\u0654\u0656\bu\1\2\u0655\u0657")
buf.write("\5\u00eav\2\u0656\u0655\3\2\2\2\u0656\u0657\3\2\2\2\u0657")
buf.write("\u065c\3\2\2\2\u0658\u0659\f\3\2\2\u0659\u065b\5\u00ea")
buf.write("v\2\u065a\u0658\3\2\2\2\u065b\u065e\3\2\2\2\u065c\u065a")
buf.write("\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u00e9\3\2\2\2\u065e")
buf.write("\u065c\3\2\2\2\u065f\u0660\7V\2\2\u0660\u0661\5\u00e8")
buf.write("u\2\u0661\u0662\7W\2\2\u0662\u0671\3\2\2\2\u0663\u0664")
buf.write("\7X\2\2\u0664\u0665\5\u00e8u\2\u0665\u0666\7Y\2\2\u0666")
buf.write("\u0671\3\2\2\2\u0667\u0668\7Z\2\2\u0668\u0669\5\u00e8")
buf.write("u\2\u0669\u066a\7[\2\2\u066a\u0671\3\2\2\2\u066b\u066d")
buf.write("\n\b\2\2\u066c\u066b\3\2\2\2\u066d\u066e\3\2\2\2\u066e")
buf.write("\u066c\3\2\2\2\u066e\u066f\3\2\2\2\u066f\u0671\3\2\2\2")
buf.write("\u0670\u065f\3\2\2\2\u0670\u0663\3\2\2\2\u0670\u0667\3")
buf.write("\2\2\2\u0670\u066c\3\2\2\2\u0671\u00eb\3\2\2\2\u0672\u0673")
buf.write("\bw\1\2\u0673\u0674\5\u00eex\2\u0674\u067a\3\2\2\2\u0675")
buf.write("\u0676\f\3\2\2\u0676\u0677\7}\2\2\u0677\u0679\5\u00ee")
buf.write("x\2\u0678\u0675\3\2\2\2\u0679\u067c\3\2\2\2\u067a\u0678")
buf.write("\3\2\2\2\u067a\u067b\3\2\2\2\u067b\u00ed\3\2\2\2\u067c")
buf.write("\u067a\3\2\2\2\u067d\u067f\5\u00f0y\2\u067e\u0680\5\u011a")
buf.write("\u008e\2\u067f\u067e\3\2\2\2\u067f\u0680\3\2\2\2\u0680")
buf.write("\u00ef\3\2\2\2\u0681\u0687\5\u00f2z\2\u0682\u0683\5\u00f4")
buf.write("{\2\u0683\u0684\5\u00f6|\2\u0684\u0685\5\u00f8}\2\u0685")
buf.write("\u0687\3\2\2\2\u0686\u0681\3\2\2\2\u0686\u0682\3\2\2\2")
buf.write("\u0687\u00f1\3\2\2\2\u0688\u068d\5\u00f4{\2\u0689\u068a")
buf.write("\5\u00fa~\2\u068a\u068b\5\u00f2z\2\u068b\u068d\3\2\2\2")
buf.write("\u068c\u0688\3\2\2\2\u068c\u0689\3\2\2\2\u068d\u00f3\3")
buf.write("\2\2\2\u068e\u068f\b{\1\2\u068f\u0691\5\u0102\u0082\2")
buf.write("\u0690\u0692\5\u00d6l\2\u0691\u0690\3\2\2\2\u0691\u0692")
buf.write("\3\2\2\2\u0692\u0698\3\2\2\2\u0693\u0694\7V\2\2\u0694")
buf.write("\u0695\5\u00f2z\2\u0695\u0696\7W\2\2\u0696\u0698\3\2\2")
buf.write("\2\u0697\u068e\3\2\2\2\u0697\u0693\3\2\2\2\u0698\u06a6")
buf.write("\3\2\2\2\u0699\u069a\f\5\2\2\u069a\u06a5\5\u00f6|\2\u069b")
buf.write("\u069c\f\4\2\2\u069c\u069e\7X\2\2\u069d\u069f\5`\61\2")
buf.write("\u069e\u069d\3\2\2\2\u069e\u069f\3\2\2\2\u069f\u06a0\3")
buf.write("\2\2\2\u06a0\u06a2\7Y\2\2\u06a1\u06a3\5\u00d6l\2\u06a2")
buf.write("\u06a1\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3\u06a5\3\2\2\2")
buf.write("\u06a4\u0699\3\2\2\2\u06a4\u069b\3\2\2\2\u06a5\u06a8\3")
buf.write("\2\2\2\u06a6\u06a4\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u00f5")
buf.write("\3\2\2\2\u06a8\u06a6\3\2\2\2\u06a9\u06aa\7V\2\2\u06aa")
buf.write("\u06ab\5\u0110\u0089\2\u06ab\u06ad\7W\2\2\u06ac\u06ae")
buf.write("\5\u00fc\177\2\u06ad\u06ac\3\2\2\2\u06ad\u06ae\3\2\2\2")
buf.write("\u06ae\u06b0\3\2\2\2\u06af\u06b1\5\u0100\u0081\2\u06b0")
buf.write("\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2\2\2")
buf.write("\u06b2\u06b4\5\u0180\u00c1\2\u06b3\u06b2\3\2\2\2\u06b3")
buf.write("\u06b4\3\2\2\2\u06b4\u06b6\3\2\2\2\u06b5\u06b7\5\u00d6")
buf.write("l\2\u06b6\u06b5\3\2\2\2\u06b6\u06b7\3\2\2\2\u06b7\u00f7")
buf.write("\3\2\2\2\u06b8\u06b9\7\177\2\2\u06b9\u06bb\5\u009cO\2")
buf.write("\u06ba\u06bc\5\u0106\u0084\2\u06bb\u06ba\3\2\2\2\u06bb")
buf.write("\u06bc\3\2\2\2\u06bc\u00f9\3\2\2\2\u06bd\u06bf\7^\2\2")
buf.write("\u06be\u06c0\5\u00d6l\2\u06bf\u06be\3\2\2\2\u06bf\u06c0")
buf.write("\3\2\2\2\u06c0\u06c2\3\2\2\2\u06c1\u06c3\5\u00fc\177\2")
buf.write("\u06c2\u06c1\3\2\2\2\u06c2\u06c3\3\2\2\2\u06c3\u06d5\3")
buf.write("\2\2\2\u06c4\u06c6\7b\2\2\u06c5\u06c7\5\u00d6l\2\u06c6")
buf.write("\u06c5\3\2\2\2\u06c6\u06c7\3\2\2\2\u06c7\u06d5\3\2\2\2")
buf.write("\u06c8\u06ca\7\5\2\2\u06c9\u06cb\5\u00d6l\2\u06ca\u06c9")
buf.write("\3\2\2\2\u06ca\u06cb\3\2\2\2\u06cb\u06d5\3\2\2\2\u06cc")
buf.write("\u06cd\5\f\7\2\u06cd\u06cf\7^\2\2\u06ce\u06d0\5\u00d6")
buf.write("l\2\u06cf\u06ce\3\2\2\2\u06cf\u06d0\3\2\2\2\u06d0\u06d2")
buf.write("\3\2\2\2\u06d1\u06d3\5\u00fc\177\2\u06d2\u06d1\3\2\2\2")
buf.write("\u06d2\u06d3\3\2\2\2\u06d3\u06d5\3\2\2\2\u06d4\u06bd\3")
buf.write("\2\2\2\u06d4\u06c4\3\2\2\2\u06d4\u06c8\3\2\2\2\u06d4\u06cc")
buf.write("\3\2\2\2\u06d5\u00fb\3\2\2\2\u06d6\u06d8\5\u00fe\u0080")
buf.write("\2\u06d7\u06d9\5\u00fc\177\2\u06d8\u06d7\3\2\2\2\u06d8")
buf.write("\u06d9\3\2\2\2\u06d9\u00fd\3\2\2\2\u06da\u06db\t\t\2\2")
buf.write("\u06db\u00ff\3\2\2\2\u06dc\u06dd\t\n\2\2\u06dd\u0101\3")
buf.write("\2\2\2\u06de\u06e0\7\u0086\2\2\u06df\u06de\3\2\2\2\u06df")
buf.write("\u06e0\3\2\2\2\u06e0\u06e1\3\2\2\2\u06e1\u06e2\5\6\4\2")
buf.write("\u06e2\u0103\3\2\2\2\u06e3\u06e5\5\u009aN\2\u06e4\u06e6")
buf.write("\5\u0106\u0084\2\u06e5\u06e4\3\2\2\2\u06e5\u06e6\3\2\2")
buf.write("\2\u06e6\u0105\3\2\2\2\u06e7\u06f0\5\u0108\u0085\2\u06e8")
buf.write("\u06ea\5\u010a\u0086\2\u06e9\u06e8\3\2\2\2\u06e9\u06ea")
buf.write("\3\2\2\2\u06ea\u06eb\3\2\2\2\u06eb\u06ec\5\u00f6|\2\u06ec")
buf.write("\u06ed\5\u00f8}\2\u06ed\u06f0\3\2\2\2\u06ee\u06f0\5\u010c")
buf.write("\u0087\2\u06ef\u06e7\3\2\2\2\u06ef\u06e9\3\2\2\2\u06ef")
buf.write("\u06ee\3\2\2\2\u06f0\u0107\3\2\2\2\u06f1\u06f7\5\u010a")
buf.write("\u0086\2\u06f2\u06f4\5\u00fa~\2\u06f3\u06f5\5\u0108\u0085")
buf.write("\2\u06f4\u06f3\3\2\2\2\u06f4\u06f5\3\2\2\2\u06f5\u06f7")
buf.write("\3\2\2\2\u06f6\u06f1\3\2\2\2\u06f6\u06f2\3\2\2\2\u06f7")
buf.write("\u0109\3\2\2\2\u06f8\u06f9\b\u0086\1\2\u06f9\u0707\5\u00f6")
buf.write("|\2\u06fa\u06fc\7X\2\2\u06fb\u06fd\5`\61\2\u06fc\u06fb")
buf.write("\3\2\2\2\u06fc\u06fd\3\2\2\2\u06fd\u06fe\3\2\2\2\u06fe")
buf.write("\u0700\7Y\2\2\u06ff\u0701\5\u00d6l\2\u0700\u06ff\3\2\2")
buf.write("\2\u0700\u0701\3\2\2\2\u0701\u0707\3\2\2\2\u0702\u0703")
buf.write("\7V\2\2\u0703\u0704\5\u0108\u0085\2\u0704\u0705\7W\2\2")
buf.write("\u0705\u0707\3\2\2\2\u0706\u06f8\3\2\2\2\u0706\u06fa\3")
buf.write("\2\2\2\u0706\u0702\3\2\2\2\u0707\u0715\3\2\2\2\u0708\u0709")
buf.write("\f\7\2\2\u0709\u0714\5\u00f6|\2\u070a\u070b\f\5\2\2\u070b")
buf.write("\u070d\7X\2\2\u070c\u070e\5`\61\2\u070d\u070c\3\2\2\2")
buf.write("\u070d\u070e\3\2\2\2\u070e\u070f\3\2\2\2\u070f\u0711\7")
buf.write("Y\2\2\u0710\u0712\5\u00d6l\2\u0711\u0710\3\2\2\2\u0711")
buf.write("\u0712\3\2\2\2\u0712\u0714\3\2\2\2\u0713\u0708\3\2\2\2")
buf.write("\u0713\u070a\3\2\2\2\u0714\u0717\3\2\2\2\u0715\u0713\3")
buf.write("\2\2\2\u0715\u0716\3\2\2\2\u0716\u010b\3\2\2\2\u0717\u0715")
buf.write("\3\2\2\2\u0718\u071d\5\u010e\u0088\2\u0719\u071a\5\u00fa")
buf.write("~\2\u071a\u071b\5\u010c\u0087\2\u071b\u071d\3\2\2\2\u071c")
buf.write("\u0718\3\2\2\2\u071c\u0719\3\2\2\2\u071d\u010d\3\2\2\2")
buf.write("\u071e\u071f\b\u0088\1\2\u071f\u0720\7\u0086\2\2\u0720")
buf.write("\u072e\3\2\2\2\u0721\u0722\f\5\2\2\u0722\u072d\5\u00f6")
buf.write("|\2\u0723\u0724\f\4\2\2\u0724\u0726\7X\2\2\u0725\u0727")
buf.write("\5`\61\2\u0726\u0725\3\2\2\2\u0726\u0727\3\2\2\2\u0727")
buf.write("\u0728\3\2\2\2\u0728\u072a\7Y\2\2\u0729\u072b\5\u00d6")
buf.write("l\2\u072a\u0729\3\2\2\2\u072a\u072b\3\2\2\2\u072b\u072d")
buf.write("\3\2\2\2\u072c\u0721\3\2\2\2\u072c\u0723\3\2\2\2\u072d")
buf.write("\u0730\3\2\2\2\u072e\u072c\3\2\2\2\u072e\u072f\3\2\2\2")
buf.write("\u072f\u010f\3\2\2\2\u0730\u072e\3\2\2\2\u0731\u0733\5")
buf.write("\u0112\u008a\2\u0732\u0731\3\2\2\2\u0732\u0733\3\2\2\2")
buf.write("\u0733\u0735\3\2\2\2\u0734\u0736\7\u0086\2\2\u0735\u0734")
buf.write("\3\2\2\2\u0735\u0736\3\2\2\2\u0736\u073c\3\2\2\2\u0737")
buf.write("\u0738\5\u0112\u008a\2\u0738\u0739\7}\2\2\u0739\u073a")
buf.write("\7\u0086\2\2\u073a\u073c\3\2\2\2\u073b\u0732\3\2\2\2\u073b")
buf.write("\u0737\3\2\2\2\u073c\u0111\3\2\2\2\u073d\u073e\b\u008a")
buf.write("\1\2\u073e\u073f\5\u0114\u008b\2\u073f\u0745\3\2\2\2\u0740")
buf.write("\u0741\f\3\2\2\u0741\u0742\7}\2\2\u0742\u0744\5\u0114")
buf.write("\u008b\2\u0743\u0740\3\2\2\2\u0744\u0747\3\2\2\2\u0745")
buf.write("\u0743\3\2\2\2\u0745\u0746\3\2\2\2\u0746\u0113\3\2\2\2")
buf.write("\u0747\u0745\3\2\2\2\u0748\u074a\5\u00d6l\2\u0749\u0748")
buf.write("\3\2\2\2\u0749\u074a\3\2\2\2\u074a\u074b\3\2\2\2\u074b")
buf.write("\u074c\5\u008eH\2\u074c\u074d\5\u00f0y\2\u074d\u0768\3")
buf.write("\2\2\2\u074e\u0750\5\u00d6l\2\u074f\u074e\3\2\2\2\u074f")
buf.write("\u0750\3\2\2\2\u0750\u0751\3\2\2\2\u0751\u0752\5\u008e")
buf.write("H\2\u0752\u0753\5\u00f0y\2\u0753\u0754\7f\2\2\u0754\u0755")
buf.write("\5\u011e\u0090\2\u0755\u0768\3\2\2\2\u0756\u0758\5\u00d6")
buf.write("l\2\u0757\u0756\3\2\2\2\u0757\u0758\3\2\2\2\u0758\u0759")
buf.write("\3\2\2\2\u0759\u075b\5\u008eH\2\u075a\u075c\5\u0106\u0084")
buf.write("\2\u075b\u075a\3\2\2\2\u075b\u075c\3\2\2\2\u075c\u0768")
buf.write("\3\2\2\2\u075d\u075f\5\u00d6l\2\u075e\u075d\3\2\2\2\u075e")
buf.write("\u075f\3\2\2\2\u075f\u0760\3\2\2\2\u0760\u0762\5\u008e")
buf.write("H\2\u0761\u0763\5\u0106\u0084\2\u0762\u0761\3\2\2\2\u0762")
buf.write("\u0763\3\2\2\2\u0763\u0764\3\2\2\2\u0764\u0765\7f\2\2")
buf.write("\u0765\u0766\5\u011e\u0090\2\u0766\u0768\3\2\2\2\u0767")
buf.write("\u0749\3\2\2\2\u0767\u074f\3\2\2\2\u0767\u0757\3\2\2\2")
buf.write("\u0767\u075e\3\2\2\2\u0768\u0115\3\2\2\2\u0769\u076b\5")
buf.write("\u00d6l\2\u076a\u0769\3\2\2\2\u076a\u076b\3\2\2\2\u076b")
buf.write("\u076d\3\2\2\2\u076c\u076e\5\u008eH\2\u076d\u076c\3\2")
buf.write("\2\2\u076d\u076e\3\2\2\2\u076e\u076f\3\2\2\2\u076f\u0771")
buf.write("\5\u00f0y\2\u0770\u0772\5\u0138\u009d\2\u0771\u0770\3")
buf.write("\2\2\2\u0771\u0772\3\2\2\2\u0772\u0773\3\2\2\2\u0773\u0774")
buf.write("\5\u0118\u008d\2\u0774\u0117\3\2\2\2\u0775\u0777\5\u0150")
buf.write("\u00a9\2\u0776\u0775\3\2\2\2\u0776\u0777\3\2\2\2\u0777")
buf.write("\u0778\3\2\2\2\u0778\u0781\5h\65\2\u0779\u0781\5\u0176")
buf.write("\u00bc\2\u077a\u077b\7f\2\2\u077b\u077c\7\36\2\2\u077c")
buf.write("\u0781\7\u0083\2\2\u077d\u077e\7f\2\2\u077e\u077f\7\37")
buf.write("\2\2\u077f\u0781\7\u0083\2\2\u0780\u0776\3\2\2\2\u0780")
buf.write("\u0779\3\2\2\2\u0780\u077a\3\2\2\2\u0780\u077d\3\2\2\2")
buf.write("\u0781\u0119\3\2\2\2\u0782\u0788\5\u011c\u008f\2\u0783")
buf.write("\u0784\7V\2\2\u0784\u0785\5&\24\2\u0785\u0786\7W\2\2\u0786")
buf.write("\u0788\3\2\2\2\u0787\u0782\3\2\2\2\u0787\u0783\3\2\2\2")
buf.write("\u0788\u011b\3\2\2\2\u0789\u078a\7f\2\2\u078a\u078d\5")
buf.write("\u011e\u0090\2\u078b\u078d\5\u0122\u0092\2\u078c\u0789")
buf.write("\3\2\2\2\u078c\u078b\3\2\2\2\u078d\u011d\3\2\2\2\u078e")
buf.write("\u0791\5Z.\2\u078f\u0791\5\u0122\u0092\2\u0790\u078e\3")
buf.write("\2\2\2\u0790\u078f\3\2\2\2\u0791\u011f\3\2\2\2\u0792\u0793")
buf.write("\b\u0091\1\2\u0793\u0795\5\u011e\u0090\2\u0794\u0796\7")
buf.write("\u0086\2\2\u0795\u0794\3\2\2\2\u0795\u0796\3\2\2\2\u0796")
buf.write("\u079f\3\2\2\2\u0797\u0798\f\3\2\2\u0798\u0799\7}\2\2")
buf.write("\u0799\u079b\5\u011e\u0090\2\u079a\u079c\7\u0086\2\2\u079b")
buf.write("\u079a\3\2\2\2\u079b\u079c\3\2\2\2\u079c\u079e\3\2\2\2")
buf.write("\u079d\u0797\3\2\2\2\u079e\u07a1\3\2\2\2\u079f\u079d\3")
buf.write("\2\2\2\u079f\u07a0\3\2\2\2\u07a0\u0121\3\2\2\2\u07a1\u079f")
buf.write("\3\2\2\2\u07a2\u07a3\7Z\2\2\u07a3\u07a5\5\u0120\u0091")
buf.write("\2\u07a4\u07a6\7}\2\2\u07a5\u07a4\3\2\2\2\u07a5\u07a6")
buf.write("\3\2\2\2\u07a6\u07a7\3\2\2\2\u07a7\u07a8\7[\2\2\u07a8")
buf.write("\u07ac\3\2\2\2\u07a9\u07aa\7Z\2\2\u07aa\u07ac\7[\2\2\u07ab")
buf.write("\u07a2\3\2\2\2\u07ab\u07a9\3\2\2\2\u07ac\u0123\3\2\2\2")
buf.write("\u07ad\u07b0\7\u0087\2\2\u07ae\u07b0\5\u0164\u00b3\2\u07af")
buf.write("\u07ad\3\2\2\2\u07af\u07ae\3\2\2\2\u07b0\u0125\3\2\2\2")
buf.write("\u07b1\u07b2\5\u0128\u0095\2\u07b2\u07b4\7Z\2\2\u07b3")
buf.write("\u07b5\5\u0130\u0099\2\u07b4\u07b3\3\2\2\2\u07b4\u07b5")
buf.write("\3\2\2\2\u07b5\u07b6\3\2\2\2\u07b6\u07b7\7[\2\2\u07b7")
buf.write("\u0127\3\2\2\2\u07b8\u07ba\5\u012e\u0098\2\u07b9\u07bb")
buf.write("\5\u00d6l\2\u07ba\u07b9\3\2\2\2\u07ba\u07bb\3\2\2\2\u07bb")
buf.write("\u07bc\3\2\2\2\u07bc\u07be\5\u012a\u0096\2\u07bd\u07bf")
buf.write("\5\u012c\u0097\2\u07be\u07bd\3\2\2\2\u07be\u07bf\3\2\2")
buf.write("\2\u07bf\u07c1\3\2\2\2\u07c0\u07c2\5\u013e\u00a0\2\u07c1")
buf.write("\u07c0\3\2\2\2\u07c1\u07c2\3\2\2\2\u07c2\u07cb\3\2\2\2")
buf.write("\u07c3\u07c5\5\u012e\u0098\2\u07c4\u07c6\5\u00d6l\2\u07c5")
buf.write("\u07c4\3\2\2\2\u07c5\u07c6\3\2\2\2\u07c6\u07c8\3\2\2\2")
buf.write("\u07c7\u07c9\5\u013e\u00a0\2\u07c8\u07c7\3\2\2\2\u07c8")
buf.write("\u07c9\3\2\2\2\u07c9\u07cb\3\2\2\2\u07ca\u07b8\3\2\2\2")
buf.write("\u07ca\u07c3\3\2\2\2\u07cb\u0129\3\2\2\2\u07cc\u07ce\5")
buf.write("\f\7\2\u07cd\u07cc\3\2\2\2\u07cd\u07ce\3\2\2\2\u07ce\u07cf")
buf.write("\3\2\2\2\u07cf\u07d0\5\u0124\u0093\2\u07d0\u012b\3\2\2")
buf.write("\2\u07d1\u07d2\7(\2\2\u07d2\u012d\3\2\2\2\u07d3\u07d4")
buf.write("\t\13\2\2\u07d4\u012f\3\2\2\2\u07d5\u07d7\5\u0132\u009a")
buf.write("\2\u07d6\u07d8\5\u0130\u0099\2\u07d7\u07d6\3\2\2\2\u07d7")
buf.write("\u07d8\3\2\2\2\u07d8\u07df\3\2\2\2\u07d9\u07da\5\u0148")
buf.write("\u00a5\2\u07da\u07dc\7\u0081\2\2\u07db\u07dd\5\u0130\u0099")
buf.write("\2\u07dc\u07db\3\2\2\2\u07dc\u07dd\3\2\2\2\u07dd\u07df")
buf.write("\3\2\2\2\u07de\u07d5\3\2\2\2\u07de\u07d9\3\2\2\2\u07df")
buf.write("\u0131\3\2\2\2\u07e0\u07e2\5\u00d6l\2\u07e1\u07e0\3\2")
buf.write("\2\2\u07e1\u07e2\3\2\2\2\u07e2\u07e4\3\2\2\2\u07e3\u07e5")
buf.write("\5\u008eH\2\u07e4\u07e3\3\2\2\2\u07e4\u07e5\3\2\2\2\u07e5")
buf.write("\u07e7\3\2\2\2\u07e6\u07e8\5\u0134\u009b\2\u07e7\u07e6")
buf.write("\3\2\2\2\u07e7\u07e8\3\2\2\2\u07e8\u07e9\3\2\2\2\u07e9")
buf.write("\u07f1\7\u0083\2\2\u07ea\u07f1\5\u0116\u008c\2\u07eb\u07f1")
buf.write("\5\u00ceh\2\u07ec\u07f1\5\u0086D\2\u07ed\u07f1\5\u015c")
buf.write("\u00af\2\u07ee\u07f1\5\u0082B\2\u07ef\u07f1\5\u0088E\2")
buf.write("\u07f0\u07e1\3\2\2\2\u07f0\u07ea\3\2\2\2\u07f0\u07eb\3")
buf.write("\2\2\2\u07f0\u07ec\3\2\2\2\u07f0\u07ed\3\2\2\2\u07f0\u07ee")
buf.write("\3\2\2\2\u07f0\u07ef\3\2\2\2\u07f1\u0133\3\2\2\2\u07f2")
buf.write("\u07f3\b\u009b\1\2\u07f3\u07f4\5\u0136\u009c\2\u07f4\u07fa")
buf.write("\3\2\2\2\u07f5\u07f6\f\3\2\2\u07f6\u07f7\7}\2\2\u07f7")
buf.write("\u07f9\5\u0136\u009c\2\u07f8\u07f5\3\2\2\2\u07f9\u07fc")
buf.write("\3\2\2\2\u07fa\u07f8\3\2\2\2\u07fa\u07fb\3\2\2\2\u07fb")
buf.write("\u0135\3\2\2\2\u07fc\u07fa\3\2\2\2\u07fd\u07ff\5\u00f0")
buf.write("y\2\u07fe\u0800\5\u0138\u009d\2\u07ff\u07fe\3\2\2\2\u07ff")
buf.write("\u0800\3\2\2\2\u0800\u0802\3\2\2\2\u0801\u0803\5\u013c")
buf.write("\u009f\2\u0802\u0801\3\2\2\2\u0802\u0803\3\2\2\2\u0803")
buf.write("\u0811\3\2\2\2\u0804\u0806\5\u00f0y\2\u0805\u0807\5\u011c")
buf.write("\u008f\2\u0806\u0805\3\2\2\2\u0806\u0807\3\2\2\2\u0807")
buf.write("\u0811\3\2\2\2\u0808\u080a\7\u0087\2\2\u0809\u0808\3\2")
buf.write("\2\2\u0809\u080a\3\2\2\2\u080a\u080c\3\2\2\2\u080b\u080d")
buf.write("\5\u00d6l\2\u080c\u080b\3\2\2\2\u080c\u080d\3\2\2\2\u080d")
buf.write("\u080e\3\2\2\2\u080e\u080f\7\u0081\2\2\u080f\u0811\5`")
buf.write("\61\2\u0810\u07fd\3\2\2\2\u0810\u0804\3\2\2\2\u0810\u0809")
buf.write("\3\2\2\2\u0811\u0137\3\2\2\2\u0812\u0813\b\u009d\1\2\u0813")
buf.write("\u0814\5\u013a\u009e\2\u0814\u0819\3\2\2\2\u0815\u0816")
buf.write("\f\3\2\2\u0816\u0818\5\u013a\u009e\2\u0817\u0815\3\2\2")
buf.write("\2\u0818\u081b\3\2\2\2\u0819\u0817\3\2\2\2\u0819\u081a")
buf.write("\3\2\2\2\u081a\u0139\3\2\2\2\u081b\u0819\3\2\2\2\u081c")
buf.write("\u081d\t\f\2\2\u081d\u013b\3\2\2\2\u081e\u081f\7f\2\2")
buf.write("\u081f\u0820\7\u008a\2\2\u0820\u0821\b\u009f\1\2\u0821")
buf.write("\u013d\3\2\2\2\u0822\u0823\7\u0081\2\2\u0823\u0824\5\u0140")
buf.write("\u00a1\2\u0824\u013f\3\2\2\2\u0825\u0826\b\u00a1\1\2\u0826")
buf.write("\u0828\5\u0142\u00a2\2\u0827\u0829\7\u0086\2\2\u0828\u0827")
buf.write("\3\2\2\2\u0828\u0829\3\2\2\2\u0829\u0832\3\2\2\2\u082a")
buf.write("\u082b\f\3\2\2\u082b\u082c\7}\2\2\u082c\u082e\5\u0142")
buf.write("\u00a2\2\u082d\u082f\7\u0086\2\2\u082e\u082d\3\2\2\2\u082e")
buf.write("\u082f\3\2\2\2\u082f\u0831\3\2\2\2\u0830\u082a\3\2\2\2")
buf.write("\u0831\u0834\3\2\2\2\u0832\u0830\3\2\2\2\u0832\u0833\3")
buf.write("\2\2\2\u0833\u0141\3\2\2\2\u0834\u0832\3\2\2\2\u0835\u0837")
buf.write("\5\u00d6l\2\u0836\u0835\3\2\2\2\u0836\u0837\3\2\2\2\u0837")
buf.write("\u0838\3\2\2\2\u0838\u084b\5\u0146\u00a4\2\u0839\u083b")
buf.write("\5\u00d6l\2\u083a\u0839\3\2\2\2\u083a\u083b\3\2\2\2\u083b")
buf.write("\u083c\3\2\2\2\u083c\u083e\7Q\2\2\u083d\u083f\5\u0148")
buf.write("\u00a5\2\u083e\u083d\3\2\2\2\u083e\u083f\3\2\2\2\u083f")
buf.write("\u0840\3\2\2\2\u0840\u084b\5\u0146\u00a4\2\u0841\u0843")
buf.write("\5\u00d6l\2\u0842\u0841\3\2\2\2\u0842\u0843\3\2\2\2\u0843")
buf.write("\u0844\3\2\2\2\u0844\u0846\5\u0148\u00a5\2\u0845\u0847")
buf.write("\7Q\2\2\u0846\u0845\3\2\2\2\u0846\u0847\3\2\2\2\u0847")
buf.write("\u0848\3\2\2\2\u0848\u0849\5\u0146\u00a4\2\u0849\u084b")
buf.write("\3\2\2\2\u084a\u0836\3\2\2\2\u084a\u083a\3\2\2\2\u084a")
buf.write("\u0842\3\2\2\2\u084b\u0143\3\2\2\2\u084c\u084e\5\f\7\2")
buf.write("\u084d\u084c\3\2\2\2\u084d\u084e\3\2\2\2\u084e\u084f\3")
buf.write("\2\2\2\u084f\u0852\5\u0124\u0093\2\u0850\u0852\5\u00a2")
buf.write("R\2\u0851\u084d\3\2\2\2\u0851\u0850\3\2\2\2\u0852\u0145")
buf.write("\3\2\2\2\u0853\u0854\5\u0144\u00a3\2\u0854\u0147\3\2\2")
buf.write("\2\u0855\u0856\t\r\2\2\u0856\u0149\3\2\2\2\u0857\u0858")
buf.write("\7\66\2\2\u0858\u0859\5\u014c\u00a7\2\u0859\u014b\3\2")
buf.write("\2\2\u085a\u085c\5\u009aN\2\u085b\u085d\5\u014e\u00a8")
buf.write("\2\u085c\u085b\3\2\2\2\u085c\u085d\3\2\2\2\u085d\u014d")
buf.write("\3\2\2\2\u085e\u0860\5\u00fa~\2\u085f\u0861\5\u014e\u00a8")
buf.write("\2\u0860\u085f\3\2\2\2\u0860\u0861\3\2\2\2\u0861\u014f")
buf.write("\3\2\2\2\u0862\u0863\7\u0081\2\2\u0863\u0864\5\u0152\u00aa")
buf.write("\2\u0864\u0151\3\2\2\2\u0865\u0867\5\u0154\u00ab\2\u0866")
buf.write("\u0868\7\u0086\2\2\u0867\u0866\3\2\2\2\u0867\u0868\3\2")
buf.write("\2\2\u0868\u0871\3\2\2\2\u0869\u086b\5\u0154\u00ab\2\u086a")
buf.write("\u086c\7\u0086\2\2\u086b\u086a\3\2\2\2\u086b\u086c\3\2")
buf.write("\2\2\u086c\u086d\3\2\2\2\u086d\u086e\7}\2\2\u086e\u086f")
buf.write("\5\u0152\u00aa\2\u086f\u0871\3\2\2\2\u0870\u0865\3\2\2")
buf.write("\2\u0870\u0869\3\2\2\2\u0871\u0153\3\2\2\2\u0872\u0873")
buf.write("\5\u0156\u00ac\2\u0873\u0875\7V\2\2\u0874\u0876\5&\24")
buf.write("\2\u0875\u0874\3\2\2\2\u0875\u0876\3\2\2\2\u0876\u0877")
buf.write("\3\2\2\2\u0877\u0878\7W\2\2\u0878\u087d\3\2\2\2\u0879")
buf.write("\u087a\5\u0156\u00ac\2\u087a\u087b\5\u0122\u0092\2\u087b")
buf.write("\u087d\3\2\2\2\u087c\u0872\3\2\2\2\u087c\u0879\3\2\2\2")
buf.write("\u087d\u0155\3\2\2\2\u087e\u0881\5\u0144\u00a3\2\u087f")
buf.write("\u0881\7\u0087\2\2\u0880\u087e\3\2\2\2\u0880\u087f\3\2")
buf.write("\2\2\u0881\u0157\3\2\2\2\u0882\u0883\7\66\2\2\u0883\u0884")
buf.write("\5\u018c\u00c7\2\u0884\u0159\3\2\2\2\u0885\u0886\7\66")
buf.write("\2\2\u0886\u0887\7\u0090\2\2\u0887\u088b\7\u0087\2\2\u0888")
buf.write("\u0889\7\66\2\2\u0889\u088b\7\u0093\2\2\u088a\u0885\3")
buf.write("\2\2\2\u088a\u0888\3\2\2\2\u088b\u015b\3\2\2\2\u088c\u088d")
buf.write("\7F\2\2\u088d\u088e\7g\2\2\u088e\u088f\5\u015e\u00b0\2")
buf.write("\u088f\u0890\7h\2\2\u0890\u0891\5~@\2\u0891\u015d\3\2")
buf.write("\2\2\u0892\u0893\b\u00b0\1\2\u0893\u0894\5\u0160\u00b1")
buf.write("\2\u0894\u089a\3\2\2\2\u0895\u0896\f\3\2\2\u0896\u0897")
buf.write("\7}\2\2\u0897\u0899\5\u0160\u00b1\2\u0898\u0895\3\2\2")
buf.write("\2\u0899\u089c\3\2\2\2\u089a\u0898\3\2\2\2\u089a\u089b")
buf.write("\3\2\2\2\u089b\u015f\3\2\2\2\u089c\u089a\3\2\2\2\u089d")
buf.write("\u08a0\5\u0162\u00b2\2\u089e\u08a0\5\u0114\u008b\2\u089f")
buf.write("\u089d\3\2\2\2\u089f\u089e\3\2\2\2\u08a0\u0161\3\2\2\2")
buf.write("\u08a1\u08a3\7\30\2\2\u08a2\u08a4\7\u0086\2\2\u08a3\u08a2")
buf.write("\3\2\2\2\u08a3\u08a4\3\2\2\2\u08a4\u08a6\3\2\2\2\u08a5")
buf.write("\u08a7\7\u0087\2\2\u08a6\u08a5\3\2\2\2\u08a6\u08a7\3\2")
buf.write("\2\2\u08a7\u08d2\3\2\2\2\u08a8\u08aa\7\30\2\2\u08a9\u08ab")
buf.write("\7\u0087\2\2\u08aa\u08a9\3\2\2\2\u08aa\u08ab\3\2\2\2\u08ab")
buf.write("\u08ac\3\2\2\2\u08ac\u08ad\7f\2\2\u08ad\u08d2\5\u0104")
buf.write("\u0083\2\u08ae\u08b0\7M\2\2\u08af\u08b1\7\u0086\2\2\u08b0")
buf.write("\u08af\3\2\2\2\u08b0\u08b1\3\2\2\2\u08b1\u08b3\3\2\2\2")
buf.write("\u08b2\u08b4\7\u0087\2\2\u08b3\u08b2\3\2\2\2\u08b3\u08b4")
buf.write("\3\2\2\2\u08b4\u08d2\3\2\2\2\u08b5\u08b7\7M\2\2\u08b6")
buf.write("\u08b8\7\u0087\2\2\u08b7\u08b6\3\2\2\2\u08b7\u08b8\3\2")
buf.write("\2\2\u08b8\u08b9\3\2\2\2\u08b9\u08ba\7f\2\2\u08ba\u08d2")
buf.write("\5\u0104\u0083\2\u08bb\u08bc\7F\2\2\u08bc\u08bd\7g\2\2")
buf.write("\u08bd\u08be\5\u015e\u00b0\2\u08be\u08bf\7h\2\2\u08bf")
buf.write("\u08c1\7\30\2\2\u08c0\u08c2\7\u0086\2\2\u08c1\u08c0\3")
buf.write("\2\2\2\u08c1\u08c2\3\2\2\2\u08c2\u08c4\3\2\2\2\u08c3\u08c5")
buf.write("\7\u0087\2\2\u08c4\u08c3\3\2\2\2\u08c4\u08c5\3\2\2\2\u08c5")
buf.write("\u08d2\3\2\2\2\u08c6\u08c7\7F\2\2\u08c7\u08c8\7g\2\2\u08c8")
buf.write("\u08c9\5\u015e\u00b0\2\u08c9\u08ca\7h\2\2\u08ca\u08cc")
buf.write("\7\30\2\2\u08cb\u08cd\7\u0087\2\2\u08cc\u08cb\3\2\2\2")
buf.write("\u08cc\u08cd\3\2\2\2\u08cd\u08ce\3\2\2\2\u08ce\u08cf\7")
buf.write("f\2\2\u08cf\u08d0\5\6\4\2\u08d0\u08d2\3\2\2\2\u08d1\u08a1")
buf.write("\3\2\2\2\u08d1\u08a8\3\2\2\2\u08d1\u08ae\3\2\2\2\u08d1")
buf.write("\u08b5\3\2\2\2\u08d1\u08bb\3\2\2\2\u08d1\u08c6\3\2\2\2")
buf.write("\u08d2\u0163\3\2\2\2\u08d3\u08d4\5\u0168\u00b5\2\u08d4")
buf.write("\u08d6\7g\2\2\u08d5\u08d7\5\u016a\u00b6\2\u08d6\u08d5")
buf.write("\3\2\2\2\u08d6\u08d7\3\2\2\2\u08d7\u08d8\3\2\2\2\u08d8")
buf.write("\u08d9\7h\2\2\u08d9\u0165\3\2\2\2\u08da\u08ea\5\u0164")
buf.write("\u00b3\2\u08db\u08dc\5\u0158\u00ad\2\u08dc\u08de\7g\2")
buf.write("\2\u08dd\u08df\5\u016a\u00b6\2\u08de\u08dd\3\2\2\2\u08de")
buf.write("\u08df\3\2\2\2\u08df\u08e0\3\2\2\2\u08e0\u08e1\7h\2\2")
buf.write("\u08e1\u08ea\3\2\2\2\u08e2\u08e3\5\u015a\u00ae\2\u08e3")
buf.write("\u08e5\7g\2\2\u08e4\u08e6\5\u016a\u00b6\2\u08e5\u08e4")
buf.write("\3\2\2\2\u08e5\u08e6\3\2\2\2\u08e6\u08e7\3\2\2\2\u08e7")
buf.write("\u08e8\7h\2\2\u08e8\u08ea\3\2\2\2\u08e9\u08da\3\2\2\2")
buf.write("\u08e9\u08db\3\2\2\2\u08e9\u08e2\3\2\2\2\u08ea\u0167\3")
buf.write("\2\2\2\u08eb\u08ec\7\u0087\2\2\u08ec\u0169\3\2\2\2\u08ed")
buf.write("\u08ee\b\u00b6\1\2\u08ee\u08f0\5\u016c\u00b7\2\u08ef\u08f1")
buf.write("\7\u0086\2\2\u08f0\u08ef\3\2\2\2\u08f0\u08f1\3\2\2\2\u08f1")
buf.write("\u08fa\3\2\2\2\u08f2\u08f3\f\3\2\2\u08f3\u08f4\7}\2\2")
buf.write("\u08f4\u08f6\5\u016c\u00b7\2\u08f5\u08f7\7\u0086\2\2\u08f6")
buf.write("\u08f5\3\2\2\2\u08f6\u08f7\3\2\2\2\u08f7\u08f9\3\2\2\2")
buf.write("\u08f8\u08f2\3\2\2\2\u08f9\u08fc\3\2\2\2\u08fa\u08f8\3")
buf.write("\2\2\2\u08fa\u08fb\3\2\2\2\u08fb\u016b\3\2\2\2\u08fc\u08fa")
buf.write("\3\2\2\2\u08fd\u0901\5\u0104\u0083\2\u08fe\u0901\5`\61")
buf.write("\2\u08ff\u0901\5\6\4\2\u0900\u08fd\3\2\2\2\u0900\u08fe")
buf.write("\3\2\2\2\u0900\u08ff\3\2\2\2\u0901\u016d\3\2\2\2\u0902")
buf.write("\u0903\7M\2\2\u0903\u0904\5\f\7\2\u0904\u0905\7\u0087")
buf.write("\2\2\u0905\u090e\3\2\2\2\u0906\u0907\7M\2\2\u0907\u0909")
buf.write("\5\f\7\2\u0908\u090a\7F\2\2\u0909\u0908\3\2\2\2\u0909")
buf.write("\u090a\3\2\2\2\u090a\u090b\3\2\2\2\u090b\u090c\5\u0164")
buf.write("\u00b3\2\u090c\u090e\3\2\2\2\u090d\u0902\3\2\2\2\u090d")
buf.write("\u0906\3\2\2\2\u090e\u016f\3\2\2\2\u090f\u0911\7\'\2\2")
buf.write("\u0910\u090f\3\2\2\2\u0910\u0911\3\2\2\2\u0911\u0912\3")
buf.write("\2\2\2\u0912\u0913\7F\2\2\u0913\u0914\5~@\2\u0914\u0171")
buf.write("\3\2\2\2\u0915\u0916\7F\2\2\u0916\u0917\7g\2\2\u0917\u0918")
buf.write("\7h\2\2\u0918\u0919\5~@\2\u0919\u0173\3\2\2\2\u091a\u091b")
buf.write("\7J\2\2\u091b\u091c\5h\65\2\u091c\u091d\5\u0178\u00bd")
buf.write("\2\u091d\u0175\3\2\2\2\u091e\u0920\7J\2\2\u091f\u0921")
buf.write("\5\u0150\u00a9\2\u0920\u091f\3\2\2\2\u0920\u0921\3\2\2")
buf.write("\2\u0921\u0922\3\2\2\2\u0922\u0923\5h\65\2\u0923\u0924")
buf.write("\5\u0178\u00bd\2\u0924\u0177\3\2\2\2\u0925\u0927\5\u017a")
buf.write("\u00be\2\u0926\u0928\5\u0178\u00bd\2\u0927\u0926\3\2\2")
buf.write("\2\u0927\u0928\3\2\2\2\u0928\u0179\3\2\2\2\u0929\u092a")
buf.write("\7\24\2\2\u092a\u092b\7V\2\2\u092b\u092c\5\u017c\u00bf")
buf.write("\2\u092c\u092d\7W\2\2\u092d\u092e\5h\65\2\u092e\u017b")
buf.write("\3\2\2\2\u092f\u0931\5\u00d6l\2\u0930\u092f\3\2\2\2\u0930")
buf.write("\u0931\3\2\2\2\u0931\u0932\3\2\2\2\u0932\u0933\5\u009a")
buf.write("N\2\u0933\u0934\5\u00f0y\2\u0934\u093e\3\2\2\2\u0935\u0937")
buf.write("\5\u00d6l\2\u0936\u0935\3\2\2\2\u0936\u0937\3\2\2\2\u0937")
buf.write("\u0938\3\2\2\2\u0938\u093a\5\u009aN\2\u0939\u093b\5\u0106")
buf.write("\u0084\2\u093a\u0939\3\2\2\2\u093a\u093b\3\2\2\2\u093b")
buf.write("\u093e\3\2\2\2\u093c\u093e\7\u0086\2\2\u093d\u0930\3\2")
buf.write("\2\2\u093d\u0936\3\2\2\2\u093d\u093c\3\2\2\2\u093e\u017d")
buf.write("\3\2\2\2\u093f\u0941\7I\2\2\u0940\u0942\5Z.\2\u0941\u0940")
buf.write("\3\2\2\2\u0941\u0942\3\2\2\2\u0942\u017f\3\2\2\2\u0943")
buf.write("\u0946\5\u0182\u00c2\2\u0944\u0946\5\u0186\u00c4\2\u0945")
buf.write("\u0943\3\2\2\2\u0945\u0944\3\2\2\2\u0946\u0181\3\2\2\2")
buf.write("\u0947\u0948\7I\2\2\u0948\u094a\7V\2\2\u0949\u094b\5\u0184")
buf.write("\u00c3\2\u094a\u0949\3\2\2\2\u094a\u094b\3\2\2\2\u094b")
buf.write("\u094c\3\2\2\2\u094c\u094d\7W\2\2\u094d\u0183\3\2\2\2")
buf.write("\u094e\u094f\b\u00c3\1\2\u094f\u0951\5\u0104\u0083\2\u0950")
buf.write("\u0952\7\u0086\2\2\u0951\u0950\3\2\2\2\u0951\u0952\3\2")
buf.write("\2\2\u0952\u095b\3\2\2\2\u0953\u0954\f\3\2\2\u0954\u0955")
buf.write("\7}\2\2\u0955\u0957\5\u0104\u0083\2\u0956\u0958\7\u0086")
buf.write("\2\2\u0957\u0956\3\2\2\2\u0957\u0958\3\2\2\2\u0958\u095a")
buf.write("\3\2\2\2\u0959\u0953\3\2\2\2\u095a\u095d\3\2\2\2\u095b")
buf.write("\u0959\3\2\2\2\u095b\u095c\3\2\2\2\u095c\u0185\3\2\2\2")
buf.write("\u095d\u095b\3\2\2\2\u095e\u095f\7\64\2\2\u095f\u0960")
buf.write("\7V\2\2\u0960\u0961\5`\61\2\u0961\u0962\7W\2\2\u0962\u0965")
buf.write("\3\2\2\2\u0963\u0965\7\64\2\2\u0964\u095e\3\2\2\2\u0964")
buf.write("\u0963\3\2\2\2\u0965\u0187\3\2\2\2\u0966\u0967\7\t\2\2")
buf.write("\u0967\u0189\3\2\2\2\u0968\u0969\7\n\2\2\u0969\u018b\3")
buf.write("\2\2\2\u096a\u099e\7\63\2\2\u096b\u099e\7\37\2\2\u096c")
buf.write("\u096d\7\63\2\2\u096d\u096e\7X\2\2\u096e\u099e\7Y\2\2")
buf.write("\u096f\u0970\7\37\2\2\u0970\u0971\7X\2\2\u0971\u099e\7")
buf.write("Y\2\2\u0972\u099e\7\\\2\2\u0973\u099e\7]\2\2\u0974\u099e")
buf.write("\7^\2\2\u0975\u099e\7_\2\2\u0976\u099e\7`\2\2\u0977\u099e")
buf.write("\7a\2\2\u0978\u099e\7b\2\2\u0979\u099e\7c\2\2\u097a\u099e")
buf.write("\7d\2\2\u097b\u099e\7\3\2\2\u097c\u099e\7\4\2\2\u097d")
buf.write("\u099e\7f\2\2\u097e\u099e\7g\2\2\u097f\u099e\7h\2\2\u0980")
buf.write("\u099e\7i\2\2\u0981\u099e\7j\2\2\u0982\u099e\7k\2\2\u0983")
buf.write("\u099e\7l\2\2\u0984\u099e\7m\2\2\u0985\u099e\7n\2\2\u0986")
buf.write("\u099e\7o\2\2\u0987\u099e\7p\2\2\u0988\u099e\7q\2\2\u0989")
buf.write("\u099e\7r\2\2\u098a\u099e\7t\2\2\u098b\u099e\7s\2\2\u098c")
buf.write("\u099e\7u\2\2\u098d\u099e\7v\2\2\u098e\u099e\7w\2\2\u098f")
buf.write("\u099e\7x\2\2\u0990\u099e\7\5\2\2\u0991\u099e\7\6\2\2")
buf.write("\u0992\u099e\7\7\2\2\u0993\u099e\7\b\2\2\u0994\u099e\7")
buf.write("{\2\2\u0995\u099e\7|\2\2\u0996\u099e\7}\2\2\u0997\u099e")
buf.write("\7~\2\2\u0998\u099e\7\177\2\2\u0999\u099a\7V\2\2\u099a")
buf.write("\u099e\7W\2\2\u099b\u099c\7X\2\2\u099c\u099e\7Y\2\2\u099d")
buf.write("\u096a\3\2\2\2\u099d\u096b\3\2\2\2\u099d\u096c\3\2\2\2")
buf.write("\u099d\u096f\3\2\2\2\u099d\u0972\3\2\2\2\u099d\u0973\3")
buf.write("\2\2\2\u099d\u0974\3\2\2\2\u099d\u0975\3\2\2\2\u099d\u0976")
buf.write("\3\2\2\2\u099d\u0977\3\2\2\2\u099d\u0978\3\2\2\2\u099d")
buf.write("\u0979\3\2\2\2\u099d\u097a\3\2\2\2\u099d\u097b\3\2\2\2")
buf.write("\u099d\u097c\3\2\2\2\u099d\u097d\3\2\2\2\u099d\u097e\3")
buf.write("\2\2\2\u099d\u097f\3\2\2\2\u099d\u0980\3\2\2\2\u099d\u0981")
buf.write("\3\2\2\2\u099d\u0982\3\2\2\2\u099d\u0983\3\2\2\2\u099d")
buf.write("\u0984\3\2\2\2\u099d\u0985\3\2\2\2\u099d\u0986\3\2\2\2")
buf.write("\u099d\u0987\3\2\2\2\u099d\u0988\3\2\2\2\u099d\u0989\3")
buf.write("\2\2\2\u099d\u098a\3\2\2\2\u099d\u098b\3\2\2\2\u099d\u098c")
buf.write("\3\2\2\2\u099d\u098d\3\2\2\2\u099d\u098e\3\2\2\2\u099d")
buf.write("\u098f\3\2\2\2\u099d\u0990\3\2\2\2\u099d\u0991\3\2\2\2")
buf.write("\u099d\u0992\3\2\2\2\u099d\u0993\3\2\2\2\u099d\u0994\3")
buf.write("\2\2\2\u099d\u0995\3\2\2\2\u099d\u0996\3\2\2\2\u099d\u0997")
buf.write("\3\2\2\2\u099d\u0998\3\2\2\2\u099d\u0999\3\2\2\2\u099d")
buf.write("\u099b\3\2\2\2\u099e\u018d\3\2\2\2\u099f\u09a7\7\u0088")
buf.write("\2\2\u09a0\u09a7\7\u008e\2\2\u09a1\u09a7\7\u008f\2\2\u09a2")
buf.write("\u09a7\7\u0090\2\2\u09a3\u09a7\5\u0190\u00c9\2\u09a4\u09a7")
buf.write("\5\u0192\u00ca\2\u09a5\u09a7\5\u0194\u00cb\2\u09a6\u099f")
buf.write("\3\2\2\2\u09a6\u09a0\3\2\2\2\u09a6\u09a1\3\2\2\2\u09a6")
buf.write("\u09a2\3\2\2\2\u09a6\u09a3\3\2\2\2\u09a6\u09a4\3\2\2\2")
buf.write("\u09a6\u09a5\3\2\2\2\u09a7\u018f\3\2\2\2\u09a8\u09ab\5")
buf.write("\u0188\u00c5\2\u09a9\u09ab\5\u018a\u00c6\2\u09aa\u09a8")
buf.write("\3\2\2\2\u09aa\u09a9\3\2\2\2\u09ab\u0191\3\2\2\2\u09ac")
buf.write("\u09ad\7\65\2\2\u09ad\u0193\3\2\2\2\u09ae\u09af\t\16\2")
buf.write("\2\u09af\u0195\3\2\2\2\u013f\u0197\u01a3\u01a7\u01b2\u01b6")
buf.write("\u01c5\u01cc\u01d1\u01d3\u01d8\u01de\u01e8\u01ef\u01f5")
buf.write("\u01f9\u01fe\u0204\u020b\u0211\u0214\u0217\u021a\u0221")
buf.write("\u0228\u025c\u026b\u0271\u0277\u0284\u0286\u0290\u029f")
buf.write("\u02a5\u02c3\u02c8\u02cc\u02d0\u02d3\u02d7\u02dd\u02df")
buf.write("\u02e7\u02eb\u02ee\u02f5\u02fc\u0300\u0305\u0309\u030c")
buf.write("\u0311\u0317\u0324\u032f\u0331\u0340\u0342\u034e\u0350")
buf.write("\u035c\u0370\u0372\u037e\u0380\u038b\u0396\u03a1\u03ad")
buf.write("\u03af\u03bb\u03bd\u03c7\u03cf\u03db\u03e2\u03e6\u03ea")
buf.write("\u03ee\u03f2\u03f7\u03fa\u03fd\u0403\u040b\u0410\u0413")
buf.write("\u0419\u0424\u043b\u043f\u0447\u044d\u0461\u0465\u0472")
buf.write("\u0476\u0479\u0480\u0488\u0492\u049d\u04a9\u04b3\u04b8")
buf.write("\u04bf\u04c2\u04c7\u04cc\u04e1\u04e5\u04ea\u04f5\u04fb")
buf.write("\u04ff\u0504\u0508\u050d\u0510\u0526\u052c\u0537\u053b")
buf.write("\u053e\u0548\u054e\u0551\u0558\u0562\u0566\u0569\u056c")
buf.write("\u0570\u0575\u0577\u057b\u057f\u0588\u0595\u059d\u05a3")
buf.write("\u05a9\u05ad\u05b0\u05b9\u05c2\u05ca\u05d5\u05db\u05e6")
buf.write("\u05e9\u05ee\u05fd\u0603\u060c\u0616\u061c\u0624\u0628")
buf.write("\u062c\u0631\u0636\u063d\u063f\u0644\u0648\u0656\u065c")
buf.write("\u066e\u0670\u067a\u067f\u0686\u068c\u0691\u0697\u069e")
buf.write("\u06a2\u06a4\u06a6\u06ad\u06b0\u06b3\u06b6\u06bb\u06bf")
buf.write("\u06c2\u06c6\u06ca\u06cf\u06d2\u06d4\u06d8\u06df\u06e5")
buf.write("\u06e9\u06ef\u06f4\u06f6\u06fc\u0700\u0706\u070d\u0711")
buf.write("\u0713\u0715\u071c\u0726\u072a\u072c\u072e\u0732\u0735")
buf.write("\u073b\u0745\u0749\u074f\u0757\u075b\u075e\u0762\u0767")
buf.write("\u076a\u076d\u0771\u0776\u0780\u0787\u078c\u0790\u0795")
buf.write("\u079b\u079f\u07a5\u07ab\u07af\u07b4\u07ba\u07be\u07c1")
buf.write("\u07c5\u07c8\u07ca\u07cd\u07d7\u07dc\u07de\u07e1\u07e4")
buf.write("\u07e7\u07f0\u07fa\u07ff\u0802\u0806\u0809\u080c\u0810")
buf.write("\u0819\u0828\u082e\u0832\u0836\u083a\u083e\u0842\u0846")
buf.write("\u084a\u084d\u0851\u085c\u0860\u0867\u086b\u0870\u0875")
buf.write("\u087c\u0880\u088a\u089a\u089f\u08a3\u08a6\u08aa\u08b0")
buf.write("\u08b3\u08b7\u08c1\u08c4\u08cc\u08d1\u08d6\u08de\u08e5")
buf.write("\u08e9\u08f0\u08f6\u08fa\u0900\u0909\u090d\u0910\u0920")
buf.write("\u0927\u0930\u0936\u093a\u093d\u0941\u0945\u094a\u0951")
buf.write("\u0957\u095b\u0964\u099d\u09a6\u09aa")
return buf.getvalue()
[docs]
class CPP14Parser ( Parser ):
grammarFileName = "CPP14.g4"
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
sharedContextCache = PredictionContextCache()
literalNames = [ "<INVALID>", "'!'", "'not'", "'&&'", "'and'", "'||'",
"'or'", "'false'", "'true'", "<INVALID>", "<INVALID>",
"'alignas'", "'alignof'", "'asm'", "'auto'", "'bool'",
"'break'", "'case'", "'catch'", "'char'", "'char16_t'",
"'char32_t'", "'class'", "'const'", "'constexpr'",
"'const_cast'", "'continue'", "'decltype'", "'default'",
"'delete'", "'do'", "'double'", "'dynamic_cast'", "'else'",
"'enum'", "'explicit'", "'export'", "'extern'", "'final'",
"'float'", "'for'", "'friend'", "'goto'", "'if'", "'inline'",
"'int'", "'long'", "'mutable'", "'namespace'", "'new'",
"'noexcept'", "'nullptr'", "'operator'", "'override'",
"'private'", "'protected'", "'public'", "'register'",
"'reinterpret_cast'", "'return'", "'short'", "'signed'",
"'sizeof'", "'static'", "'static_assert'", "'static_cast'",
"'struct'", "'switch'", "'template'", "'this'", "'thread_local'",
"'throw'", "'try'", "'typedef'", "'typeid'", "'typename'",
"'union'", "'unsigned'", "'using'", "'virtual'", "'void'",
"'volatile'", "'wchar_t'", "'while'", "'('", "')'",
"'['", "']'", "'{'", "'}'", "'+'", "'-'", "'*'", "'/'",
"'%'", "'^'", "'&'", "'|'", "'~'", "<INVALID>", "'='",
"'<'", "'>'", "'+='", "'-='", "'*='", "'/='", "'%='",
"'^='", "'&='", "'|='", "'<<'", "'>>'", "'<<='", "'>>='",
"'=='", "'!='", "'<='", "'>='", "<INVALID>", "<INVALID>",
"'++'", "'--'", "','", "'->*'", "'->'", "'?'", "':'",
"'::'", "';'", "'.'", "'.*'", "'...'" ]
symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "MultiLineMacro", "Directive", "Alignas",
"Alignof", "Asm", "Auto", "Bool", "Break", "Case",
"Catch", "Char", "Char16", "Char32", "Class", "Const",
"Constexpr", "Const_cast", "Continue", "Decltype",
"Default", "Delete", "Do", "Double", "Dynamic_cast",
"Else", "Enum", "Explicit", "Export", "Extern", "Final",
"Float", "For", "Friend", "Goto", "If", "Inline",
"Int", "Long", "Mutable", "Namespace", "New", "Noexcept",
"Nullptr", "Operator", "Override", "Private", "Protected",
"Public", "Register", "Reinterpret_cast", "Return",
"Short", "Signed", "Sizeof", "Static", "Static_assert",
"Static_cast", "Struct", "Switch", "Template", "This",
"Thread_local", "Throw", "Try", "Typedef", "Typeid_",
"Typename_", "Union", "Unsigned", "Using", "Virtual",
"Void", "Volatile", "Wchar", "While", "LeftParen",
"RightParen", "LeftBracket", "RightBracket", "LeftBrace",
"RightBrace", "Plus", "Minus", "Star", "Div", "Mod",
"Caret", "And", "Or", "Tilde", "Not", "Assign", "Less",
"Greater", "PlusAssign", "MinusAssign", "StarAssign",
"DivAssign", "ModAssign", "XorAssign", "AndAssign",
"OrAssign", "LeftShift", "RightShift", "LeftShiftAssign",
"RightShiftAssign", "Equal", "NotEqual", "LessEqual",
"GreaterEqual", "AndAnd", "OrOr", "PlusPlus", "MinusMinus",
"Comma", "ArrowStar", "Arrow", "Question", "Colon",
"Doublecolon", "Semi", "Dot", "DotStar", "Ellipsis",
"Identifier", "Integerliteral", "Decimalliteral",
"Octalliteral", "Hexadecimalliteral", "Binaryliteral",
"Integersuffix", "Characterliteral", "Floatingliteral",
"Stringliteral", "Userdefinedintegerliteral", "Userdefinedfloatingliteral",
"Userdefinedstringliteral", "Userdefinedcharacterliteral",
"Whitespace", "Newline", "BlockComment", "LineComment" ]
RULE_translationunit = 0
RULE_primaryexpression = 1
RULE_idexpression = 2
RULE_unqualifiedid = 3
RULE_qualifiedid = 4
RULE_nestednamespecifier = 5
RULE_lambdaexpression = 6
RULE_lambdaintroducer = 7
RULE_lambdacapture = 8
RULE_capturedefault = 9
RULE_capturelist = 10
RULE_capture = 11
RULE_simplecapture = 12
RULE_initcapture = 13
RULE_lambdadeclarator = 14
RULE_postfixexpression = 15
RULE_typeidofexpr = 16
RULE_typeidofthetypeid = 17
RULE_expressionlist = 18
RULE_pseudodestructorname = 19
RULE_unaryexpression = 20
RULE_unaryoperator = 21
RULE_newexpression = 22
RULE_newplacement = 23
RULE_newtypeid = 24
RULE_newdeclarator = 25
RULE_noptrnewdeclarator = 26
RULE_newinitializer = 27
RULE_deleteexpression = 28
RULE_noexceptexpression = 29
RULE_castexpression = 30
RULE_pmexpression = 31
RULE_multiplicativeexpression = 32
RULE_additiveexpression = 33
RULE_shiftexpression = 34
RULE_shiftoperator = 35
RULE_relationalexpression = 36
RULE_equalityexpression = 37
RULE_andexpression = 38
RULE_exclusiveorexpression = 39
RULE_inclusiveorexpression = 40
RULE_logicalandexpression = 41
RULE_logicalorexpression = 42
RULE_conditionalexpression = 43
RULE_assignmentexpression = 44
RULE_assignmentoperator = 45
RULE_expression = 46
RULE_constantexpression = 47
RULE_statement = 48
RULE_labeledstatement = 49
RULE_expressionstatement = 50
RULE_compoundstatement = 51
RULE_statementseq = 52
RULE_selectionstatement = 53
RULE_condition = 54
RULE_iterationstatement = 55
RULE_forinitstatement = 56
RULE_forrangedeclaration = 57
RULE_forrangeinitializer = 58
RULE_jumpstatement = 59
RULE_declarationstatement = 60
RULE_declarationseq = 61
RULE_declaration = 62
RULE_blockdeclaration = 63
RULE_aliasdeclaration = 64
RULE_simpledeclaration = 65
RULE_static_assertdeclaration = 66
RULE_emptydeclaration = 67
RULE_attributedeclaration = 68
RULE_declspecifier = 69
RULE_declspecifierseq = 70
RULE_storageclassspecifier = 71
RULE_functionspecifier = 72
RULE_typedefname = 73
RULE_typespecifier = 74
RULE_trailingtypespecifier = 75
RULE_typespecifierseq = 76
RULE_trailingtypespecifierseq = 77
RULE_simpletypespecifier = 78
RULE_thetypename = 79
RULE_decltypespecifier = 80
RULE_elaboratedtypespecifier = 81
RULE_enumname = 82
RULE_enumspecifier = 83
RULE_enumhead = 84
RULE_opaqueenumdeclaration = 85
RULE_enumkey = 86
RULE_enumbase = 87
RULE_enumeratorlist = 88
RULE_enumeratordefinition = 89
RULE_enumerator = 90
RULE_namespacename = 91
RULE_originalnamespacename = 92
RULE_namespacedefinition = 93
RULE_namednamespacedefinition = 94
RULE_originalnamespacedefinition = 95
RULE_extensionnamespacedefinition = 96
RULE_unnamednamespacedefinition = 97
RULE_namespacebody = 98
RULE_namespacealias = 99
RULE_namespacealiasdefinition = 100
RULE_qualifiednamespacespecifier = 101
RULE_usingdeclaration = 102
RULE_usingdirective = 103
RULE_asmdefinition = 104
RULE_linkagespecification = 105
RULE_attributespecifierseq = 106
RULE_attributespecifier = 107
RULE_alignmentspecifier = 108
RULE_attributelist = 109
RULE_attribute = 110
RULE_attributetoken = 111
RULE_attributescopedtoken = 112
RULE_attributenamespace = 113
RULE_attributeargumentclause = 114
RULE_balancedtokenseq = 115
RULE_balancedtoken = 116
RULE_initdeclaratorlist = 117
RULE_initdeclarator = 118
RULE_declarator = 119
RULE_ptrdeclarator = 120
RULE_noptrdeclarator = 121
RULE_parametersandqualifiers = 122
RULE_trailingreturntype = 123
RULE_ptroperator = 124
RULE_cvqualifierseq = 125
RULE_cvqualifier = 126
RULE_refqualifier = 127
RULE_declaratorid = 128
RULE_thetypeid = 129
RULE_abstractdeclarator = 130
RULE_ptrabstractdeclarator = 131
RULE_noptrabstractdeclarator = 132
RULE_abstractpackdeclarator = 133
RULE_noptrabstractpackdeclarator = 134
RULE_parameterdeclarationclause = 135
RULE_parameterdeclarationlist = 136
RULE_parameterdeclaration = 137
RULE_functiondefinition = 138
RULE_functionbody = 139
RULE_initializer = 140
RULE_braceorequalinitializer = 141
RULE_initializerclause = 142
RULE_initializerlist = 143
RULE_bracedinitlist = 144
RULE_classname = 145
RULE_classspecifier = 146
RULE_classhead = 147
RULE_classheadname = 148
RULE_classvirtspecifier = 149
RULE_classkey = 150
RULE_memberspecification = 151
RULE_memberdeclaration = 152
RULE_memberdeclaratorlist = 153
RULE_memberdeclarator = 154
RULE_virtspecifierseq = 155
RULE_virtspecifier = 156
RULE_purespecifier = 157
RULE_baseclause = 158
RULE_basespecifierlist = 159
RULE_basespecifier = 160
RULE_classordecltype = 161
RULE_basetypespecifier = 162
RULE_accessspecifier = 163
RULE_conversionfunctionid = 164
RULE_conversiontypeid = 165
RULE_conversiondeclarator = 166
RULE_ctorinitializer = 167
RULE_meminitializerlist = 168
RULE_meminitializer = 169
RULE_meminitializerid = 170
RULE_operatorfunctionid = 171
RULE_literaloperatorid = 172
RULE_templatedeclaration = 173
RULE_templateparameterlist = 174
RULE_templateparameter = 175
RULE_typeparameter = 176
RULE_simpletemplateid = 177
RULE_templateid = 178
RULE_templatename = 179
RULE_templateargumentlist = 180
RULE_templateargument = 181
RULE_typenamespecifier = 182
RULE_explicitinstantiation = 183
RULE_explicitspecialization = 184
RULE_tryblock = 185
RULE_functiontryblock = 186
RULE_handlerseq = 187
RULE_handler = 188
RULE_exceptiondeclaration = 189
RULE_throwexpression = 190
RULE_exceptionspecification = 191
RULE_dynamicexceptionspecification = 192
RULE_typeidlist = 193
RULE_noexceptspecification = 194
RULE_false = 195
RULE_true = 196
RULE_theoperator = 197
RULE_literal = 198
RULE_booleanliteral = 199
RULE_pointerliteral = 200
RULE_userdefinedliteral = 201
ruleNames = [ "translationunit", "primaryexpression", "idexpression",
"unqualifiedid", "qualifiedid", "nestednamespecifier",
"lambdaexpression", "lambdaintroducer", "lambdacapture",
"capturedefault", "capturelist", "capture", "simplecapture",
"initcapture", "lambdadeclarator", "postfixexpression",
"typeidofexpr", "typeidofthetypeid", "expressionlist",
"pseudodestructorname", "unaryexpression", "unaryoperator",
"newexpression", "newplacement", "newtypeid", "newdeclarator",
"noptrnewdeclarator", "newinitializer", "deleteexpression",
"noexceptexpression", "castexpression", "pmexpression",
"multiplicativeexpression", "additiveexpression", "shiftexpression",
"shiftoperator", "relationalexpression", "equalityexpression",
"andexpression", "exclusiveorexpression", "inclusiveorexpression",
"logicalandexpression", "logicalorexpression", "conditionalexpression",
"assignmentexpression", "assignmentoperator", "expression",
"constantexpression", "statement", "labeledstatement",
"expressionstatement", "compoundstatement", "statementseq",
"selectionstatement", "condition", "iterationstatement",
"forinitstatement", "forrangedeclaration", "forrangeinitializer",
"jumpstatement", "declarationstatement", "declarationseq",
"declaration", "blockdeclaration", "aliasdeclaration",
"simpledeclaration", "static_assertdeclaration", "emptydeclaration",
"attributedeclaration", "declspecifier", "declspecifierseq",
"storageclassspecifier", "functionspecifier", "typedefname",
"typespecifier", "trailingtypespecifier", "typespecifierseq",
"trailingtypespecifierseq", "simpletypespecifier", "thetypename",
"decltypespecifier", "elaboratedtypespecifier", "enumname",
"enumspecifier", "enumhead", "opaqueenumdeclaration",
"enumkey", "enumbase", "enumeratorlist", "enumeratordefinition",
"enumerator", "namespacename", "originalnamespacename",
"namespacedefinition", "namednamespacedefinition", "originalnamespacedefinition",
"extensionnamespacedefinition", "unnamednamespacedefinition",
"namespacebody", "namespacealias", "namespacealiasdefinition",
"qualifiednamespacespecifier", "usingdeclaration", "usingdirective",
"asmdefinition", "linkagespecification", "attributespecifierseq",
"attributespecifier", "alignmentspecifier", "attributelist",
"attribute", "attributetoken", "attributescopedtoken",
"attributenamespace", "attributeargumentclause", "balancedtokenseq",
"balancedtoken", "initdeclaratorlist", "initdeclarator",
"declarator", "ptrdeclarator", "noptrdeclarator", "parametersandqualifiers",
"trailingreturntype", "ptroperator", "cvqualifierseq",
"cvqualifier", "refqualifier", "declaratorid", "thetypeid",
"abstractdeclarator", "ptrabstractdeclarator", "noptrabstractdeclarator",
"abstractpackdeclarator", "noptrabstractpackdeclarator",
"parameterdeclarationclause", "parameterdeclarationlist",
"parameterdeclaration", "functiondefinition", "functionbody",
"initializer", "braceorequalinitializer", "initializerclause",
"initializerlist", "bracedinitlist", "classname", "classspecifier",
"classhead", "classheadname", "classvirtspecifier", "classkey",
"memberspecification", "memberdeclaration", "memberdeclaratorlist",
"memberdeclarator", "virtspecifierseq", "virtspecifier",
"purespecifier", "baseclause", "basespecifierlist", "basespecifier",
"classordecltype", "basetypespecifier", "accessspecifier",
"conversionfunctionid", "conversiontypeid", "conversiondeclarator",
"ctorinitializer", "meminitializerlist", "meminitializer",
"meminitializerid", "operatorfunctionid", "literaloperatorid",
"templatedeclaration", "templateparameterlist", "templateparameter",
"typeparameter", "simpletemplateid", "templateid", "templatename",
"templateargumentlist", "templateargument", "typenamespecifier",
"explicitinstantiation", "explicitspecialization", "tryblock",
"functiontryblock", "handlerseq", "handler", "exceptiondeclaration",
"throwexpression", "exceptionspecification", "dynamicexceptionspecification",
"typeidlist", "noexceptspecification", "false", "true",
"theoperator", "literal", "booleanliteral", "pointerliteral",
"userdefinedliteral" ]
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
MultiLineMacro=9
Directive=10
Alignas=11
Alignof=12
Asm=13
Auto=14
Bool=15
Break=16
Case=17
Catch=18
Char=19
Char16=20
Char32=21
Class=22
Const=23
Constexpr=24
Const_cast=25
Continue=26
Decltype=27
Default=28
Delete=29
Do=30
Double=31
Dynamic_cast=32
Else=33
Enum=34
Explicit=35
Export=36
Extern=37
Final=38
Float=39
For=40
Friend=41
Goto=42
If=43
Inline=44
Int=45
Long=46
Mutable=47
Namespace=48
New=49
Noexcept=50
Nullptr=51
Operator=52
Override=53
Private=54
Protected=55
Public=56
Register=57
Reinterpret_cast=58
Return=59
Short=60
Signed=61
Sizeof=62
Static=63
Static_assert=64
Static_cast=65
Struct=66
Switch=67
Template=68
This=69
Thread_local=70
Throw=71
Try=72
Typedef=73
Typeid_=74
Typename_=75
Union=76
Unsigned=77
Using=78
Virtual=79
Void=80
Volatile=81
Wchar=82
While=83
LeftParen=84
RightParen=85
LeftBracket=86
RightBracket=87
LeftBrace=88
RightBrace=89
Plus=90
Minus=91
Star=92
Div=93
Mod=94
Caret=95
And=96
Or=97
Tilde=98
Not=99
Assign=100
Less=101
Greater=102
PlusAssign=103
MinusAssign=104
StarAssign=105
DivAssign=106
ModAssign=107
XorAssign=108
AndAssign=109
OrAssign=110
LeftShift=111
RightShift=112
LeftShiftAssign=113
RightShiftAssign=114
Equal=115
NotEqual=116
LessEqual=117
GreaterEqual=118
AndAnd=119
OrOr=120
PlusPlus=121
MinusMinus=122
Comma=123
ArrowStar=124
Arrow=125
Question=126
Colon=127
Doublecolon=128
Semi=129
Dot=130
DotStar=131
Ellipsis=132
Identifier=133
Integerliteral=134
Decimalliteral=135
Octalliteral=136
Hexadecimalliteral=137
Binaryliteral=138
Integersuffix=139
Characterliteral=140
Floatingliteral=141
Stringliteral=142
Userdefinedintegerliteral=143
Userdefinedfloatingliteral=144
Userdefinedstringliteral=145
Userdefinedcharacterliteral=146
Whitespace=147
Newline=148
BlockComment=149
LineComment=150
def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
super().__init__(input, output)
self.checkVersion("4.8")
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
self._predicates = None
[docs]
class TranslationunitContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EOF(self):
return self.getToken(CPP14Parser.EOF, 0)
[docs]
def declarationseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_translationunit
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTranslationunit" ):
listener.enterTranslationunit(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTranslationunit" ):
listener.exitTranslationunit(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTranslationunit" ):
return visitor.visitTranslationunit(self)
else:
return visitor.visitChildren(self)
[docs]
def translationunit(self):
localctx = CPP14Parser.TranslationunitContext(self, self._ctx, self.state)
self.enterRule(localctx, 0, self.RULE_translationunit)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 405
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__2) | (1 << CPP14Parser.Alignas) | (1 << CPP14Parser.Asm) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Constexpr) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Explicit) | (1 << CPP14Parser.Extern) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Friend) | (1 << CPP14Parser.Inline) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.Mutable) | (1 << CPP14Parser.Namespace) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Register) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Static))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CPP14Parser.Static_assert - 64)) | (1 << (CPP14Parser.Struct - 64)) | (1 << (CPP14Parser.Template - 64)) | (1 << (CPP14Parser.Thread_local - 64)) | (1 << (CPP14Parser.Typedef - 64)) | (1 << (CPP14Parser.Typename_ - 64)) | (1 << (CPP14Parser.Union - 64)) | (1 << (CPP14Parser.Unsigned - 64)) | (1 << (CPP14Parser.Using - 64)) | (1 << (CPP14Parser.Virtual - 64)) | (1 << (CPP14Parser.Void - 64)) | (1 << (CPP14Parser.Volatile - 64)) | (1 << (CPP14Parser.Wchar - 64)) | (1 << (CPP14Parser.LeftParen - 64)) | (1 << (CPP14Parser.LeftBracket - 64)) | (1 << (CPP14Parser.Star - 64)) | (1 << (CPP14Parser.And - 64)) | (1 << (CPP14Parser.Tilde - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (CPP14Parser.Doublecolon - 128)) | (1 << (CPP14Parser.Semi - 128)) | (1 << (CPP14Parser.Ellipsis - 128)) | (1 << (CPP14Parser.Identifier - 128)))) != 0):
self.state = 404
self.declarationseq(0)
self.state = 407
self.match(CPP14Parser.EOF)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PrimaryexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def literal(self):
return self.getTypedRuleContext(CPP14Parser.LiteralContext,0)
[docs]
def This(self):
return self.getToken(CPP14Parser.This, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def idexpression(self):
return self.getTypedRuleContext(CPP14Parser.IdexpressionContext,0)
[docs]
def lambdaexpression(self):
return self.getTypedRuleContext(CPP14Parser.LambdaexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_primaryexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPrimaryexpression" ):
listener.enterPrimaryexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPrimaryexpression" ):
listener.exitPrimaryexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPrimaryexpression" ):
return visitor.visitPrimaryexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def primaryexpression(self):
localctx = CPP14Parser.PrimaryexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 2, self.RULE_primaryexpression)
try:
self.state = 417
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.T__6, CPP14Parser.T__7, CPP14Parser.Nullptr, CPP14Parser.Integerliteral, CPP14Parser.Characterliteral, CPP14Parser.Floatingliteral, CPP14Parser.Stringliteral, CPP14Parser.Userdefinedintegerliteral, CPP14Parser.Userdefinedfloatingliteral, CPP14Parser.Userdefinedstringliteral, CPP14Parser.Userdefinedcharacterliteral]:
self.enterOuterAlt(localctx, 1)
self.state = 409
self.literal()
pass
elif token in [CPP14Parser.This]:
self.enterOuterAlt(localctx, 2)
self.state = 410
self.match(CPP14Parser.This)
pass
elif token in [CPP14Parser.LeftParen]:
self.enterOuterAlt(localctx, 3)
self.state = 411
self.match(CPP14Parser.LeftParen)
self.state = 412
self.expression(0)
self.state = 413
self.match(CPP14Parser.RightParen)
pass
elif token in [CPP14Parser.Decltype, CPP14Parser.Operator, CPP14Parser.Tilde, CPP14Parser.Doublecolon, CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 4)
self.state = 415
self.idexpression()
pass
elif token in [CPP14Parser.LeftBracket]:
self.enterOuterAlt(localctx, 5)
self.state = 416
self.lambdaexpression()
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
[docs]
class IdexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unqualifiedid(self):
return self.getTypedRuleContext(CPP14Parser.UnqualifiedidContext,0)
[docs]
def qualifiedid(self):
return self.getTypedRuleContext(CPP14Parser.QualifiedidContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_idexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIdexpression" ):
listener.enterIdexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIdexpression" ):
listener.exitIdexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIdexpression" ):
return visitor.visitIdexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def idexpression(self):
localctx = CPP14Parser.IdexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 4, self.RULE_idexpression)
try:
self.state = 421
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 419
self.unqualifiedid()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 420
self.qualifiedid()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UnqualifiedidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def operatorfunctionid(self):
return self.getTypedRuleContext(CPP14Parser.OperatorfunctionidContext,0)
[docs]
def conversionfunctionid(self):
return self.getTypedRuleContext(CPP14Parser.ConversionfunctionidContext,0)
[docs]
def literaloperatorid(self):
return self.getTypedRuleContext(CPP14Parser.LiteraloperatoridContext,0)
[docs]
def Tilde(self):
return self.getToken(CPP14Parser.Tilde, 0)
[docs]
def classname(self):
return self.getTypedRuleContext(CPP14Parser.ClassnameContext,0)
[docs]
def decltypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.DecltypespecifierContext,0)
[docs]
def templateid(self):
return self.getTypedRuleContext(CPP14Parser.TemplateidContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_unqualifiedid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnqualifiedid" ):
listener.enterUnqualifiedid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnqualifiedid" ):
listener.exitUnqualifiedid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnqualifiedid" ):
return visitor.visitUnqualifiedid(self)
else:
return visitor.visitChildren(self)
[docs]
def unqualifiedid(self):
localctx = CPP14Parser.UnqualifiedidContext(self, self._ctx, self.state)
self.enterRule(localctx, 6, self.RULE_unqualifiedid)
try:
self.state = 432
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 423
self.match(CPP14Parser.Identifier)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 424
self.operatorfunctionid()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 425
self.conversionfunctionid()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 426
self.literaloperatorid()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 427
self.match(CPP14Parser.Tilde)
self.state = 428
self.classname()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 429
self.match(CPP14Parser.Tilde)
self.state = 430
self.decltypespecifier()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 431
self.templateid()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class QualifiedidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def unqualifiedid(self):
return self.getTypedRuleContext(CPP14Parser.UnqualifiedidContext,0)
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_qualifiedid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterQualifiedid" ):
listener.enterQualifiedid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitQualifiedid" ):
listener.exitQualifiedid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitQualifiedid" ):
return visitor.visitQualifiedid(self)
else:
return visitor.visitChildren(self)
[docs]
def qualifiedid(self):
localctx = CPP14Parser.QualifiedidContext(self, self._ctx, self.state)
self.enterRule(localctx, 8, self.RULE_qualifiedid)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 434
self.nestednamespecifier(0)
self.state = 436
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Template:
self.state = 435
self.match(CPP14Parser.Template)
self.state = 438
self.unqualifiedid()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NestednamespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Doublecolon(self):
return self.getToken(CPP14Parser.Doublecolon, 0)
[docs]
def thetypename(self):
return self.getTypedRuleContext(CPP14Parser.ThetypenameContext,0)
[docs]
def namespacename(self):
return self.getTypedRuleContext(CPP14Parser.NamespacenameContext,0)
[docs]
def decltypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.DecltypespecifierContext,0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def simpletemplateid(self):
return self.getTypedRuleContext(CPP14Parser.SimpletemplateidContext,0)
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_nestednamespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNestednamespecifier" ):
listener.enterNestednamespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNestednamespecifier" ):
listener.exitNestednamespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNestednamespecifier" ):
return visitor.visitNestednamespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def nestednamespecifier(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.NestednamespecifierContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 10
self.enterRecursionRule(localctx, 10, self.RULE_nestednamespecifier, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 451
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
if la_ == 1:
self.state = 441
self.match(CPP14Parser.Doublecolon)
pass
elif la_ == 2:
self.state = 442
self.thetypename()
self.state = 443
self.match(CPP14Parser.Doublecolon)
pass
elif la_ == 3:
self.state = 445
self.namespacename()
self.state = 446
self.match(CPP14Parser.Doublecolon)
pass
elif la_ == 4:
self.state = 448
self.decltypespecifier()
self.state = 449
self.match(CPP14Parser.Doublecolon)
pass
self._ctx.stop = self._input.LT(-1)
self.state = 465
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,8,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 463
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
if la_ == 1:
localctx = CPP14Parser.NestednamespecifierContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_nestednamespecifier)
self.state = 453
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 454
self.match(CPP14Parser.Identifier)
self.state = 455
self.match(CPP14Parser.Doublecolon)
pass
elif la_ == 2:
localctx = CPP14Parser.NestednamespecifierContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_nestednamespecifier)
self.state = 456
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 458
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Template:
self.state = 457
self.match(CPP14Parser.Template)
self.state = 460
self.simpletemplateid()
self.state = 461
self.match(CPP14Parser.Doublecolon)
pass
self.state = 467
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,8,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class LambdaexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def lambdaintroducer(self):
return self.getTypedRuleContext(CPP14Parser.LambdaintroducerContext,0)
[docs]
def compoundstatement(self):
return self.getTypedRuleContext(CPP14Parser.CompoundstatementContext,0)
[docs]
def lambdadeclarator(self):
return self.getTypedRuleContext(CPP14Parser.LambdadeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_lambdaexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLambdaexpression" ):
listener.enterLambdaexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLambdaexpression" ):
listener.exitLambdaexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLambdaexpression" ):
return visitor.visitLambdaexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def lambdaexpression(self):
localctx = CPP14Parser.LambdaexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 12, self.RULE_lambdaexpression)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 468
self.lambdaintroducer()
self.state = 470
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.LeftParen:
self.state = 469
self.lambdadeclarator()
self.state = 472
self.compoundstatement()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LambdaintroducerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftBracket(self):
return self.getToken(CPP14Parser.LeftBracket, 0)
[docs]
def RightBracket(self):
return self.getToken(CPP14Parser.RightBracket, 0)
[docs]
def lambdacapture(self):
return self.getTypedRuleContext(CPP14Parser.LambdacaptureContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_lambdaintroducer
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLambdaintroducer" ):
listener.enterLambdaintroducer(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLambdaintroducer" ):
listener.exitLambdaintroducer(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLambdaintroducer" ):
return visitor.visitLambdaintroducer(self)
else:
return visitor.visitChildren(self)
[docs]
def lambdaintroducer(self):
localctx = CPP14Parser.LambdaintroducerContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_lambdaintroducer)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 474
self.match(CPP14Parser.LeftBracket)
self.state = 476
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (CPP14Parser.This - 69)) | (1 << (CPP14Parser.And - 69)) | (1 << (CPP14Parser.Assign - 69)))) != 0) or _la==CPP14Parser.Identifier:
self.state = 475
self.lambdacapture()
self.state = 478
self.match(CPP14Parser.RightBracket)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LambdacaptureContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def capturedefault(self):
return self.getTypedRuleContext(CPP14Parser.CapturedefaultContext,0)
[docs]
def capturelist(self):
return self.getTypedRuleContext(CPP14Parser.CapturelistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_lambdacapture
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLambdacapture" ):
listener.enterLambdacapture(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLambdacapture" ):
listener.exitLambdacapture(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLambdacapture" ):
return visitor.visitLambdacapture(self)
else:
return visitor.visitChildren(self)
[docs]
def lambdacapture(self):
localctx = CPP14Parser.LambdacaptureContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_lambdacapture)
try:
self.state = 486
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 480
self.capturedefault()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 481
self.capturelist(0)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 482
self.capturedefault()
self.state = 483
self.match(CPP14Parser.Comma)
self.state = 484
self.capturelist(0)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CapturedefaultContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def And(self):
return self.getToken(CPP14Parser.And, 0)
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_capturedefault
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCapturedefault" ):
listener.enterCapturedefault(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCapturedefault" ):
listener.exitCapturedefault(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCapturedefault" ):
return visitor.visitCapturedefault(self)
else:
return visitor.visitChildren(self)
[docs]
def capturedefault(self):
localctx = CPP14Parser.CapturedefaultContext(self, self._ctx, self.state)
self.enterRule(localctx, 18, self.RULE_capturedefault)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 488
_la = self._input.LA(1)
if not(_la==CPP14Parser.And or _la==CPP14Parser.Assign):
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
[docs]
class CapturelistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def capture(self):
return self.getTypedRuleContext(CPP14Parser.CaptureContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def capturelist(self):
return self.getTypedRuleContext(CPP14Parser.CapturelistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_capturelist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCapturelist" ):
listener.enterCapturelist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCapturelist" ):
listener.exitCapturelist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCapturelist" ):
return visitor.visitCapturelist(self)
else:
return visitor.visitChildren(self)
[docs]
def capturelist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.CapturelistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 20
self.enterRecursionRule(localctx, 20, self.RULE_capturelist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 491
self.capture()
self.state = 493
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
if la_ == 1:
self.state = 492
self.match(CPP14Parser.Ellipsis)
self._ctx.stop = self._input.LT(-1)
self.state = 503
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,14,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.CapturelistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_capturelist)
self.state = 495
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 496
self.match(CPP14Parser.Comma)
self.state = 497
self.capture()
self.state = 499
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
if la_ == 1:
self.state = 498
self.match(CPP14Parser.Ellipsis)
self.state = 505
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,14,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class CaptureContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def simplecapture(self):
return self.getTypedRuleContext(CPP14Parser.SimplecaptureContext,0)
[docs]
def initcapture(self):
return self.getTypedRuleContext(CPP14Parser.InitcaptureContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_capture
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCapture" ):
listener.enterCapture(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCapture" ):
listener.exitCapture(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCapture" ):
return visitor.visitCapture(self)
else:
return visitor.visitChildren(self)
[docs]
def capture(self):
localctx = CPP14Parser.CaptureContext(self, self._ctx, self.state)
self.enterRule(localctx, 22, self.RULE_capture)
try:
self.state = 508
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 506
self.simplecapture()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 507
self.initcapture()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SimplecaptureContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def And(self):
return self.getToken(CPP14Parser.And, 0)
[docs]
def This(self):
return self.getToken(CPP14Parser.This, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_simplecapture
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSimplecapture" ):
listener.enterSimplecapture(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSimplecapture" ):
listener.exitSimplecapture(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSimplecapture" ):
return visitor.visitSimplecapture(self)
else:
return visitor.visitChildren(self)
[docs]
def simplecapture(self):
localctx = CPP14Parser.SimplecaptureContext(self, self._ctx, self.state)
self.enterRule(localctx, 24, self.RULE_simplecapture)
try:
self.state = 514
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 1)
self.state = 510
self.match(CPP14Parser.Identifier)
pass
elif token in [CPP14Parser.And]:
self.enterOuterAlt(localctx, 2)
self.state = 511
self.match(CPP14Parser.And)
self.state = 512
self.match(CPP14Parser.Identifier)
pass
elif token in [CPP14Parser.This]:
self.enterOuterAlt(localctx, 3)
self.state = 513
self.match(CPP14Parser.This)
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
[docs]
class InitcaptureContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def initializer(self):
return self.getTypedRuleContext(CPP14Parser.InitializerContext,0)
[docs]
def And(self):
return self.getToken(CPP14Parser.And, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_initcapture
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInitcapture" ):
listener.enterInitcapture(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInitcapture" ):
listener.exitInitcapture(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInitcapture" ):
return visitor.visitInitcapture(self)
else:
return visitor.visitChildren(self)
[docs]
def initcapture(self):
localctx = CPP14Parser.InitcaptureContext(self, self._ctx, self.state)
self.enterRule(localctx, 26, self.RULE_initcapture)
try:
self.state = 521
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 1)
self.state = 516
self.match(CPP14Parser.Identifier)
self.state = 517
self.initializer()
pass
elif token in [CPP14Parser.And]:
self.enterOuterAlt(localctx, 2)
self.state = 518
self.match(CPP14Parser.And)
self.state = 519
self.match(CPP14Parser.Identifier)
self.state = 520
self.initializer()
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
[docs]
class LambdadeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def parameterdeclarationclause(self):
return self.getTypedRuleContext(CPP14Parser.ParameterdeclarationclauseContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def Mutable(self):
return self.getToken(CPP14Parser.Mutable, 0)
[docs]
def exceptionspecification(self):
return self.getTypedRuleContext(CPP14Parser.ExceptionspecificationContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def trailingreturntype(self):
return self.getTypedRuleContext(CPP14Parser.TrailingreturntypeContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_lambdadeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLambdadeclarator" ):
listener.enterLambdadeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLambdadeclarator" ):
listener.exitLambdadeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLambdadeclarator" ):
return visitor.visitLambdadeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def lambdadeclarator(self):
localctx = CPP14Parser.LambdadeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 28, self.RULE_lambdadeclarator)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 523
self.match(CPP14Parser.LeftParen)
self.state = 524
self.parameterdeclarationclause()
self.state = 525
self.match(CPP14Parser.RightParen)
self.state = 527
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Mutable:
self.state = 526
self.match(CPP14Parser.Mutable)
self.state = 530
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Noexcept or _la==CPP14Parser.Throw:
self.state = 529
self.exceptionspecification()
self.state = 533
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 532
self.attributespecifierseq(0)
self.state = 536
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Arrow:
self.state = 535
self.trailingreturntype()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PostfixexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def primaryexpression(self):
return self.getTypedRuleContext(CPP14Parser.PrimaryexpressionContext,0)
[docs]
def simpletypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.SimpletypespecifierContext,0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def expressionlist(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionlistContext,0)
[docs]
def typenamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.TypenamespecifierContext,0)
[docs]
def bracedinitlist(self):
return self.getTypedRuleContext(CPP14Parser.BracedinitlistContext,0)
[docs]
def Dynamic_cast(self):
return self.getToken(CPP14Parser.Dynamic_cast, 0)
[docs]
def Less(self):
return self.getToken(CPP14Parser.Less, 0)
[docs]
def thetypeid(self):
return self.getTypedRuleContext(CPP14Parser.ThetypeidContext,0)
[docs]
def Greater(self):
return self.getToken(CPP14Parser.Greater, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def Static_cast(self):
return self.getToken(CPP14Parser.Static_cast, 0)
[docs]
def Reinterpret_cast(self):
return self.getToken(CPP14Parser.Reinterpret_cast, 0)
[docs]
def Const_cast(self):
return self.getToken(CPP14Parser.Const_cast, 0)
[docs]
def typeidofthetypeid(self):
return self.getTypedRuleContext(CPP14Parser.TypeidofthetypeidContext,0)
[docs]
def postfixexpression(self):
return self.getTypedRuleContext(CPP14Parser.PostfixexpressionContext,0)
[docs]
def LeftBracket(self):
return self.getToken(CPP14Parser.LeftBracket, 0)
[docs]
def RightBracket(self):
return self.getToken(CPP14Parser.RightBracket, 0)
[docs]
def Dot(self):
return self.getToken(CPP14Parser.Dot, 0)
[docs]
def idexpression(self):
return self.getTypedRuleContext(CPP14Parser.IdexpressionContext,0)
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def Arrow(self):
return self.getToken(CPP14Parser.Arrow, 0)
[docs]
def pseudodestructorname(self):
return self.getTypedRuleContext(CPP14Parser.PseudodestructornameContext,0)
[docs]
def PlusPlus(self):
return self.getToken(CPP14Parser.PlusPlus, 0)
[docs]
def MinusMinus(self):
return self.getToken(CPP14Parser.MinusMinus, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_postfixexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPostfixexpression" ):
listener.enterPostfixexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPostfixexpression" ):
listener.exitPostfixexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPostfixexpression" ):
return visitor.visitPostfixexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def postfixexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.PostfixexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 30
self.enterRecursionRule(localctx, 30, self.RULE_postfixexpression, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 602
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
if la_ == 1:
self.state = 539
self.primaryexpression()
pass
elif la_ == 2:
self.state = 540
self.simpletypespecifier()
self.state = 541
self.match(CPP14Parser.LeftParen)
self.state = 543
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Throw - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.LeftBrace - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 542
self.expressionlist()
self.state = 545
self.match(CPP14Parser.RightParen)
pass
elif la_ == 3:
self.state = 547
self.typenamespecifier()
self.state = 548
self.match(CPP14Parser.LeftParen)
self.state = 550
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Throw - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.LeftBrace - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 549
self.expressionlist()
self.state = 552
self.match(CPP14Parser.RightParen)
pass
elif la_ == 4:
self.state = 554
self.simpletypespecifier()
self.state = 555
self.bracedinitlist()
pass
elif la_ == 5:
self.state = 557
self.typenamespecifier()
self.state = 558
self.bracedinitlist()
pass
elif la_ == 6:
self.state = 560
self.match(CPP14Parser.Dynamic_cast)
self.state = 561
self.match(CPP14Parser.Less)
self.state = 562
self.thetypeid()
self.state = 563
self.match(CPP14Parser.Greater)
self.state = 564
self.match(CPP14Parser.LeftParen)
self.state = 565
self.expression(0)
self.state = 566
self.match(CPP14Parser.RightParen)
pass
elif la_ == 7:
self.state = 568
self.match(CPP14Parser.Static_cast)
self.state = 569
self.match(CPP14Parser.Less)
self.state = 570
self.thetypeid()
self.state = 571
self.match(CPP14Parser.Greater)
self.state = 572
self.match(CPP14Parser.LeftParen)
self.state = 573
self.expression(0)
self.state = 574
self.match(CPP14Parser.RightParen)
pass
elif la_ == 8:
self.state = 576
self.match(CPP14Parser.Reinterpret_cast)
self.state = 577
self.match(CPP14Parser.Less)
self.state = 578
self.thetypeid()
self.state = 579
self.match(CPP14Parser.Greater)
self.state = 580
self.match(CPP14Parser.LeftParen)
self.state = 581
self.expression(0)
self.state = 582
self.match(CPP14Parser.RightParen)
pass
elif la_ == 9:
self.state = 584
self.match(CPP14Parser.Const_cast)
self.state = 585
self.match(CPP14Parser.Less)
self.state = 586
self.thetypeid()
self.state = 587
self.match(CPP14Parser.Greater)
self.state = 588
self.match(CPP14Parser.LeftParen)
self.state = 589
self.expression(0)
self.state = 590
self.match(CPP14Parser.RightParen)
pass
elif la_ == 10:
self.state = 592
self.typeidofthetypeid()
self.state = 593
self.match(CPP14Parser.LeftParen)
self.state = 594
self.expression(0)
self.state = 595
self.match(CPP14Parser.RightParen)
pass
elif la_ == 11:
self.state = 597
self.typeidofthetypeid()
self.state = 598
self.match(CPP14Parser.LeftParen)
self.state = 599
self.thetypeid()
self.state = 600
self.match(CPP14Parser.RightParen)
pass
self._ctx.stop = self._input.LT(-1)
self.state = 644
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,29,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 642
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
if la_ == 1:
localctx = CPP14Parser.PostfixexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixexpression)
self.state = 604
if not self.precpred(self._ctx, 19):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
self.state = 605
self.match(CPP14Parser.LeftBracket)
self.state = 606
self.expression(0)
self.state = 607
self.match(CPP14Parser.RightBracket)
pass
elif la_ == 2:
localctx = CPP14Parser.PostfixexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixexpression)
self.state = 609
if not self.precpred(self._ctx, 18):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
self.state = 610
self.match(CPP14Parser.LeftBracket)
self.state = 611
self.bracedinitlist()
self.state = 612
self.match(CPP14Parser.RightBracket)
pass
elif la_ == 3:
localctx = CPP14Parser.PostfixexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixexpression)
self.state = 614
if not self.precpred(self._ctx, 17):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
self.state = 615
self.match(CPP14Parser.LeftParen)
self.state = 617
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Throw - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.LeftBrace - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 616
self.expressionlist()
self.state = 619
self.match(CPP14Parser.RightParen)
pass
elif la_ == 4:
localctx = CPP14Parser.PostfixexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixexpression)
self.state = 620
if not self.precpred(self._ctx, 12):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
self.state = 621
self.match(CPP14Parser.Dot)
self.state = 623
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Template:
self.state = 622
self.match(CPP14Parser.Template)
self.state = 625
self.idexpression()
pass
elif la_ == 5:
localctx = CPP14Parser.PostfixexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixexpression)
self.state = 626
if not self.precpred(self._ctx, 11):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
self.state = 627
self.match(CPP14Parser.Arrow)
self.state = 629
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Template:
self.state = 628
self.match(CPP14Parser.Template)
self.state = 631
self.idexpression()
pass
elif la_ == 6:
localctx = CPP14Parser.PostfixexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixexpression)
self.state = 632
if not self.precpred(self._ctx, 10):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
self.state = 633
self.match(CPP14Parser.Dot)
self.state = 634
self.pseudodestructorname()
pass
elif la_ == 7:
localctx = CPP14Parser.PostfixexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixexpression)
self.state = 635
if not self.precpred(self._ctx, 9):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
self.state = 636
self.match(CPP14Parser.Arrow)
self.state = 637
self.pseudodestructorname()
pass
elif la_ == 8:
localctx = CPP14Parser.PostfixexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixexpression)
self.state = 638
if not self.precpred(self._ctx, 8):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
self.state = 639
self.match(CPP14Parser.PlusPlus)
pass
elif la_ == 9:
localctx = CPP14Parser.PostfixexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixexpression)
self.state = 640
if not self.precpred(self._ctx, 7):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
self.state = 641
self.match(CPP14Parser.MinusMinus)
pass
self.state = 646
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,29,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class TypeidofexprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Typeid_(self):
return self.getToken(CPP14Parser.Typeid_, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_typeidofexpr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeidofexpr" ):
listener.enterTypeidofexpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeidofexpr" ):
listener.exitTypeidofexpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeidofexpr" ):
return visitor.visitTypeidofexpr(self)
else:
return visitor.visitChildren(self)
[docs]
def typeidofexpr(self):
localctx = CPP14Parser.TypeidofexprContext(self, self._ctx, self.state)
self.enterRule(localctx, 32, self.RULE_typeidofexpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 647
self.match(CPP14Parser.Typeid_)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeidofthetypeidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Typeid_(self):
return self.getToken(CPP14Parser.Typeid_, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_typeidofthetypeid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeidofthetypeid" ):
listener.enterTypeidofthetypeid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeidofthetypeid" ):
listener.exitTypeidofthetypeid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeidofthetypeid" ):
return visitor.visitTypeidofthetypeid(self)
else:
return visitor.visitChildren(self)
[docs]
def typeidofthetypeid(self):
localctx = CPP14Parser.TypeidofthetypeidContext(self, self._ctx, self.state)
self.enterRule(localctx, 34, self.RULE_typeidofthetypeid)
try:
self.enterOuterAlt(localctx, 1)
self.state = 649
self.match(CPP14Parser.Typeid_)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExpressionlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def initializerlist(self):
return self.getTypedRuleContext(CPP14Parser.InitializerlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_expressionlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExpressionlist" ):
listener.enterExpressionlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExpressionlist" ):
listener.exitExpressionlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExpressionlist" ):
return visitor.visitExpressionlist(self)
else:
return visitor.visitChildren(self)
[docs]
def expressionlist(self):
localctx = CPP14Parser.ExpressionlistContext(self, self._ctx, self.state)
self.enterRule(localctx, 36, self.RULE_expressionlist)
try:
self.enterOuterAlt(localctx, 1)
self.state = 651
self.initializerlist(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PseudodestructornameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def thetypename(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CPP14Parser.ThetypenameContext)
else:
return self.getTypedRuleContext(CPP14Parser.ThetypenameContext,i)
[docs]
def Doublecolon(self):
return self.getToken(CPP14Parser.Doublecolon, 0)
[docs]
def Tilde(self):
return self.getToken(CPP14Parser.Tilde, 0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def simpletemplateid(self):
return self.getTypedRuleContext(CPP14Parser.SimpletemplateidContext,0)
[docs]
def decltypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.DecltypespecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_pseudodestructorname
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPseudodestructorname" ):
listener.enterPseudodestructorname(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPseudodestructorname" ):
listener.exitPseudodestructorname(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPseudodestructorname" ):
return visitor.visitPseudodestructorname(self)
else:
return visitor.visitChildren(self)
[docs]
def pseudodestructorname(self):
localctx = CPP14Parser.PseudodestructornameContext(self, self._ctx, self.state)
self.enterRule(localctx, 38, self.RULE_pseudodestructorname)
self._la = 0 # Token type
try:
self.state = 675
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 654
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
if la_ == 1:
self.state = 653
self.nestednamespecifier(0)
self.state = 656
self.thetypename()
self.state = 657
self.match(CPP14Parser.Doublecolon)
self.state = 658
self.match(CPP14Parser.Tilde)
self.state = 659
self.thetypename()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 661
self.nestednamespecifier(0)
self.state = 662
self.match(CPP14Parser.Template)
self.state = 663
self.simpletemplateid()
self.state = 664
self.match(CPP14Parser.Doublecolon)
self.state = 665
self.match(CPP14Parser.Tilde)
self.state = 666
self.thetypename()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 669
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Decltype or _la==CPP14Parser.Doublecolon or _la==CPP14Parser.Identifier:
self.state = 668
self.nestednamespecifier(0)
self.state = 671
self.match(CPP14Parser.Tilde)
self.state = 672
self.thetypename()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 673
self.match(CPP14Parser.Tilde)
self.state = 674
self.decltypespecifier()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UnaryexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def postfixexpression(self):
return self.getTypedRuleContext(CPP14Parser.PostfixexpressionContext,0)
[docs]
def PlusPlus(self):
return self.getToken(CPP14Parser.PlusPlus, 0)
[docs]
def castexpression(self):
return self.getTypedRuleContext(CPP14Parser.CastexpressionContext,0)
[docs]
def MinusMinus(self):
return self.getToken(CPP14Parser.MinusMinus, 0)
[docs]
def unaryoperator(self):
return self.getTypedRuleContext(CPP14Parser.UnaryoperatorContext,0)
[docs]
def Sizeof(self):
return self.getToken(CPP14Parser.Sizeof, 0)
[docs]
def unaryexpression(self):
return self.getTypedRuleContext(CPP14Parser.UnaryexpressionContext,0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def thetypeid(self):
return self.getTypedRuleContext(CPP14Parser.ThetypeidContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def Alignof(self):
return self.getToken(CPP14Parser.Alignof, 0)
[docs]
def noexceptexpression(self):
return self.getTypedRuleContext(CPP14Parser.NoexceptexpressionContext,0)
[docs]
def newexpression(self):
return self.getTypedRuleContext(CPP14Parser.NewexpressionContext,0)
[docs]
def deleteexpression(self):
return self.getTypedRuleContext(CPP14Parser.DeleteexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_unaryexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnaryexpression" ):
listener.enterUnaryexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnaryexpression" ):
listener.exitUnaryexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnaryexpression" ):
return visitor.visitUnaryexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def unaryexpression(self):
localctx = CPP14Parser.UnaryexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 40, self.RULE_unaryexpression)
try:
self.state = 705
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 677
self.postfixexpression(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 678
self.match(CPP14Parser.PlusPlus)
self.state = 679
self.castexpression()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 680
self.match(CPP14Parser.MinusMinus)
self.state = 681
self.castexpression()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 682
self.unaryoperator()
self.state = 683
self.castexpression()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 685
self.match(CPP14Parser.Sizeof)
self.state = 686
self.unaryexpression()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 687
self.match(CPP14Parser.Sizeof)
self.state = 688
self.match(CPP14Parser.LeftParen)
self.state = 689
self.thetypeid()
self.state = 690
self.match(CPP14Parser.RightParen)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 692
self.match(CPP14Parser.Sizeof)
self.state = 693
self.match(CPP14Parser.Ellipsis)
self.state = 694
self.match(CPP14Parser.LeftParen)
self.state = 695
self.match(CPP14Parser.Identifier)
self.state = 696
self.match(CPP14Parser.RightParen)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 697
self.match(CPP14Parser.Alignof)
self.state = 698
self.match(CPP14Parser.LeftParen)
self.state = 699
self.thetypeid()
self.state = 700
self.match(CPP14Parser.RightParen)
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 702
self.noexceptexpression()
pass
elif la_ == 10:
self.enterOuterAlt(localctx, 10)
self.state = 703
self.newexpression()
pass
elif la_ == 11:
self.enterOuterAlt(localctx, 11)
self.state = 704
self.deleteexpression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UnaryoperatorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Or(self):
return self.getToken(CPP14Parser.Or, 0)
[docs]
def Star(self):
return self.getToken(CPP14Parser.Star, 0)
[docs]
def And(self):
return self.getToken(CPP14Parser.And, 0)
[docs]
def Plus(self):
return self.getToken(CPP14Parser.Plus, 0)
[docs]
def Tilde(self):
return self.getToken(CPP14Parser.Tilde, 0)
[docs]
def Minus(self):
return self.getToken(CPP14Parser.Minus, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_unaryoperator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnaryoperator" ):
listener.enterUnaryoperator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnaryoperator" ):
listener.exitUnaryoperator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnaryoperator" ):
return visitor.visitUnaryoperator(self)
else:
return visitor.visitChildren(self)
[docs]
def unaryoperator(self):
localctx = CPP14Parser.UnaryoperatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 42, self.RULE_unaryoperator)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 707
_la = self._input.LA(1)
if not(_la==CPP14Parser.T__0 or _la==CPP14Parser.T__1 or ((((_la - 90)) & ~0x3f) == 0 and ((1 << (_la - 90)) & ((1 << (CPP14Parser.Plus - 90)) | (1 << (CPP14Parser.Minus - 90)) | (1 << (CPP14Parser.Star - 90)) | (1 << (CPP14Parser.And - 90)) | (1 << (CPP14Parser.Or - 90)) | (1 << (CPP14Parser.Tilde - 90)))) != 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
[docs]
class NewexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def New(self):
return self.getToken(CPP14Parser.New, 0)
[docs]
def newtypeid(self):
return self.getTypedRuleContext(CPP14Parser.NewtypeidContext,0)
[docs]
def Doublecolon(self):
return self.getToken(CPP14Parser.Doublecolon, 0)
[docs]
def newplacement(self):
return self.getTypedRuleContext(CPP14Parser.NewplacementContext,0)
[docs]
def newinitializer(self):
return self.getTypedRuleContext(CPP14Parser.NewinitializerContext,0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def thetypeid(self):
return self.getTypedRuleContext(CPP14Parser.ThetypeidContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_newexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNewexpression" ):
listener.enterNewexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNewexpression" ):
listener.exitNewexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNewexpression" ):
return visitor.visitNewexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def newexpression(self):
localctx = CPP14Parser.NewexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 44, self.RULE_newexpression)
self._la = 0 # Token type
try:
self.state = 733
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 710
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Doublecolon:
self.state = 709
self.match(CPP14Parser.Doublecolon)
self.state = 712
self.match(CPP14Parser.New)
self.state = 714
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.LeftParen:
self.state = 713
self.newplacement()
self.state = 716
self.newtypeid()
self.state = 718
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
if la_ == 1:
self.state = 717
self.newinitializer()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 721
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Doublecolon:
self.state = 720
self.match(CPP14Parser.Doublecolon)
self.state = 723
self.match(CPP14Parser.New)
self.state = 725
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
if la_ == 1:
self.state = 724
self.newplacement()
self.state = 727
self.match(CPP14Parser.LeftParen)
self.state = 728
self.thetypeid()
self.state = 729
self.match(CPP14Parser.RightParen)
self.state = 731
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
if la_ == 1:
self.state = 730
self.newinitializer()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NewplacementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def expressionlist(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionlistContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_newplacement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNewplacement" ):
listener.enterNewplacement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNewplacement" ):
listener.exitNewplacement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNewplacement" ):
return visitor.visitNewplacement(self)
else:
return visitor.visitChildren(self)
[docs]
def newplacement(self):
localctx = CPP14Parser.NewplacementContext(self, self._ctx, self.state)
self.enterRule(localctx, 46, self.RULE_newplacement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 735
self.match(CPP14Parser.LeftParen)
self.state = 736
self.expressionlist()
self.state = 737
self.match(CPP14Parser.RightParen)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NewtypeidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.TypespecifierseqContext,0)
[docs]
def newdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NewdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_newtypeid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNewtypeid" ):
listener.enterNewtypeid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNewtypeid" ):
listener.exitNewtypeid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNewtypeid" ):
return visitor.visitNewtypeid(self)
else:
return visitor.visitChildren(self)
[docs]
def newtypeid(self):
localctx = CPP14Parser.NewtypeidContext(self, self._ctx, self.state)
self.enterRule(localctx, 48, self.RULE_newtypeid)
try:
self.enterOuterAlt(localctx, 1)
self.state = 739
self.typespecifierseq()
self.state = 741
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
if la_ == 1:
self.state = 740
self.newdeclarator()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NewdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ptroperator(self):
return self.getTypedRuleContext(CPP14Parser.PtroperatorContext,0)
[docs]
def newdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NewdeclaratorContext,0)
[docs]
def noptrnewdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrnewdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_newdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNewdeclarator" ):
listener.enterNewdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNewdeclarator" ):
listener.exitNewdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNewdeclarator" ):
return visitor.visitNewdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def newdeclarator(self):
localctx = CPP14Parser.NewdeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 50, self.RULE_newdeclarator)
try:
self.state = 748
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.T__2, CPP14Parser.Decltype, CPP14Parser.Star, CPP14Parser.And, CPP14Parser.Doublecolon, CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 1)
self.state = 743
self.ptroperator()
self.state = 745
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
if la_ == 1:
self.state = 744
self.newdeclarator()
pass
elif token in [CPP14Parser.LeftBracket]:
self.enterOuterAlt(localctx, 2)
self.state = 747
self.noptrnewdeclarator(0)
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
[docs]
class NoptrnewdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftBracket(self):
return self.getToken(CPP14Parser.LeftBracket, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def RightBracket(self):
return self.getToken(CPP14Parser.RightBracket, 0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def noptrnewdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrnewdeclaratorContext,0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_noptrnewdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNoptrnewdeclarator" ):
listener.enterNoptrnewdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNoptrnewdeclarator" ):
listener.exitNoptrnewdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNoptrnewdeclarator" ):
return visitor.visitNoptrnewdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def noptrnewdeclarator(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.NoptrnewdeclaratorContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 52
self.enterRecursionRule(localctx, 52, self.RULE_noptrnewdeclarator, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 751
self.match(CPP14Parser.LeftBracket)
self.state = 752
self.expression(0)
self.state = 753
self.match(CPP14Parser.RightBracket)
self.state = 755
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
if la_ == 1:
self.state = 754
self.attributespecifierseq(0)
self._ctx.stop = self._input.LT(-1)
self.state = 766
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:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.NoptrnewdeclaratorContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_noptrnewdeclarator)
self.state = 757
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 758
self.match(CPP14Parser.LeftBracket)
self.state = 759
self.constantexpression()
self.state = 760
self.match(CPP14Parser.RightBracket)
self.state = 762
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
if la_ == 1:
self.state = 761
self.attributespecifierseq(0)
self.state = 768
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.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class NewinitializerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def expressionlist(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionlistContext,0)
[docs]
def bracedinitlist(self):
return self.getTypedRuleContext(CPP14Parser.BracedinitlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_newinitializer
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNewinitializer" ):
listener.enterNewinitializer(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNewinitializer" ):
listener.exitNewinitializer(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNewinitializer" ):
return visitor.visitNewinitializer(self)
else:
return visitor.visitChildren(self)
[docs]
def newinitializer(self):
localctx = CPP14Parser.NewinitializerContext(self, self._ctx, self.state)
self.enterRule(localctx, 54, self.RULE_newinitializer)
self._la = 0 # Token type
try:
self.state = 775
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.LeftParen]:
self.enterOuterAlt(localctx, 1)
self.state = 769
self.match(CPP14Parser.LeftParen)
self.state = 771
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Throw - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.LeftBrace - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 770
self.expressionlist()
self.state = 773
self.match(CPP14Parser.RightParen)
pass
elif token in [CPP14Parser.LeftBrace]:
self.enterOuterAlt(localctx, 2)
self.state = 774
self.bracedinitlist()
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
[docs]
class DeleteexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Delete(self):
return self.getToken(CPP14Parser.Delete, 0)
[docs]
def castexpression(self):
return self.getTypedRuleContext(CPP14Parser.CastexpressionContext,0)
[docs]
def Doublecolon(self):
return self.getToken(CPP14Parser.Doublecolon, 0)
[docs]
def LeftBracket(self):
return self.getToken(CPP14Parser.LeftBracket, 0)
[docs]
def RightBracket(self):
return self.getToken(CPP14Parser.RightBracket, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_deleteexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeleteexpression" ):
listener.enterDeleteexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeleteexpression" ):
listener.exitDeleteexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeleteexpression" ):
return visitor.visitDeleteexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def deleteexpression(self):
localctx = CPP14Parser.DeleteexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 56, self.RULE_deleteexpression)
self._la = 0 # Token type
try:
self.state = 789
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 778
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Doublecolon:
self.state = 777
self.match(CPP14Parser.Doublecolon)
self.state = 780
self.match(CPP14Parser.Delete)
self.state = 781
self.castexpression()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 783
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Doublecolon:
self.state = 782
self.match(CPP14Parser.Doublecolon)
self.state = 785
self.match(CPP14Parser.Delete)
self.state = 786
self.match(CPP14Parser.LeftBracket)
self.state = 787
self.match(CPP14Parser.RightBracket)
self.state = 788
self.castexpression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NoexceptexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Noexcept(self):
return self.getToken(CPP14Parser.Noexcept, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_noexceptexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNoexceptexpression" ):
listener.enterNoexceptexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNoexceptexpression" ):
listener.exitNoexceptexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNoexceptexpression" ):
return visitor.visitNoexceptexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def noexceptexpression(self):
localctx = CPP14Parser.NoexceptexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 58, self.RULE_noexceptexpression)
try:
self.enterOuterAlt(localctx, 1)
self.state = 791
self.match(CPP14Parser.Noexcept)
self.state = 792
self.match(CPP14Parser.LeftParen)
self.state = 793
self.expression(0)
self.state = 794
self.match(CPP14Parser.RightParen)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CastexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def unaryexpression(self):
return self.getTypedRuleContext(CPP14Parser.UnaryexpressionContext,0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def thetypeid(self):
return self.getTypedRuleContext(CPP14Parser.ThetypeidContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def castexpression(self):
return self.getTypedRuleContext(CPP14Parser.CastexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_castexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCastexpression" ):
listener.enterCastexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCastexpression" ):
listener.exitCastexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCastexpression" ):
return visitor.visitCastexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def castexpression(self):
localctx = CPP14Parser.CastexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 60, self.RULE_castexpression)
try:
self.state = 802
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 796
self.unaryexpression()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 797
self.match(CPP14Parser.LeftParen)
self.state = 798
self.thetypeid()
self.state = 799
self.match(CPP14Parser.RightParen)
self.state = 800
self.castexpression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PmexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def castexpression(self):
return self.getTypedRuleContext(CPP14Parser.CastexpressionContext,0)
[docs]
def pmexpression(self):
return self.getTypedRuleContext(CPP14Parser.PmexpressionContext,0)
[docs]
def DotStar(self):
return self.getToken(CPP14Parser.DotStar, 0)
[docs]
def ArrowStar(self):
return self.getToken(CPP14Parser.ArrowStar, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_pmexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPmexpression" ):
listener.enterPmexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPmexpression" ):
listener.exitPmexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPmexpression" ):
return visitor.visitPmexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def pmexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.PmexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 62
self.enterRecursionRule(localctx, 62, self.RULE_pmexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 805
self.castexpression()
self._ctx.stop = self._input.LT(-1)
self.state = 815
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,54,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 813
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
if la_ == 1:
localctx = CPP14Parser.PmexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_pmexpression)
self.state = 807
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 808
self.match(CPP14Parser.DotStar)
self.state = 809
self.castexpression()
pass
elif la_ == 2:
localctx = CPP14Parser.PmexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_pmexpression)
self.state = 810
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 811
self.match(CPP14Parser.ArrowStar)
self.state = 812
self.castexpression()
pass
self.state = 817
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,54,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class MultiplicativeexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def pmexpression(self):
return self.getTypedRuleContext(CPP14Parser.PmexpressionContext,0)
[docs]
def multiplicativeexpression(self):
return self.getTypedRuleContext(CPP14Parser.MultiplicativeexpressionContext,0)
[docs]
def Star(self):
return self.getToken(CPP14Parser.Star, 0)
[docs]
def Div(self):
return self.getToken(CPP14Parser.Div, 0)
[docs]
def Mod(self):
return self.getToken(CPP14Parser.Mod, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_multiplicativeexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMultiplicativeexpression" ):
listener.enterMultiplicativeexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMultiplicativeexpression" ):
listener.exitMultiplicativeexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMultiplicativeexpression" ):
return visitor.visitMultiplicativeexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def multiplicativeexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.MultiplicativeexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 64
self.enterRecursionRule(localctx, 64, self.RULE_multiplicativeexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 819
self.pmexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 832
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,56,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 830
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
if la_ == 1:
localctx = CPP14Parser.MultiplicativeexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeexpression)
self.state = 821
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 822
self.match(CPP14Parser.Star)
self.state = 823
self.pmexpression(0)
pass
elif la_ == 2:
localctx = CPP14Parser.MultiplicativeexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeexpression)
self.state = 824
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 825
self.match(CPP14Parser.Div)
self.state = 826
self.pmexpression(0)
pass
elif la_ == 3:
localctx = CPP14Parser.MultiplicativeexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeexpression)
self.state = 827
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 828
self.match(CPP14Parser.Mod)
self.state = 829
self.pmexpression(0)
pass
self.state = 834
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,56,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AdditiveexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def multiplicativeexpression(self):
return self.getTypedRuleContext(CPP14Parser.MultiplicativeexpressionContext,0)
[docs]
def additiveexpression(self):
return self.getTypedRuleContext(CPP14Parser.AdditiveexpressionContext,0)
[docs]
def Plus(self):
return self.getToken(CPP14Parser.Plus, 0)
[docs]
def Minus(self):
return self.getToken(CPP14Parser.Minus, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_additiveexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAdditiveexpression" ):
listener.enterAdditiveexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAdditiveexpression" ):
listener.exitAdditiveexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAdditiveexpression" ):
return visitor.visitAdditiveexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def additiveexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.AdditiveexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 66
self.enterRecursionRule(localctx, 66, self.RULE_additiveexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 836
self.multiplicativeexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 846
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:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 844
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
if la_ == 1:
localctx = CPP14Parser.AdditiveexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveexpression)
self.state = 838
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 839
self.match(CPP14Parser.Plus)
self.state = 840
self.multiplicativeexpression(0)
pass
elif la_ == 2:
localctx = CPP14Parser.AdditiveexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveexpression)
self.state = 841
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 842
self.match(CPP14Parser.Minus)
self.state = 843
self.multiplicativeexpression(0)
pass
self.state = 848
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.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ShiftexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def additiveexpression(self):
return self.getTypedRuleContext(CPP14Parser.AdditiveexpressionContext,0)
[docs]
def shiftexpression(self):
return self.getTypedRuleContext(CPP14Parser.ShiftexpressionContext,0)
[docs]
def shiftoperator(self):
return self.getTypedRuleContext(CPP14Parser.ShiftoperatorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_shiftexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterShiftexpression" ):
listener.enterShiftexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitShiftexpression" ):
listener.exitShiftexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitShiftexpression" ):
return visitor.visitShiftexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def shiftexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.ShiftexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 68
self.enterRecursionRule(localctx, 68, self.RULE_shiftexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 850
self.additiveexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 858
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,59,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.ShiftexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_shiftexpression)
self.state = 852
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 853
self.shiftoperator()
self.state = 854
self.additiveexpression(0)
self.state = 860
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,59,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ShiftoperatorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def RightShift(self):
return self.getToken(CPP14Parser.RightShift, 0)
[docs]
def LeftShift(self):
return self.getToken(CPP14Parser.LeftShift, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_shiftoperator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterShiftoperator" ):
listener.enterShiftoperator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitShiftoperator" ):
listener.exitShiftoperator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitShiftoperator" ):
return visitor.visitShiftoperator(self)
else:
return visitor.visitChildren(self)
[docs]
def shiftoperator(self):
localctx = CPP14Parser.ShiftoperatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 70, self.RULE_shiftoperator)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 861
_la = self._input.LA(1)
if not(_la==CPP14Parser.LeftShift or _la==CPP14Parser.RightShift):
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
[docs]
class RelationalexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def shiftexpression(self):
return self.getTypedRuleContext(CPP14Parser.ShiftexpressionContext,0)
[docs]
def relationalexpression(self):
return self.getTypedRuleContext(CPP14Parser.RelationalexpressionContext,0)
[docs]
def Less(self):
return self.getToken(CPP14Parser.Less, 0)
[docs]
def Greater(self):
return self.getToken(CPP14Parser.Greater, 0)
[docs]
def LessEqual(self):
return self.getToken(CPP14Parser.LessEqual, 0)
[docs]
def GreaterEqual(self):
return self.getToken(CPP14Parser.GreaterEqual, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_relationalexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRelationalexpression" ):
listener.enterRelationalexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRelationalexpression" ):
listener.exitRelationalexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRelationalexpression" ):
return visitor.visitRelationalexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def relationalexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.RelationalexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 72
self.enterRecursionRule(localctx, 72, self.RULE_relationalexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 864
self.shiftexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 880
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,61,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 878
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
if la_ == 1:
localctx = CPP14Parser.RelationalexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalexpression)
self.state = 866
if not self.precpred(self._ctx, 4):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
self.state = 867
self.match(CPP14Parser.Less)
self.state = 868
self.shiftexpression(0)
pass
elif la_ == 2:
localctx = CPP14Parser.RelationalexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalexpression)
self.state = 869
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 870
self.match(CPP14Parser.Greater)
self.state = 871
self.shiftexpression(0)
pass
elif la_ == 3:
localctx = CPP14Parser.RelationalexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalexpression)
self.state = 872
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 873
self.match(CPP14Parser.LessEqual)
self.state = 874
self.shiftexpression(0)
pass
elif la_ == 4:
localctx = CPP14Parser.RelationalexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalexpression)
self.state = 875
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 876
self.match(CPP14Parser.GreaterEqual)
self.state = 877
self.shiftexpression(0)
pass
self.state = 882
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,61,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class EqualityexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def relationalexpression(self):
return self.getTypedRuleContext(CPP14Parser.RelationalexpressionContext,0)
[docs]
def equalityexpression(self):
return self.getTypedRuleContext(CPP14Parser.EqualityexpressionContext,0)
[docs]
def Equal(self):
return self.getToken(CPP14Parser.Equal, 0)
[docs]
def NotEqual(self):
return self.getToken(CPP14Parser.NotEqual, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_equalityexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEqualityexpression" ):
listener.enterEqualityexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEqualityexpression" ):
listener.exitEqualityexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEqualityexpression" ):
return visitor.visitEqualityexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def equalityexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.EqualityexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 74
self.enterRecursionRule(localctx, 74, self.RULE_equalityexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 884
self.relationalexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 894
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,63,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 892
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
if la_ == 1:
localctx = CPP14Parser.EqualityexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_equalityexpression)
self.state = 886
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 887
self.match(CPP14Parser.Equal)
self.state = 888
self.relationalexpression(0)
pass
elif la_ == 2:
localctx = CPP14Parser.EqualityexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_equalityexpression)
self.state = 889
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 890
self.match(CPP14Parser.NotEqual)
self.state = 891
self.relationalexpression(0)
pass
self.state = 896
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,63,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AndexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def equalityexpression(self):
return self.getTypedRuleContext(CPP14Parser.EqualityexpressionContext,0)
[docs]
def andexpression(self):
return self.getTypedRuleContext(CPP14Parser.AndexpressionContext,0)
[docs]
def And(self):
return self.getToken(CPP14Parser.And, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_andexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAndexpression" ):
listener.enterAndexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAndexpression" ):
listener.exitAndexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAndexpression" ):
return visitor.visitAndexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def andexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.AndexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 76
self.enterRecursionRule(localctx, 76, self.RULE_andexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 898
self.equalityexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 905
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,64,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.AndexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_andexpression)
self.state = 900
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 901
self.match(CPP14Parser.And)
self.state = 902
self.equalityexpression(0)
self.state = 907
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,64,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ExclusiveorexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def andexpression(self):
return self.getTypedRuleContext(CPP14Parser.AndexpressionContext,0)
[docs]
def exclusiveorexpression(self):
return self.getTypedRuleContext(CPP14Parser.ExclusiveorexpressionContext,0)
[docs]
def Caret(self):
return self.getToken(CPP14Parser.Caret, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_exclusiveorexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExclusiveorexpression" ):
listener.enterExclusiveorexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExclusiveorexpression" ):
listener.exitExclusiveorexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExclusiveorexpression" ):
return visitor.visitExclusiveorexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def exclusiveorexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.ExclusiveorexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 78
self.enterRecursionRule(localctx, 78, self.RULE_exclusiveorexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 909
self.andexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 916
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,65,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.ExclusiveorexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_exclusiveorexpression)
self.state = 911
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 912
self.match(CPP14Parser.Caret)
self.state = 913
self.andexpression(0)
self.state = 918
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,65,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class InclusiveorexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def exclusiveorexpression(self):
return self.getTypedRuleContext(CPP14Parser.ExclusiveorexpressionContext,0)
[docs]
def inclusiveorexpression(self):
return self.getTypedRuleContext(CPP14Parser.InclusiveorexpressionContext,0)
[docs]
def Or(self):
return self.getToken(CPP14Parser.Or, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_inclusiveorexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInclusiveorexpression" ):
listener.enterInclusiveorexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInclusiveorexpression" ):
listener.exitInclusiveorexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInclusiveorexpression" ):
return visitor.visitInclusiveorexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def inclusiveorexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.InclusiveorexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 80
self.enterRecursionRule(localctx, 80, self.RULE_inclusiveorexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 920
self.exclusiveorexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 927
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,66,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.InclusiveorexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_inclusiveorexpression)
self.state = 922
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 923
self.match(CPP14Parser.Or)
self.state = 924
self.exclusiveorexpression(0)
self.state = 929
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,66,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class LogicalandexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def inclusiveorexpression(self):
return self.getTypedRuleContext(CPP14Parser.InclusiveorexpressionContext,0)
[docs]
def logicalandexpression(self):
return self.getTypedRuleContext(CPP14Parser.LogicalandexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_logicalandexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLogicalandexpression" ):
listener.enterLogicalandexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLogicalandexpression" ):
listener.exitLogicalandexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLogicalandexpression" ):
return visitor.visitLogicalandexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def logicalandexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.LogicalandexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 82
self.enterRecursionRule(localctx, 82, self.RULE_logicalandexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 931
self.inclusiveorexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 941
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,68,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 939
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
if la_ == 1:
localctx = CPP14Parser.LogicalandexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalandexpression)
self.state = 933
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 934
self.match(CPP14Parser.T__2)
self.state = 935
self.inclusiveorexpression(0)
pass
elif la_ == 2:
localctx = CPP14Parser.LogicalandexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalandexpression)
self.state = 936
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 937
self.match(CPP14Parser.T__3)
self.state = 938
self.inclusiveorexpression(0)
pass
self.state = 943
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,68,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class LogicalorexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def logicalandexpression(self):
return self.getTypedRuleContext(CPP14Parser.LogicalandexpressionContext,0)
[docs]
def logicalorexpression(self):
return self.getTypedRuleContext(CPP14Parser.LogicalorexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_logicalorexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLogicalorexpression" ):
listener.enterLogicalorexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLogicalorexpression" ):
listener.exitLogicalorexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLogicalorexpression" ):
return visitor.visitLogicalorexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def logicalorexpression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.LogicalorexpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 84
self.enterRecursionRule(localctx, 84, self.RULE_logicalorexpression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 945
self.logicalandexpression(0)
self._ctx.stop = self._input.LT(-1)
self.state = 955
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,70,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 953
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
if la_ == 1:
localctx = CPP14Parser.LogicalorexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalorexpression)
self.state = 947
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 948
self.match(CPP14Parser.T__4)
self.state = 949
self.logicalandexpression(0)
pass
elif la_ == 2:
localctx = CPP14Parser.LogicalorexpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalorexpression)
self.state = 950
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 951
self.match(CPP14Parser.T__5)
self.state = 952
self.logicalandexpression(0)
pass
self.state = 957
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,70,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ConditionalexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def logicalorexpression(self):
return self.getTypedRuleContext(CPP14Parser.LogicalorexpressionContext,0)
[docs]
def Question(self):
return self.getToken(CPP14Parser.Question, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def Colon(self):
return self.getToken(CPP14Parser.Colon, 0)
[docs]
def assignmentexpression(self):
return self.getTypedRuleContext(CPP14Parser.AssignmentexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_conditionalexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConditionalexpression" ):
listener.enterConditionalexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConditionalexpression" ):
listener.exitConditionalexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConditionalexpression" ):
return visitor.visitConditionalexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def conditionalexpression(self):
localctx = CPP14Parser.ConditionalexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 86, self.RULE_conditionalexpression)
try:
self.state = 965
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 958
self.logicalorexpression(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 959
self.logicalorexpression(0)
self.state = 960
self.match(CPP14Parser.Question)
self.state = 961
self.expression(0)
self.state = 962
self.match(CPP14Parser.Colon)
self.state = 963
self.assignmentexpression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AssignmentexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def conditionalexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConditionalexpressionContext,0)
[docs]
def logicalorexpression(self):
return self.getTypedRuleContext(CPP14Parser.LogicalorexpressionContext,0)
[docs]
def assignmentoperator(self):
return self.getTypedRuleContext(CPP14Parser.AssignmentoperatorContext,0)
[docs]
def initializerclause(self):
return self.getTypedRuleContext(CPP14Parser.InitializerclauseContext,0)
[docs]
def throwexpression(self):
return self.getTypedRuleContext(CPP14Parser.ThrowexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_assignmentexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssignmentexpression" ):
listener.enterAssignmentexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssignmentexpression" ):
listener.exitAssignmentexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssignmentexpression" ):
return visitor.visitAssignmentexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def assignmentexpression(self):
localctx = CPP14Parser.AssignmentexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 88, self.RULE_assignmentexpression)
try:
self.state = 973
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 967
self.conditionalexpression()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 968
self.logicalorexpression(0)
self.state = 969
self.assignmentoperator()
self.state = 970
self.initializerclause()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 972
self.throwexpression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AssignmentoperatorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def StarAssign(self):
return self.getToken(CPP14Parser.StarAssign, 0)
[docs]
def DivAssign(self):
return self.getToken(CPP14Parser.DivAssign, 0)
[docs]
def ModAssign(self):
return self.getToken(CPP14Parser.ModAssign, 0)
[docs]
def PlusAssign(self):
return self.getToken(CPP14Parser.PlusAssign, 0)
[docs]
def MinusAssign(self):
return self.getToken(CPP14Parser.MinusAssign, 0)
[docs]
def RightShiftAssign(self):
return self.getToken(CPP14Parser.RightShiftAssign, 0)
[docs]
def LeftShiftAssign(self):
return self.getToken(CPP14Parser.LeftShiftAssign, 0)
[docs]
def AndAssign(self):
return self.getToken(CPP14Parser.AndAssign, 0)
[docs]
def XorAssign(self):
return self.getToken(CPP14Parser.XorAssign, 0)
[docs]
def OrAssign(self):
return self.getToken(CPP14Parser.OrAssign, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_assignmentoperator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssignmentoperator" ):
listener.enterAssignmentoperator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssignmentoperator" ):
listener.exitAssignmentoperator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssignmentoperator" ):
return visitor.visitAssignmentoperator(self)
else:
return visitor.visitChildren(self)
[docs]
def assignmentoperator(self):
localctx = CPP14Parser.AssignmentoperatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 90, self.RULE_assignmentoperator)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 975
_la = self._input.LA(1)
if not(((((_la - 100)) & ~0x3f) == 0 and ((1 << (_la - 100)) & ((1 << (CPP14Parser.Assign - 100)) | (1 << (CPP14Parser.PlusAssign - 100)) | (1 << (CPP14Parser.MinusAssign - 100)) | (1 << (CPP14Parser.StarAssign - 100)) | (1 << (CPP14Parser.DivAssign - 100)) | (1 << (CPP14Parser.ModAssign - 100)) | (1 << (CPP14Parser.XorAssign - 100)) | (1 << (CPP14Parser.AndAssign - 100)) | (1 << (CPP14Parser.OrAssign - 100)) | (1 << (CPP14Parser.LeftShiftAssign - 100)) | (1 << (CPP14Parser.RightShiftAssign - 100)))) != 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
[docs]
class ExpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def assignmentexpression(self):
return self.getTypedRuleContext(CPP14Parser.AssignmentexpressionContext,0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_expression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExpression" ):
listener.enterExpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExpression" ):
listener.exitExpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExpression" ):
return visitor.visitExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def expression(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.ExpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 92
self.enterRecursionRule(localctx, 92, self.RULE_expression, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 978
self.assignmentexpression()
self._ctx.stop = self._input.LT(-1)
self.state = 985
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:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.ExpressionContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 980
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 981
self.match(CPP14Parser.Comma)
self.state = 982
self.assignmentexpression()
self.state = 987
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.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ConstantexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def conditionalexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConditionalexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_constantexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConstantexpression" ):
listener.enterConstantexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConstantexpression" ):
listener.exitConstantexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConstantexpression" ):
return visitor.visitConstantexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def constantexpression(self):
localctx = CPP14Parser.ConstantexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 94, self.RULE_constantexpression)
try:
self.enterOuterAlt(localctx, 1)
self.state = 988
self.conditionalexpression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def labeledstatement(self):
return self.getTypedRuleContext(CPP14Parser.LabeledstatementContext,0)
[docs]
def expressionstatement(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionstatementContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def compoundstatement(self):
return self.getTypedRuleContext(CPP14Parser.CompoundstatementContext,0)
[docs]
def selectionstatement(self):
return self.getTypedRuleContext(CPP14Parser.SelectionstatementContext,0)
[docs]
def iterationstatement(self):
return self.getTypedRuleContext(CPP14Parser.IterationstatementContext,0)
[docs]
def jumpstatement(self):
return self.getTypedRuleContext(CPP14Parser.JumpstatementContext,0)
[docs]
def declarationstatement(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationstatementContext,0)
[docs]
def tryblock(self):
return self.getTypedRuleContext(CPP14Parser.TryblockContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_statement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStatement" ):
listener.enterStatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStatement" ):
listener.exitStatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStatement" ):
return visitor.visitStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def statement(self):
localctx = CPP14Parser.StatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 96, self.RULE_statement)
self._la = 0 # Token type
try:
self.state = 1016
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 990
self.labeledstatement()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 992
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
if la_ == 1:
self.state = 991
self.attributespecifierseq(0)
self.state = 994
self.expressionstatement()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 996
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 995
self.attributespecifierseq(0)
self.state = 998
self.compoundstatement()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1000
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 999
self.attributespecifierseq(0)
self.state = 1002
self.selectionstatement()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1004
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1003
self.attributespecifierseq(0)
self.state = 1006
self.iterationstatement()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 1008
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1007
self.attributespecifierseq(0)
self.state = 1010
self.jumpstatement()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 1011
self.declarationstatement()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 1013
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1012
self.attributespecifierseq(0)
self.state = 1015
self.tryblock()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LabeledstatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def Colon(self):
return self.getToken(CPP14Parser.Colon, 0)
[docs]
def statement(self):
return self.getTypedRuleContext(CPP14Parser.StatementContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def Case(self):
return self.getToken(CPP14Parser.Case, 0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def Default(self):
return self.getToken(CPP14Parser.Default, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_labeledstatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLabeledstatement" ):
listener.enterLabeledstatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLabeledstatement" ):
listener.exitLabeledstatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLabeledstatement" ):
return visitor.visitLabeledstatement(self)
else:
return visitor.visitChildren(self)
[docs]
def labeledstatement(self):
localctx = CPP14Parser.LabeledstatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 98, self.RULE_labeledstatement)
self._la = 0 # Token type
try:
self.state = 1038
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1019
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1018
self.attributespecifierseq(0)
self.state = 1021
self.match(CPP14Parser.Identifier)
self.state = 1022
self.match(CPP14Parser.Colon)
self.state = 1023
self.statement()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1025
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1024
self.attributespecifierseq(0)
self.state = 1027
self.match(CPP14Parser.Case)
self.state = 1028
self.constantexpression()
self.state = 1029
self.match(CPP14Parser.Colon)
self.state = 1030
self.statement()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1033
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1032
self.attributespecifierseq(0)
self.state = 1035
self.match(CPP14Parser.Default)
self.state = 1036
self.match(CPP14Parser.Colon)
self.state = 1037
self.statement()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExpressionstatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_expressionstatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExpressionstatement" ):
listener.enterExpressionstatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExpressionstatement" ):
listener.exitExpressionstatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExpressionstatement" ):
return visitor.visitExpressionstatement(self)
else:
return visitor.visitChildren(self)
[docs]
def expressionstatement(self):
localctx = CPP14Parser.ExpressionstatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 100, self.RULE_expressionstatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1041
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Throw - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 1040
self.expression(0)
self.state = 1043
self.match(CPP14Parser.Semi)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CompoundstatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftBrace(self):
return self.getToken(CPP14Parser.LeftBrace, 0)
[docs]
def RightBrace(self):
return self.getToken(CPP14Parser.RightBrace, 0)
[docs]
def statementseq(self):
return self.getTypedRuleContext(CPP14Parser.StatementseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_compoundstatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCompoundstatement" ):
listener.enterCompoundstatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCompoundstatement" ):
listener.exitCompoundstatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCompoundstatement" ):
return visitor.visitCompoundstatement(self)
else:
return visitor.visitChildren(self)
[docs]
def compoundstatement(self):
localctx = CPP14Parser.CompoundstatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 102, self.RULE_compoundstatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1045
self.match(CPP14Parser.LeftBrace)
self.state = 1047
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__2) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignas) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Asm) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Break) | (1 << CPP14Parser.Case) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Constexpr) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Continue) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Default) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Do) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Explicit) | (1 << CPP14Parser.Extern) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.For) | (1 << CPP14Parser.Friend) | (1 << CPP14Parser.Goto) | (1 << CPP14Parser.If) | (1 << CPP14Parser.Inline) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.Mutable) | (1 << CPP14Parser.Namespace) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Register) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Return) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof) | (1 << CPP14Parser.Static))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CPP14Parser.Static_assert - 64)) | (1 << (CPP14Parser.Static_cast - 64)) | (1 << (CPP14Parser.Struct - 64)) | (1 << (CPP14Parser.Switch - 64)) | (1 << (CPP14Parser.This - 64)) | (1 << (CPP14Parser.Thread_local - 64)) | (1 << (CPP14Parser.Throw - 64)) | (1 << (CPP14Parser.Try - 64)) | (1 << (CPP14Parser.Typedef - 64)) | (1 << (CPP14Parser.Typeid_ - 64)) | (1 << (CPP14Parser.Typename_ - 64)) | (1 << (CPP14Parser.Union - 64)) | (1 << (CPP14Parser.Unsigned - 64)) | (1 << (CPP14Parser.Using - 64)) | (1 << (CPP14Parser.Virtual - 64)) | (1 << (CPP14Parser.Void - 64)) | (1 << (CPP14Parser.Volatile - 64)) | (1 << (CPP14Parser.Wchar - 64)) | (1 << (CPP14Parser.While - 64)) | (1 << (CPP14Parser.LeftParen - 64)) | (1 << (CPP14Parser.LeftBracket - 64)) | (1 << (CPP14Parser.LeftBrace - 64)) | (1 << (CPP14Parser.Plus - 64)) | (1 << (CPP14Parser.Minus - 64)) | (1 << (CPP14Parser.Star - 64)) | (1 << (CPP14Parser.And - 64)) | (1 << (CPP14Parser.Or - 64)) | (1 << (CPP14Parser.Tilde - 64)) | (1 << (CPP14Parser.PlusPlus - 64)) | (1 << (CPP14Parser.MinusMinus - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (CPP14Parser.Doublecolon - 128)) | (1 << (CPP14Parser.Semi - 128)) | (1 << (CPP14Parser.Ellipsis - 128)) | (1 << (CPP14Parser.Identifier - 128)) | (1 << (CPP14Parser.Integerliteral - 128)) | (1 << (CPP14Parser.Characterliteral - 128)) | (1 << (CPP14Parser.Floatingliteral - 128)) | (1 << (CPP14Parser.Stringliteral - 128)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 128)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 128)) | (1 << (CPP14Parser.Userdefinedstringliteral - 128)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 128)))) != 0):
self.state = 1046
self.statementseq(0)
self.state = 1049
self.match(CPP14Parser.RightBrace)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StatementseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def statement(self):
return self.getTypedRuleContext(CPP14Parser.StatementContext,0)
[docs]
def statementseq(self):
return self.getTypedRuleContext(CPP14Parser.StatementseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_statementseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStatementseq" ):
listener.enterStatementseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStatementseq" ):
listener.exitStatementseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStatementseq" ):
return visitor.visitStatementseq(self)
else:
return visitor.visitChildren(self)
[docs]
def statementseq(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.StatementseqContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 104
self.enterRecursionRule(localctx, 104, self.RULE_statementseq, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1052
self.statement()
self._ctx.stop = self._input.LT(-1)
self.state = 1058
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,87,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.StatementseqContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_statementseq)
self.state = 1054
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1055
self.statement()
self.state = 1060
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,87,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class SelectionstatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def If(self):
return self.getToken(CPP14Parser.If, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def condition(self):
return self.getTypedRuleContext(CPP14Parser.ConditionContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def statement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CPP14Parser.StatementContext)
else:
return self.getTypedRuleContext(CPP14Parser.StatementContext,i)
[docs]
def Else(self):
return self.getToken(CPP14Parser.Else, 0)
[docs]
def Switch(self):
return self.getToken(CPP14Parser.Switch, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_selectionstatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSelectionstatement" ):
listener.enterSelectionstatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSelectionstatement" ):
listener.exitSelectionstatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSelectionstatement" ):
return visitor.visitSelectionstatement(self)
else:
return visitor.visitChildren(self)
[docs]
def selectionstatement(self):
localctx = CPP14Parser.SelectionstatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 106, self.RULE_selectionstatement)
try:
self.state = 1081
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1061
self.match(CPP14Parser.If)
self.state = 1062
self.match(CPP14Parser.LeftParen)
self.state = 1063
self.condition()
self.state = 1064
self.match(CPP14Parser.RightParen)
self.state = 1065
self.statement()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1067
self.match(CPP14Parser.If)
self.state = 1068
self.match(CPP14Parser.LeftParen)
self.state = 1069
self.condition()
self.state = 1070
self.match(CPP14Parser.RightParen)
self.state = 1071
self.statement()
self.state = 1072
self.match(CPP14Parser.Else)
self.state = 1073
self.statement()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1075
self.match(CPP14Parser.Switch)
self.state = 1076
self.match(CPP14Parser.LeftParen)
self.state = 1077
self.condition()
self.state = 1078
self.match(CPP14Parser.RightParen)
self.state = 1079
self.statement()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ConditionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def declspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclspecifierseqContext,0)
[docs]
def declarator(self):
return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def initializerclause(self):
return self.getTypedRuleContext(CPP14Parser.InitializerclauseContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def bracedinitlist(self):
return self.getTypedRuleContext(CPP14Parser.BracedinitlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_condition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCondition" ):
listener.enterCondition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCondition" ):
listener.exitCondition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCondition" ):
return visitor.visitCondition(self)
else:
return visitor.visitChildren(self)
[docs]
def condition(self):
localctx = CPP14Parser.ConditionContext(self, self._ctx, self.state)
self.enterRule(localctx, 108, self.RULE_condition)
self._la = 0 # Token type
try:
self.state = 1099
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,91,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1083
self.expression(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1085
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1084
self.attributespecifierseq(0)
self.state = 1087
self.declspecifierseq()
self.state = 1088
self.declarator()
self.state = 1089
self.match(CPP14Parser.Assign)
self.state = 1090
self.initializerclause()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1093
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1092
self.attributespecifierseq(0)
self.state = 1095
self.declspecifierseq()
self.state = 1096
self.declarator()
self.state = 1097
self.bracedinitlist()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IterationstatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def While(self):
return self.getToken(CPP14Parser.While, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def condition(self):
return self.getTypedRuleContext(CPP14Parser.ConditionContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def statement(self):
return self.getTypedRuleContext(CPP14Parser.StatementContext,0)
[docs]
def Do(self):
return self.getToken(CPP14Parser.Do, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def For(self):
return self.getToken(CPP14Parser.For, 0)
[docs]
def forinitstatement(self):
return self.getTypedRuleContext(CPP14Parser.ForinitstatementContext,0)
[docs]
def forrangedeclaration(self):
return self.getTypedRuleContext(CPP14Parser.ForrangedeclarationContext,0)
[docs]
def Colon(self):
return self.getToken(CPP14Parser.Colon, 0)
[docs]
def forrangeinitializer(self):
return self.getTypedRuleContext(CPP14Parser.ForrangeinitializerContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_iterationstatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIterationstatement" ):
listener.enterIterationstatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIterationstatement" ):
listener.exitIterationstatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIterationstatement" ):
return visitor.visitIterationstatement(self)
else:
return visitor.visitChildren(self)
[docs]
def iterationstatement(self):
localctx = CPP14Parser.IterationstatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 110, self.RULE_iterationstatement)
self._la = 0 # Token type
try:
self.state = 1136
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1101
self.match(CPP14Parser.While)
self.state = 1102
self.match(CPP14Parser.LeftParen)
self.state = 1103
self.condition()
self.state = 1104
self.match(CPP14Parser.RightParen)
self.state = 1105
self.statement()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1107
self.match(CPP14Parser.Do)
self.state = 1108
self.statement()
self.state = 1109
self.match(CPP14Parser.While)
self.state = 1110
self.match(CPP14Parser.LeftParen)
self.state = 1111
self.expression(0)
self.state = 1112
self.match(CPP14Parser.RightParen)
self.state = 1113
self.match(CPP14Parser.Semi)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1115
self.match(CPP14Parser.For)
self.state = 1116
self.match(CPP14Parser.LeftParen)
self.state = 1117
self.forinitstatement()
self.state = 1119
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignas) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Constexpr) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Explicit) | (1 << CPP14Parser.Extern) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Friend) | (1 << CPP14Parser.Inline) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.Mutable) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Register) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof) | (1 << CPP14Parser.Static))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.Struct - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Thread_local - 65)) | (1 << (CPP14Parser.Throw - 65)) | (1 << (CPP14Parser.Typedef - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Union - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Virtual - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Volatile - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 1118
self.condition()
self.state = 1121
self.match(CPP14Parser.Semi)
self.state = 1123
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Throw - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 1122
self.expression(0)
self.state = 1125
self.match(CPP14Parser.RightParen)
self.state = 1126
self.statement()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1128
self.match(CPP14Parser.For)
self.state = 1129
self.match(CPP14Parser.LeftParen)
self.state = 1130
self.forrangedeclaration()
self.state = 1131
self.match(CPP14Parser.Colon)
self.state = 1132
self.forrangeinitializer()
self.state = 1133
self.match(CPP14Parser.RightParen)
self.state = 1134
self.statement()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ForinitstatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expressionstatement(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionstatementContext,0)
[docs]
def simpledeclaration(self):
return self.getTypedRuleContext(CPP14Parser.SimpledeclarationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_forinitstatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterForinitstatement" ):
listener.enterForinitstatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitForinitstatement" ):
listener.exitForinitstatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitForinitstatement" ):
return visitor.visitForinitstatement(self)
else:
return visitor.visitChildren(self)
[docs]
def forinitstatement(self):
localctx = CPP14Parser.ForinitstatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 112, self.RULE_forinitstatement)
try:
self.state = 1140
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,95,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1138
self.expressionstatement()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1139
self.simpledeclaration()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ForrangedeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def declspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclspecifierseqContext,0)
[docs]
def declarator(self):
return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_forrangedeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterForrangedeclaration" ):
listener.enterForrangedeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitForrangedeclaration" ):
listener.exitForrangedeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitForrangedeclaration" ):
return visitor.visitForrangedeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def forrangedeclaration(self):
localctx = CPP14Parser.ForrangedeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 114, self.RULE_forrangedeclaration)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1143
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1142
self.attributespecifierseq(0)
self.state = 1145
self.declspecifierseq()
self.state = 1146
self.declarator()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ForrangeinitializerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def bracedinitlist(self):
return self.getTypedRuleContext(CPP14Parser.BracedinitlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_forrangeinitializer
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterForrangeinitializer" ):
listener.enterForrangeinitializer(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitForrangeinitializer" ):
listener.exitForrangeinitializer(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitForrangeinitializer" ):
return visitor.visitForrangeinitializer(self)
else:
return visitor.visitChildren(self)
[docs]
def forrangeinitializer(self):
localctx = CPP14Parser.ForrangeinitializerContext(self, self._ctx, self.state)
self.enterRule(localctx, 116, self.RULE_forrangeinitializer)
try:
self.state = 1150
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.T__0, CPP14Parser.T__1, CPP14Parser.T__6, CPP14Parser.T__7, CPP14Parser.Alignof, CPP14Parser.Auto, CPP14Parser.Bool, CPP14Parser.Char, CPP14Parser.Char16, CPP14Parser.Char32, CPP14Parser.Const_cast, CPP14Parser.Decltype, CPP14Parser.Delete, CPP14Parser.Double, CPP14Parser.Dynamic_cast, CPP14Parser.Float, CPP14Parser.Int, CPP14Parser.Long, CPP14Parser.New, CPP14Parser.Noexcept, CPP14Parser.Nullptr, CPP14Parser.Operator, CPP14Parser.Reinterpret_cast, CPP14Parser.Short, CPP14Parser.Signed, CPP14Parser.Sizeof, CPP14Parser.Static_cast, CPP14Parser.This, CPP14Parser.Throw, CPP14Parser.Typeid_, CPP14Parser.Typename_, CPP14Parser.Unsigned, CPP14Parser.Void, CPP14Parser.Wchar, CPP14Parser.LeftParen, CPP14Parser.LeftBracket, CPP14Parser.Plus, CPP14Parser.Minus, CPP14Parser.Star, CPP14Parser.And, CPP14Parser.Or, CPP14Parser.Tilde, CPP14Parser.PlusPlus, CPP14Parser.MinusMinus, CPP14Parser.Doublecolon, CPP14Parser.Identifier, CPP14Parser.Integerliteral, CPP14Parser.Characterliteral, CPP14Parser.Floatingliteral, CPP14Parser.Stringliteral, CPP14Parser.Userdefinedintegerliteral, CPP14Parser.Userdefinedfloatingliteral, CPP14Parser.Userdefinedstringliteral, CPP14Parser.Userdefinedcharacterliteral]:
self.enterOuterAlt(localctx, 1)
self.state = 1148
self.expression(0)
pass
elif token in [CPP14Parser.LeftBrace]:
self.enterOuterAlt(localctx, 2)
self.state = 1149
self.bracedinitlist()
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
[docs]
class JumpstatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Break(self):
return self.getToken(CPP14Parser.Break, 0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def Continue(self):
return self.getToken(CPP14Parser.Continue, 0)
[docs]
def Return(self):
return self.getToken(CPP14Parser.Return, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def bracedinitlist(self):
return self.getTypedRuleContext(CPP14Parser.BracedinitlistContext,0)
[docs]
def Goto(self):
return self.getToken(CPP14Parser.Goto, 0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_jumpstatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterJumpstatement" ):
listener.enterJumpstatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitJumpstatement" ):
listener.exitJumpstatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitJumpstatement" ):
return visitor.visitJumpstatement(self)
else:
return visitor.visitChildren(self)
[docs]
def jumpstatement(self):
localctx = CPP14Parser.JumpstatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 118, self.RULE_jumpstatement)
self._la = 0 # Token type
try:
self.state = 1168
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,99,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1152
self.match(CPP14Parser.Break)
self.state = 1153
self.match(CPP14Parser.Semi)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1154
self.match(CPP14Parser.Continue)
self.state = 1155
self.match(CPP14Parser.Semi)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1156
self.match(CPP14Parser.Return)
self.state = 1158
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Throw - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 1157
self.expression(0)
self.state = 1160
self.match(CPP14Parser.Semi)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1161
self.match(CPP14Parser.Return)
self.state = 1162
self.bracedinitlist()
self.state = 1163
self.match(CPP14Parser.Semi)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1165
self.match(CPP14Parser.Goto)
self.state = 1166
self.match(CPP14Parser.Identifier)
self.state = 1167
self.match(CPP14Parser.Semi)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DeclarationstatementContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def blockdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.BlockdeclarationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_declarationstatement
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclarationstatement" ):
listener.enterDeclarationstatement(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclarationstatement" ):
listener.exitDeclarationstatement(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeclarationstatement" ):
return visitor.visitDeclarationstatement(self)
else:
return visitor.visitChildren(self)
[docs]
def declarationstatement(self):
localctx = CPP14Parser.DeclarationstatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 120, self.RULE_declarationstatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1170
self.blockdeclaration()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DeclarationseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def declaration(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)
[docs]
def declarationseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_declarationseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclarationseq" ):
listener.enterDeclarationseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclarationseq" ):
listener.exitDeclarationseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeclarationseq" ):
return visitor.visitDeclarationseq(self)
else:
return visitor.visitChildren(self)
[docs]
def declarationseq(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.DeclarationseqContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 122
self.enterRecursionRule(localctx, 122, self.RULE_declarationseq, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1173
self.declaration()
self._ctx.stop = self._input.LT(-1)
self.state = 1179
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,100,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.DeclarationseqContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_declarationseq)
self.state = 1175
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1176
self.declaration()
self.state = 1181
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,100,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class DeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def blockdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.BlockdeclarationContext,0)
[docs]
def functiondefinition(self):
return self.getTypedRuleContext(CPP14Parser.FunctiondefinitionContext,0)
[docs]
def templatedeclaration(self):
return self.getTypedRuleContext(CPP14Parser.TemplatedeclarationContext,0)
[docs]
def explicitinstantiation(self):
return self.getTypedRuleContext(CPP14Parser.ExplicitinstantiationContext,0)
[docs]
def explicitspecialization(self):
return self.getTypedRuleContext(CPP14Parser.ExplicitspecializationContext,0)
[docs]
def linkagespecification(self):
return self.getTypedRuleContext(CPP14Parser.LinkagespecificationContext,0)
[docs]
def namespacedefinition(self):
return self.getTypedRuleContext(CPP14Parser.NamespacedefinitionContext,0)
[docs]
def emptydeclaration(self):
return self.getTypedRuleContext(CPP14Parser.EmptydeclarationContext,0)
[docs]
def attributedeclaration(self):
return self.getTypedRuleContext(CPP14Parser.AttributedeclarationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_declaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclaration" ):
listener.enterDeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclaration" ):
listener.exitDeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeclaration" ):
return visitor.visitDeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def declaration(self):
localctx = CPP14Parser.DeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 124, self.RULE_declaration)
try:
self.state = 1191
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1182
self.blockdeclaration()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1183
self.functiondefinition()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1184
self.templatedeclaration()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1185
self.explicitinstantiation()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1186
self.explicitspecialization()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 1187
self.linkagespecification()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 1188
self.namespacedefinition()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 1189
self.emptydeclaration()
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 1190
self.attributedeclaration()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BlockdeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def simpledeclaration(self):
return self.getTypedRuleContext(CPP14Parser.SimpledeclarationContext,0)
[docs]
def asmdefinition(self):
return self.getTypedRuleContext(CPP14Parser.AsmdefinitionContext,0)
[docs]
def namespacealiasdefinition(self):
return self.getTypedRuleContext(CPP14Parser.NamespacealiasdefinitionContext,0)
[docs]
def usingdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.UsingdeclarationContext,0)
[docs]
def usingdirective(self):
return self.getTypedRuleContext(CPP14Parser.UsingdirectiveContext,0)
[docs]
def static_assertdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.Static_assertdeclarationContext,0)
[docs]
def aliasdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.AliasdeclarationContext,0)
[docs]
def opaqueenumdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.OpaqueenumdeclarationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_blockdeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBlockdeclaration" ):
listener.enterBlockdeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBlockdeclaration" ):
listener.exitBlockdeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBlockdeclaration" ):
return visitor.visitBlockdeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def blockdeclaration(self):
localctx = CPP14Parser.BlockdeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 126, self.RULE_blockdeclaration)
try:
self.state = 1201
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1193
self.simpledeclaration()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1194
self.asmdefinition()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1195
self.namespacealiasdefinition()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1196
self.usingdeclaration()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1197
self.usingdirective()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 1198
self.static_assertdeclaration()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 1199
self.aliasdeclaration()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 1200
self.opaqueenumdeclaration()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AliasdeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Using(self):
return self.getToken(CPP14Parser.Using, 0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def thetypeid(self):
return self.getTypedRuleContext(CPP14Parser.ThetypeidContext,0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_aliasdeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAliasdeclaration" ):
listener.enterAliasdeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAliasdeclaration" ):
listener.exitAliasdeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAliasdeclaration" ):
return visitor.visitAliasdeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def aliasdeclaration(self):
localctx = CPP14Parser.AliasdeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 128, self.RULE_aliasdeclaration)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1203
self.match(CPP14Parser.Using)
self.state = 1204
self.match(CPP14Parser.Identifier)
self.state = 1206
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1205
self.attributespecifierseq(0)
self.state = 1208
self.match(CPP14Parser.Assign)
self.state = 1209
self.thetypeid()
self.state = 1210
self.match(CPP14Parser.Semi)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SimpledeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def declspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclspecifierseqContext,0)
[docs]
def initdeclaratorlist(self):
return self.getTypedRuleContext(CPP14Parser.InitdeclaratorlistContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_simpledeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSimpledeclaration" ):
listener.enterSimpledeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSimpledeclaration" ):
listener.exitSimpledeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSimpledeclaration" ):
return visitor.visitSimpledeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def simpledeclaration(self):
localctx = CPP14Parser.SimpledeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 130, self.RULE_simpledeclaration)
self._la = 0 # Token type
try:
self.state = 1226
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.T__2, CPP14Parser.Auto, CPP14Parser.Bool, CPP14Parser.Char, CPP14Parser.Char16, CPP14Parser.Char32, CPP14Parser.Class, CPP14Parser.Const, CPP14Parser.Constexpr, CPP14Parser.Decltype, CPP14Parser.Double, CPP14Parser.Enum, CPP14Parser.Explicit, CPP14Parser.Extern, CPP14Parser.Float, CPP14Parser.Friend, CPP14Parser.Inline, CPP14Parser.Int, CPP14Parser.Long, CPP14Parser.Mutable, CPP14Parser.Operator, CPP14Parser.Register, CPP14Parser.Short, CPP14Parser.Signed, CPP14Parser.Static, CPP14Parser.Struct, CPP14Parser.Thread_local, CPP14Parser.Typedef, CPP14Parser.Typename_, CPP14Parser.Union, CPP14Parser.Unsigned, CPP14Parser.Virtual, CPP14Parser.Void, CPP14Parser.Volatile, CPP14Parser.Wchar, CPP14Parser.LeftParen, CPP14Parser.Star, CPP14Parser.And, CPP14Parser.Tilde, CPP14Parser.Doublecolon, CPP14Parser.Semi, CPP14Parser.Ellipsis, CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 1)
self.state = 1213
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
if la_ == 1:
self.state = 1212
self.declspecifierseq()
self.state = 1216
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__2) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Operator))) != 0) or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (CPP14Parser.LeftParen - 84)) | (1 << (CPP14Parser.Star - 84)) | (1 << (CPP14Parser.And - 84)) | (1 << (CPP14Parser.Tilde - 84)) | (1 << (CPP14Parser.Doublecolon - 84)) | (1 << (CPP14Parser.Ellipsis - 84)) | (1 << (CPP14Parser.Identifier - 84)))) != 0):
self.state = 1215
self.initdeclaratorlist(0)
self.state = 1218
self.match(CPP14Parser.Semi)
pass
elif token in [CPP14Parser.Alignas, CPP14Parser.LeftBracket]:
self.enterOuterAlt(localctx, 2)
self.state = 1219
self.attributespecifierseq(0)
self.state = 1221
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
if la_ == 1:
self.state = 1220
self.declspecifierseq()
self.state = 1223
self.initdeclaratorlist(0)
self.state = 1224
self.match(CPP14Parser.Semi)
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
[docs]
class Static_assertdeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Static_assert(self):
return self.getToken(CPP14Parser.Static_assert, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def Stringliteral(self):
return self.getToken(CPP14Parser.Stringliteral, 0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_static_assertdeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStatic_assertdeclaration" ):
listener.enterStatic_assertdeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStatic_assertdeclaration" ):
listener.exitStatic_assertdeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStatic_assertdeclaration" ):
return visitor.visitStatic_assertdeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def static_assertdeclaration(self):
localctx = CPP14Parser.Static_assertdeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 132, self.RULE_static_assertdeclaration)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1228
self.match(CPP14Parser.Static_assert)
self.state = 1229
self.match(CPP14Parser.LeftParen)
self.state = 1230
self.constantexpression()
self.state = 1231
self.match(CPP14Parser.Comma)
self.state = 1232
self.match(CPP14Parser.Stringliteral)
self.state = 1233
self.match(CPP14Parser.RightParen)
self.state = 1234
self.match(CPP14Parser.Semi)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EmptydeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_emptydeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEmptydeclaration" ):
listener.enterEmptydeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEmptydeclaration" ):
listener.exitEmptydeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEmptydeclaration" ):
return visitor.visitEmptydeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def emptydeclaration(self):
localctx = CPP14Parser.EmptydeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 134, self.RULE_emptydeclaration)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1236
self.match(CPP14Parser.Semi)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AttributedeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_attributedeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttributedeclaration" ):
listener.enterAttributedeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttributedeclaration" ):
listener.exitAttributedeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttributedeclaration" ):
return visitor.visitAttributedeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def attributedeclaration(self):
localctx = CPP14Parser.AttributedeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 136, self.RULE_attributedeclaration)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1238
self.attributespecifierseq(0)
self.state = 1239
self.match(CPP14Parser.Semi)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DeclspecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def storageclassspecifier(self):
return self.getTypedRuleContext(CPP14Parser.StorageclassspecifierContext,0)
[docs]
def typespecifier(self):
return self.getTypedRuleContext(CPP14Parser.TypespecifierContext,0)
[docs]
def functionspecifier(self):
return self.getTypedRuleContext(CPP14Parser.FunctionspecifierContext,0)
[docs]
def Friend(self):
return self.getToken(CPP14Parser.Friend, 0)
[docs]
def Typedef(self):
return self.getToken(CPP14Parser.Typedef, 0)
[docs]
def Constexpr(self):
return self.getToken(CPP14Parser.Constexpr, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_declspecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclspecifier" ):
listener.enterDeclspecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclspecifier" ):
listener.exitDeclspecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeclspecifier" ):
return visitor.visitDeclspecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def declspecifier(self):
localctx = CPP14Parser.DeclspecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 138, self.RULE_declspecifier)
try:
self.state = 1247
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Extern, CPP14Parser.Mutable, CPP14Parser.Register, CPP14Parser.Static, CPP14Parser.Thread_local]:
self.enterOuterAlt(localctx, 1)
self.state = 1241
self.storageclassspecifier()
pass
elif token in [CPP14Parser.Auto, CPP14Parser.Bool, CPP14Parser.Char, CPP14Parser.Char16, CPP14Parser.Char32, CPP14Parser.Class, CPP14Parser.Const, CPP14Parser.Decltype, CPP14Parser.Double, CPP14Parser.Enum, CPP14Parser.Float, CPP14Parser.Int, CPP14Parser.Long, CPP14Parser.Short, CPP14Parser.Signed, CPP14Parser.Struct, CPP14Parser.Typename_, CPP14Parser.Union, CPP14Parser.Unsigned, CPP14Parser.Void, CPP14Parser.Volatile, CPP14Parser.Wchar, CPP14Parser.Doublecolon, CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 2)
self.state = 1242
self.typespecifier()
pass
elif token in [CPP14Parser.Explicit, CPP14Parser.Inline, CPP14Parser.Virtual]:
self.enterOuterAlt(localctx, 3)
self.state = 1243
self.functionspecifier()
pass
elif token in [CPP14Parser.Friend]:
self.enterOuterAlt(localctx, 4)
self.state = 1244
self.match(CPP14Parser.Friend)
pass
elif token in [CPP14Parser.Typedef]:
self.enterOuterAlt(localctx, 5)
self.state = 1245
self.match(CPP14Parser.Typedef)
pass
elif token in [CPP14Parser.Constexpr]:
self.enterOuterAlt(localctx, 6)
self.state = 1246
self.match(CPP14Parser.Constexpr)
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
[docs]
class DeclspecifierseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def declspecifier(self):
return self.getTypedRuleContext(CPP14Parser.DeclspecifierContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def declspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclspecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_declspecifierseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclspecifierseq" ):
listener.enterDeclspecifierseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclspecifierseq" ):
listener.exitDeclspecifierseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeclspecifierseq" ):
return visitor.visitDeclspecifierseq(self)
else:
return visitor.visitChildren(self)
[docs]
def declspecifierseq(self):
localctx = CPP14Parser.DeclspecifierseqContext(self, self._ctx, self.state)
self.enterRule(localctx, 140, self.RULE_declspecifierseq)
try:
self.state = 1256
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1249
self.declspecifier()
self.state = 1251
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
if la_ == 1:
self.state = 1250
self.attributespecifierseq(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1253
self.declspecifier()
self.state = 1254
self.declspecifierseq()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StorageclassspecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Register(self):
return self.getToken(CPP14Parser.Register, 0)
[docs]
def Static(self):
return self.getToken(CPP14Parser.Static, 0)
[docs]
def Thread_local(self):
return self.getToken(CPP14Parser.Thread_local, 0)
[docs]
def Extern(self):
return self.getToken(CPP14Parser.Extern, 0)
[docs]
def Mutable(self):
return self.getToken(CPP14Parser.Mutable, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_storageclassspecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStorageclassspecifier" ):
listener.enterStorageclassspecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStorageclassspecifier" ):
listener.exitStorageclassspecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStorageclassspecifier" ):
return visitor.visitStorageclassspecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def storageclassspecifier(self):
localctx = CPP14Parser.StorageclassspecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 142, self.RULE_storageclassspecifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1258
_la = self._input.LA(1)
if not(((((_la - 37)) & ~0x3f) == 0 and ((1 << (_la - 37)) & ((1 << (CPP14Parser.Extern - 37)) | (1 << (CPP14Parser.Mutable - 37)) | (1 << (CPP14Parser.Register - 37)) | (1 << (CPP14Parser.Static - 37)) | (1 << (CPP14Parser.Thread_local - 37)))) != 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
[docs]
class FunctionspecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Inline(self):
return self.getToken(CPP14Parser.Inline, 0)
[docs]
def Virtual(self):
return self.getToken(CPP14Parser.Virtual, 0)
[docs]
def Explicit(self):
return self.getToken(CPP14Parser.Explicit, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_functionspecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionspecifier" ):
listener.enterFunctionspecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionspecifier" ):
listener.exitFunctionspecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionspecifier" ):
return visitor.visitFunctionspecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def functionspecifier(self):
localctx = CPP14Parser.FunctionspecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 144, self.RULE_functionspecifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1260
_la = self._input.LA(1)
if not(((((_la - 35)) & ~0x3f) == 0 and ((1 << (_la - 35)) & ((1 << (CPP14Parser.Explicit - 35)) | (1 << (CPP14Parser.Inline - 35)) | (1 << (CPP14Parser.Virtual - 35)))) != 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
[docs]
class TypedefnameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_typedefname
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypedefname" ):
listener.enterTypedefname(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypedefname" ):
listener.exitTypedefname(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypedefname" ):
return visitor.visitTypedefname(self)
else:
return visitor.visitChildren(self)
[docs]
def typedefname(self):
localctx = CPP14Parser.TypedefnameContext(self, self._ctx, self.state)
self.enterRule(localctx, 146, self.RULE_typedefname)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1262
self.match(CPP14Parser.Identifier)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def trailingtypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.TrailingtypespecifierContext,0)
[docs]
def classspecifier(self):
return self.getTypedRuleContext(CPP14Parser.ClassspecifierContext,0)
[docs]
def enumspecifier(self):
return self.getTypedRuleContext(CPP14Parser.EnumspecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_typespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypespecifier" ):
listener.enterTypespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypespecifier" ):
listener.exitTypespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypespecifier" ):
return visitor.visitTypespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def typespecifier(self):
localctx = CPP14Parser.TypespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 148, self.RULE_typespecifier)
try:
self.state = 1267
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1264
self.trailingtypespecifier()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1265
self.classspecifier()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1266
self.enumspecifier()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TrailingtypespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def simpletypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.SimpletypespecifierContext,0)
[docs]
def elaboratedtypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.ElaboratedtypespecifierContext,0)
[docs]
def typenamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.TypenamespecifierContext,0)
[docs]
def cvqualifier(self):
return self.getTypedRuleContext(CPP14Parser.CvqualifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_trailingtypespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTrailingtypespecifier" ):
listener.enterTrailingtypespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTrailingtypespecifier" ):
listener.exitTrailingtypespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTrailingtypespecifier" ):
return visitor.visitTrailingtypespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def trailingtypespecifier(self):
localctx = CPP14Parser.TrailingtypespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 150, self.RULE_trailingtypespecifier)
try:
self.state = 1273
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Auto, CPP14Parser.Bool, CPP14Parser.Char, CPP14Parser.Char16, CPP14Parser.Char32, CPP14Parser.Decltype, CPP14Parser.Double, CPP14Parser.Float, CPP14Parser.Int, CPP14Parser.Long, CPP14Parser.Short, CPP14Parser.Signed, CPP14Parser.Unsigned, CPP14Parser.Void, CPP14Parser.Wchar, CPP14Parser.Doublecolon, CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 1)
self.state = 1269
self.simpletypespecifier()
pass
elif token in [CPP14Parser.Class, CPP14Parser.Enum, CPP14Parser.Struct, CPP14Parser.Union]:
self.enterOuterAlt(localctx, 2)
self.state = 1270
self.elaboratedtypespecifier()
pass
elif token in [CPP14Parser.Typename_]:
self.enterOuterAlt(localctx, 3)
self.state = 1271
self.typenamespecifier()
pass
elif token in [CPP14Parser.Const, CPP14Parser.Volatile]:
self.enterOuterAlt(localctx, 4)
self.state = 1272
self.cvqualifier()
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
[docs]
class TypespecifierseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typespecifier(self):
return self.getTypedRuleContext(CPP14Parser.TypespecifierContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def typespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.TypespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_typespecifierseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypespecifierseq" ):
listener.enterTypespecifierseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypespecifierseq" ):
listener.exitTypespecifierseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypespecifierseq" ):
return visitor.visitTypespecifierseq(self)
else:
return visitor.visitChildren(self)
[docs]
def typespecifierseq(self):
localctx = CPP14Parser.TypespecifierseqContext(self, self._ctx, self.state)
self.enterRule(localctx, 152, self.RULE_typespecifierseq)
try:
self.state = 1282
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1275
self.typespecifier()
self.state = 1277
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
if la_ == 1:
self.state = 1276
self.attributespecifierseq(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1279
self.typespecifier()
self.state = 1280
self.typespecifierseq()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TrailingtypespecifierseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def trailingtypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.TrailingtypespecifierContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def trailingtypespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.TrailingtypespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_trailingtypespecifierseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTrailingtypespecifierseq" ):
listener.enterTrailingtypespecifierseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTrailingtypespecifierseq" ):
listener.exitTrailingtypespecifierseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTrailingtypespecifierseq" ):
return visitor.visitTrailingtypespecifierseq(self)
else:
return visitor.visitChildren(self)
[docs]
def trailingtypespecifierseq(self):
localctx = CPP14Parser.TrailingtypespecifierseqContext(self, self._ctx, self.state)
self.enterRule(localctx, 154, self.RULE_trailingtypespecifierseq)
try:
self.state = 1291
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1284
self.trailingtypespecifier()
self.state = 1286
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,115,self._ctx)
if la_ == 1:
self.state = 1285
self.attributespecifierseq(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1288
self.trailingtypespecifier()
self.state = 1289
self.trailingtypespecifierseq()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SimpletypespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def thetypename(self):
return self.getTypedRuleContext(CPP14Parser.ThetypenameContext,0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def simpletemplateid(self):
return self.getTypedRuleContext(CPP14Parser.SimpletemplateidContext,0)
[docs]
def Char(self):
return self.getToken(CPP14Parser.Char, 0)
[docs]
def Char16(self):
return self.getToken(CPP14Parser.Char16, 0)
[docs]
def Char32(self):
return self.getToken(CPP14Parser.Char32, 0)
[docs]
def Wchar(self):
return self.getToken(CPP14Parser.Wchar, 0)
[docs]
def Bool(self):
return self.getToken(CPP14Parser.Bool, 0)
[docs]
def Short(self):
return self.getToken(CPP14Parser.Short, 0)
[docs]
def Int(self):
return self.getToken(CPP14Parser.Int, 0)
[docs]
def Long(self):
return self.getToken(CPP14Parser.Long, 0)
[docs]
def Signed(self):
return self.getToken(CPP14Parser.Signed, 0)
[docs]
def Unsigned(self):
return self.getToken(CPP14Parser.Unsigned, 0)
[docs]
def Float(self):
return self.getToken(CPP14Parser.Float, 0)
[docs]
def Double(self):
return self.getToken(CPP14Parser.Double, 0)
[docs]
def Void(self):
return self.getToken(CPP14Parser.Void, 0)
[docs]
def Auto(self):
return self.getToken(CPP14Parser.Auto, 0)
[docs]
def decltypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.DecltypespecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_simpletypespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSimpletypespecifier" ):
listener.enterSimpletypespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSimpletypespecifier" ):
listener.exitSimpletypespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSimpletypespecifier" ):
return visitor.visitSimpletypespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def simpletypespecifier(self):
localctx = CPP14Parser.SimpletypespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 156, self.RULE_simpletypespecifier)
try:
self.state = 1316
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,118,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1294
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
if la_ == 1:
self.state = 1293
self.nestednamespecifier(0)
self.state = 1296
self.thetypename()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1297
self.nestednamespecifier(0)
self.state = 1298
self.match(CPP14Parser.Template)
self.state = 1299
self.simpletemplateid()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1301
self.match(CPP14Parser.Char)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1302
self.match(CPP14Parser.Char16)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 1303
self.match(CPP14Parser.Char32)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 1304
self.match(CPP14Parser.Wchar)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 1305
self.match(CPP14Parser.Bool)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 1306
self.match(CPP14Parser.Short)
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 1307
self.match(CPP14Parser.Int)
pass
elif la_ == 10:
self.enterOuterAlt(localctx, 10)
self.state = 1308
self.match(CPP14Parser.Long)
pass
elif la_ == 11:
self.enterOuterAlt(localctx, 11)
self.state = 1309
self.match(CPP14Parser.Signed)
pass
elif la_ == 12:
self.enterOuterAlt(localctx, 12)
self.state = 1310
self.match(CPP14Parser.Unsigned)
pass
elif la_ == 13:
self.enterOuterAlt(localctx, 13)
self.state = 1311
self.match(CPP14Parser.Float)
pass
elif la_ == 14:
self.enterOuterAlt(localctx, 14)
self.state = 1312
self.match(CPP14Parser.Double)
pass
elif la_ == 15:
self.enterOuterAlt(localctx, 15)
self.state = 1313
self.match(CPP14Parser.Void)
pass
elif la_ == 16:
self.enterOuterAlt(localctx, 16)
self.state = 1314
self.match(CPP14Parser.Auto)
pass
elif la_ == 17:
self.enterOuterAlt(localctx, 17)
self.state = 1315
self.decltypespecifier()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ThetypenameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def classname(self):
return self.getTypedRuleContext(CPP14Parser.ClassnameContext,0)
[docs]
def enumname(self):
return self.getTypedRuleContext(CPP14Parser.EnumnameContext,0)
[docs]
def typedefname(self):
return self.getTypedRuleContext(CPP14Parser.TypedefnameContext,0)
[docs]
def simpletemplateid(self):
return self.getTypedRuleContext(CPP14Parser.SimpletemplateidContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_thetypename
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterThetypename" ):
listener.enterThetypename(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitThetypename" ):
listener.exitThetypename(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitThetypename" ):
return visitor.visitThetypename(self)
else:
return visitor.visitChildren(self)
[docs]
def thetypename(self):
localctx = CPP14Parser.ThetypenameContext(self, self._ctx, self.state)
self.enterRule(localctx, 158, self.RULE_thetypename)
try:
self.state = 1322
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1318
self.classname()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1319
self.enumname()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1320
self.typedefname()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1321
self.simpletemplateid()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DecltypespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Decltype(self):
return self.getToken(CPP14Parser.Decltype, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def Auto(self):
return self.getToken(CPP14Parser.Auto, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_decltypespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDecltypespecifier" ):
listener.enterDecltypespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDecltypespecifier" ):
listener.exitDecltypespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDecltypespecifier" ):
return visitor.visitDecltypespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def decltypespecifier(self):
localctx = CPP14Parser.DecltypespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 160, self.RULE_decltypespecifier)
try:
self.state = 1333
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,120,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1324
self.match(CPP14Parser.Decltype)
self.state = 1325
self.match(CPP14Parser.LeftParen)
self.state = 1326
self.expression(0)
self.state = 1327
self.match(CPP14Parser.RightParen)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1329
self.match(CPP14Parser.Decltype)
self.state = 1330
self.match(CPP14Parser.LeftParen)
self.state = 1331
self.match(CPP14Parser.Auto)
self.state = 1332
self.match(CPP14Parser.RightParen)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ElaboratedtypespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def classkey(self):
return self.getTypedRuleContext(CPP14Parser.ClasskeyContext,0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def simpletemplateid(self):
return self.getTypedRuleContext(CPP14Parser.SimpletemplateidContext,0)
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def Enum(self):
return self.getToken(CPP14Parser.Enum, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_elaboratedtypespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElaboratedtypespecifier" ):
listener.enterElaboratedtypespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElaboratedtypespecifier" ):
listener.exitElaboratedtypespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElaboratedtypespecifier" ):
return visitor.visitElaboratedtypespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def elaboratedtypespecifier(self):
localctx = CPP14Parser.ElaboratedtypespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 162, self.RULE_elaboratedtypespecifier)
self._la = 0 # Token type
try:
self.state = 1359
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1335
self.classkey()
self.state = 1337
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1336
self.attributespecifierseq(0)
self.state = 1340
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
if la_ == 1:
self.state = 1339
self.nestednamespecifier(0)
self.state = 1342
self.match(CPP14Parser.Identifier)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1344
self.classkey()
self.state = 1345
self.simpletemplateid()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1347
self.classkey()
self.state = 1348
self.nestednamespecifier(0)
self.state = 1350
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Template:
self.state = 1349
self.match(CPP14Parser.Template)
self.state = 1352
self.simpletemplateid()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1354
self.match(CPP14Parser.Enum)
self.state = 1356
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
if la_ == 1:
self.state = 1355
self.nestednamespecifier(0)
self.state = 1358
self.match(CPP14Parser.Identifier)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EnumnameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_enumname
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumname" ):
listener.enterEnumname(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumname" ):
listener.exitEnumname(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnumname" ):
return visitor.visitEnumname(self)
else:
return visitor.visitChildren(self)
[docs]
def enumname(self):
localctx = CPP14Parser.EnumnameContext(self, self._ctx, self.state)
self.enterRule(localctx, 164, self.RULE_enumname)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1361
self.match(CPP14Parser.Identifier)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EnumspecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def enumhead(self):
return self.getTypedRuleContext(CPP14Parser.EnumheadContext,0)
[docs]
def LeftBrace(self):
return self.getToken(CPP14Parser.LeftBrace, 0)
[docs]
def RightBrace(self):
return self.getToken(CPP14Parser.RightBrace, 0)
[docs]
def enumeratorlist(self):
return self.getTypedRuleContext(CPP14Parser.EnumeratorlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_enumspecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumspecifier" ):
listener.enterEnumspecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumspecifier" ):
listener.exitEnumspecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnumspecifier" ):
return visitor.visitEnumspecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def enumspecifier(self):
localctx = CPP14Parser.EnumspecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 166, self.RULE_enumspecifier)
self._la = 0 # Token type
try:
self.state = 1376
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1363
self.enumhead()
self.state = 1364
self.match(CPP14Parser.LeftBrace)
self.state = 1366
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Identifier:
self.state = 1365
self.enumeratorlist(0)
self.state = 1368
self.match(CPP14Parser.RightBrace)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1370
self.enumhead()
self.state = 1371
self.match(CPP14Parser.LeftBrace)
self.state = 1372
self.enumeratorlist(0)
self.state = 1373
self.match(CPP14Parser.Comma)
self.state = 1374
self.match(CPP14Parser.RightBrace)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EnumheadContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def enumkey(self):
return self.getTypedRuleContext(CPP14Parser.EnumkeyContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def enumbase(self):
return self.getTypedRuleContext(CPP14Parser.EnumbaseContext,0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_enumhead
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumhead" ):
listener.enterEnumhead(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumhead" ):
listener.exitEnumhead(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnumhead" ):
return visitor.visitEnumhead(self)
else:
return visitor.visitChildren(self)
[docs]
def enumhead(self):
localctx = CPP14Parser.EnumheadContext(self, self._ctx, self.state)
self.enterRule(localctx, 168, self.RULE_enumhead)
self._la = 0 # Token type
try:
self.state = 1397
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1378
self.enumkey()
self.state = 1380
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1379
self.attributespecifierseq(0)
self.state = 1383
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Identifier:
self.state = 1382
self.match(CPP14Parser.Identifier)
self.state = 1386
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Colon:
self.state = 1385
self.enumbase()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1388
self.enumkey()
self.state = 1390
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1389
self.attributespecifierseq(0)
self.state = 1392
self.nestednamespecifier(0)
self.state = 1393
self.match(CPP14Parser.Identifier)
self.state = 1395
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Colon:
self.state = 1394
self.enumbase()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OpaqueenumdeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def enumkey(self):
return self.getTypedRuleContext(CPP14Parser.EnumkeyContext,0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def enumbase(self):
return self.getTypedRuleContext(CPP14Parser.EnumbaseContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_opaqueenumdeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOpaqueenumdeclaration" ):
listener.enterOpaqueenumdeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOpaqueenumdeclaration" ):
listener.exitOpaqueenumdeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOpaqueenumdeclaration" ):
return visitor.visitOpaqueenumdeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def opaqueenumdeclaration(self):
localctx = CPP14Parser.OpaqueenumdeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 170, self.RULE_opaqueenumdeclaration)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1399
self.enumkey()
self.state = 1401
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1400
self.attributespecifierseq(0)
self.state = 1403
self.match(CPP14Parser.Identifier)
self.state = 1405
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Colon:
self.state = 1404
self.enumbase()
self.state = 1407
self.match(CPP14Parser.Semi)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EnumkeyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Enum(self):
return self.getToken(CPP14Parser.Enum, 0)
[docs]
def Class(self):
return self.getToken(CPP14Parser.Class, 0)
[docs]
def Struct(self):
return self.getToken(CPP14Parser.Struct, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_enumkey
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumkey" ):
listener.enterEnumkey(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumkey" ):
listener.exitEnumkey(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnumkey" ):
return visitor.visitEnumkey(self)
else:
return visitor.visitChildren(self)
[docs]
def enumkey(self):
localctx = CPP14Parser.EnumkeyContext(self, self._ctx, self.state)
self.enterRule(localctx, 172, self.RULE_enumkey)
try:
self.state = 1414
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1409
self.match(CPP14Parser.Enum)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1410
self.match(CPP14Parser.Enum)
self.state = 1411
self.match(CPP14Parser.Class)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1412
self.match(CPP14Parser.Enum)
self.state = 1413
self.match(CPP14Parser.Struct)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EnumbaseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Colon(self):
return self.getToken(CPP14Parser.Colon, 0)
[docs]
def typespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.TypespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_enumbase
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumbase" ):
listener.enterEnumbase(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumbase" ):
listener.exitEnumbase(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnumbase" ):
return visitor.visitEnumbase(self)
else:
return visitor.visitChildren(self)
[docs]
def enumbase(self):
localctx = CPP14Parser.EnumbaseContext(self, self._ctx, self.state)
self.enterRule(localctx, 174, self.RULE_enumbase)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1416
self.match(CPP14Parser.Colon)
self.state = 1417
self.typespecifierseq()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EnumeratorlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def enumeratordefinition(self):
return self.getTypedRuleContext(CPP14Parser.EnumeratordefinitionContext,0)
[docs]
def enumeratorlist(self):
return self.getTypedRuleContext(CPP14Parser.EnumeratorlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_enumeratorlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumeratorlist" ):
listener.enterEnumeratorlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumeratorlist" ):
listener.exitEnumeratorlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnumeratorlist" ):
return visitor.visitEnumeratorlist(self)
else:
return visitor.visitChildren(self)
[docs]
def enumeratorlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.EnumeratorlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 176
self.enterRecursionRule(localctx, 176, self.RULE_enumeratorlist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1420
self.enumeratordefinition()
self._ctx.stop = self._input.LT(-1)
self.state = 1427
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,137,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.EnumeratorlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_enumeratorlist)
self.state = 1422
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1423
self.match(CPP14Parser.Comma)
self.state = 1424
self.enumeratordefinition()
self.state = 1429
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,137,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class EnumeratordefinitionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def enumerator(self):
return self.getTypedRuleContext(CPP14Parser.EnumeratorContext,0)
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_enumeratordefinition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumeratordefinition" ):
listener.enterEnumeratordefinition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumeratordefinition" ):
listener.exitEnumeratordefinition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnumeratordefinition" ):
return visitor.visitEnumeratordefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def enumeratordefinition(self):
localctx = CPP14Parser.EnumeratordefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 178, self.RULE_enumeratordefinition)
try:
self.state = 1435
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,138,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1430
self.enumerator()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1431
self.enumerator()
self.state = 1432
self.match(CPP14Parser.Assign)
self.state = 1433
self.constantexpression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EnumeratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_enumerator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumerator" ):
listener.enterEnumerator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumerator" ):
listener.exitEnumerator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnumerator" ):
return visitor.visitEnumerator(self)
else:
return visitor.visitChildren(self)
[docs]
def enumerator(self):
localctx = CPP14Parser.EnumeratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 180, self.RULE_enumerator)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1437
self.match(CPP14Parser.Identifier)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamespacenameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def originalnamespacename(self):
return self.getTypedRuleContext(CPP14Parser.OriginalnamespacenameContext,0)
[docs]
def namespacealias(self):
return self.getTypedRuleContext(CPP14Parser.NamespacealiasContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_namespacename
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamespacename" ):
listener.enterNamespacename(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamespacename" ):
listener.exitNamespacename(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamespacename" ):
return visitor.visitNamespacename(self)
else:
return visitor.visitChildren(self)
[docs]
def namespacename(self):
localctx = CPP14Parser.NamespacenameContext(self, self._ctx, self.state)
self.enterRule(localctx, 182, self.RULE_namespacename)
try:
self.state = 1441
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1439
self.originalnamespacename()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1440
self.namespacealias()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OriginalnamespacenameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_originalnamespacename
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOriginalnamespacename" ):
listener.enterOriginalnamespacename(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOriginalnamespacename" ):
listener.exitOriginalnamespacename(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOriginalnamespacename" ):
return visitor.visitOriginalnamespacename(self)
else:
return visitor.visitChildren(self)
[docs]
def originalnamespacename(self):
localctx = CPP14Parser.OriginalnamespacenameContext(self, self._ctx, self.state)
self.enterRule(localctx, 184, self.RULE_originalnamespacename)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1443
self.match(CPP14Parser.Identifier)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamespacedefinitionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def namednamespacedefinition(self):
return self.getTypedRuleContext(CPP14Parser.NamednamespacedefinitionContext,0)
[docs]
def unnamednamespacedefinition(self):
return self.getTypedRuleContext(CPP14Parser.UnnamednamespacedefinitionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_namespacedefinition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamespacedefinition" ):
listener.enterNamespacedefinition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamespacedefinition" ):
listener.exitNamespacedefinition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamespacedefinition" ):
return visitor.visitNamespacedefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def namespacedefinition(self):
localctx = CPP14Parser.NamespacedefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 186, self.RULE_namespacedefinition)
try:
self.state = 1447
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,140,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1445
self.namednamespacedefinition()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1446
self.unnamednamespacedefinition()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamednamespacedefinitionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def originalnamespacedefinition(self):
return self.getTypedRuleContext(CPP14Parser.OriginalnamespacedefinitionContext,0)
[docs]
def extensionnamespacedefinition(self):
return self.getTypedRuleContext(CPP14Parser.ExtensionnamespacedefinitionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_namednamespacedefinition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamednamespacedefinition" ):
listener.enterNamednamespacedefinition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamednamespacedefinition" ):
listener.exitNamednamespacedefinition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamednamespacedefinition" ):
return visitor.visitNamednamespacedefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def namednamespacedefinition(self):
localctx = CPP14Parser.NamednamespacedefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 188, self.RULE_namednamespacedefinition)
try:
self.state = 1451
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1449
self.originalnamespacedefinition()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1450
self.extensionnamespacedefinition()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OriginalnamespacedefinitionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Namespace(self):
return self.getToken(CPP14Parser.Namespace, 0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def LeftBrace(self):
return self.getToken(CPP14Parser.LeftBrace, 0)
[docs]
def namespacebody(self):
return self.getTypedRuleContext(CPP14Parser.NamespacebodyContext,0)
[docs]
def RightBrace(self):
return self.getToken(CPP14Parser.RightBrace, 0)
[docs]
def Inline(self):
return self.getToken(CPP14Parser.Inline, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_originalnamespacedefinition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOriginalnamespacedefinition" ):
listener.enterOriginalnamespacedefinition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOriginalnamespacedefinition" ):
listener.exitOriginalnamespacedefinition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOriginalnamespacedefinition" ):
return visitor.visitOriginalnamespacedefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def originalnamespacedefinition(self):
localctx = CPP14Parser.OriginalnamespacedefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 190, self.RULE_originalnamespacedefinition)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1454
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Inline:
self.state = 1453
self.match(CPP14Parser.Inline)
self.state = 1456
self.match(CPP14Parser.Namespace)
self.state = 1457
self.match(CPP14Parser.Identifier)
self.state = 1458
self.match(CPP14Parser.LeftBrace)
self.state = 1459
self.namespacebody()
self.state = 1460
self.match(CPP14Parser.RightBrace)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExtensionnamespacedefinitionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Namespace(self):
return self.getToken(CPP14Parser.Namespace, 0)
[docs]
def originalnamespacename(self):
return self.getTypedRuleContext(CPP14Parser.OriginalnamespacenameContext,0)
[docs]
def LeftBrace(self):
return self.getToken(CPP14Parser.LeftBrace, 0)
[docs]
def namespacebody(self):
return self.getTypedRuleContext(CPP14Parser.NamespacebodyContext,0)
[docs]
def RightBrace(self):
return self.getToken(CPP14Parser.RightBrace, 0)
[docs]
def Inline(self):
return self.getToken(CPP14Parser.Inline, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_extensionnamespacedefinition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExtensionnamespacedefinition" ):
listener.enterExtensionnamespacedefinition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExtensionnamespacedefinition" ):
listener.exitExtensionnamespacedefinition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExtensionnamespacedefinition" ):
return visitor.visitExtensionnamespacedefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def extensionnamespacedefinition(self):
localctx = CPP14Parser.ExtensionnamespacedefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 192, self.RULE_extensionnamespacedefinition)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1463
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Inline:
self.state = 1462
self.match(CPP14Parser.Inline)
self.state = 1465
self.match(CPP14Parser.Namespace)
self.state = 1466
self.originalnamespacename()
self.state = 1467
self.match(CPP14Parser.LeftBrace)
self.state = 1468
self.namespacebody()
self.state = 1469
self.match(CPP14Parser.RightBrace)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UnnamednamespacedefinitionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Namespace(self):
return self.getToken(CPP14Parser.Namespace, 0)
[docs]
def LeftBrace(self):
return self.getToken(CPP14Parser.LeftBrace, 0)
[docs]
def namespacebody(self):
return self.getTypedRuleContext(CPP14Parser.NamespacebodyContext,0)
[docs]
def RightBrace(self):
return self.getToken(CPP14Parser.RightBrace, 0)
[docs]
def Inline(self):
return self.getToken(CPP14Parser.Inline, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_unnamednamespacedefinition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnnamednamespacedefinition" ):
listener.enterUnnamednamespacedefinition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnnamednamespacedefinition" ):
listener.exitUnnamednamespacedefinition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUnnamednamespacedefinition" ):
return visitor.visitUnnamednamespacedefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def unnamednamespacedefinition(self):
localctx = CPP14Parser.UnnamednamespacedefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 194, self.RULE_unnamednamespacedefinition)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1472
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Inline:
self.state = 1471
self.match(CPP14Parser.Inline)
self.state = 1474
self.match(CPP14Parser.Namespace)
self.state = 1475
self.match(CPP14Parser.LeftBrace)
self.state = 1476
self.namespacebody()
self.state = 1477
self.match(CPP14Parser.RightBrace)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamespacebodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def declarationseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_namespacebody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamespacebody" ):
listener.enterNamespacebody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamespacebody" ):
listener.exitNamespacebody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamespacebody" ):
return visitor.visitNamespacebody(self)
else:
return visitor.visitChildren(self)
[docs]
def namespacebody(self):
localctx = CPP14Parser.NamespacebodyContext(self, self._ctx, self.state)
self.enterRule(localctx, 196, self.RULE_namespacebody)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1480
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__2) | (1 << CPP14Parser.Alignas) | (1 << CPP14Parser.Asm) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Constexpr) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Explicit) | (1 << CPP14Parser.Extern) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Friend) | (1 << CPP14Parser.Inline) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.Mutable) | (1 << CPP14Parser.Namespace) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Register) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Static))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CPP14Parser.Static_assert - 64)) | (1 << (CPP14Parser.Struct - 64)) | (1 << (CPP14Parser.Template - 64)) | (1 << (CPP14Parser.Thread_local - 64)) | (1 << (CPP14Parser.Typedef - 64)) | (1 << (CPP14Parser.Typename_ - 64)) | (1 << (CPP14Parser.Union - 64)) | (1 << (CPP14Parser.Unsigned - 64)) | (1 << (CPP14Parser.Using - 64)) | (1 << (CPP14Parser.Virtual - 64)) | (1 << (CPP14Parser.Void - 64)) | (1 << (CPP14Parser.Volatile - 64)) | (1 << (CPP14Parser.Wchar - 64)) | (1 << (CPP14Parser.LeftParen - 64)) | (1 << (CPP14Parser.LeftBracket - 64)) | (1 << (CPP14Parser.Star - 64)) | (1 << (CPP14Parser.And - 64)) | (1 << (CPP14Parser.Tilde - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (CPP14Parser.Doublecolon - 128)) | (1 << (CPP14Parser.Semi - 128)) | (1 << (CPP14Parser.Ellipsis - 128)) | (1 << (CPP14Parser.Identifier - 128)))) != 0):
self.state = 1479
self.declarationseq(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamespacealiasContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_namespacealias
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamespacealias" ):
listener.enterNamespacealias(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamespacealias" ):
listener.exitNamespacealias(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamespacealias" ):
return visitor.visitNamespacealias(self)
else:
return visitor.visitChildren(self)
[docs]
def namespacealias(self):
localctx = CPP14Parser.NamespacealiasContext(self, self._ctx, self.state)
self.enterRule(localctx, 198, self.RULE_namespacealias)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1482
self.match(CPP14Parser.Identifier)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NamespacealiasdefinitionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Namespace(self):
return self.getToken(CPP14Parser.Namespace, 0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def qualifiednamespacespecifier(self):
return self.getTypedRuleContext(CPP14Parser.QualifiednamespacespecifierContext,0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_namespacealiasdefinition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamespacealiasdefinition" ):
listener.enterNamespacealiasdefinition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamespacealiasdefinition" ):
listener.exitNamespacealiasdefinition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamespacealiasdefinition" ):
return visitor.visitNamespacealiasdefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def namespacealiasdefinition(self):
localctx = CPP14Parser.NamespacealiasdefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 200, self.RULE_namespacealiasdefinition)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1484
self.match(CPP14Parser.Namespace)
self.state = 1485
self.match(CPP14Parser.Identifier)
self.state = 1486
self.match(CPP14Parser.Assign)
self.state = 1487
self.qualifiednamespacespecifier()
self.state = 1488
self.match(CPP14Parser.Semi)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class QualifiednamespacespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def namespacename(self):
return self.getTypedRuleContext(CPP14Parser.NamespacenameContext,0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_qualifiednamespacespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterQualifiednamespacespecifier" ):
listener.enterQualifiednamespacespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitQualifiednamespacespecifier" ):
listener.exitQualifiednamespacespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitQualifiednamespacespecifier" ):
return visitor.visitQualifiednamespacespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def qualifiednamespacespecifier(self):
localctx = CPP14Parser.QualifiednamespacespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 202, self.RULE_qualifiednamespacespecifier)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1491
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
if la_ == 1:
self.state = 1490
self.nestednamespecifier(0)
self.state = 1493
self.namespacename()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UsingdeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Using(self):
return self.getToken(CPP14Parser.Using, 0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def unqualifiedid(self):
return self.getTypedRuleContext(CPP14Parser.UnqualifiedidContext,0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def Typename_(self):
return self.getToken(CPP14Parser.Typename_, 0)
[docs]
def Doublecolon(self):
return self.getToken(CPP14Parser.Doublecolon, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_usingdeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUsingdeclaration" ):
listener.enterUsingdeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUsingdeclaration" ):
listener.exitUsingdeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUsingdeclaration" ):
return visitor.visitUsingdeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def usingdeclaration(self):
localctx = CPP14Parser.UsingdeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 204, self.RULE_usingdeclaration)
self._la = 0 # Token type
try:
self.state = 1508
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1495
self.match(CPP14Parser.Using)
self.state = 1497
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Typename_:
self.state = 1496
self.match(CPP14Parser.Typename_)
self.state = 1499
self.nestednamespecifier(0)
self.state = 1500
self.unqualifiedid()
self.state = 1501
self.match(CPP14Parser.Semi)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1503
self.match(CPP14Parser.Using)
self.state = 1504
self.match(CPP14Parser.Doublecolon)
self.state = 1505
self.unqualifiedid()
self.state = 1506
self.match(CPP14Parser.Semi)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UsingdirectiveContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Using(self):
return self.getToken(CPP14Parser.Using, 0)
[docs]
def Namespace(self):
return self.getToken(CPP14Parser.Namespace, 0)
[docs]
def namespacename(self):
return self.getTypedRuleContext(CPP14Parser.NamespacenameContext,0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_usingdirective
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUsingdirective" ):
listener.enterUsingdirective(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUsingdirective" ):
listener.exitUsingdirective(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUsingdirective" ):
return visitor.visitUsingdirective(self)
else:
return visitor.visitChildren(self)
[docs]
def usingdirective(self):
localctx = CPP14Parser.UsingdirectiveContext(self, self._ctx, self.state)
self.enterRule(localctx, 206, self.RULE_usingdirective)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1511
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1510
self.attributespecifierseq(0)
self.state = 1513
self.match(CPP14Parser.Using)
self.state = 1514
self.match(CPP14Parser.Namespace)
self.state = 1516
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,150,self._ctx)
if la_ == 1:
self.state = 1515
self.nestednamespecifier(0)
self.state = 1518
self.namespacename()
self.state = 1519
self.match(CPP14Parser.Semi)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AsmdefinitionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Asm(self):
return self.getToken(CPP14Parser.Asm, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def Stringliteral(self):
return self.getToken(CPP14Parser.Stringliteral, 0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_asmdefinition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAsmdefinition" ):
listener.enterAsmdefinition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAsmdefinition" ):
listener.exitAsmdefinition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAsmdefinition" ):
return visitor.visitAsmdefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def asmdefinition(self):
localctx = CPP14Parser.AsmdefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 208, self.RULE_asmdefinition)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1521
self.match(CPP14Parser.Asm)
self.state = 1522
self.match(CPP14Parser.LeftParen)
self.state = 1523
self.match(CPP14Parser.Stringliteral)
self.state = 1524
self.match(CPP14Parser.RightParen)
self.state = 1525
self.match(CPP14Parser.Semi)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LinkagespecificationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Extern(self):
return self.getToken(CPP14Parser.Extern, 0)
[docs]
def Stringliteral(self):
return self.getToken(CPP14Parser.Stringliteral, 0)
[docs]
def LeftBrace(self):
return self.getToken(CPP14Parser.LeftBrace, 0)
[docs]
def RightBrace(self):
return self.getToken(CPP14Parser.RightBrace, 0)
[docs]
def declarationseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)
[docs]
def declaration(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_linkagespecification
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLinkagespecification" ):
listener.enterLinkagespecification(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLinkagespecification" ):
listener.exitLinkagespecification(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLinkagespecification" ):
return visitor.visitLinkagespecification(self)
else:
return visitor.visitChildren(self)
[docs]
def linkagespecification(self):
localctx = CPP14Parser.LinkagespecificationContext(self, self._ctx, self.state)
self.enterRule(localctx, 210, self.RULE_linkagespecification)
self._la = 0 # Token type
try:
self.state = 1537
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,152,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1527
self.match(CPP14Parser.Extern)
self.state = 1528
self.match(CPP14Parser.Stringliteral)
self.state = 1529
self.match(CPP14Parser.LeftBrace)
self.state = 1531
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__2) | (1 << CPP14Parser.Alignas) | (1 << CPP14Parser.Asm) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Constexpr) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Explicit) | (1 << CPP14Parser.Extern) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Friend) | (1 << CPP14Parser.Inline) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.Mutable) | (1 << CPP14Parser.Namespace) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Register) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Static))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CPP14Parser.Static_assert - 64)) | (1 << (CPP14Parser.Struct - 64)) | (1 << (CPP14Parser.Template - 64)) | (1 << (CPP14Parser.Thread_local - 64)) | (1 << (CPP14Parser.Typedef - 64)) | (1 << (CPP14Parser.Typename_ - 64)) | (1 << (CPP14Parser.Union - 64)) | (1 << (CPP14Parser.Unsigned - 64)) | (1 << (CPP14Parser.Using - 64)) | (1 << (CPP14Parser.Virtual - 64)) | (1 << (CPP14Parser.Void - 64)) | (1 << (CPP14Parser.Volatile - 64)) | (1 << (CPP14Parser.Wchar - 64)) | (1 << (CPP14Parser.LeftParen - 64)) | (1 << (CPP14Parser.LeftBracket - 64)) | (1 << (CPP14Parser.Star - 64)) | (1 << (CPP14Parser.And - 64)) | (1 << (CPP14Parser.Tilde - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (CPP14Parser.Doublecolon - 128)) | (1 << (CPP14Parser.Semi - 128)) | (1 << (CPP14Parser.Ellipsis - 128)) | (1 << (CPP14Parser.Identifier - 128)))) != 0):
self.state = 1530
self.declarationseq(0)
self.state = 1533
self.match(CPP14Parser.RightBrace)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1534
self.match(CPP14Parser.Extern)
self.state = 1535
self.match(CPP14Parser.Stringliteral)
self.state = 1536
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
[docs]
class AttributespecifierseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def attributespecifier(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_attributespecifierseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttributespecifierseq" ):
listener.enterAttributespecifierseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttributespecifierseq" ):
listener.exitAttributespecifierseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttributespecifierseq" ):
return visitor.visitAttributespecifierseq(self)
else:
return visitor.visitChildren(self)
[docs]
def attributespecifierseq(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.AttributespecifierseqContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 212
self.enterRecursionRule(localctx, 212, self.RULE_attributespecifierseq, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1540
self.attributespecifier()
self._ctx.stop = self._input.LT(-1)
self.state = 1546
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,153,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.AttributespecifierseqContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_attributespecifierseq)
self.state = 1542
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1543
self.attributespecifier()
self.state = 1548
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,153,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AttributespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftBracket(self, i:int=None):
if i is None:
return self.getTokens(CPP14Parser.LeftBracket)
else:
return self.getToken(CPP14Parser.LeftBracket, i)
[docs]
def attributelist(self):
return self.getTypedRuleContext(CPP14Parser.AttributelistContext,0)
[docs]
def RightBracket(self, i:int=None):
if i is None:
return self.getTokens(CPP14Parser.RightBracket)
else:
return self.getToken(CPP14Parser.RightBracket, i)
[docs]
def alignmentspecifier(self):
return self.getTypedRuleContext(CPP14Parser.AlignmentspecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_attributespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttributespecifier" ):
listener.enterAttributespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttributespecifier" ):
listener.exitAttributespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttributespecifier" ):
return visitor.visitAttributespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def attributespecifier(self):
localctx = CPP14Parser.AttributespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 214, self.RULE_attributespecifier)
try:
self.state = 1556
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.LeftBracket]:
self.enterOuterAlt(localctx, 1)
self.state = 1549
self.match(CPP14Parser.LeftBracket)
self.state = 1550
self.match(CPP14Parser.LeftBracket)
self.state = 1551
self.attributelist(0)
self.state = 1552
self.match(CPP14Parser.RightBracket)
self.state = 1553
self.match(CPP14Parser.RightBracket)
pass
elif token in [CPP14Parser.Alignas]:
self.enterOuterAlt(localctx, 2)
self.state = 1555
self.alignmentspecifier()
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
[docs]
class AlignmentspecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Alignas(self):
return self.getToken(CPP14Parser.Alignas, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def thetypeid(self):
return self.getTypedRuleContext(CPP14Parser.ThetypeidContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_alignmentspecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAlignmentspecifier" ):
listener.enterAlignmentspecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAlignmentspecifier" ):
listener.exitAlignmentspecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAlignmentspecifier" ):
return visitor.visitAlignmentspecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def alignmentspecifier(self):
localctx = CPP14Parser.AlignmentspecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 216, self.RULE_alignmentspecifier)
self._la = 0 # Token type
try:
self.state = 1574
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,157,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1558
self.match(CPP14Parser.Alignas)
self.state = 1559
self.match(CPP14Parser.LeftParen)
self.state = 1560
self.thetypeid()
self.state = 1562
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Ellipsis:
self.state = 1561
self.match(CPP14Parser.Ellipsis)
self.state = 1564
self.match(CPP14Parser.RightParen)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1566
self.match(CPP14Parser.Alignas)
self.state = 1567
self.match(CPP14Parser.LeftParen)
self.state = 1568
self.constantexpression()
self.state = 1570
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Ellipsis:
self.state = 1569
self.match(CPP14Parser.Ellipsis)
self.state = 1572
self.match(CPP14Parser.RightParen)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AttributelistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def attribute(self):
return self.getTypedRuleContext(CPP14Parser.AttributeContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def attributelist(self):
return self.getTypedRuleContext(CPP14Parser.AttributelistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_attributelist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttributelist" ):
listener.enterAttributelist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttributelist" ):
listener.exitAttributelist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttributelist" ):
return visitor.visitAttributelist(self)
else:
return visitor.visitChildren(self)
[docs]
def attributelist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.AttributelistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 218
self.enterRecursionRule(localctx, 218, self.RULE_attributelist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1583
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
if la_ == 1:
self.state = 1578
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
if la_ == 1:
self.state = 1577
self.attribute()
pass
elif la_ == 2:
self.state = 1580
self.attribute()
self.state = 1581
self.match(CPP14Parser.Ellipsis)
pass
self._ctx.stop = self._input.LT(-1)
self.state = 1597
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,162,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 1595
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,161,self._ctx)
if la_ == 1:
localctx = CPP14Parser.AttributelistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_attributelist)
self.state = 1585
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 1586
self.match(CPP14Parser.Comma)
self.state = 1588
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
if la_ == 1:
self.state = 1587
self.attribute()
pass
elif la_ == 2:
localctx = CPP14Parser.AttributelistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_attributelist)
self.state = 1590
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1591
self.match(CPP14Parser.Comma)
self.state = 1592
self.attribute()
self.state = 1593
self.match(CPP14Parser.Ellipsis)
pass
self.state = 1599
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,162,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AttributeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def attributetoken(self):
return self.getTypedRuleContext(CPP14Parser.AttributetokenContext,0)
[docs]
def attributeargumentclause(self):
return self.getTypedRuleContext(CPP14Parser.AttributeargumentclauseContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_attribute
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttribute" ):
listener.enterAttribute(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttribute" ):
listener.exitAttribute(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttribute" ):
return visitor.visitAttribute(self)
else:
return visitor.visitChildren(self)
[docs]
def attribute(self):
localctx = CPP14Parser.AttributeContext(self, self._ctx, self.state)
self.enterRule(localctx, 220, self.RULE_attribute)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1600
self.attributetoken()
self.state = 1602
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,163,self._ctx)
if la_ == 1:
self.state = 1601
self.attributeargumentclause()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AttributetokenContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def attributescopedtoken(self):
return self.getTypedRuleContext(CPP14Parser.AttributescopedtokenContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_attributetoken
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttributetoken" ):
listener.enterAttributetoken(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttributetoken" ):
listener.exitAttributetoken(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttributetoken" ):
return visitor.visitAttributetoken(self)
else:
return visitor.visitChildren(self)
[docs]
def attributetoken(self):
localctx = CPP14Parser.AttributetokenContext(self, self._ctx, self.state)
self.enterRule(localctx, 222, self.RULE_attributetoken)
try:
self.state = 1606
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1604
self.match(CPP14Parser.Identifier)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1605
self.attributescopedtoken()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AttributescopedtokenContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def attributenamespace(self):
return self.getTypedRuleContext(CPP14Parser.AttributenamespaceContext,0)
[docs]
def Doublecolon(self):
return self.getToken(CPP14Parser.Doublecolon, 0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_attributescopedtoken
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttributescopedtoken" ):
listener.enterAttributescopedtoken(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttributescopedtoken" ):
listener.exitAttributescopedtoken(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttributescopedtoken" ):
return visitor.visitAttributescopedtoken(self)
else:
return visitor.visitChildren(self)
[docs]
def attributescopedtoken(self):
localctx = CPP14Parser.AttributescopedtokenContext(self, self._ctx, self.state)
self.enterRule(localctx, 224, self.RULE_attributescopedtoken)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1608
self.attributenamespace()
self.state = 1609
self.match(CPP14Parser.Doublecolon)
self.state = 1610
self.match(CPP14Parser.Identifier)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AttributenamespaceContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_attributenamespace
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttributenamespace" ):
listener.enterAttributenamespace(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttributenamespace" ):
listener.exitAttributenamespace(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttributenamespace" ):
return visitor.visitAttributenamespace(self)
else:
return visitor.visitChildren(self)
[docs]
def attributenamespace(self):
localctx = CPP14Parser.AttributenamespaceContext(self, self._ctx, self.state)
self.enterRule(localctx, 226, self.RULE_attributenamespace)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1612
self.match(CPP14Parser.Identifier)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AttributeargumentclauseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def balancedtokenseq(self):
return self.getTypedRuleContext(CPP14Parser.BalancedtokenseqContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_attributeargumentclause
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAttributeargumentclause" ):
listener.enterAttributeargumentclause(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAttributeargumentclause" ):
listener.exitAttributeargumentclause(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAttributeargumentclause" ):
return visitor.visitAttributeargumentclause(self)
else:
return visitor.visitChildren(self)
[docs]
def attributeargumentclause(self):
localctx = CPP14Parser.AttributeargumentclauseContext(self, self._ctx, self.state)
self.enterRule(localctx, 228, self.RULE_attributeargumentclause)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1614
self.match(CPP14Parser.LeftParen)
self.state = 1615
self.balancedtokenseq(0)
self.state = 1616
self.match(CPP14Parser.RightParen)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BalancedtokenseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def balancedtoken(self):
return self.getTypedRuleContext(CPP14Parser.BalancedtokenContext,0)
[docs]
def balancedtokenseq(self):
return self.getTypedRuleContext(CPP14Parser.BalancedtokenseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_balancedtokenseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBalancedtokenseq" ):
listener.enterBalancedtokenseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBalancedtokenseq" ):
listener.exitBalancedtokenseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBalancedtokenseq" ):
return visitor.visitBalancedtokenseq(self)
else:
return visitor.visitChildren(self)
[docs]
def balancedtokenseq(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.BalancedtokenseqContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 230
self.enterRecursionRule(localctx, 230, self.RULE_balancedtokenseq, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1620
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
if la_ == 1:
self.state = 1619
self.balancedtoken()
self._ctx.stop = self._input.LT(-1)
self.state = 1626
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,166,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.BalancedtokenseqContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_balancedtokenseq)
self.state = 1622
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1623
self.balancedtoken()
self.state = 1628
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,166,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class BalancedtokenContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftParen(self, i:int=None):
if i is None:
return self.getTokens(CPP14Parser.LeftParen)
else:
return self.getToken(CPP14Parser.LeftParen, i)
[docs]
def balancedtokenseq(self):
return self.getTypedRuleContext(CPP14Parser.BalancedtokenseqContext,0)
[docs]
def RightParen(self, i:int=None):
if i is None:
return self.getTokens(CPP14Parser.RightParen)
else:
return self.getToken(CPP14Parser.RightParen, i)
[docs]
def LeftBracket(self, i:int=None):
if i is None:
return self.getTokens(CPP14Parser.LeftBracket)
else:
return self.getToken(CPP14Parser.LeftBracket, i)
[docs]
def RightBracket(self, i:int=None):
if i is None:
return self.getTokens(CPP14Parser.RightBracket)
else:
return self.getToken(CPP14Parser.RightBracket, i)
[docs]
def LeftBrace(self, i:int=None):
if i is None:
return self.getTokens(CPP14Parser.LeftBrace)
else:
return self.getToken(CPP14Parser.LeftBrace, i)
[docs]
def RightBrace(self, i:int=None):
if i is None:
return self.getTokens(CPP14Parser.RightBrace)
else:
return self.getToken(CPP14Parser.RightBrace, i)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_balancedtoken
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBalancedtoken" ):
listener.enterBalancedtoken(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBalancedtoken" ):
listener.exitBalancedtoken(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBalancedtoken" ):
return visitor.visitBalancedtoken(self)
else:
return visitor.visitChildren(self)
[docs]
def balancedtoken(self):
localctx = CPP14Parser.BalancedtokenContext(self, self._ctx, self.state)
self.enterRule(localctx, 232, self.RULE_balancedtoken)
self._la = 0 # Token type
try:
self.state = 1646
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.LeftParen]:
self.enterOuterAlt(localctx, 1)
self.state = 1629
self.match(CPP14Parser.LeftParen)
self.state = 1630
self.balancedtokenseq(0)
self.state = 1631
self.match(CPP14Parser.RightParen)
pass
elif token in [CPP14Parser.LeftBracket]:
self.enterOuterAlt(localctx, 2)
self.state = 1633
self.match(CPP14Parser.LeftBracket)
self.state = 1634
self.balancedtokenseq(0)
self.state = 1635
self.match(CPP14Parser.RightBracket)
pass
elif token in [CPP14Parser.LeftBrace]:
self.enterOuterAlt(localctx, 3)
self.state = 1637
self.match(CPP14Parser.LeftBrace)
self.state = 1638
self.balancedtokenseq(0)
self.state = 1639
self.match(CPP14Parser.RightBrace)
pass
elif token in [CPP14Parser.T__0, CPP14Parser.T__1, CPP14Parser.T__2, CPP14Parser.T__3, CPP14Parser.T__4, CPP14Parser.T__5, CPP14Parser.T__6, CPP14Parser.T__7, CPP14Parser.MultiLineMacro, CPP14Parser.Directive, CPP14Parser.Alignas, CPP14Parser.Alignof, CPP14Parser.Asm, CPP14Parser.Auto, CPP14Parser.Bool, CPP14Parser.Break, CPP14Parser.Case, CPP14Parser.Catch, CPP14Parser.Char, CPP14Parser.Char16, CPP14Parser.Char32, CPP14Parser.Class, CPP14Parser.Const, CPP14Parser.Constexpr, CPP14Parser.Const_cast, CPP14Parser.Continue, CPP14Parser.Decltype, CPP14Parser.Default, CPP14Parser.Delete, CPP14Parser.Do, CPP14Parser.Double, CPP14Parser.Dynamic_cast, CPP14Parser.Else, CPP14Parser.Enum, CPP14Parser.Explicit, CPP14Parser.Export, CPP14Parser.Extern, CPP14Parser.Final, CPP14Parser.Float, CPP14Parser.For, CPP14Parser.Friend, CPP14Parser.Goto, CPP14Parser.If, CPP14Parser.Inline, CPP14Parser.Int, CPP14Parser.Long, CPP14Parser.Mutable, CPP14Parser.Namespace, CPP14Parser.New, CPP14Parser.Noexcept, CPP14Parser.Nullptr, CPP14Parser.Operator, CPP14Parser.Override, CPP14Parser.Private, CPP14Parser.Protected, CPP14Parser.Public, CPP14Parser.Register, CPP14Parser.Reinterpret_cast, CPP14Parser.Return, CPP14Parser.Short, CPP14Parser.Signed, CPP14Parser.Sizeof, CPP14Parser.Static, CPP14Parser.Static_assert, CPP14Parser.Static_cast, CPP14Parser.Struct, CPP14Parser.Switch, CPP14Parser.Template, CPP14Parser.This, CPP14Parser.Thread_local, CPP14Parser.Throw, CPP14Parser.Try, CPP14Parser.Typedef, CPP14Parser.Typeid_, CPP14Parser.Typename_, CPP14Parser.Union, CPP14Parser.Unsigned, CPP14Parser.Using, CPP14Parser.Virtual, CPP14Parser.Void, CPP14Parser.Volatile, CPP14Parser.Wchar, CPP14Parser.While, CPP14Parser.Plus, CPP14Parser.Minus, CPP14Parser.Star, CPP14Parser.Div, CPP14Parser.Mod, CPP14Parser.Caret, CPP14Parser.And, CPP14Parser.Or, CPP14Parser.Tilde, CPP14Parser.Not, CPP14Parser.Assign, CPP14Parser.Less, CPP14Parser.Greater, CPP14Parser.PlusAssign, CPP14Parser.MinusAssign, CPP14Parser.StarAssign, CPP14Parser.DivAssign, CPP14Parser.ModAssign, CPP14Parser.XorAssign, CPP14Parser.AndAssign, CPP14Parser.OrAssign, CPP14Parser.LeftShift, CPP14Parser.RightShift, CPP14Parser.LeftShiftAssign, CPP14Parser.RightShiftAssign, CPP14Parser.Equal, CPP14Parser.NotEqual, CPP14Parser.LessEqual, CPP14Parser.GreaterEqual, CPP14Parser.AndAnd, CPP14Parser.OrOr, CPP14Parser.PlusPlus, CPP14Parser.MinusMinus, CPP14Parser.Comma, CPP14Parser.ArrowStar, CPP14Parser.Arrow, CPP14Parser.Question, CPP14Parser.Colon, CPP14Parser.Doublecolon, CPP14Parser.Semi, CPP14Parser.Dot, CPP14Parser.DotStar, CPP14Parser.Ellipsis, CPP14Parser.Identifier, CPP14Parser.Integerliteral, CPP14Parser.Decimalliteral, CPP14Parser.Octalliteral, CPP14Parser.Hexadecimalliteral, CPP14Parser.Binaryliteral, CPP14Parser.Integersuffix, CPP14Parser.Characterliteral, CPP14Parser.Floatingliteral, CPP14Parser.Stringliteral, CPP14Parser.Userdefinedintegerliteral, CPP14Parser.Userdefinedfloatingliteral, CPP14Parser.Userdefinedstringliteral, CPP14Parser.Userdefinedcharacterliteral, CPP14Parser.Whitespace, CPP14Parser.Newline, CPP14Parser.BlockComment, CPP14Parser.LineComment]:
self.enterOuterAlt(localctx, 4)
self.state = 1642
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 1641
_la = self._input.LA(1)
if _la <= 0 or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (CPP14Parser.LeftParen - 84)) | (1 << (CPP14Parser.RightParen - 84)) | (1 << (CPP14Parser.LeftBracket - 84)) | (1 << (CPP14Parser.RightBracket - 84)) | (1 << (CPP14Parser.LeftBrace - 84)) | (1 << (CPP14Parser.RightBrace - 84)))) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
else:
raise NoViableAltException(self)
self.state = 1644
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,167,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
[docs]
class InitdeclaratorlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def initdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.InitdeclaratorContext,0)
[docs]
def initdeclaratorlist(self):
return self.getTypedRuleContext(CPP14Parser.InitdeclaratorlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_initdeclaratorlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInitdeclaratorlist" ):
listener.enterInitdeclaratorlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInitdeclaratorlist" ):
listener.exitInitdeclaratorlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInitdeclaratorlist" ):
return visitor.visitInitdeclaratorlist(self)
else:
return visitor.visitChildren(self)
[docs]
def initdeclaratorlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.InitdeclaratorlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 234
self.enterRecursionRule(localctx, 234, self.RULE_initdeclaratorlist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1649
self.initdeclarator()
self._ctx.stop = self._input.LT(-1)
self.state = 1656
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,169,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.InitdeclaratorlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_initdeclaratorlist)
self.state = 1651
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1652
self.match(CPP14Parser.Comma)
self.state = 1653
self.initdeclarator()
self.state = 1658
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,169,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class InitdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def declarator(self):
return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)
[docs]
def initializer(self):
return self.getTypedRuleContext(CPP14Parser.InitializerContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_initdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInitdeclarator" ):
listener.enterInitdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInitdeclarator" ):
listener.exitInitdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInitdeclarator" ):
return visitor.visitInitdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def initdeclarator(self):
localctx = CPP14Parser.InitdeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 236, self.RULE_initdeclarator)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1659
self.declarator()
self.state = 1661
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,170,self._ctx)
if la_ == 1:
self.state = 1660
self.initializer()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ptrdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.PtrdeclaratorContext,0)
[docs]
def noptrdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrdeclaratorContext,0)
[docs]
def parametersandqualifiers(self):
return self.getTypedRuleContext(CPP14Parser.ParametersandqualifiersContext,0)
[docs]
def trailingreturntype(self):
return self.getTypedRuleContext(CPP14Parser.TrailingreturntypeContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_declarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclarator" ):
listener.enterDeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclarator" ):
listener.exitDeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeclarator" ):
return visitor.visitDeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def declarator(self):
localctx = CPP14Parser.DeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 238, self.RULE_declarator)
try:
self.state = 1668
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1663
self.ptrdeclarator()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1664
self.noptrdeclarator(0)
self.state = 1665
self.parametersandqualifiers()
self.state = 1666
self.trailingreturntype()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PtrdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def noptrdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrdeclaratorContext,0)
[docs]
def ptroperator(self):
return self.getTypedRuleContext(CPP14Parser.PtroperatorContext,0)
[docs]
def ptrdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.PtrdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_ptrdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPtrdeclarator" ):
listener.enterPtrdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPtrdeclarator" ):
listener.exitPtrdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPtrdeclarator" ):
return visitor.visitPtrdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def ptrdeclarator(self):
localctx = CPP14Parser.PtrdeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 240, self.RULE_ptrdeclarator)
try:
self.state = 1674
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,172,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1670
self.noptrdeclarator(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1671
self.ptroperator()
self.state = 1672
self.ptrdeclarator()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NoptrdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def declaratorid(self):
return self.getTypedRuleContext(CPP14Parser.DeclaratoridContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def ptrdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.PtrdeclaratorContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def noptrdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrdeclaratorContext,0)
[docs]
def parametersandqualifiers(self):
return self.getTypedRuleContext(CPP14Parser.ParametersandqualifiersContext,0)
[docs]
def LeftBracket(self):
return self.getToken(CPP14Parser.LeftBracket, 0)
[docs]
def RightBracket(self):
return self.getToken(CPP14Parser.RightBracket, 0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_noptrdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNoptrdeclarator" ):
listener.enterNoptrdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNoptrdeclarator" ):
listener.exitNoptrdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNoptrdeclarator" ):
return visitor.visitNoptrdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def noptrdeclarator(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.NoptrdeclaratorContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 242
self.enterRecursionRule(localctx, 242, self.RULE_noptrdeclarator, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1685
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Decltype, CPP14Parser.Operator, CPP14Parser.Tilde, CPP14Parser.Doublecolon, CPP14Parser.Ellipsis, CPP14Parser.Identifier]:
self.state = 1677
self.declaratorid()
self.state = 1679
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
if la_ == 1:
self.state = 1678
self.attributespecifierseq(0)
pass
elif token in [CPP14Parser.LeftParen]:
self.state = 1681
self.match(CPP14Parser.LeftParen)
self.state = 1682
self.ptrdeclarator()
self.state = 1683
self.match(CPP14Parser.RightParen)
pass
else:
raise NoViableAltException(self)
self._ctx.stop = self._input.LT(-1)
self.state = 1700
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,178,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 1698
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,177,self._ctx)
if la_ == 1:
localctx = CPP14Parser.NoptrdeclaratorContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_noptrdeclarator)
self.state = 1687
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 1688
self.parametersandqualifiers()
pass
elif la_ == 2:
localctx = CPP14Parser.NoptrdeclaratorContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_noptrdeclarator)
self.state = 1689
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 1690
self.match(CPP14Parser.LeftBracket)
self.state = 1692
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 1691
self.constantexpression()
self.state = 1694
self.match(CPP14Parser.RightBracket)
self.state = 1696
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,176,self._ctx)
if la_ == 1:
self.state = 1695
self.attributespecifierseq(0)
pass
self.state = 1702
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,178,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ParametersandqualifiersContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def parameterdeclarationclause(self):
return self.getTypedRuleContext(CPP14Parser.ParameterdeclarationclauseContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def cvqualifierseq(self):
return self.getTypedRuleContext(CPP14Parser.CvqualifierseqContext,0)
[docs]
def refqualifier(self):
return self.getTypedRuleContext(CPP14Parser.RefqualifierContext,0)
[docs]
def exceptionspecification(self):
return self.getTypedRuleContext(CPP14Parser.ExceptionspecificationContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_parametersandqualifiers
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParametersandqualifiers" ):
listener.enterParametersandqualifiers(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParametersandqualifiers" ):
listener.exitParametersandqualifiers(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParametersandqualifiers" ):
return visitor.visitParametersandqualifiers(self)
else:
return visitor.visitChildren(self)
[docs]
def parametersandqualifiers(self):
localctx = CPP14Parser.ParametersandqualifiersContext(self, self._ctx, self.state)
self.enterRule(localctx, 244, self.RULE_parametersandqualifiers)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1703
self.match(CPP14Parser.LeftParen)
self.state = 1704
self.parameterdeclarationclause()
self.state = 1705
self.match(CPP14Parser.RightParen)
self.state = 1707
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
if la_ == 1:
self.state = 1706
self.cvqualifierseq()
self.state = 1710
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
if la_ == 1:
self.state = 1709
self.refqualifier()
self.state = 1713
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
if la_ == 1:
self.state = 1712
self.exceptionspecification()
self.state = 1716
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
if la_ == 1:
self.state = 1715
self.attributespecifierseq(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TrailingreturntypeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Arrow(self):
return self.getToken(CPP14Parser.Arrow, 0)
[docs]
def trailingtypespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.TrailingtypespecifierseqContext,0)
[docs]
def abstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.AbstractdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_trailingreturntype
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTrailingreturntype" ):
listener.enterTrailingreturntype(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTrailingreturntype" ):
listener.exitTrailingreturntype(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTrailingreturntype" ):
return visitor.visitTrailingreturntype(self)
else:
return visitor.visitChildren(self)
[docs]
def trailingreturntype(self):
localctx = CPP14Parser.TrailingreturntypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 246, self.RULE_trailingreturntype)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1718
self.match(CPP14Parser.Arrow)
self.state = 1719
self.trailingtypespecifierseq()
self.state = 1721
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,183,self._ctx)
if la_ == 1:
self.state = 1720
self.abstractdeclarator()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PtroperatorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Star(self):
return self.getToken(CPP14Parser.Star, 0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def cvqualifierseq(self):
return self.getTypedRuleContext(CPP14Parser.CvqualifierseqContext,0)
[docs]
def And(self):
return self.getToken(CPP14Parser.And, 0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_ptroperator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPtroperator" ):
listener.enterPtroperator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPtroperator" ):
listener.exitPtroperator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPtroperator" ):
return visitor.visitPtroperator(self)
else:
return visitor.visitChildren(self)
[docs]
def ptroperator(self):
localctx = CPP14Parser.PtroperatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 248, self.RULE_ptroperator)
try:
self.state = 1746
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Star]:
self.enterOuterAlt(localctx, 1)
self.state = 1723
self.match(CPP14Parser.Star)
self.state = 1725
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,184,self._ctx)
if la_ == 1:
self.state = 1724
self.attributespecifierseq(0)
self.state = 1728
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
if la_ == 1:
self.state = 1727
self.cvqualifierseq()
pass
elif token in [CPP14Parser.And]:
self.enterOuterAlt(localctx, 2)
self.state = 1730
self.match(CPP14Parser.And)
self.state = 1732
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
if la_ == 1:
self.state = 1731
self.attributespecifierseq(0)
pass
elif token in [CPP14Parser.T__2]:
self.enterOuterAlt(localctx, 3)
self.state = 1734
self.match(CPP14Parser.T__2)
self.state = 1736
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,187,self._ctx)
if la_ == 1:
self.state = 1735
self.attributespecifierseq(0)
pass
elif token in [CPP14Parser.Decltype, CPP14Parser.Doublecolon, CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 4)
self.state = 1738
self.nestednamespecifier(0)
self.state = 1739
self.match(CPP14Parser.Star)
self.state = 1741
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,188,self._ctx)
if la_ == 1:
self.state = 1740
self.attributespecifierseq(0)
self.state = 1744
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,189,self._ctx)
if la_ == 1:
self.state = 1743
self.cvqualifierseq()
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
[docs]
class CvqualifierseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def cvqualifier(self):
return self.getTypedRuleContext(CPP14Parser.CvqualifierContext,0)
[docs]
def cvqualifierseq(self):
return self.getTypedRuleContext(CPP14Parser.CvqualifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_cvqualifierseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCvqualifierseq" ):
listener.enterCvqualifierseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCvqualifierseq" ):
listener.exitCvqualifierseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCvqualifierseq" ):
return visitor.visitCvqualifierseq(self)
else:
return visitor.visitChildren(self)
[docs]
def cvqualifierseq(self):
localctx = CPP14Parser.CvqualifierseqContext(self, self._ctx, self.state)
self.enterRule(localctx, 250, self.RULE_cvqualifierseq)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1748
self.cvqualifier()
self.state = 1750
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
if la_ == 1:
self.state = 1749
self.cvqualifierseq()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CvqualifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Const(self):
return self.getToken(CPP14Parser.Const, 0)
[docs]
def Volatile(self):
return self.getToken(CPP14Parser.Volatile, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_cvqualifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCvqualifier" ):
listener.enterCvqualifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCvqualifier" ):
listener.exitCvqualifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCvqualifier" ):
return visitor.visitCvqualifier(self)
else:
return visitor.visitChildren(self)
[docs]
def cvqualifier(self):
localctx = CPP14Parser.CvqualifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 252, self.RULE_cvqualifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1752
_la = self._input.LA(1)
if not(_la==CPP14Parser.Const or _la==CPP14Parser.Volatile):
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
[docs]
class RefqualifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def And(self):
return self.getToken(CPP14Parser.And, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_refqualifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRefqualifier" ):
listener.enterRefqualifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRefqualifier" ):
listener.exitRefqualifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRefqualifier" ):
return visitor.visitRefqualifier(self)
else:
return visitor.visitChildren(self)
[docs]
def refqualifier(self):
localctx = CPP14Parser.RefqualifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 254, self.RULE_refqualifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1754
_la = self._input.LA(1)
if not(_la==CPP14Parser.T__2 or _la==CPP14Parser.And):
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
[docs]
class DeclaratoridContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def idexpression(self):
return self.getTypedRuleContext(CPP14Parser.IdexpressionContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_declaratorid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclaratorid" ):
listener.enterDeclaratorid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclaratorid" ):
listener.exitDeclaratorid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDeclaratorid" ):
return visitor.visitDeclaratorid(self)
else:
return visitor.visitChildren(self)
[docs]
def declaratorid(self):
localctx = CPP14Parser.DeclaratoridContext(self, self._ctx, self.state)
self.enterRule(localctx, 256, self.RULE_declaratorid)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1757
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Ellipsis:
self.state = 1756
self.match(CPP14Parser.Ellipsis)
self.state = 1759
self.idexpression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ThetypeidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.TypespecifierseqContext,0)
[docs]
def abstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.AbstractdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_thetypeid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterThetypeid" ):
listener.enterThetypeid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitThetypeid" ):
listener.exitThetypeid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitThetypeid" ):
return visitor.visitThetypeid(self)
else:
return visitor.visitChildren(self)
[docs]
def thetypeid(self):
localctx = CPP14Parser.ThetypeidContext(self, self._ctx, self.state)
self.enterRule(localctx, 258, self.RULE_thetypeid)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1761
self.typespecifierseq()
self.state = 1763
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,193,self._ctx)
if la_ == 1:
self.state = 1762
self.abstractdeclarator()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AbstractdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ptrabstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.PtrabstractdeclaratorContext,0)
[docs]
def parametersandqualifiers(self):
return self.getTypedRuleContext(CPP14Parser.ParametersandqualifiersContext,0)
[docs]
def trailingreturntype(self):
return self.getTypedRuleContext(CPP14Parser.TrailingreturntypeContext,0)
[docs]
def noptrabstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrabstractdeclaratorContext,0)
[docs]
def abstractpackdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.AbstractpackdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_abstractdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAbstractdeclarator" ):
listener.enterAbstractdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAbstractdeclarator" ):
listener.exitAbstractdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAbstractdeclarator" ):
return visitor.visitAbstractdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def abstractdeclarator(self):
localctx = CPP14Parser.AbstractdeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 260, self.RULE_abstractdeclarator)
try:
self.state = 1773
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1765
self.ptrabstractdeclarator()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1767
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
if la_ == 1:
self.state = 1766
self.noptrabstractdeclarator(0)
self.state = 1769
self.parametersandqualifiers()
self.state = 1770
self.trailingreturntype()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1772
self.abstractpackdeclarator()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PtrabstractdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def noptrabstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrabstractdeclaratorContext,0)
[docs]
def ptroperator(self):
return self.getTypedRuleContext(CPP14Parser.PtroperatorContext,0)
[docs]
def ptrabstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.PtrabstractdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_ptrabstractdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPtrabstractdeclarator" ):
listener.enterPtrabstractdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPtrabstractdeclarator" ):
listener.exitPtrabstractdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPtrabstractdeclarator" ):
return visitor.visitPtrabstractdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def ptrabstractdeclarator(self):
localctx = CPP14Parser.PtrabstractdeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 262, self.RULE_ptrabstractdeclarator)
try:
self.state = 1780
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.LeftParen, CPP14Parser.LeftBracket]:
self.enterOuterAlt(localctx, 1)
self.state = 1775
self.noptrabstractdeclarator(0)
pass
elif token in [CPP14Parser.T__2, CPP14Parser.Decltype, CPP14Parser.Star, CPP14Parser.And, CPP14Parser.Doublecolon, CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 2)
self.state = 1776
self.ptroperator()
self.state = 1778
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
if la_ == 1:
self.state = 1777
self.ptrabstractdeclarator()
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
[docs]
class NoptrabstractdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def parametersandqualifiers(self):
return self.getTypedRuleContext(CPP14Parser.ParametersandqualifiersContext,0)
[docs]
def LeftBracket(self):
return self.getToken(CPP14Parser.LeftBracket, 0)
[docs]
def RightBracket(self):
return self.getToken(CPP14Parser.RightBracket, 0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def ptrabstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.PtrabstractdeclaratorContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def noptrabstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrabstractdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_noptrabstractdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNoptrabstractdeclarator" ):
listener.enterNoptrabstractdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNoptrabstractdeclarator" ):
listener.exitNoptrabstractdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNoptrabstractdeclarator" ):
return visitor.visitNoptrabstractdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def noptrabstractdeclarator(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.NoptrabstractdeclaratorContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 264
self.enterRecursionRule(localctx, 264, self.RULE_noptrabstractdeclarator, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1796
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
if la_ == 1:
self.state = 1783
self.parametersandqualifiers()
pass
elif la_ == 2:
self.state = 1784
self.match(CPP14Parser.LeftBracket)
self.state = 1786
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 1785
self.constantexpression()
self.state = 1788
self.match(CPP14Parser.RightBracket)
self.state = 1790
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
if la_ == 1:
self.state = 1789
self.attributespecifierseq(0)
pass
elif la_ == 3:
self.state = 1792
self.match(CPP14Parser.LeftParen)
self.state = 1793
self.ptrabstractdeclarator()
self.state = 1794
self.match(CPP14Parser.RightParen)
pass
self._ctx.stop = self._input.LT(-1)
self.state = 1811
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,204,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 1809
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
if la_ == 1:
localctx = CPP14Parser.NoptrabstractdeclaratorContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_noptrabstractdeclarator)
self.state = 1798
if not self.precpred(self._ctx, 5):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
self.state = 1799
self.parametersandqualifiers()
pass
elif la_ == 2:
localctx = CPP14Parser.NoptrabstractdeclaratorContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_noptrabstractdeclarator)
self.state = 1800
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 1801
self.match(CPP14Parser.LeftBracket)
self.state = 1803
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 1802
self.constantexpression()
self.state = 1805
self.match(CPP14Parser.RightBracket)
self.state = 1807
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,202,self._ctx)
if la_ == 1:
self.state = 1806
self.attributespecifierseq(0)
pass
self.state = 1813
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,204,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AbstractpackdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def noptrabstractpackdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrabstractpackdeclaratorContext,0)
[docs]
def ptroperator(self):
return self.getTypedRuleContext(CPP14Parser.PtroperatorContext,0)
[docs]
def abstractpackdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.AbstractpackdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_abstractpackdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAbstractpackdeclarator" ):
listener.enterAbstractpackdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAbstractpackdeclarator" ):
listener.exitAbstractpackdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAbstractpackdeclarator" ):
return visitor.visitAbstractpackdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def abstractpackdeclarator(self):
localctx = CPP14Parser.AbstractpackdeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 266, self.RULE_abstractpackdeclarator)
try:
self.state = 1818
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Ellipsis]:
self.enterOuterAlt(localctx, 1)
self.state = 1814
self.noptrabstractpackdeclarator(0)
pass
elif token in [CPP14Parser.T__2, CPP14Parser.Decltype, CPP14Parser.Star, CPP14Parser.And, CPP14Parser.Doublecolon, CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 2)
self.state = 1815
self.ptroperator()
self.state = 1816
self.abstractpackdeclarator()
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
[docs]
class NoptrabstractpackdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def noptrabstractpackdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.NoptrabstractpackdeclaratorContext,0)
[docs]
def parametersandqualifiers(self):
return self.getTypedRuleContext(CPP14Parser.ParametersandqualifiersContext,0)
[docs]
def LeftBracket(self):
return self.getToken(CPP14Parser.LeftBracket, 0)
[docs]
def RightBracket(self):
return self.getToken(CPP14Parser.RightBracket, 0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_noptrabstractpackdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNoptrabstractpackdeclarator" ):
listener.enterNoptrabstractpackdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNoptrabstractpackdeclarator" ):
listener.exitNoptrabstractpackdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNoptrabstractpackdeclarator" ):
return visitor.visitNoptrabstractpackdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def noptrabstractpackdeclarator(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.NoptrabstractpackdeclaratorContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 268
self.enterRecursionRule(localctx, 268, self.RULE_noptrabstractpackdeclarator, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1821
self.match(CPP14Parser.Ellipsis)
self._ctx.stop = self._input.LT(-1)
self.state = 1836
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,209,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 1834
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
if la_ == 1:
localctx = CPP14Parser.NoptrabstractpackdeclaratorContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_noptrabstractpackdeclarator)
self.state = 1823
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 1824
self.parametersandqualifiers()
pass
elif la_ == 2:
localctx = CPP14Parser.NoptrabstractpackdeclaratorContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_noptrabstractpackdeclarator)
self.state = 1825
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 1826
self.match(CPP14Parser.LeftBracket)
self.state = 1828
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 1827
self.constantexpression()
self.state = 1830
self.match(CPP14Parser.RightBracket)
self.state = 1832
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,207,self._ctx)
if la_ == 1:
self.state = 1831
self.attributespecifierseq(0)
pass
self.state = 1838
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,209,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ParameterdeclarationclauseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def parameterdeclarationlist(self):
return self.getTypedRuleContext(CPP14Parser.ParameterdeclarationlistContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_parameterdeclarationclause
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParameterdeclarationclause" ):
listener.enterParameterdeclarationclause(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParameterdeclarationclause" ):
listener.exitParameterdeclarationclause(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParameterdeclarationclause" ):
return visitor.visitParameterdeclarationclause(self)
else:
return visitor.visitChildren(self)
[docs]
def parameterdeclarationclause(self):
localctx = CPP14Parser.ParameterdeclarationclauseContext(self, self._ctx, self.state)
self.enterRule(localctx, 270, self.RULE_parameterdeclarationclause)
self._la = 0 # Token type
try:
self.state = 1849
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1840
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & ((1 << (CPP14Parser.Alignas - 11)) | (1 << (CPP14Parser.Auto - 11)) | (1 << (CPP14Parser.Bool - 11)) | (1 << (CPP14Parser.Char - 11)) | (1 << (CPP14Parser.Char16 - 11)) | (1 << (CPP14Parser.Char32 - 11)) | (1 << (CPP14Parser.Class - 11)) | (1 << (CPP14Parser.Const - 11)) | (1 << (CPP14Parser.Constexpr - 11)) | (1 << (CPP14Parser.Decltype - 11)) | (1 << (CPP14Parser.Double - 11)) | (1 << (CPP14Parser.Enum - 11)) | (1 << (CPP14Parser.Explicit - 11)) | (1 << (CPP14Parser.Extern - 11)) | (1 << (CPP14Parser.Float - 11)) | (1 << (CPP14Parser.Friend - 11)) | (1 << (CPP14Parser.Inline - 11)) | (1 << (CPP14Parser.Int - 11)) | (1 << (CPP14Parser.Long - 11)) | (1 << (CPP14Parser.Mutable - 11)) | (1 << (CPP14Parser.Register - 11)) | (1 << (CPP14Parser.Short - 11)) | (1 << (CPP14Parser.Signed - 11)) | (1 << (CPP14Parser.Static - 11)) | (1 << (CPP14Parser.Struct - 11)) | (1 << (CPP14Parser.Thread_local - 11)) | (1 << (CPP14Parser.Typedef - 11)))) != 0) or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (CPP14Parser.Typename_ - 75)) | (1 << (CPP14Parser.Union - 75)) | (1 << (CPP14Parser.Unsigned - 75)) | (1 << (CPP14Parser.Virtual - 75)) | (1 << (CPP14Parser.Void - 75)) | (1 << (CPP14Parser.Volatile - 75)) | (1 << (CPP14Parser.Wchar - 75)) | (1 << (CPP14Parser.LeftBracket - 75)) | (1 << (CPP14Parser.Doublecolon - 75)) | (1 << (CPP14Parser.Identifier - 75)))) != 0):
self.state = 1839
self.parameterdeclarationlist(0)
self.state = 1843
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Ellipsis:
self.state = 1842
self.match(CPP14Parser.Ellipsis)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1845
self.parameterdeclarationlist(0)
self.state = 1846
self.match(CPP14Parser.Comma)
self.state = 1847
self.match(CPP14Parser.Ellipsis)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ParameterdeclarationlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def parameterdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.ParameterdeclarationContext,0)
[docs]
def parameterdeclarationlist(self):
return self.getTypedRuleContext(CPP14Parser.ParameterdeclarationlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_parameterdeclarationlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParameterdeclarationlist" ):
listener.enterParameterdeclarationlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParameterdeclarationlist" ):
listener.exitParameterdeclarationlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParameterdeclarationlist" ):
return visitor.visitParameterdeclarationlist(self)
else:
return visitor.visitChildren(self)
[docs]
def parameterdeclarationlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.ParameterdeclarationlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 272
self.enterRecursionRule(localctx, 272, self.RULE_parameterdeclarationlist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1852
self.parameterdeclaration()
self._ctx.stop = self._input.LT(-1)
self.state = 1859
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,213,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.ParameterdeclarationlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_parameterdeclarationlist)
self.state = 1854
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1855
self.match(CPP14Parser.Comma)
self.state = 1856
self.parameterdeclaration()
self.state = 1861
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,213,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ParameterdeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def declspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclspecifierseqContext,0)
[docs]
def declarator(self):
return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def initializerclause(self):
return self.getTypedRuleContext(CPP14Parser.InitializerclauseContext,0)
[docs]
def abstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.AbstractdeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_parameterdeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParameterdeclaration" ):
listener.enterParameterdeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParameterdeclaration" ):
listener.exitParameterdeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParameterdeclaration" ):
return visitor.visitParameterdeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def parameterdeclaration(self):
localctx = CPP14Parser.ParameterdeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 274, self.RULE_parameterdeclaration)
self._la = 0 # Token type
try:
self.state = 1893
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,220,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1863
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1862
self.attributespecifierseq(0)
self.state = 1865
self.declspecifierseq()
self.state = 1866
self.declarator()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1869
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1868
self.attributespecifierseq(0)
self.state = 1871
self.declspecifierseq()
self.state = 1872
self.declarator()
self.state = 1873
self.match(CPP14Parser.Assign)
self.state = 1874
self.initializerclause()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1877
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1876
self.attributespecifierseq(0)
self.state = 1879
self.declspecifierseq()
self.state = 1881
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,217,self._ctx)
if la_ == 1:
self.state = 1880
self.abstractdeclarator()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1884
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1883
self.attributespecifierseq(0)
self.state = 1886
self.declspecifierseq()
self.state = 1888
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.T__2 or _la==CPP14Parser.Decltype or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (CPP14Parser.LeftParen - 84)) | (1 << (CPP14Parser.LeftBracket - 84)) | (1 << (CPP14Parser.Star - 84)) | (1 << (CPP14Parser.And - 84)) | (1 << (CPP14Parser.Doublecolon - 84)) | (1 << (CPP14Parser.Ellipsis - 84)) | (1 << (CPP14Parser.Identifier - 84)))) != 0):
self.state = 1887
self.abstractdeclarator()
self.state = 1890
self.match(CPP14Parser.Assign)
self.state = 1891
self.initializerclause()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FunctiondefinitionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def declarator(self):
return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)
[docs]
def functionbody(self):
return self.getTypedRuleContext(CPP14Parser.FunctionbodyContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def declspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclspecifierseqContext,0)
[docs]
def virtspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.VirtspecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_functiondefinition
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctiondefinition" ):
listener.enterFunctiondefinition(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctiondefinition" ):
listener.exitFunctiondefinition(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctiondefinition" ):
return visitor.visitFunctiondefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def functiondefinition(self):
localctx = CPP14Parser.FunctiondefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 276, self.RULE_functiondefinition)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1896
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1895
self.attributespecifierseq(0)
self.state = 1899
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,222,self._ctx)
if la_ == 1:
self.state = 1898
self.declspecifierseq()
self.state = 1901
self.declarator()
self.state = 1903
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Final or _la==CPP14Parser.Override:
self.state = 1902
self.virtspecifierseq(0)
self.state = 1905
self.functionbody()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FunctionbodyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def compoundstatement(self):
return self.getTypedRuleContext(CPP14Parser.CompoundstatementContext,0)
[docs]
def ctorinitializer(self):
return self.getTypedRuleContext(CPP14Parser.CtorinitializerContext,0)
[docs]
def functiontryblock(self):
return self.getTypedRuleContext(CPP14Parser.FunctiontryblockContext,0)
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def Default(self):
return self.getToken(CPP14Parser.Default, 0)
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def Delete(self):
return self.getToken(CPP14Parser.Delete, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_functionbody
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctionbody" ):
listener.enterFunctionbody(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctionbody" ):
listener.exitFunctionbody(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctionbody" ):
return visitor.visitFunctionbody(self)
else:
return visitor.visitChildren(self)
[docs]
def functionbody(self):
localctx = CPP14Parser.FunctionbodyContext(self, self._ctx, self.state)
self.enterRule(localctx, 278, self.RULE_functionbody)
self._la = 0 # Token type
try:
self.state = 1918
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,225,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1908
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Colon:
self.state = 1907
self.ctorinitializer()
self.state = 1910
self.compoundstatement()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1911
self.functiontryblock()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 1912
self.match(CPP14Parser.Assign)
self.state = 1913
self.match(CPP14Parser.Default)
self.state = 1914
self.match(CPP14Parser.Semi)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 1915
self.match(CPP14Parser.Assign)
self.state = 1916
self.match(CPP14Parser.Delete)
self.state = 1917
self.match(CPP14Parser.Semi)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class InitializerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def braceorequalinitializer(self):
return self.getTypedRuleContext(CPP14Parser.BraceorequalinitializerContext,0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def expressionlist(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionlistContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_initializer
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInitializer" ):
listener.enterInitializer(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInitializer" ):
listener.exitInitializer(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInitializer" ):
return visitor.visitInitializer(self)
else:
return visitor.visitChildren(self)
[docs]
def initializer(self):
localctx = CPP14Parser.InitializerContext(self, self._ctx, self.state)
self.enterRule(localctx, 280, self.RULE_initializer)
try:
self.state = 1925
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.LeftBrace, CPP14Parser.Assign]:
self.enterOuterAlt(localctx, 1)
self.state = 1920
self.braceorequalinitializer()
pass
elif token in [CPP14Parser.LeftParen]:
self.enterOuterAlt(localctx, 2)
self.state = 1921
self.match(CPP14Parser.LeftParen)
self.state = 1922
self.expressionlist()
self.state = 1923
self.match(CPP14Parser.RightParen)
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
[docs]
class BraceorequalinitializerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def initializerclause(self):
return self.getTypedRuleContext(CPP14Parser.InitializerclauseContext,0)
[docs]
def bracedinitlist(self):
return self.getTypedRuleContext(CPP14Parser.BracedinitlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_braceorequalinitializer
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBraceorequalinitializer" ):
listener.enterBraceorequalinitializer(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBraceorequalinitializer" ):
listener.exitBraceorequalinitializer(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBraceorequalinitializer" ):
return visitor.visitBraceorequalinitializer(self)
else:
return visitor.visitChildren(self)
[docs]
def braceorequalinitializer(self):
localctx = CPP14Parser.BraceorequalinitializerContext(self, self._ctx, self.state)
self.enterRule(localctx, 282, self.RULE_braceorequalinitializer)
try:
self.state = 1930
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Assign]:
self.enterOuterAlt(localctx, 1)
self.state = 1927
self.match(CPP14Parser.Assign)
self.state = 1928
self.initializerclause()
pass
elif token in [CPP14Parser.LeftBrace]:
self.enterOuterAlt(localctx, 2)
self.state = 1929
self.bracedinitlist()
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
[docs]
class InitializerclauseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def assignmentexpression(self):
return self.getTypedRuleContext(CPP14Parser.AssignmentexpressionContext,0)
[docs]
def bracedinitlist(self):
return self.getTypedRuleContext(CPP14Parser.BracedinitlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_initializerclause
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInitializerclause" ):
listener.enterInitializerclause(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInitializerclause" ):
listener.exitInitializerclause(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInitializerclause" ):
return visitor.visitInitializerclause(self)
else:
return visitor.visitChildren(self)
[docs]
def initializerclause(self):
localctx = CPP14Parser.InitializerclauseContext(self, self._ctx, self.state)
self.enterRule(localctx, 284, self.RULE_initializerclause)
try:
self.state = 1934
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.T__0, CPP14Parser.T__1, CPP14Parser.T__6, CPP14Parser.T__7, CPP14Parser.Alignof, CPP14Parser.Auto, CPP14Parser.Bool, CPP14Parser.Char, CPP14Parser.Char16, CPP14Parser.Char32, CPP14Parser.Const_cast, CPP14Parser.Decltype, CPP14Parser.Delete, CPP14Parser.Double, CPP14Parser.Dynamic_cast, CPP14Parser.Float, CPP14Parser.Int, CPP14Parser.Long, CPP14Parser.New, CPP14Parser.Noexcept, CPP14Parser.Nullptr, CPP14Parser.Operator, CPP14Parser.Reinterpret_cast, CPP14Parser.Short, CPP14Parser.Signed, CPP14Parser.Sizeof, CPP14Parser.Static_cast, CPP14Parser.This, CPP14Parser.Throw, CPP14Parser.Typeid_, CPP14Parser.Typename_, CPP14Parser.Unsigned, CPP14Parser.Void, CPP14Parser.Wchar, CPP14Parser.LeftParen, CPP14Parser.LeftBracket, CPP14Parser.Plus, CPP14Parser.Minus, CPP14Parser.Star, CPP14Parser.And, CPP14Parser.Or, CPP14Parser.Tilde, CPP14Parser.PlusPlus, CPP14Parser.MinusMinus, CPP14Parser.Doublecolon, CPP14Parser.Identifier, CPP14Parser.Integerliteral, CPP14Parser.Characterliteral, CPP14Parser.Floatingliteral, CPP14Parser.Stringliteral, CPP14Parser.Userdefinedintegerliteral, CPP14Parser.Userdefinedfloatingliteral, CPP14Parser.Userdefinedstringliteral, CPP14Parser.Userdefinedcharacterliteral]:
self.enterOuterAlt(localctx, 1)
self.state = 1932
self.assignmentexpression()
pass
elif token in [CPP14Parser.LeftBrace]:
self.enterOuterAlt(localctx, 2)
self.state = 1933
self.bracedinitlist()
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
[docs]
class InitializerlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def initializerclause(self):
return self.getTypedRuleContext(CPP14Parser.InitializerclauseContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def initializerlist(self):
return self.getTypedRuleContext(CPP14Parser.InitializerlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_initializerlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInitializerlist" ):
listener.enterInitializerlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInitializerlist" ):
listener.exitInitializerlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInitializerlist" ):
return visitor.visitInitializerlist(self)
else:
return visitor.visitChildren(self)
[docs]
def initializerlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.InitializerlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 286
self.enterRecursionRule(localctx, 286, self.RULE_initializerlist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1937
self.initializerclause()
self.state = 1939
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,229,self._ctx)
if la_ == 1:
self.state = 1938
self.match(CPP14Parser.Ellipsis)
self._ctx.stop = self._input.LT(-1)
self.state = 1949
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,231,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.InitializerlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_initializerlist)
self.state = 1941
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 1942
self.match(CPP14Parser.Comma)
self.state = 1943
self.initializerclause()
self.state = 1945
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
if la_ == 1:
self.state = 1944
self.match(CPP14Parser.Ellipsis)
self.state = 1951
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,231,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class BracedinitlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LeftBrace(self):
return self.getToken(CPP14Parser.LeftBrace, 0)
[docs]
def initializerlist(self):
return self.getTypedRuleContext(CPP14Parser.InitializerlistContext,0)
[docs]
def RightBrace(self):
return self.getToken(CPP14Parser.RightBrace, 0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_bracedinitlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBracedinitlist" ):
listener.enterBracedinitlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBracedinitlist" ):
listener.exitBracedinitlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBracedinitlist" ):
return visitor.visitBracedinitlist(self)
else:
return visitor.visitChildren(self)
[docs]
def bracedinitlist(self):
localctx = CPP14Parser.BracedinitlistContext(self, self._ctx, self.state)
self.enterRule(localctx, 288, self.RULE_bracedinitlist)
self._la = 0 # Token type
try:
self.state = 1961
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,233,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1952
self.match(CPP14Parser.LeftBrace)
self.state = 1953
self.initializerlist(0)
self.state = 1955
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Comma:
self.state = 1954
self.match(CPP14Parser.Comma)
self.state = 1957
self.match(CPP14Parser.RightBrace)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1959
self.match(CPP14Parser.LeftBrace)
self.state = 1960
self.match(CPP14Parser.RightBrace)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ClassnameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def simpletemplateid(self):
return self.getTypedRuleContext(CPP14Parser.SimpletemplateidContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_classname
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterClassname" ):
listener.enterClassname(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitClassname" ):
listener.exitClassname(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClassname" ):
return visitor.visitClassname(self)
else:
return visitor.visitChildren(self)
[docs]
def classname(self):
localctx = CPP14Parser.ClassnameContext(self, self._ctx, self.state)
self.enterRule(localctx, 290, self.RULE_classname)
try:
self.state = 1965
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1963
self.match(CPP14Parser.Identifier)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1964
self.simpletemplateid()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ClassspecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def classhead(self):
return self.getTypedRuleContext(CPP14Parser.ClassheadContext,0)
[docs]
def LeftBrace(self):
return self.getToken(CPP14Parser.LeftBrace, 0)
[docs]
def RightBrace(self):
return self.getToken(CPP14Parser.RightBrace, 0)
[docs]
def memberspecification(self):
return self.getTypedRuleContext(CPP14Parser.MemberspecificationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_classspecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterClassspecifier" ):
listener.enterClassspecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitClassspecifier" ):
listener.exitClassspecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClassspecifier" ):
return visitor.visitClassspecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def classspecifier(self):
localctx = CPP14Parser.ClassspecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 292, self.RULE_classspecifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 1967
self.classhead()
self.state = 1968
self.match(CPP14Parser.LeftBrace)
self.state = 1970
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__2) | (1 << CPP14Parser.Alignas) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Constexpr) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Explicit) | (1 << CPP14Parser.Extern) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Friend) | (1 << CPP14Parser.Inline) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.Mutable) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Private) | (1 << CPP14Parser.Protected) | (1 << CPP14Parser.Public) | (1 << CPP14Parser.Register) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Static))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CPP14Parser.Static_assert - 64)) | (1 << (CPP14Parser.Struct - 64)) | (1 << (CPP14Parser.Template - 64)) | (1 << (CPP14Parser.Thread_local - 64)) | (1 << (CPP14Parser.Typedef - 64)) | (1 << (CPP14Parser.Typename_ - 64)) | (1 << (CPP14Parser.Union - 64)) | (1 << (CPP14Parser.Unsigned - 64)) | (1 << (CPP14Parser.Using - 64)) | (1 << (CPP14Parser.Virtual - 64)) | (1 << (CPP14Parser.Void - 64)) | (1 << (CPP14Parser.Volatile - 64)) | (1 << (CPP14Parser.Wchar - 64)) | (1 << (CPP14Parser.LeftParen - 64)) | (1 << (CPP14Parser.LeftBracket - 64)) | (1 << (CPP14Parser.Star - 64)) | (1 << (CPP14Parser.And - 64)) | (1 << (CPP14Parser.Tilde - 64)) | (1 << (CPP14Parser.Colon - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (CPP14Parser.Doublecolon - 128)) | (1 << (CPP14Parser.Semi - 128)) | (1 << (CPP14Parser.Ellipsis - 128)) | (1 << (CPP14Parser.Identifier - 128)))) != 0):
self.state = 1969
self.memberspecification()
self.state = 1972
self.match(CPP14Parser.RightBrace)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ClassheadContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def classkey(self):
return self.getTypedRuleContext(CPP14Parser.ClasskeyContext,0)
[docs]
def classheadname(self):
return self.getTypedRuleContext(CPP14Parser.ClassheadnameContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def classvirtspecifier(self):
return self.getTypedRuleContext(CPP14Parser.ClassvirtspecifierContext,0)
[docs]
def baseclause(self):
return self.getTypedRuleContext(CPP14Parser.BaseclauseContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_classhead
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterClasshead" ):
listener.enterClasshead(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitClasshead" ):
listener.exitClasshead(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClasshead" ):
return visitor.visitClasshead(self)
else:
return visitor.visitChildren(self)
[docs]
def classhead(self):
localctx = CPP14Parser.ClassheadContext(self, self._ctx, self.state)
self.enterRule(localctx, 294, self.RULE_classhead)
self._la = 0 # Token type
try:
self.state = 1992
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,241,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1974
self.classkey()
self.state = 1976
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1975
self.attributespecifierseq(0)
self.state = 1978
self.classheadname()
self.state = 1980
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Final:
self.state = 1979
self.classvirtspecifier()
self.state = 1983
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Colon:
self.state = 1982
self.baseclause()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1985
self.classkey()
self.state = 1987
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 1986
self.attributespecifierseq(0)
self.state = 1990
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Colon:
self.state = 1989
self.baseclause()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ClassheadnameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def classname(self):
return self.getTypedRuleContext(CPP14Parser.ClassnameContext,0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_classheadname
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterClassheadname" ):
listener.enterClassheadname(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitClassheadname" ):
listener.exitClassheadname(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClassheadname" ):
return visitor.visitClassheadname(self)
else:
return visitor.visitChildren(self)
[docs]
def classheadname(self):
localctx = CPP14Parser.ClassheadnameContext(self, self._ctx, self.state)
self.enterRule(localctx, 296, self.RULE_classheadname)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1995
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,242,self._ctx)
if la_ == 1:
self.state = 1994
self.nestednamespecifier(0)
self.state = 1997
self.classname()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ClassvirtspecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Final(self):
return self.getToken(CPP14Parser.Final, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_classvirtspecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterClassvirtspecifier" ):
listener.enterClassvirtspecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitClassvirtspecifier" ):
listener.exitClassvirtspecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClassvirtspecifier" ):
return visitor.visitClassvirtspecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def classvirtspecifier(self):
localctx = CPP14Parser.ClassvirtspecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 298, self.RULE_classvirtspecifier)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1999
self.match(CPP14Parser.Final)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ClasskeyContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Class(self):
return self.getToken(CPP14Parser.Class, 0)
[docs]
def Struct(self):
return self.getToken(CPP14Parser.Struct, 0)
[docs]
def Union(self):
return self.getToken(CPP14Parser.Union, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_classkey
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterClasskey" ):
listener.enterClasskey(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitClasskey" ):
listener.exitClasskey(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClasskey" ):
return visitor.visitClasskey(self)
else:
return visitor.visitChildren(self)
[docs]
def classkey(self):
localctx = CPP14Parser.ClasskeyContext(self, self._ctx, self.state)
self.enterRule(localctx, 300, self.RULE_classkey)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2001
_la = self._input.LA(1)
if not(((((_la - 22)) & ~0x3f) == 0 and ((1 << (_la - 22)) & ((1 << (CPP14Parser.Class - 22)) | (1 << (CPP14Parser.Struct - 22)) | (1 << (CPP14Parser.Union - 22)))) != 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
[docs]
class MemberspecificationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def memberdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.MemberdeclarationContext,0)
[docs]
def memberspecification(self):
return self.getTypedRuleContext(CPP14Parser.MemberspecificationContext,0)
[docs]
def accessspecifier(self):
return self.getTypedRuleContext(CPP14Parser.AccessspecifierContext,0)
[docs]
def Colon(self):
return self.getToken(CPP14Parser.Colon, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_memberspecification
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMemberspecification" ):
listener.enterMemberspecification(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMemberspecification" ):
listener.exitMemberspecification(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMemberspecification" ):
return visitor.visitMemberspecification(self)
else:
return visitor.visitChildren(self)
[docs]
def memberspecification(self):
localctx = CPP14Parser.MemberspecificationContext(self, self._ctx, self.state)
self.enterRule(localctx, 302, self.RULE_memberspecification)
self._la = 0 # Token type
try:
self.state = 2012
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.T__2, CPP14Parser.Alignas, CPP14Parser.Auto, CPP14Parser.Bool, CPP14Parser.Char, CPP14Parser.Char16, CPP14Parser.Char32, CPP14Parser.Class, CPP14Parser.Const, CPP14Parser.Constexpr, CPP14Parser.Decltype, CPP14Parser.Double, CPP14Parser.Enum, CPP14Parser.Explicit, CPP14Parser.Extern, CPP14Parser.Float, CPP14Parser.Friend, CPP14Parser.Inline, CPP14Parser.Int, CPP14Parser.Long, CPP14Parser.Mutable, CPP14Parser.Operator, CPP14Parser.Register, CPP14Parser.Short, CPP14Parser.Signed, CPP14Parser.Static, CPP14Parser.Static_assert, CPP14Parser.Struct, CPP14Parser.Template, CPP14Parser.Thread_local, CPP14Parser.Typedef, CPP14Parser.Typename_, CPP14Parser.Union, CPP14Parser.Unsigned, CPP14Parser.Using, CPP14Parser.Virtual, CPP14Parser.Void, CPP14Parser.Volatile, CPP14Parser.Wchar, CPP14Parser.LeftParen, CPP14Parser.LeftBracket, CPP14Parser.Star, CPP14Parser.And, CPP14Parser.Tilde, CPP14Parser.Colon, CPP14Parser.Doublecolon, CPP14Parser.Semi, CPP14Parser.Ellipsis, CPP14Parser.Identifier]:
self.enterOuterAlt(localctx, 1)
self.state = 2003
self.memberdeclaration()
self.state = 2005
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__2) | (1 << CPP14Parser.Alignas) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Constexpr) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Explicit) | (1 << CPP14Parser.Extern) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Friend) | (1 << CPP14Parser.Inline) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.Mutable) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Private) | (1 << CPP14Parser.Protected) | (1 << CPP14Parser.Public) | (1 << CPP14Parser.Register) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Static))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CPP14Parser.Static_assert - 64)) | (1 << (CPP14Parser.Struct - 64)) | (1 << (CPP14Parser.Template - 64)) | (1 << (CPP14Parser.Thread_local - 64)) | (1 << (CPP14Parser.Typedef - 64)) | (1 << (CPP14Parser.Typename_ - 64)) | (1 << (CPP14Parser.Union - 64)) | (1 << (CPP14Parser.Unsigned - 64)) | (1 << (CPP14Parser.Using - 64)) | (1 << (CPP14Parser.Virtual - 64)) | (1 << (CPP14Parser.Void - 64)) | (1 << (CPP14Parser.Volatile - 64)) | (1 << (CPP14Parser.Wchar - 64)) | (1 << (CPP14Parser.LeftParen - 64)) | (1 << (CPP14Parser.LeftBracket - 64)) | (1 << (CPP14Parser.Star - 64)) | (1 << (CPP14Parser.And - 64)) | (1 << (CPP14Parser.Tilde - 64)) | (1 << (CPP14Parser.Colon - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (CPP14Parser.Doublecolon - 128)) | (1 << (CPP14Parser.Semi - 128)) | (1 << (CPP14Parser.Ellipsis - 128)) | (1 << (CPP14Parser.Identifier - 128)))) != 0):
self.state = 2004
self.memberspecification()
pass
elif token in [CPP14Parser.Private, CPP14Parser.Protected, CPP14Parser.Public]:
self.enterOuterAlt(localctx, 2)
self.state = 2007
self.accessspecifier()
self.state = 2008
self.match(CPP14Parser.Colon)
self.state = 2010
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__2) | (1 << CPP14Parser.Alignas) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Constexpr) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Explicit) | (1 << CPP14Parser.Extern) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Friend) | (1 << CPP14Parser.Inline) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.Mutable) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Private) | (1 << CPP14Parser.Protected) | (1 << CPP14Parser.Public) | (1 << CPP14Parser.Register) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Static))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CPP14Parser.Static_assert - 64)) | (1 << (CPP14Parser.Struct - 64)) | (1 << (CPP14Parser.Template - 64)) | (1 << (CPP14Parser.Thread_local - 64)) | (1 << (CPP14Parser.Typedef - 64)) | (1 << (CPP14Parser.Typename_ - 64)) | (1 << (CPP14Parser.Union - 64)) | (1 << (CPP14Parser.Unsigned - 64)) | (1 << (CPP14Parser.Using - 64)) | (1 << (CPP14Parser.Virtual - 64)) | (1 << (CPP14Parser.Void - 64)) | (1 << (CPP14Parser.Volatile - 64)) | (1 << (CPP14Parser.Wchar - 64)) | (1 << (CPP14Parser.LeftParen - 64)) | (1 << (CPP14Parser.LeftBracket - 64)) | (1 << (CPP14Parser.Star - 64)) | (1 << (CPP14Parser.And - 64)) | (1 << (CPP14Parser.Tilde - 64)) | (1 << (CPP14Parser.Colon - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (CPP14Parser.Doublecolon - 128)) | (1 << (CPP14Parser.Semi - 128)) | (1 << (CPP14Parser.Ellipsis - 128)) | (1 << (CPP14Parser.Identifier - 128)))) != 0):
self.state = 2009
self.memberspecification()
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
[docs]
class MemberdeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Semi(self):
return self.getToken(CPP14Parser.Semi, 0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def declspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.DeclspecifierseqContext,0)
[docs]
def memberdeclaratorlist(self):
return self.getTypedRuleContext(CPP14Parser.MemberdeclaratorlistContext,0)
[docs]
def functiondefinition(self):
return self.getTypedRuleContext(CPP14Parser.FunctiondefinitionContext,0)
[docs]
def usingdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.UsingdeclarationContext,0)
[docs]
def static_assertdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.Static_assertdeclarationContext,0)
[docs]
def templatedeclaration(self):
return self.getTypedRuleContext(CPP14Parser.TemplatedeclarationContext,0)
[docs]
def aliasdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.AliasdeclarationContext,0)
[docs]
def emptydeclaration(self):
return self.getTypedRuleContext(CPP14Parser.EmptydeclarationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_memberdeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMemberdeclaration" ):
listener.enterMemberdeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMemberdeclaration" ):
listener.exitMemberdeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMemberdeclaration" ):
return visitor.visitMemberdeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def memberdeclaration(self):
localctx = CPP14Parser.MemberdeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 304, self.RULE_memberdeclaration)
self._la = 0 # Token type
try:
self.state = 2030
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,249,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2015
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,246,self._ctx)
if la_ == 1:
self.state = 2014
self.attributespecifierseq(0)
self.state = 2018
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,247,self._ctx)
if la_ == 1:
self.state = 2017
self.declspecifierseq()
self.state = 2021
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__2) | (1 << CPP14Parser.Alignas) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Operator))) != 0) or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (CPP14Parser.LeftParen - 84)) | (1 << (CPP14Parser.LeftBracket - 84)) | (1 << (CPP14Parser.Star - 84)) | (1 << (CPP14Parser.And - 84)) | (1 << (CPP14Parser.Tilde - 84)) | (1 << (CPP14Parser.Colon - 84)) | (1 << (CPP14Parser.Doublecolon - 84)) | (1 << (CPP14Parser.Ellipsis - 84)) | (1 << (CPP14Parser.Identifier - 84)))) != 0):
self.state = 2020
self.memberdeclaratorlist(0)
self.state = 2023
self.match(CPP14Parser.Semi)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2024
self.functiondefinition()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2025
self.usingdeclaration()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 2026
self.static_assertdeclaration()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 2027
self.templatedeclaration()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 2028
self.aliasdeclaration()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 2029
self.emptydeclaration()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class MemberdeclaratorlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def memberdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.MemberdeclaratorContext,0)
[docs]
def memberdeclaratorlist(self):
return self.getTypedRuleContext(CPP14Parser.MemberdeclaratorlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_memberdeclaratorlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMemberdeclaratorlist" ):
listener.enterMemberdeclaratorlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMemberdeclaratorlist" ):
listener.exitMemberdeclaratorlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMemberdeclaratorlist" ):
return visitor.visitMemberdeclaratorlist(self)
else:
return visitor.visitChildren(self)
[docs]
def memberdeclaratorlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.MemberdeclaratorlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 306
self.enterRecursionRule(localctx, 306, self.RULE_memberdeclaratorlist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2033
self.memberdeclarator()
self._ctx.stop = self._input.LT(-1)
self.state = 2040
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,250,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.MemberdeclaratorlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_memberdeclaratorlist)
self.state = 2035
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2036
self.match(CPP14Parser.Comma)
self.state = 2037
self.memberdeclarator()
self.state = 2042
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,250,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class MemberdeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def declarator(self):
return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)
[docs]
def virtspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.VirtspecifierseqContext,0)
[docs]
def purespecifier(self):
return self.getTypedRuleContext(CPP14Parser.PurespecifierContext,0)
[docs]
def braceorequalinitializer(self):
return self.getTypedRuleContext(CPP14Parser.BraceorequalinitializerContext,0)
[docs]
def Colon(self):
return self.getToken(CPP14Parser.Colon, 0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_memberdeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMemberdeclarator" ):
listener.enterMemberdeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMemberdeclarator" ):
listener.exitMemberdeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMemberdeclarator" ):
return visitor.visitMemberdeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def memberdeclarator(self):
localctx = CPP14Parser.MemberdeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 308, self.RULE_memberdeclarator)
self._la = 0 # Token type
try:
self.state = 2062
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2043
self.declarator()
self.state = 2045
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,251,self._ctx)
if la_ == 1:
self.state = 2044
self.virtspecifierseq(0)
self.state = 2048
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
if la_ == 1:
self.state = 2047
self.purespecifier()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2050
self.declarator()
self.state = 2052
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,253,self._ctx)
if la_ == 1:
self.state = 2051
self.braceorequalinitializer()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2055
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Identifier:
self.state = 2054
self.match(CPP14Parser.Identifier)
self.state = 2058
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 2057
self.attributespecifierseq(0)
self.state = 2060
self.match(CPP14Parser.Colon)
self.state = 2061
self.constantexpression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class VirtspecifierseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def virtspecifier(self):
return self.getTypedRuleContext(CPP14Parser.VirtspecifierContext,0)
[docs]
def virtspecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.VirtspecifierseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_virtspecifierseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVirtspecifierseq" ):
listener.enterVirtspecifierseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVirtspecifierseq" ):
listener.exitVirtspecifierseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVirtspecifierseq" ):
return visitor.visitVirtspecifierseq(self)
else:
return visitor.visitChildren(self)
[docs]
def virtspecifierseq(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.VirtspecifierseqContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 310
self.enterRecursionRule(localctx, 310, self.RULE_virtspecifierseq, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2065
self.virtspecifier()
self._ctx.stop = self._input.LT(-1)
self.state = 2071
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,257,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.VirtspecifierseqContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_virtspecifierseq)
self.state = 2067
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2068
self.virtspecifier()
self.state = 2073
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,257,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class VirtspecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Override(self):
return self.getToken(CPP14Parser.Override, 0)
[docs]
def Final(self):
return self.getToken(CPP14Parser.Final, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_virtspecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVirtspecifier" ):
listener.enterVirtspecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVirtspecifier" ):
listener.exitVirtspecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVirtspecifier" ):
return visitor.visitVirtspecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def virtspecifier(self):
localctx = CPP14Parser.VirtspecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 312, self.RULE_virtspecifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2074
_la = self._input.LA(1)
if not(_la==CPP14Parser.Final or _la==CPP14Parser.Override):
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
[docs]
class PurespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.val = None # Token
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def Octalliteral(self):
return self.getToken(CPP14Parser.Octalliteral, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_purespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPurespecifier" ):
listener.enterPurespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPurespecifier" ):
listener.exitPurespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPurespecifier" ):
return visitor.visitPurespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def purespecifier(self):
localctx = CPP14Parser.PurespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 314, self.RULE_purespecifier)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2076
self.match(CPP14Parser.Assign)
self.state = 2077
localctx.val = self.match(CPP14Parser.Octalliteral)
if((None if localctx.val is None else localctx.val.text)!="0"): raise("error");
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BaseclauseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Colon(self):
return self.getToken(CPP14Parser.Colon, 0)
[docs]
def basespecifierlist(self):
return self.getTypedRuleContext(CPP14Parser.BasespecifierlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_baseclause
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBaseclause" ):
listener.enterBaseclause(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBaseclause" ):
listener.exitBaseclause(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBaseclause" ):
return visitor.visitBaseclause(self)
else:
return visitor.visitChildren(self)
[docs]
def baseclause(self):
localctx = CPP14Parser.BaseclauseContext(self, self._ctx, self.state)
self.enterRule(localctx, 316, self.RULE_baseclause)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2080
self.match(CPP14Parser.Colon)
self.state = 2081
self.basespecifierlist(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BasespecifierlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def basespecifier(self):
return self.getTypedRuleContext(CPP14Parser.BasespecifierContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def basespecifierlist(self):
return self.getTypedRuleContext(CPP14Parser.BasespecifierlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_basespecifierlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBasespecifierlist" ):
listener.enterBasespecifierlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBasespecifierlist" ):
listener.exitBasespecifierlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBasespecifierlist" ):
return visitor.visitBasespecifierlist(self)
else:
return visitor.visitChildren(self)
[docs]
def basespecifierlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.BasespecifierlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 318
self.enterRecursionRule(localctx, 318, self.RULE_basespecifierlist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2084
self.basespecifier()
self.state = 2086
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
if la_ == 1:
self.state = 2085
self.match(CPP14Parser.Ellipsis)
self._ctx.stop = self._input.LT(-1)
self.state = 2096
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,260,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.BasespecifierlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_basespecifierlist)
self.state = 2088
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2089
self.match(CPP14Parser.Comma)
self.state = 2090
self.basespecifier()
self.state = 2092
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,259,self._ctx)
if la_ == 1:
self.state = 2091
self.match(CPP14Parser.Ellipsis)
self.state = 2098
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,260,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class BasespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def basetypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.BasetypespecifierContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def Virtual(self):
return self.getToken(CPP14Parser.Virtual, 0)
[docs]
def accessspecifier(self):
return self.getTypedRuleContext(CPP14Parser.AccessspecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_basespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBasespecifier" ):
listener.enterBasespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBasespecifier" ):
listener.exitBasespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBasespecifier" ):
return visitor.visitBasespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def basespecifier(self):
localctx = CPP14Parser.BasespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 320, self.RULE_basespecifier)
self._la = 0 # Token type
try:
self.state = 2120
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,266,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2100
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 2099
self.attributespecifierseq(0)
self.state = 2102
self.basetypespecifier()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2104
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 2103
self.attributespecifierseq(0)
self.state = 2106
self.match(CPP14Parser.Virtual)
self.state = 2108
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.Private) | (1 << CPP14Parser.Protected) | (1 << CPP14Parser.Public))) != 0):
self.state = 2107
self.accessspecifier()
self.state = 2110
self.basetypespecifier()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2112
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 2111
self.attributespecifierseq(0)
self.state = 2114
self.accessspecifier()
self.state = 2116
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Virtual:
self.state = 2115
self.match(CPP14Parser.Virtual)
self.state = 2118
self.basetypespecifier()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ClassordecltypeContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def classname(self):
return self.getTypedRuleContext(CPP14Parser.ClassnameContext,0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def decltypespecifier(self):
return self.getTypedRuleContext(CPP14Parser.DecltypespecifierContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_classordecltype
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterClassordecltype" ):
listener.enterClassordecltype(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitClassordecltype" ):
listener.exitClassordecltype(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClassordecltype" ):
return visitor.visitClassordecltype(self)
else:
return visitor.visitChildren(self)
[docs]
def classordecltype(self):
localctx = CPP14Parser.ClassordecltypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 322, self.RULE_classordecltype)
try:
self.state = 2127
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,268,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2123
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,267,self._ctx)
if la_ == 1:
self.state = 2122
self.nestednamespecifier(0)
self.state = 2125
self.classname()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2126
self.decltypespecifier()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BasetypespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def classordecltype(self):
return self.getTypedRuleContext(CPP14Parser.ClassordecltypeContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_basetypespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBasetypespecifier" ):
listener.enterBasetypespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBasetypespecifier" ):
listener.exitBasetypespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBasetypespecifier" ):
return visitor.visitBasetypespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def basetypespecifier(self):
localctx = CPP14Parser.BasetypespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 324, self.RULE_basetypespecifier)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2129
self.classordecltype()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AccessspecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Private(self):
return self.getToken(CPP14Parser.Private, 0)
[docs]
def Protected(self):
return self.getToken(CPP14Parser.Protected, 0)
[docs]
def Public(self):
return self.getToken(CPP14Parser.Public, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_accessspecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAccessspecifier" ):
listener.enterAccessspecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAccessspecifier" ):
listener.exitAccessspecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAccessspecifier" ):
return visitor.visitAccessspecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def accessspecifier(self):
localctx = CPP14Parser.AccessspecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 326, self.RULE_accessspecifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2131
_la = self._input.LA(1)
if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.Private) | (1 << CPP14Parser.Protected) | (1 << CPP14Parser.Public))) != 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
[docs]
class ConversionfunctionidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Operator(self):
return self.getToken(CPP14Parser.Operator, 0)
[docs]
def conversiontypeid(self):
return self.getTypedRuleContext(CPP14Parser.ConversiontypeidContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_conversionfunctionid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConversionfunctionid" ):
listener.enterConversionfunctionid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConversionfunctionid" ):
listener.exitConversionfunctionid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConversionfunctionid" ):
return visitor.visitConversionfunctionid(self)
else:
return visitor.visitChildren(self)
[docs]
def conversionfunctionid(self):
localctx = CPP14Parser.ConversionfunctionidContext(self, self._ctx, self.state)
self.enterRule(localctx, 328, self.RULE_conversionfunctionid)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2133
self.match(CPP14Parser.Operator)
self.state = 2134
self.conversiontypeid()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ConversiontypeidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.TypespecifierseqContext,0)
[docs]
def conversiondeclarator(self):
return self.getTypedRuleContext(CPP14Parser.ConversiondeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_conversiontypeid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConversiontypeid" ):
listener.enterConversiontypeid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConversiontypeid" ):
listener.exitConversiontypeid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConversiontypeid" ):
return visitor.visitConversiontypeid(self)
else:
return visitor.visitChildren(self)
[docs]
def conversiontypeid(self):
localctx = CPP14Parser.ConversiontypeidContext(self, self._ctx, self.state)
self.enterRule(localctx, 330, self.RULE_conversiontypeid)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2136
self.typespecifierseq()
self.state = 2138
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,269,self._ctx)
if la_ == 1:
self.state = 2137
self.conversiondeclarator()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ConversiondeclaratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ptroperator(self):
return self.getTypedRuleContext(CPP14Parser.PtroperatorContext,0)
[docs]
def conversiondeclarator(self):
return self.getTypedRuleContext(CPP14Parser.ConversiondeclaratorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_conversiondeclarator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConversiondeclarator" ):
listener.enterConversiondeclarator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConversiondeclarator" ):
listener.exitConversiondeclarator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitConversiondeclarator" ):
return visitor.visitConversiondeclarator(self)
else:
return visitor.visitChildren(self)
[docs]
def conversiondeclarator(self):
localctx = CPP14Parser.ConversiondeclaratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 332, self.RULE_conversiondeclarator)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2140
self.ptroperator()
self.state = 2142
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,270,self._ctx)
if la_ == 1:
self.state = 2141
self.conversiondeclarator()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class CtorinitializerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Colon(self):
return self.getToken(CPP14Parser.Colon, 0)
[docs]
def meminitializerlist(self):
return self.getTypedRuleContext(CPP14Parser.MeminitializerlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_ctorinitializer
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCtorinitializer" ):
listener.enterCtorinitializer(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCtorinitializer" ):
listener.exitCtorinitializer(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCtorinitializer" ):
return visitor.visitCtorinitializer(self)
else:
return visitor.visitChildren(self)
[docs]
def ctorinitializer(self):
localctx = CPP14Parser.CtorinitializerContext(self, self._ctx, self.state)
self.enterRule(localctx, 334, self.RULE_ctorinitializer)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2144
self.match(CPP14Parser.Colon)
self.state = 2145
self.meminitializerlist()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class MeminitializerlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def meminitializer(self):
return self.getTypedRuleContext(CPP14Parser.MeminitializerContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def meminitializerlist(self):
return self.getTypedRuleContext(CPP14Parser.MeminitializerlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_meminitializerlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMeminitializerlist" ):
listener.enterMeminitializerlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMeminitializerlist" ):
listener.exitMeminitializerlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMeminitializerlist" ):
return visitor.visitMeminitializerlist(self)
else:
return visitor.visitChildren(self)
[docs]
def meminitializerlist(self):
localctx = CPP14Parser.MeminitializerlistContext(self, self._ctx, self.state)
self.enterRule(localctx, 336, self.RULE_meminitializerlist)
self._la = 0 # Token type
try:
self.state = 2158
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,273,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2147
self.meminitializer()
self.state = 2149
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Ellipsis:
self.state = 2148
self.match(CPP14Parser.Ellipsis)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2151
self.meminitializer()
self.state = 2153
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Ellipsis:
self.state = 2152
self.match(CPP14Parser.Ellipsis)
self.state = 2155
self.match(CPP14Parser.Comma)
self.state = 2156
self.meminitializerlist()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class MeminitializerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def meminitializerid(self):
return self.getTypedRuleContext(CPP14Parser.MeminitializeridContext,0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def expressionlist(self):
return self.getTypedRuleContext(CPP14Parser.ExpressionlistContext,0)
[docs]
def bracedinitlist(self):
return self.getTypedRuleContext(CPP14Parser.BracedinitlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_meminitializer
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMeminitializer" ):
listener.enterMeminitializer(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMeminitializer" ):
listener.exitMeminitializer(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMeminitializer" ):
return visitor.visitMeminitializer(self)
else:
return visitor.visitChildren(self)
[docs]
def meminitializer(self):
localctx = CPP14Parser.MeminitializerContext(self, self._ctx, self.state)
self.enterRule(localctx, 338, self.RULE_meminitializer)
self._la = 0 # Token type
try:
self.state = 2170
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,275,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2160
self.meminitializerid()
self.state = 2161
self.match(CPP14Parser.LeftParen)
self.state = 2163
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Throw - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.LeftBrace - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 2162
self.expressionlist()
self.state = 2165
self.match(CPP14Parser.RightParen)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2167
self.meminitializerid()
self.state = 2168
self.bracedinitlist()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class MeminitializeridContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def classordecltype(self):
return self.getTypedRuleContext(CPP14Parser.ClassordecltypeContext,0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_meminitializerid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMeminitializerid" ):
listener.enterMeminitializerid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMeminitializerid" ):
listener.exitMeminitializerid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMeminitializerid" ):
return visitor.visitMeminitializerid(self)
else:
return visitor.visitChildren(self)
[docs]
def meminitializerid(self):
localctx = CPP14Parser.MeminitializeridContext(self, self._ctx, self.state)
self.enterRule(localctx, 340, self.RULE_meminitializerid)
try:
self.state = 2174
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,276,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2172
self.classordecltype()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2173
self.match(CPP14Parser.Identifier)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OperatorfunctionidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Operator(self):
return self.getToken(CPP14Parser.Operator, 0)
[docs]
def theoperator(self):
return self.getTypedRuleContext(CPP14Parser.TheoperatorContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_operatorfunctionid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOperatorfunctionid" ):
listener.enterOperatorfunctionid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOperatorfunctionid" ):
listener.exitOperatorfunctionid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOperatorfunctionid" ):
return visitor.visitOperatorfunctionid(self)
else:
return visitor.visitChildren(self)
[docs]
def operatorfunctionid(self):
localctx = CPP14Parser.OperatorfunctionidContext(self, self._ctx, self.state)
self.enterRule(localctx, 342, self.RULE_operatorfunctionid)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2176
self.match(CPP14Parser.Operator)
self.state = 2177
self.theoperator()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LiteraloperatoridContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Operator(self):
return self.getToken(CPP14Parser.Operator, 0)
[docs]
def Stringliteral(self):
return self.getToken(CPP14Parser.Stringliteral, 0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def Userdefinedstringliteral(self):
return self.getToken(CPP14Parser.Userdefinedstringliteral, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_literaloperatorid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLiteraloperatorid" ):
listener.enterLiteraloperatorid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLiteraloperatorid" ):
listener.exitLiteraloperatorid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLiteraloperatorid" ):
return visitor.visitLiteraloperatorid(self)
else:
return visitor.visitChildren(self)
[docs]
def literaloperatorid(self):
localctx = CPP14Parser.LiteraloperatoridContext(self, self._ctx, self.state)
self.enterRule(localctx, 344, self.RULE_literaloperatorid)
try:
self.state = 2184
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,277,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2179
self.match(CPP14Parser.Operator)
self.state = 2180
self.match(CPP14Parser.Stringliteral)
self.state = 2181
self.match(CPP14Parser.Identifier)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2182
self.match(CPP14Parser.Operator)
self.state = 2183
self.match(CPP14Parser.Userdefinedstringliteral)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TemplatedeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def Less(self):
return self.getToken(CPP14Parser.Less, 0)
[docs]
def templateparameterlist(self):
return self.getTypedRuleContext(CPP14Parser.TemplateparameterlistContext,0)
[docs]
def Greater(self):
return self.getToken(CPP14Parser.Greater, 0)
[docs]
def declaration(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_templatedeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTemplatedeclaration" ):
listener.enterTemplatedeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTemplatedeclaration" ):
listener.exitTemplatedeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTemplatedeclaration" ):
return visitor.visitTemplatedeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def templatedeclaration(self):
localctx = CPP14Parser.TemplatedeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 346, self.RULE_templatedeclaration)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2186
self.match(CPP14Parser.Template)
self.state = 2187
self.match(CPP14Parser.Less)
self.state = 2188
self.templateparameterlist(0)
self.state = 2189
self.match(CPP14Parser.Greater)
self.state = 2190
self.declaration()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TemplateparameterlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def templateparameter(self):
return self.getTypedRuleContext(CPP14Parser.TemplateparameterContext,0)
[docs]
def templateparameterlist(self):
return self.getTypedRuleContext(CPP14Parser.TemplateparameterlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_templateparameterlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTemplateparameterlist" ):
listener.enterTemplateparameterlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTemplateparameterlist" ):
listener.exitTemplateparameterlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTemplateparameterlist" ):
return visitor.visitTemplateparameterlist(self)
else:
return visitor.visitChildren(self)
[docs]
def templateparameterlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.TemplateparameterlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 348
self.enterRecursionRule(localctx, 348, self.RULE_templateparameterlist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2193
self.templateparameter()
self._ctx.stop = self._input.LT(-1)
self.state = 2200
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,278,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.TemplateparameterlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_templateparameterlist)
self.state = 2195
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2196
self.match(CPP14Parser.Comma)
self.state = 2197
self.templateparameter()
self.state = 2202
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,278,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class TemplateparameterContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typeparameter(self):
return self.getTypedRuleContext(CPP14Parser.TypeparameterContext,0)
[docs]
def parameterdeclaration(self):
return self.getTypedRuleContext(CPP14Parser.ParameterdeclarationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_templateparameter
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTemplateparameter" ):
listener.enterTemplateparameter(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTemplateparameter" ):
listener.exitTemplateparameter(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTemplateparameter" ):
return visitor.visitTemplateparameter(self)
else:
return visitor.visitChildren(self)
[docs]
def templateparameter(self):
localctx = CPP14Parser.TemplateparameterContext(self, self._ctx, self.state)
self.enterRule(localctx, 350, self.RULE_templateparameter)
try:
self.state = 2205
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,279,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2203
self.typeparameter()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2204
self.parameterdeclaration()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeparameterContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Class(self):
return self.getToken(CPP14Parser.Class, 0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def thetypeid(self):
return self.getTypedRuleContext(CPP14Parser.ThetypeidContext,0)
[docs]
def Typename_(self):
return self.getToken(CPP14Parser.Typename_, 0)
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def Less(self):
return self.getToken(CPP14Parser.Less, 0)
[docs]
def templateparameterlist(self):
return self.getTypedRuleContext(CPP14Parser.TemplateparameterlistContext,0)
[docs]
def Greater(self):
return self.getToken(CPP14Parser.Greater, 0)
[docs]
def idexpression(self):
return self.getTypedRuleContext(CPP14Parser.IdexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_typeparameter
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeparameter" ):
listener.enterTypeparameter(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeparameter" ):
listener.exitTypeparameter(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeparameter" ):
return visitor.visitTypeparameter(self)
else:
return visitor.visitChildren(self)
[docs]
def typeparameter(self):
localctx = CPP14Parser.TypeparameterContext(self, self._ctx, self.state)
self.enterRule(localctx, 352, self.RULE_typeparameter)
self._la = 0 # Token type
try:
self.state = 2255
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,289,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2207
self.match(CPP14Parser.Class)
self.state = 2209
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,280,self._ctx)
if la_ == 1:
self.state = 2208
self.match(CPP14Parser.Ellipsis)
self.state = 2212
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,281,self._ctx)
if la_ == 1:
self.state = 2211
self.match(CPP14Parser.Identifier)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2214
self.match(CPP14Parser.Class)
self.state = 2216
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Identifier:
self.state = 2215
self.match(CPP14Parser.Identifier)
self.state = 2218
self.match(CPP14Parser.Assign)
self.state = 2219
self.thetypeid()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2220
self.match(CPP14Parser.Typename_)
self.state = 2222
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,283,self._ctx)
if la_ == 1:
self.state = 2221
self.match(CPP14Parser.Ellipsis)
self.state = 2225
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,284,self._ctx)
if la_ == 1:
self.state = 2224
self.match(CPP14Parser.Identifier)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 2227
self.match(CPP14Parser.Typename_)
self.state = 2229
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Identifier:
self.state = 2228
self.match(CPP14Parser.Identifier)
self.state = 2231
self.match(CPP14Parser.Assign)
self.state = 2232
self.thetypeid()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 2233
self.match(CPP14Parser.Template)
self.state = 2234
self.match(CPP14Parser.Less)
self.state = 2235
self.templateparameterlist(0)
self.state = 2236
self.match(CPP14Parser.Greater)
self.state = 2237
self.match(CPP14Parser.Class)
self.state = 2239
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,286,self._ctx)
if la_ == 1:
self.state = 2238
self.match(CPP14Parser.Ellipsis)
self.state = 2242
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,287,self._ctx)
if la_ == 1:
self.state = 2241
self.match(CPP14Parser.Identifier)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 2244
self.match(CPP14Parser.Template)
self.state = 2245
self.match(CPP14Parser.Less)
self.state = 2246
self.templateparameterlist(0)
self.state = 2247
self.match(CPP14Parser.Greater)
self.state = 2248
self.match(CPP14Parser.Class)
self.state = 2250
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Identifier:
self.state = 2249
self.match(CPP14Parser.Identifier)
self.state = 2252
self.match(CPP14Parser.Assign)
self.state = 2253
self.idexpression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SimpletemplateidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def templatename(self):
return self.getTypedRuleContext(CPP14Parser.TemplatenameContext,0)
[docs]
def Less(self):
return self.getToken(CPP14Parser.Less, 0)
[docs]
def Greater(self):
return self.getToken(CPP14Parser.Greater, 0)
[docs]
def templateargumentlist(self):
return self.getTypedRuleContext(CPP14Parser.TemplateargumentlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_simpletemplateid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSimpletemplateid" ):
listener.enterSimpletemplateid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSimpletemplateid" ):
listener.exitSimpletemplateid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSimpletemplateid" ):
return visitor.visitSimpletemplateid(self)
else:
return visitor.visitChildren(self)
[docs]
def simpletemplateid(self):
localctx = CPP14Parser.SimpletemplateidContext(self, self._ctx, self.state)
self.enterRule(localctx, 354, self.RULE_simpletemplateid)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2257
self.templatename()
self.state = 2258
self.match(CPP14Parser.Less)
self.state = 2260
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.Struct - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Union - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Volatile - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 2259
self.templateargumentlist(0)
self.state = 2262
self.match(CPP14Parser.Greater)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TemplateidContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def simpletemplateid(self):
return self.getTypedRuleContext(CPP14Parser.SimpletemplateidContext,0)
[docs]
def operatorfunctionid(self):
return self.getTypedRuleContext(CPP14Parser.OperatorfunctionidContext,0)
[docs]
def Less(self):
return self.getToken(CPP14Parser.Less, 0)
[docs]
def Greater(self):
return self.getToken(CPP14Parser.Greater, 0)
[docs]
def templateargumentlist(self):
return self.getTypedRuleContext(CPP14Parser.TemplateargumentlistContext,0)
[docs]
def literaloperatorid(self):
return self.getTypedRuleContext(CPP14Parser.LiteraloperatoridContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_templateid
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTemplateid" ):
listener.enterTemplateid(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTemplateid" ):
listener.exitTemplateid(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTemplateid" ):
return visitor.visitTemplateid(self)
else:
return visitor.visitChildren(self)
[docs]
def templateid(self):
localctx = CPP14Parser.TemplateidContext(self, self._ctx, self.state)
self.enterRule(localctx, 356, self.RULE_templateid)
self._la = 0 # Token type
try:
self.state = 2279
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,293,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2264
self.simpletemplateid()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2265
self.operatorfunctionid()
self.state = 2266
self.match(CPP14Parser.Less)
self.state = 2268
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.Struct - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Union - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Volatile - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 2267
self.templateargumentlist(0)
self.state = 2270
self.match(CPP14Parser.Greater)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2272
self.literaloperatorid()
self.state = 2273
self.match(CPP14Parser.Less)
self.state = 2275
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CPP14Parser.T__0) | (1 << CPP14Parser.T__1) | (1 << CPP14Parser.T__6) | (1 << CPP14Parser.T__7) | (1 << CPP14Parser.Alignof) | (1 << CPP14Parser.Auto) | (1 << CPP14Parser.Bool) | (1 << CPP14Parser.Char) | (1 << CPP14Parser.Char16) | (1 << CPP14Parser.Char32) | (1 << CPP14Parser.Class) | (1 << CPP14Parser.Const) | (1 << CPP14Parser.Const_cast) | (1 << CPP14Parser.Decltype) | (1 << CPP14Parser.Delete) | (1 << CPP14Parser.Double) | (1 << CPP14Parser.Dynamic_cast) | (1 << CPP14Parser.Enum) | (1 << CPP14Parser.Float) | (1 << CPP14Parser.Int) | (1 << CPP14Parser.Long) | (1 << CPP14Parser.New) | (1 << CPP14Parser.Noexcept) | (1 << CPP14Parser.Nullptr) | (1 << CPP14Parser.Operator) | (1 << CPP14Parser.Reinterpret_cast) | (1 << CPP14Parser.Short) | (1 << CPP14Parser.Signed) | (1 << CPP14Parser.Sizeof))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CPP14Parser.Static_cast - 65)) | (1 << (CPP14Parser.Struct - 65)) | (1 << (CPP14Parser.This - 65)) | (1 << (CPP14Parser.Typeid_ - 65)) | (1 << (CPP14Parser.Typename_ - 65)) | (1 << (CPP14Parser.Union - 65)) | (1 << (CPP14Parser.Unsigned - 65)) | (1 << (CPP14Parser.Void - 65)) | (1 << (CPP14Parser.Volatile - 65)) | (1 << (CPP14Parser.Wchar - 65)) | (1 << (CPP14Parser.LeftParen - 65)) | (1 << (CPP14Parser.LeftBracket - 65)) | (1 << (CPP14Parser.Plus - 65)) | (1 << (CPP14Parser.Minus - 65)) | (1 << (CPP14Parser.Star - 65)) | (1 << (CPP14Parser.And - 65)) | (1 << (CPP14Parser.Or - 65)) | (1 << (CPP14Parser.Tilde - 65)) | (1 << (CPP14Parser.PlusPlus - 65)) | (1 << (CPP14Parser.MinusMinus - 65)) | (1 << (CPP14Parser.Doublecolon - 65)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (CPP14Parser.Identifier - 133)) | (1 << (CPP14Parser.Integerliteral - 133)) | (1 << (CPP14Parser.Characterliteral - 133)) | (1 << (CPP14Parser.Floatingliteral - 133)) | (1 << (CPP14Parser.Stringliteral - 133)) | (1 << (CPP14Parser.Userdefinedintegerliteral - 133)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 133)) | (1 << (CPP14Parser.Userdefinedstringliteral - 133)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 133)))) != 0):
self.state = 2274
self.templateargumentlist(0)
self.state = 2277
self.match(CPP14Parser.Greater)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TemplatenameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_templatename
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTemplatename" ):
listener.enterTemplatename(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTemplatename" ):
listener.exitTemplatename(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTemplatename" ):
return visitor.visitTemplatename(self)
else:
return visitor.visitChildren(self)
[docs]
def templatename(self):
localctx = CPP14Parser.TemplatenameContext(self, self._ctx, self.state)
self.enterRule(localctx, 358, self.RULE_templatename)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2281
self.match(CPP14Parser.Identifier)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TemplateargumentlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def templateargument(self):
return self.getTypedRuleContext(CPP14Parser.TemplateargumentContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def templateargumentlist(self):
return self.getTypedRuleContext(CPP14Parser.TemplateargumentlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_templateargumentlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTemplateargumentlist" ):
listener.enterTemplateargumentlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTemplateargumentlist" ):
listener.exitTemplateargumentlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTemplateargumentlist" ):
return visitor.visitTemplateargumentlist(self)
else:
return visitor.visitChildren(self)
[docs]
def templateargumentlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.TemplateargumentlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 360
self.enterRecursionRule(localctx, 360, self.RULE_templateargumentlist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2284
self.templateargument()
self.state = 2286
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,294,self._ctx)
if la_ == 1:
self.state = 2285
self.match(CPP14Parser.Ellipsis)
self._ctx.stop = self._input.LT(-1)
self.state = 2296
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,296,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.TemplateargumentlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_templateargumentlist)
self.state = 2288
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2289
self.match(CPP14Parser.Comma)
self.state = 2290
self.templateargument()
self.state = 2292
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,295,self._ctx)
if la_ == 1:
self.state = 2291
self.match(CPP14Parser.Ellipsis)
self.state = 2298
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,296,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class TemplateargumentContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def thetypeid(self):
return self.getTypedRuleContext(CPP14Parser.ThetypeidContext,0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def idexpression(self):
return self.getTypedRuleContext(CPP14Parser.IdexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_templateargument
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTemplateargument" ):
listener.enterTemplateargument(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTemplateargument" ):
listener.exitTemplateargument(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTemplateargument" ):
return visitor.visitTemplateargument(self)
else:
return visitor.visitChildren(self)
[docs]
def templateargument(self):
localctx = CPP14Parser.TemplateargumentContext(self, self._ctx, self.state)
self.enterRule(localctx, 362, self.RULE_templateargument)
try:
self.state = 2302
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,297,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2299
self.thetypeid()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2300
self.constantexpression()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2301
self.idexpression()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypenamespecifierContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Typename_(self):
return self.getToken(CPP14Parser.Typename_, 0)
[docs]
def nestednamespecifier(self):
return self.getTypedRuleContext(CPP14Parser.NestednamespecifierContext,0)
[docs]
def Identifier(self):
return self.getToken(CPP14Parser.Identifier, 0)
[docs]
def simpletemplateid(self):
return self.getTypedRuleContext(CPP14Parser.SimpletemplateidContext,0)
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_typenamespecifier
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypenamespecifier" ):
listener.enterTypenamespecifier(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypenamespecifier" ):
listener.exitTypenamespecifier(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypenamespecifier" ):
return visitor.visitTypenamespecifier(self)
else:
return visitor.visitChildren(self)
[docs]
def typenamespecifier(self):
localctx = CPP14Parser.TypenamespecifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 364, self.RULE_typenamespecifier)
self._la = 0 # Token type
try:
self.state = 2315
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,299,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2304
self.match(CPP14Parser.Typename_)
self.state = 2305
self.nestednamespecifier(0)
self.state = 2306
self.match(CPP14Parser.Identifier)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2308
self.match(CPP14Parser.Typename_)
self.state = 2309
self.nestednamespecifier(0)
self.state = 2311
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Template:
self.state = 2310
self.match(CPP14Parser.Template)
self.state = 2313
self.simpletemplateid()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExplicitinstantiationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def declaration(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)
[docs]
def Extern(self):
return self.getToken(CPP14Parser.Extern, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_explicitinstantiation
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExplicitinstantiation" ):
listener.enterExplicitinstantiation(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExplicitinstantiation" ):
listener.exitExplicitinstantiation(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExplicitinstantiation" ):
return visitor.visitExplicitinstantiation(self)
else:
return visitor.visitChildren(self)
[docs]
def explicitinstantiation(self):
localctx = CPP14Parser.ExplicitinstantiationContext(self, self._ctx, self.state)
self.enterRule(localctx, 366, self.RULE_explicitinstantiation)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2318
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Extern:
self.state = 2317
self.match(CPP14Parser.Extern)
self.state = 2320
self.match(CPP14Parser.Template)
self.state = 2321
self.declaration()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExplicitspecializationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Template(self):
return self.getToken(CPP14Parser.Template, 0)
[docs]
def Less(self):
return self.getToken(CPP14Parser.Less, 0)
[docs]
def Greater(self):
return self.getToken(CPP14Parser.Greater, 0)
[docs]
def declaration(self):
return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_explicitspecialization
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExplicitspecialization" ):
listener.enterExplicitspecialization(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExplicitspecialization" ):
listener.exitExplicitspecialization(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExplicitspecialization" ):
return visitor.visitExplicitspecialization(self)
else:
return visitor.visitChildren(self)
[docs]
def explicitspecialization(self):
localctx = CPP14Parser.ExplicitspecializationContext(self, self._ctx, self.state)
self.enterRule(localctx, 368, self.RULE_explicitspecialization)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2323
self.match(CPP14Parser.Template)
self.state = 2324
self.match(CPP14Parser.Less)
self.state = 2325
self.match(CPP14Parser.Greater)
self.state = 2326
self.declaration()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TryblockContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Try(self):
return self.getToken(CPP14Parser.Try, 0)
[docs]
def compoundstatement(self):
return self.getTypedRuleContext(CPP14Parser.CompoundstatementContext,0)
[docs]
def handlerseq(self):
return self.getTypedRuleContext(CPP14Parser.HandlerseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_tryblock
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTryblock" ):
listener.enterTryblock(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTryblock" ):
listener.exitTryblock(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTryblock" ):
return visitor.visitTryblock(self)
else:
return visitor.visitChildren(self)
[docs]
def tryblock(self):
localctx = CPP14Parser.TryblockContext(self, self._ctx, self.state)
self.enterRule(localctx, 370, self.RULE_tryblock)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2328
self.match(CPP14Parser.Try)
self.state = 2329
self.compoundstatement()
self.state = 2330
self.handlerseq()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FunctiontryblockContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Try(self):
return self.getToken(CPP14Parser.Try, 0)
[docs]
def compoundstatement(self):
return self.getTypedRuleContext(CPP14Parser.CompoundstatementContext,0)
[docs]
def handlerseq(self):
return self.getTypedRuleContext(CPP14Parser.HandlerseqContext,0)
[docs]
def ctorinitializer(self):
return self.getTypedRuleContext(CPP14Parser.CtorinitializerContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_functiontryblock
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunctiontryblock" ):
listener.enterFunctiontryblock(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunctiontryblock" ):
listener.exitFunctiontryblock(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFunctiontryblock" ):
return visitor.visitFunctiontryblock(self)
else:
return visitor.visitChildren(self)
[docs]
def functiontryblock(self):
localctx = CPP14Parser.FunctiontryblockContext(self, self._ctx, self.state)
self.enterRule(localctx, 372, self.RULE_functiontryblock)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2332
self.match(CPP14Parser.Try)
self.state = 2334
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Colon:
self.state = 2333
self.ctorinitializer()
self.state = 2336
self.compoundstatement()
self.state = 2337
self.handlerseq()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class HandlerseqContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def handler(self):
return self.getTypedRuleContext(CPP14Parser.HandlerContext,0)
[docs]
def handlerseq(self):
return self.getTypedRuleContext(CPP14Parser.HandlerseqContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_handlerseq
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterHandlerseq" ):
listener.enterHandlerseq(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitHandlerseq" ):
listener.exitHandlerseq(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitHandlerseq" ):
return visitor.visitHandlerseq(self)
else:
return visitor.visitChildren(self)
[docs]
def handlerseq(self):
localctx = CPP14Parser.HandlerseqContext(self, self._ctx, self.state)
self.enterRule(localctx, 374, self.RULE_handlerseq)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2339
self.handler()
self.state = 2341
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,302,self._ctx)
if la_ == 1:
self.state = 2340
self.handlerseq()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class HandlerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Catch(self):
return self.getToken(CPP14Parser.Catch, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def exceptiondeclaration(self):
return self.getTypedRuleContext(CPP14Parser.ExceptiondeclarationContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def compoundstatement(self):
return self.getTypedRuleContext(CPP14Parser.CompoundstatementContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_handler
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterHandler" ):
listener.enterHandler(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitHandler" ):
listener.exitHandler(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitHandler" ):
return visitor.visitHandler(self)
else:
return visitor.visitChildren(self)
[docs]
def handler(self):
localctx = CPP14Parser.HandlerContext(self, self._ctx, self.state)
self.enterRule(localctx, 376, self.RULE_handler)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2343
self.match(CPP14Parser.Catch)
self.state = 2344
self.match(CPP14Parser.LeftParen)
self.state = 2345
self.exceptiondeclaration()
self.state = 2346
self.match(CPP14Parser.RightParen)
self.state = 2347
self.compoundstatement()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExceptiondeclarationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def typespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.TypespecifierseqContext,0)
[docs]
def declarator(self):
return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)
[docs]
def attributespecifierseq(self):
return self.getTypedRuleContext(CPP14Parser.AttributespecifierseqContext,0)
[docs]
def abstractdeclarator(self):
return self.getTypedRuleContext(CPP14Parser.AbstractdeclaratorContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_exceptiondeclaration
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExceptiondeclaration" ):
listener.enterExceptiondeclaration(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExceptiondeclaration" ):
listener.exitExceptiondeclaration(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExceptiondeclaration" ):
return visitor.visitExceptiondeclaration(self)
else:
return visitor.visitChildren(self)
[docs]
def exceptiondeclaration(self):
localctx = CPP14Parser.ExceptiondeclarationContext(self, self._ctx, self.state)
self.enterRule(localctx, 378, self.RULE_exceptiondeclaration)
self._la = 0 # Token type
try:
self.state = 2363
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,306,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2350
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 2349
self.attributespecifierseq(0)
self.state = 2352
self.typespecifierseq()
self.state = 2353
self.declarator()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2356
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.Alignas or _la==CPP14Parser.LeftBracket:
self.state = 2355
self.attributespecifierseq(0)
self.state = 2358
self.typespecifierseq()
self.state = 2360
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==CPP14Parser.T__2 or _la==CPP14Parser.Decltype or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (CPP14Parser.LeftParen - 84)) | (1 << (CPP14Parser.LeftBracket - 84)) | (1 << (CPP14Parser.Star - 84)) | (1 << (CPP14Parser.And - 84)) | (1 << (CPP14Parser.Doublecolon - 84)) | (1 << (CPP14Parser.Ellipsis - 84)) | (1 << (CPP14Parser.Identifier - 84)))) != 0):
self.state = 2359
self.abstractdeclarator()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2362
self.match(CPP14Parser.Ellipsis)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ThrowexpressionContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Throw(self):
return self.getToken(CPP14Parser.Throw, 0)
[docs]
def assignmentexpression(self):
return self.getTypedRuleContext(CPP14Parser.AssignmentexpressionContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_throwexpression
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterThrowexpression" ):
listener.enterThrowexpression(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitThrowexpression" ):
listener.exitThrowexpression(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitThrowexpression" ):
return visitor.visitThrowexpression(self)
else:
return visitor.visitChildren(self)
[docs]
def throwexpression(self):
localctx = CPP14Parser.ThrowexpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 380, self.RULE_throwexpression)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2365
self.match(CPP14Parser.Throw)
self.state = 2367
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,307,self._ctx)
if la_ == 1:
self.state = 2366
self.assignmentexpression()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExceptionspecificationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dynamicexceptionspecification(self):
return self.getTypedRuleContext(CPP14Parser.DynamicexceptionspecificationContext,0)
[docs]
def noexceptspecification(self):
return self.getTypedRuleContext(CPP14Parser.NoexceptspecificationContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_exceptionspecification
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExceptionspecification" ):
listener.enterExceptionspecification(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExceptionspecification" ):
listener.exitExceptionspecification(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExceptionspecification" ):
return visitor.visitExceptionspecification(self)
else:
return visitor.visitChildren(self)
[docs]
def exceptionspecification(self):
localctx = CPP14Parser.ExceptionspecificationContext(self, self._ctx, self.state)
self.enterRule(localctx, 382, self.RULE_exceptionspecification)
try:
self.state = 2371
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Throw]:
self.enterOuterAlt(localctx, 1)
self.state = 2369
self.dynamicexceptionspecification()
pass
elif token in [CPP14Parser.Noexcept]:
self.enterOuterAlt(localctx, 2)
self.state = 2370
self.noexceptspecification()
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
[docs]
class DynamicexceptionspecificationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Throw(self):
return self.getToken(CPP14Parser.Throw, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def typeidlist(self):
return self.getTypedRuleContext(CPP14Parser.TypeidlistContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_dynamicexceptionspecification
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDynamicexceptionspecification" ):
listener.enterDynamicexceptionspecification(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDynamicexceptionspecification" ):
listener.exitDynamicexceptionspecification(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDynamicexceptionspecification" ):
return visitor.visitDynamicexceptionspecification(self)
else:
return visitor.visitChildren(self)
[docs]
def dynamicexceptionspecification(self):
localctx = CPP14Parser.DynamicexceptionspecificationContext(self, self._ctx, self.state)
self.enterRule(localctx, 384, self.RULE_dynamicexceptionspecification)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2373
self.match(CPP14Parser.Throw)
self.state = 2374
self.match(CPP14Parser.LeftParen)
self.state = 2376
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & ((1 << (CPP14Parser.Auto - 14)) | (1 << (CPP14Parser.Bool - 14)) | (1 << (CPP14Parser.Char - 14)) | (1 << (CPP14Parser.Char16 - 14)) | (1 << (CPP14Parser.Char32 - 14)) | (1 << (CPP14Parser.Class - 14)) | (1 << (CPP14Parser.Const - 14)) | (1 << (CPP14Parser.Decltype - 14)) | (1 << (CPP14Parser.Double - 14)) | (1 << (CPP14Parser.Enum - 14)) | (1 << (CPP14Parser.Float - 14)) | (1 << (CPP14Parser.Int - 14)) | (1 << (CPP14Parser.Long - 14)) | (1 << (CPP14Parser.Short - 14)) | (1 << (CPP14Parser.Signed - 14)) | (1 << (CPP14Parser.Struct - 14)) | (1 << (CPP14Parser.Typename_ - 14)) | (1 << (CPP14Parser.Union - 14)) | (1 << (CPP14Parser.Unsigned - 14)))) != 0) or ((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (CPP14Parser.Void - 80)) | (1 << (CPP14Parser.Volatile - 80)) | (1 << (CPP14Parser.Wchar - 80)) | (1 << (CPP14Parser.Doublecolon - 80)) | (1 << (CPP14Parser.Identifier - 80)))) != 0):
self.state = 2375
self.typeidlist(0)
self.state = 2378
self.match(CPP14Parser.RightParen)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypeidlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def thetypeid(self):
return self.getTypedRuleContext(CPP14Parser.ThetypeidContext,0)
[docs]
def Ellipsis(self):
return self.getToken(CPP14Parser.Ellipsis, 0)
[docs]
def typeidlist(self):
return self.getTypedRuleContext(CPP14Parser.TypeidlistContext,0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_typeidlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypeidlist" ):
listener.enterTypeidlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypeidlist" ):
listener.exitTypeidlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypeidlist" ):
return visitor.visitTypeidlist(self)
else:
return visitor.visitChildren(self)
[docs]
def typeidlist(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = CPP14Parser.TypeidlistContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 386
self.enterRecursionRule(localctx, 386, self.RULE_typeidlist, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2381
self.thetypeid()
self.state = 2383
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,310,self._ctx)
if la_ == 1:
self.state = 2382
self.match(CPP14Parser.Ellipsis)
self._ctx.stop = self._input.LT(-1)
self.state = 2393
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,312,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = CPP14Parser.TypeidlistContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_typeidlist)
self.state = 2385
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 2386
self.match(CPP14Parser.Comma)
self.state = 2387
self.thetypeid()
self.state = 2389
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,311,self._ctx)
if la_ == 1:
self.state = 2388
self.match(CPP14Parser.Ellipsis)
self.state = 2395
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,312,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class NoexceptspecificationContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Noexcept(self):
return self.getToken(CPP14Parser.Noexcept, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def constantexpression(self):
return self.getTypedRuleContext(CPP14Parser.ConstantexpressionContext,0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_noexceptspecification
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNoexceptspecification" ):
listener.enterNoexceptspecification(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNoexceptspecification" ):
listener.exitNoexceptspecification(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNoexceptspecification" ):
return visitor.visitNoexceptspecification(self)
else:
return visitor.visitChildren(self)
[docs]
def noexceptspecification(self):
localctx = CPP14Parser.NoexceptspecificationContext(self, self._ctx, self.state)
self.enterRule(localctx, 388, self.RULE_noexceptspecification)
try:
self.state = 2402
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,313,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2396
self.match(CPP14Parser.Noexcept)
self.state = 2397
self.match(CPP14Parser.LeftParen)
self.state = 2398
self.constantexpression()
self.state = 2399
self.match(CPP14Parser.RightParen)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2401
self.match(CPP14Parser.Noexcept)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FalseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_false
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFalse" ):
listener.enterFalse(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFalse" ):
listener.exitFalse(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFalse" ):
return visitor.visitFalse(self)
else:
return visitor.visitChildren(self)
[docs]
def false(self):
localctx = CPP14Parser.FalseContext(self, self._ctx, self.state)
self.enterRule(localctx, 390, self.RULE_false)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2404
self.match(CPP14Parser.T__6)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TrueContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_true
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTrue" ):
listener.enterTrue(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTrue" ):
listener.exitTrue(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTrue" ):
return visitor.visitTrue(self)
else:
return visitor.visitChildren(self)
[docs]
def true(self):
localctx = CPP14Parser.TrueContext(self, self._ctx, self.state)
self.enterRule(localctx, 392, self.RULE_true)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2406
self.match(CPP14Parser.T__7)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TheoperatorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def New(self):
return self.getToken(CPP14Parser.New, 0)
[docs]
def Delete(self):
return self.getToken(CPP14Parser.Delete, 0)
[docs]
def LeftBracket(self):
return self.getToken(CPP14Parser.LeftBracket, 0)
[docs]
def RightBracket(self):
return self.getToken(CPP14Parser.RightBracket, 0)
[docs]
def Plus(self):
return self.getToken(CPP14Parser.Plus, 0)
[docs]
def Minus(self):
return self.getToken(CPP14Parser.Minus, 0)
[docs]
def Star(self):
return self.getToken(CPP14Parser.Star, 0)
[docs]
def Div(self):
return self.getToken(CPP14Parser.Div, 0)
[docs]
def Mod(self):
return self.getToken(CPP14Parser.Mod, 0)
[docs]
def Caret(self):
return self.getToken(CPP14Parser.Caret, 0)
[docs]
def And(self):
return self.getToken(CPP14Parser.And, 0)
[docs]
def Or(self):
return self.getToken(CPP14Parser.Or, 0)
[docs]
def Tilde(self):
return self.getToken(CPP14Parser.Tilde, 0)
[docs]
def Assign(self):
return self.getToken(CPP14Parser.Assign, 0)
[docs]
def Less(self):
return self.getToken(CPP14Parser.Less, 0)
[docs]
def Greater(self):
return self.getToken(CPP14Parser.Greater, 0)
[docs]
def PlusAssign(self):
return self.getToken(CPP14Parser.PlusAssign, 0)
[docs]
def MinusAssign(self):
return self.getToken(CPP14Parser.MinusAssign, 0)
[docs]
def StarAssign(self):
return self.getToken(CPP14Parser.StarAssign, 0)
[docs]
def DivAssign(self):
return self.getToken(CPP14Parser.DivAssign, 0)
[docs]
def ModAssign(self):
return self.getToken(CPP14Parser.ModAssign, 0)
[docs]
def XorAssign(self):
return self.getToken(CPP14Parser.XorAssign, 0)
[docs]
def AndAssign(self):
return self.getToken(CPP14Parser.AndAssign, 0)
[docs]
def OrAssign(self):
return self.getToken(CPP14Parser.OrAssign, 0)
[docs]
def LeftShift(self):
return self.getToken(CPP14Parser.LeftShift, 0)
[docs]
def RightShift(self):
return self.getToken(CPP14Parser.RightShift, 0)
[docs]
def RightShiftAssign(self):
return self.getToken(CPP14Parser.RightShiftAssign, 0)
[docs]
def LeftShiftAssign(self):
return self.getToken(CPP14Parser.LeftShiftAssign, 0)
[docs]
def Equal(self):
return self.getToken(CPP14Parser.Equal, 0)
[docs]
def NotEqual(self):
return self.getToken(CPP14Parser.NotEqual, 0)
[docs]
def LessEqual(self):
return self.getToken(CPP14Parser.LessEqual, 0)
[docs]
def GreaterEqual(self):
return self.getToken(CPP14Parser.GreaterEqual, 0)
[docs]
def PlusPlus(self):
return self.getToken(CPP14Parser.PlusPlus, 0)
[docs]
def MinusMinus(self):
return self.getToken(CPP14Parser.MinusMinus, 0)
[docs]
def Comma(self):
return self.getToken(CPP14Parser.Comma, 0)
[docs]
def ArrowStar(self):
return self.getToken(CPP14Parser.ArrowStar, 0)
[docs]
def Arrow(self):
return self.getToken(CPP14Parser.Arrow, 0)
[docs]
def LeftParen(self):
return self.getToken(CPP14Parser.LeftParen, 0)
[docs]
def RightParen(self):
return self.getToken(CPP14Parser.RightParen, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_theoperator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTheoperator" ):
listener.enterTheoperator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTheoperator" ):
listener.exitTheoperator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTheoperator" ):
return visitor.visitTheoperator(self)
else:
return visitor.visitChildren(self)
[docs]
def theoperator(self):
localctx = CPP14Parser.TheoperatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 394, self.RULE_theoperator)
try:
self.state = 2459
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,314,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 2408
self.match(CPP14Parser.New)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 2409
self.match(CPP14Parser.Delete)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 2410
self.match(CPP14Parser.New)
self.state = 2411
self.match(CPP14Parser.LeftBracket)
self.state = 2412
self.match(CPP14Parser.RightBracket)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 2413
self.match(CPP14Parser.Delete)
self.state = 2414
self.match(CPP14Parser.LeftBracket)
self.state = 2415
self.match(CPP14Parser.RightBracket)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 2416
self.match(CPP14Parser.Plus)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 2417
self.match(CPP14Parser.Minus)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 2418
self.match(CPP14Parser.Star)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 2419
self.match(CPP14Parser.Div)
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 2420
self.match(CPP14Parser.Mod)
pass
elif la_ == 10:
self.enterOuterAlt(localctx, 10)
self.state = 2421
self.match(CPP14Parser.Caret)
pass
elif la_ == 11:
self.enterOuterAlt(localctx, 11)
self.state = 2422
self.match(CPP14Parser.And)
pass
elif la_ == 12:
self.enterOuterAlt(localctx, 12)
self.state = 2423
self.match(CPP14Parser.Or)
pass
elif la_ == 13:
self.enterOuterAlt(localctx, 13)
self.state = 2424
self.match(CPP14Parser.Tilde)
pass
elif la_ == 14:
self.enterOuterAlt(localctx, 14)
self.state = 2425
self.match(CPP14Parser.T__0)
pass
elif la_ == 15:
self.enterOuterAlt(localctx, 15)
self.state = 2426
self.match(CPP14Parser.T__1)
pass
elif la_ == 16:
self.enterOuterAlt(localctx, 16)
self.state = 2427
self.match(CPP14Parser.Assign)
pass
elif la_ == 17:
self.enterOuterAlt(localctx, 17)
self.state = 2428
self.match(CPP14Parser.Less)
pass
elif la_ == 18:
self.enterOuterAlt(localctx, 18)
self.state = 2429
self.match(CPP14Parser.Greater)
pass
elif la_ == 19:
self.enterOuterAlt(localctx, 19)
self.state = 2430
self.match(CPP14Parser.PlusAssign)
pass
elif la_ == 20:
self.enterOuterAlt(localctx, 20)
self.state = 2431
self.match(CPP14Parser.MinusAssign)
pass
elif la_ == 21:
self.enterOuterAlt(localctx, 21)
self.state = 2432
self.match(CPP14Parser.StarAssign)
pass
elif la_ == 22:
self.enterOuterAlt(localctx, 22)
self.state = 2433
self.match(CPP14Parser.DivAssign)
pass
elif la_ == 23:
self.enterOuterAlt(localctx, 23)
self.state = 2434
self.match(CPP14Parser.ModAssign)
pass
elif la_ == 24:
self.enterOuterAlt(localctx, 24)
self.state = 2435
self.match(CPP14Parser.XorAssign)
pass
elif la_ == 25:
self.enterOuterAlt(localctx, 25)
self.state = 2436
self.match(CPP14Parser.AndAssign)
pass
elif la_ == 26:
self.enterOuterAlt(localctx, 26)
self.state = 2437
self.match(CPP14Parser.OrAssign)
pass
elif la_ == 27:
self.enterOuterAlt(localctx, 27)
self.state = 2438
self.match(CPP14Parser.LeftShift)
pass
elif la_ == 28:
self.enterOuterAlt(localctx, 28)
self.state = 2439
self.match(CPP14Parser.RightShift)
pass
elif la_ == 29:
self.enterOuterAlt(localctx, 29)
self.state = 2440
self.match(CPP14Parser.RightShiftAssign)
pass
elif la_ == 30:
self.enterOuterAlt(localctx, 30)
self.state = 2441
self.match(CPP14Parser.LeftShiftAssign)
pass
elif la_ == 31:
self.enterOuterAlt(localctx, 31)
self.state = 2442
self.match(CPP14Parser.Equal)
pass
elif la_ == 32:
self.enterOuterAlt(localctx, 32)
self.state = 2443
self.match(CPP14Parser.NotEqual)
pass
elif la_ == 33:
self.enterOuterAlt(localctx, 33)
self.state = 2444
self.match(CPP14Parser.LessEqual)
pass
elif la_ == 34:
self.enterOuterAlt(localctx, 34)
self.state = 2445
self.match(CPP14Parser.GreaterEqual)
pass
elif la_ == 35:
self.enterOuterAlt(localctx, 35)
self.state = 2446
self.match(CPP14Parser.T__2)
pass
elif la_ == 36:
self.enterOuterAlt(localctx, 36)
self.state = 2447
self.match(CPP14Parser.T__3)
pass
elif la_ == 37:
self.enterOuterAlt(localctx, 37)
self.state = 2448
self.match(CPP14Parser.T__4)
pass
elif la_ == 38:
self.enterOuterAlt(localctx, 38)
self.state = 2449
self.match(CPP14Parser.T__5)
pass
elif la_ == 39:
self.enterOuterAlt(localctx, 39)
self.state = 2450
self.match(CPP14Parser.PlusPlus)
pass
elif la_ == 40:
self.enterOuterAlt(localctx, 40)
self.state = 2451
self.match(CPP14Parser.MinusMinus)
pass
elif la_ == 41:
self.enterOuterAlt(localctx, 41)
self.state = 2452
self.match(CPP14Parser.Comma)
pass
elif la_ == 42:
self.enterOuterAlt(localctx, 42)
self.state = 2453
self.match(CPP14Parser.ArrowStar)
pass
elif la_ == 43:
self.enterOuterAlt(localctx, 43)
self.state = 2454
self.match(CPP14Parser.Arrow)
pass
elif la_ == 44:
self.enterOuterAlt(localctx, 44)
self.state = 2455
self.match(CPP14Parser.LeftParen)
self.state = 2456
self.match(CPP14Parser.RightParen)
pass
elif la_ == 45:
self.enterOuterAlt(localctx, 45)
self.state = 2457
self.match(CPP14Parser.LeftBracket)
self.state = 2458
self.match(CPP14Parser.RightBracket)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class LiteralContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Integerliteral(self):
return self.getToken(CPP14Parser.Integerliteral, 0)
[docs]
def Characterliteral(self):
return self.getToken(CPP14Parser.Characterliteral, 0)
[docs]
def Floatingliteral(self):
return self.getToken(CPP14Parser.Floatingliteral, 0)
[docs]
def Stringliteral(self):
return self.getToken(CPP14Parser.Stringliteral, 0)
[docs]
def booleanliteral(self):
return self.getTypedRuleContext(CPP14Parser.BooleanliteralContext,0)
[docs]
def pointerliteral(self):
return self.getTypedRuleContext(CPP14Parser.PointerliteralContext,0)
[docs]
def userdefinedliteral(self):
return self.getTypedRuleContext(CPP14Parser.UserdefinedliteralContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_literal
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLiteral" ):
listener.enterLiteral(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLiteral" ):
listener.exitLiteral(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLiteral" ):
return visitor.visitLiteral(self)
else:
return visitor.visitChildren(self)
[docs]
def literal(self):
localctx = CPP14Parser.LiteralContext(self, self._ctx, self.state)
self.enterRule(localctx, 396, self.RULE_literal)
try:
self.state = 2468
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.Integerliteral]:
self.enterOuterAlt(localctx, 1)
self.state = 2461
self.match(CPP14Parser.Integerliteral)
pass
elif token in [CPP14Parser.Characterliteral]:
self.enterOuterAlt(localctx, 2)
self.state = 2462
self.match(CPP14Parser.Characterliteral)
pass
elif token in [CPP14Parser.Floatingliteral]:
self.enterOuterAlt(localctx, 3)
self.state = 2463
self.match(CPP14Parser.Floatingliteral)
pass
elif token in [CPP14Parser.Stringliteral]:
self.enterOuterAlt(localctx, 4)
self.state = 2464
self.match(CPP14Parser.Stringliteral)
pass
elif token in [CPP14Parser.T__6, CPP14Parser.T__7]:
self.enterOuterAlt(localctx, 5)
self.state = 2465
self.booleanliteral()
pass
elif token in [CPP14Parser.Nullptr]:
self.enterOuterAlt(localctx, 6)
self.state = 2466
self.pointerliteral()
pass
elif token in [CPP14Parser.Userdefinedintegerliteral, CPP14Parser.Userdefinedfloatingliteral, CPP14Parser.Userdefinedstringliteral, CPP14Parser.Userdefinedcharacterliteral]:
self.enterOuterAlt(localctx, 7)
self.state = 2467
self.userdefinedliteral()
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
[docs]
class BooleanliteralContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def false(self):
return self.getTypedRuleContext(CPP14Parser.FalseContext,0)
[docs]
def true(self):
return self.getTypedRuleContext(CPP14Parser.TrueContext,0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_booleanliteral
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBooleanliteral" ):
listener.enterBooleanliteral(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBooleanliteral" ):
listener.exitBooleanliteral(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBooleanliteral" ):
return visitor.visitBooleanliteral(self)
else:
return visitor.visitChildren(self)
[docs]
def booleanliteral(self):
localctx = CPP14Parser.BooleanliteralContext(self, self._ctx, self.state)
self.enterRule(localctx, 398, self.RULE_booleanliteral)
try:
self.state = 2472
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [CPP14Parser.T__6]:
self.enterOuterAlt(localctx, 1)
self.state = 2470
self.false()
pass
elif token in [CPP14Parser.T__7]:
self.enterOuterAlt(localctx, 2)
self.state = 2471
self.true()
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
[docs]
class PointerliteralContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Nullptr(self):
return self.getToken(CPP14Parser.Nullptr, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_pointerliteral
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointerliteral" ):
listener.enterPointerliteral(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointerliteral" ):
listener.exitPointerliteral(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPointerliteral" ):
return visitor.visitPointerliteral(self)
else:
return visitor.visitChildren(self)
[docs]
def pointerliteral(self):
localctx = CPP14Parser.PointerliteralContext(self, self._ctx, self.state)
self.enterRule(localctx, 400, self.RULE_pointerliteral)
try:
self.enterOuterAlt(localctx, 1)
self.state = 2474
self.match(CPP14Parser.Nullptr)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class UserdefinedliteralContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Userdefinedintegerliteral(self):
return self.getToken(CPP14Parser.Userdefinedintegerliteral, 0)
[docs]
def Userdefinedfloatingliteral(self):
return self.getToken(CPP14Parser.Userdefinedfloatingliteral, 0)
[docs]
def Userdefinedstringliteral(self):
return self.getToken(CPP14Parser.Userdefinedstringliteral, 0)
[docs]
def Userdefinedcharacterliteral(self):
return self.getToken(CPP14Parser.Userdefinedcharacterliteral, 0)
[docs]
def getRuleIndex(self):
return CPP14Parser.RULE_userdefinedliteral
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUserdefinedliteral" ):
listener.enterUserdefinedliteral(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUserdefinedliteral" ):
listener.exitUserdefinedliteral(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitUserdefinedliteral" ):
return visitor.visitUserdefinedliteral(self)
else:
return visitor.visitChildren(self)
[docs]
def userdefinedliteral(self):
localctx = CPP14Parser.UserdefinedliteralContext(self, self._ctx, self.state)
self.enterRule(localctx, 402, self.RULE_userdefinedliteral)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 2476
_la = self._input.LA(1)
if not(((((_la - 143)) & ~0x3f) == 0 and ((1 << (_la - 143)) & ((1 << (CPP14Parser.Userdefinedintegerliteral - 143)) | (1 << (CPP14Parser.Userdefinedfloatingliteral - 143)) | (1 << (CPP14Parser.Userdefinedstringliteral - 143)) | (1 << (CPP14Parser.Userdefinedcharacterliteral - 143)))) != 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
[docs]
def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
if self._predicates == None:
self._predicates = dict()
self._predicates[5] = self.nestednamespecifier_sempred
self._predicates[10] = self.capturelist_sempred
self._predicates[15] = self.postfixexpression_sempred
self._predicates[26] = self.noptrnewdeclarator_sempred
self._predicates[31] = self.pmexpression_sempred
self._predicates[32] = self.multiplicativeexpression_sempred
self._predicates[33] = self.additiveexpression_sempred
self._predicates[34] = self.shiftexpression_sempred
self._predicates[36] = self.relationalexpression_sempred
self._predicates[37] = self.equalityexpression_sempred
self._predicates[38] = self.andexpression_sempred
self._predicates[39] = self.exclusiveorexpression_sempred
self._predicates[40] = self.inclusiveorexpression_sempred
self._predicates[41] = self.logicalandexpression_sempred
self._predicates[42] = self.logicalorexpression_sempred
self._predicates[46] = self.expression_sempred
self._predicates[52] = self.statementseq_sempred
self._predicates[61] = self.declarationseq_sempred
self._predicates[88] = self.enumeratorlist_sempred
self._predicates[106] = self.attributespecifierseq_sempred
self._predicates[109] = self.attributelist_sempred
self._predicates[115] = self.balancedtokenseq_sempred
self._predicates[117] = self.initdeclaratorlist_sempred
self._predicates[121] = self.noptrdeclarator_sempred
self._predicates[132] = self.noptrabstractdeclarator_sempred
self._predicates[134] = self.noptrabstractpackdeclarator_sempred
self._predicates[136] = self.parameterdeclarationlist_sempred
self._predicates[143] = self.initializerlist_sempred
self._predicates[153] = self.memberdeclaratorlist_sempred
self._predicates[155] = self.virtspecifierseq_sempred
self._predicates[159] = self.basespecifierlist_sempred
self._predicates[174] = self.templateparameterlist_sempred
self._predicates[180] = self.templateargumentlist_sempred
self._predicates[193] = self.typeidlist_sempred
pred = self._predicates.get(ruleIndex, None)
if pred is None:
raise Exception("No predicate with index:" + str(ruleIndex))
else:
return pred(localctx, predIndex)
[docs]
def nestednamespecifier_sempred(self, localctx:NestednamespecifierContext, predIndex:int):
if predIndex == 0:
return self.precpred(self._ctx, 2)
if predIndex == 1:
return self.precpred(self._ctx, 1)
[docs]
def capturelist_sempred(self, localctx:CapturelistContext, predIndex:int):
if predIndex == 2:
return self.precpred(self._ctx, 1)
[docs]
def postfixexpression_sempred(self, localctx:PostfixexpressionContext, predIndex:int):
if predIndex == 3:
return self.precpred(self._ctx, 19)
if predIndex == 4:
return self.precpred(self._ctx, 18)
if predIndex == 5:
return self.precpred(self._ctx, 17)
if predIndex == 6:
return self.precpred(self._ctx, 12)
if predIndex == 7:
return self.precpred(self._ctx, 11)
if predIndex == 8:
return self.precpred(self._ctx, 10)
if predIndex == 9:
return self.precpred(self._ctx, 9)
if predIndex == 10:
return self.precpred(self._ctx, 8)
if predIndex == 11:
return self.precpred(self._ctx, 7)
[docs]
def noptrnewdeclarator_sempred(self, localctx:NoptrnewdeclaratorContext, predIndex:int):
if predIndex == 12:
return self.precpred(self._ctx, 1)
[docs]
def pmexpression_sempred(self, localctx:PmexpressionContext, predIndex:int):
if predIndex == 13:
return self.precpred(self._ctx, 2)
if predIndex == 14:
return self.precpred(self._ctx, 1)
[docs]
def multiplicativeexpression_sempred(self, localctx:MultiplicativeexpressionContext, predIndex:int):
if predIndex == 15:
return self.precpred(self._ctx, 3)
if predIndex == 16:
return self.precpred(self._ctx, 2)
if predIndex == 17:
return self.precpred(self._ctx, 1)
[docs]
def additiveexpression_sempred(self, localctx:AdditiveexpressionContext, predIndex:int):
if predIndex == 18:
return self.precpred(self._ctx, 2)
if predIndex == 19:
return self.precpred(self._ctx, 1)
[docs]
def shiftexpression_sempred(self, localctx:ShiftexpressionContext, predIndex:int):
if predIndex == 20:
return self.precpred(self._ctx, 1)
[docs]
def relationalexpression_sempred(self, localctx:RelationalexpressionContext, predIndex:int):
if predIndex == 21:
return self.precpred(self._ctx, 4)
if predIndex == 22:
return self.precpred(self._ctx, 3)
if predIndex == 23:
return self.precpred(self._ctx, 2)
if predIndex == 24:
return self.precpred(self._ctx, 1)
[docs]
def equalityexpression_sempred(self, localctx:EqualityexpressionContext, predIndex:int):
if predIndex == 25:
return self.precpred(self._ctx, 2)
if predIndex == 26:
return self.precpred(self._ctx, 1)
[docs]
def andexpression_sempred(self, localctx:AndexpressionContext, predIndex:int):
if predIndex == 27:
return self.precpred(self._ctx, 1)
[docs]
def exclusiveorexpression_sempred(self, localctx:ExclusiveorexpressionContext, predIndex:int):
if predIndex == 28:
return self.precpred(self._ctx, 1)
[docs]
def inclusiveorexpression_sempred(self, localctx:InclusiveorexpressionContext, predIndex:int):
if predIndex == 29:
return self.precpred(self._ctx, 1)
[docs]
def logicalandexpression_sempred(self, localctx:LogicalandexpressionContext, predIndex:int):
if predIndex == 30:
return self.precpred(self._ctx, 2)
if predIndex == 31:
return self.precpred(self._ctx, 1)
[docs]
def logicalorexpression_sempred(self, localctx:LogicalorexpressionContext, predIndex:int):
if predIndex == 32:
return self.precpred(self._ctx, 2)
if predIndex == 33:
return self.precpred(self._ctx, 1)
[docs]
def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
if predIndex == 34:
return self.precpred(self._ctx, 1)
[docs]
def statementseq_sempred(self, localctx:StatementseqContext, predIndex:int):
if predIndex == 35:
return self.precpred(self._ctx, 1)
[docs]
def declarationseq_sempred(self, localctx:DeclarationseqContext, predIndex:int):
if predIndex == 36:
return self.precpred(self._ctx, 1)
[docs]
def enumeratorlist_sempred(self, localctx:EnumeratorlistContext, predIndex:int):
if predIndex == 37:
return self.precpred(self._ctx, 1)
[docs]
def attributespecifierseq_sempred(self, localctx:AttributespecifierseqContext, predIndex:int):
if predIndex == 38:
return self.precpred(self._ctx, 1)
[docs]
def attributelist_sempred(self, localctx:AttributelistContext, predIndex:int):
if predIndex == 39:
return self.precpred(self._ctx, 3)
if predIndex == 40:
return self.precpred(self._ctx, 1)
[docs]
def balancedtokenseq_sempred(self, localctx:BalancedtokenseqContext, predIndex:int):
if predIndex == 41:
return self.precpred(self._ctx, 1)
[docs]
def initdeclaratorlist_sempred(self, localctx:InitdeclaratorlistContext, predIndex:int):
if predIndex == 42:
return self.precpred(self._ctx, 1)
[docs]
def noptrdeclarator_sempred(self, localctx:NoptrdeclaratorContext, predIndex:int):
if predIndex == 43:
return self.precpred(self._ctx, 3)
if predIndex == 44:
return self.precpred(self._ctx, 2)
[docs]
def noptrabstractdeclarator_sempred(self, localctx:NoptrabstractdeclaratorContext, predIndex:int):
if predIndex == 45:
return self.precpred(self._ctx, 5)
if predIndex == 46:
return self.precpred(self._ctx, 3)
[docs]
def noptrabstractpackdeclarator_sempred(self, localctx:NoptrabstractpackdeclaratorContext, predIndex:int):
if predIndex == 47:
return self.precpred(self._ctx, 3)
if predIndex == 48:
return self.precpred(self._ctx, 2)
[docs]
def parameterdeclarationlist_sempred(self, localctx:ParameterdeclarationlistContext, predIndex:int):
if predIndex == 49:
return self.precpred(self._ctx, 1)
[docs]
def initializerlist_sempred(self, localctx:InitializerlistContext, predIndex:int):
if predIndex == 50:
return self.precpred(self._ctx, 1)
[docs]
def memberdeclaratorlist_sempred(self, localctx:MemberdeclaratorlistContext, predIndex:int):
if predIndex == 51:
return self.precpred(self._ctx, 1)
[docs]
def virtspecifierseq_sempred(self, localctx:VirtspecifierseqContext, predIndex:int):
if predIndex == 52:
return self.precpred(self._ctx, 1)
[docs]
def basespecifierlist_sempred(self, localctx:BasespecifierlistContext, predIndex:int):
if predIndex == 53:
return self.precpred(self._ctx, 1)
[docs]
def templateparameterlist_sempred(self, localctx:TemplateparameterlistContext, predIndex:int):
if predIndex == 54:
return self.precpred(self._ctx, 1)
[docs]
def templateargumentlist_sempred(self, localctx:TemplateargumentlistContext, predIndex:int):
if predIndex == 55:
return self.precpred(self._ctx, 1)
[docs]
def typeidlist_sempred(self, localctx:TypeidlistContext, predIndex:int):
if predIndex == 56:
return self.precpred(self._ctx, 1)