| # Generated from C.bnf by ANTLR 4.5.1 |
| # encoding: utf-8 |
| from antlr4 import * |
| from io import StringIO |
| |
| def serializedATN(): |
| with StringIO() as buf: |
| buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3s") |
| buf.write("\u04e9\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\3\2") |
| buf.write("\3\2\3\2\6\2\u00ae\n\2\r\2\16\2\u00af\3\2\3\2\3\2\3\2") |
| buf.write("\3\2\3\2\5\2\u00b8\n\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2") |
| buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\5\2\u00cc\n\2") |
| buf.write("\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\7") |
| buf.write("\4\u00db\n\4\f\4\16\4\u00de\13\4\3\5\3\5\3\5\3\5\3\5\3") |
| buf.write("\5\3\5\5\5\u00e7\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3") |
| buf.write("\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6") |
| buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u010b") |
| buf.write("\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u0115\n\6\3\6") |
| buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\7\6\u0122\n\6") |
| buf.write("\f\6\16\6\u0125\13\6\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u012d") |
| buf.write("\n\7\f\7\16\7\u0130\13\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3") |
| buf.write("\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b") |
| buf.write("\3\b\5\b\u0148\n\b\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n") |
| buf.write("\3\n\3\n\3\n\3\n\3\n\5\n\u0158\n\n\3\13\3\13\3\13\3\13") |
| buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\7\13\u0166\n") |
| buf.write("\13\f\13\16\13\u0169\13\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f") |
| buf.write("\3\f\3\f\7\f\u0174\n\f\f\f\16\f\u0177\13\f\3\r\3\r\3\r") |
| buf.write("\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u0182\n\r\f\r\16\r\u0185") |
| buf.write("\13\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16") |
| buf.write("\3\16\3\16\3\16\3\16\3\16\7\16\u0196\n\16\f\16\16\16\u0199") |
| buf.write("\13\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\7") |
| buf.write("\17\u01a4\n\17\f\17\16\17\u01a7\13\17\3\20\3\20\3\20\3") |
| buf.write("\20\3\20\3\20\7\20\u01af\n\20\f\20\16\20\u01b2\13\20\3") |
| buf.write("\21\3\21\3\21\3\21\3\21\3\21\7\21\u01ba\n\21\f\21\16\21") |
| buf.write("\u01bd\13\21\3\22\3\22\3\22\3\22\3\22\3\22\7\22\u01c5") |
| buf.write("\n\22\f\22\16\22\u01c8\13\22\3\23\3\23\3\23\3\23\3\23") |
| buf.write("\3\23\7\23\u01d0\n\23\f\23\16\23\u01d3\13\23\3\24\3\24") |
| buf.write("\3\24\3\24\3\24\3\24\7\24\u01db\n\24\f\24\16\24\u01de") |
| buf.write("\13\24\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u01e6\n\25\3") |
| buf.write("\26\3\26\3\26\3\26\3\26\5\26\u01ed\n\26\3\27\3\27\3\30") |
| buf.write("\3\30\3\30\3\30\3\30\3\30\7\30\u01f7\n\30\f\30\16\30\u01fa") |
| buf.write("\13\30\3\31\3\31\3\32\3\32\5\32\u0200\n\32\3\32\3\32\3") |
| buf.write("\32\5\32\u0205\n\32\3\33\6\33\u0208\n\33\r\33\16\33\u0209") |
| buf.write("\3\34\6\34\u020d\n\34\r\34\16\34\u020e\3\35\3\35\3\35") |
| buf.write("\3\35\3\35\5\35\u0216\n\35\3\36\3\36\3\36\3\36\3\36\3") |
| buf.write("\36\7\36\u021e\n\36\f\36\16\36\u0221\13\36\3\37\3\37\3") |
| buf.write("\37\3\37\3\37\5\37\u0228\n\37\3 \3 \3!\3!\3!\3!\3!\3!") |
| buf.write("\3!\3!\3!\3!\3!\3!\3!\3!\5!\u023a\n!\3\"\3\"\5\"\u023e") |
| buf.write("\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u0247\n\"\3#\3#\3") |
| buf.write("$\3$\3$\3$\3$\7$\u0250\n$\f$\16$\u0253\13$\3%\3%\5%\u0257") |
| buf.write("\n%\3%\3%\3%\5%\u025c\n%\3&\3&\5&\u0260\n&\3&\3&\5&\u0264") |
| buf.write("\n&\5&\u0266\n&\3\'\3\'\3\'\3\'\3\'\3\'\7\'\u026e\n\'") |
| buf.write("\f\'\16\'\u0271\13\'\3(\3(\5(\u0275\n(\3(\3(\5(\u0279") |
| buf.write("\n(\3)\3)\5)\u027d\n)\3)\3)\3)\3)\3)\3)\5)\u0285\n)\3") |
| buf.write(")\3)\3)\3)\3)\3)\3)\5)\u028e\n)\3*\3*\3*\3*\3*\3*\7*\u0296") |
| buf.write("\n*\f*\16*\u0299\13*\3+\3+\3+\3+\3+\5+\u02a0\n+\3,\3,") |
| buf.write("\3-\3-\3-\3-\3-\3.\3.\3/\3/\3/\3/\3/\3/\5/\u02b1\n/\3") |
| buf.write("\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\5\60") |
| buf.write("\u02bd\n\60\3\61\5\61\u02c0\n\61\3\61\3\61\7\61\u02c4") |
| buf.write("\n\61\f\61\16\61\u02c7\13\61\3\62\3\62\3\62\3\62\3\62") |
| buf.write("\3\62\5\62\u02cf\n\62\3\62\3\62\3\62\5\62\u02d4\n\62\3") |
| buf.write("\62\5\62\u02d7\n\62\3\62\3\62\3\62\3\62\3\62\5\62\u02de") |
| buf.write("\n\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62") |
| buf.write("\3\62\3\62\3\62\5\62\u02ed\n\62\3\62\3\62\3\62\3\62\3") |
| buf.write("\62\3\62\3\62\3\62\3\62\3\62\5\62\u02f9\n\62\3\62\7\62") |
| buf.write("\u02fc\n\62\f\62\16\62\u02ff\13\62\3\63\3\63\3\63\6\63") |
| buf.write("\u0304\n\63\r\63\16\63\u0305\3\63\3\63\5\63\u030a\n\63") |
| buf.write("\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\65\3\65\3\65\7\65") |
| buf.write("\u0316\n\65\f\65\16\65\u0319\13\65\3\65\5\65\u031c\n\65") |
| buf.write("\3\66\3\66\3\66\5\66\u0321\n\66\3\66\5\66\u0324\n\66\3") |
| buf.write("\66\5\66\u0327\n\66\3\67\3\67\3\67\3\67\3\67\7\67\u032e") |
| buf.write("\n\67\f\67\16\67\u0331\13\67\38\38\58\u0335\n8\38\38\5") |
| buf.write("8\u0339\n8\38\38\38\58\u033e\n8\38\38\58\u0342\n8\38\5") |
| buf.write("8\u0345\n8\39\39\39\39\39\79\u034c\n9\f9\169\u034f\13") |
| buf.write("9\3:\3:\3:\3:\3:\5:\u0356\n:\3;\3;\3;\3;\3;\3;\7;\u035e") |
| buf.write("\n;\f;\16;\u0361\13;\3<\3<\3<\3<\3<\5<\u0368\n<\5<\u036a") |
| buf.write("\n<\3=\3=\3=\3=\3=\3=\7=\u0372\n=\f=\16=\u0375\13=\3>") |
| buf.write("\3>\5>\u0379\n>\3?\3?\5?\u037d\n?\3?\3?\7?\u0381\n?\f") |
| buf.write("?\16?\u0384\13?\5?\u0386\n?\3@\3@\3@\3@\3@\7@\u038d\n") |
| buf.write("@\f@\16@\u0390\13@\3@\3@\5@\u0394\n@\3@\5@\u0397\n@\3") |
| buf.write("@\3@\3@\3@\5@\u039d\n@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3") |
| buf.write("@\3@\3@\3@\5@\u03ad\n@\3@\3@\7@\u03b1\n@\f@\16@\u03b4") |
| buf.write("\13@\5@\u03b6\n@\3@\3@\3@\5@\u03bb\n@\3@\5@\u03be\n@\3") |
| buf.write("@\3@\3@\3@\3@\5@\u03c5\n@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3") |
| buf.write("@\3@\3@\3@\3@\3@\3@\3@\5@\u03d8\n@\3@\3@\7@\u03dc\n@\f") |
| buf.write("@\16@\u03df\13@\7@\u03e1\n@\f@\16@\u03e4\13@\3A\3A\3B") |
| buf.write("\3B\3B\3B\3B\3B\3B\3B\3B\3B\5B\u03f2\nB\3C\3C\5C\u03f6") |
| buf.write("\nC\3C\3C\3C\3C\3C\5C\u03fd\nC\3C\7C\u0400\nC\fC\16C\u0403") |
| buf.write("\13C\3D\3D\3D\3E\3E\3E\3E\3E\7E\u040d\nE\fE\16E\u0410") |
| buf.write("\13E\3F\3F\3F\3F\3F\3F\5F\u0418\nF\3G\3G\3G\3G\3G\6G\u041f") |
| buf.write("\nG\rG\16G\u0420\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3H\3") |
| buf.write("H\3H\3H\7H\u0432\nH\fH\16H\u0435\13H\5H\u0437\nH\3H\3") |
| buf.write("H\3H\3H\7H\u043d\nH\fH\16H\u0440\13H\5H\u0442\nH\7H\u0444") |
| buf.write("\nH\fH\16H\u0447\13H\3H\3H\5H\u044b\nH\3I\3I\3I\3I\3I") |
| buf.write("\3I\3I\3I\3I\3I\3I\5I\u0458\nI\3J\3J\5J\u045c\nJ\3J\3") |
| buf.write("J\3K\3K\3K\3K\3K\7K\u0465\nK\fK\16K\u0468\13K\3L\3L\5") |
| buf.write("L\u046c\nL\3M\5M\u046f\nM\3M\3M\3N\3N\3N\3N\3N\3N\3N\5") |
| buf.write("N\u047a\nN\3N\3N\3N\3N\3N\3N\5N\u0482\nN\3O\3O\3O\3O\3") |
| buf.write("O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\5O\u0495\nO\3O\3") |
| buf.write("O\5O\u0499\nO\3O\3O\5O\u049d\nO\3O\3O\3O\3O\3O\3O\5O\u04a5") |
| buf.write("\nO\3O\3O\5O\u04a9\nO\3O\3O\3O\5O\u04ae\nO\3P\3P\3P\3") |
| buf.write("P\3P\3P\3P\3P\3P\5P\u04b9\nP\3P\3P\3P\3P\3P\5P\u04c0\n") |
| buf.write("P\3Q\5Q\u04c3\nQ\3Q\3Q\3R\3R\3R\3R\3R\7R\u04cc\nR\fR\16") |
| buf.write("R\u04cf\13R\3S\3S\3S\5S\u04d4\nS\3T\5T\u04d7\nT\3T\3T") |
| buf.write("\5T\u04db\nT\3T\3T\3U\3U\3U\3U\3U\7U\u04e4\nU\fU\16U\u04e7") |
| buf.write("\13U\3U\2\36\6\n\f\24\26\30\32\34\36 \"$&.:FLRbptx~\u0084") |
| buf.write("\u0088\u0094\u00a2\u00a8V\2\4\6\b\n\f\16\20\22\24\26\30") |
| buf.write("\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`b") |
| buf.write("dfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c") |
| buf.write("\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e") |
| buf.write("\u00a0\u00a2\u00a4\u00a6\u00a8\2\16\7\2IIKKMMPPUV\3\2") |
| buf.write("[e\b\2\21\21\34\34$$**--<<\n\2\6\b\24\24\31\31\35\35\"") |
| buf.write("#\'(/\60\66\67\3\2\6\b\4\2++..\6\2\25\25%%\61\61\65\65") |
| buf.write("\5\2\n\13!!::\4\2=>ZZ\3\2=>\4\2\r\r\17\17\4\2\20\20\61") |
| buf.write("\61\u0559\2\u00cb\3\2\2\2\4\u00cd\3\2\2\2\6\u00d4\3\2") |
| buf.write("\2\2\b\u00e6\3\2\2\2\n\u010a\3\2\2\2\f\u0126\3\2\2\2\16") |
| buf.write("\u0147\3\2\2\2\20\u0149\3\2\2\2\22\u0157\3\2\2\2\24\u0159") |
| buf.write("\3\2\2\2\26\u016a\3\2\2\2\30\u0178\3\2\2\2\32\u0186\3") |
| buf.write("\2\2\2\34\u019a\3\2\2\2\36\u01a8\3\2\2\2 \u01b3\3\2\2") |
| buf.write("\2\"\u01be\3\2\2\2$\u01c9\3\2\2\2&\u01d4\3\2\2\2(\u01df") |
| buf.write("\3\2\2\2*\u01ec\3\2\2\2,\u01ee\3\2\2\2.\u01f0\3\2\2\2") |
| buf.write("\60\u01fb\3\2\2\2\62\u0204\3\2\2\2\64\u0207\3\2\2\2\66") |
| buf.write("\u020c\3\2\2\28\u0215\3\2\2\2:\u0217\3\2\2\2<\u0227\3") |
| buf.write("\2\2\2>\u0229\3\2\2\2@\u0239\3\2\2\2B\u0246\3\2\2\2D\u0248") |
| buf.write("\3\2\2\2F\u024a\3\2\2\2H\u025b\3\2\2\2J\u0265\3\2\2\2") |
| buf.write("L\u0267\3\2\2\2N\u0278\3\2\2\2P\u028d\3\2\2\2R\u028f\3") |
| buf.write("\2\2\2T\u029f\3\2\2\2V\u02a1\3\2\2\2X\u02a3\3\2\2\2Z\u02a8") |
| buf.write("\3\2\2\2\\\u02b0\3\2\2\2^\u02bc\3\2\2\2`\u02bf\3\2\2\2") |
| buf.write("b\u02ce\3\2\2\2d\u0309\3\2\2\2f\u030b\3\2\2\2h\u031b\3") |
| buf.write("\2\2\2j\u0326\3\2\2\2l\u032f\3\2\2\2n\u0344\3\2\2\2p\u0346") |
| buf.write("\3\2\2\2r\u0355\3\2\2\2t\u0357\3\2\2\2v\u0369\3\2\2\2") |
| buf.write("x\u036b\3\2\2\2z\u0376\3\2\2\2|\u0385\3\2\2\2~\u03b5\3") |
| buf.write("\2\2\2\u0080\u03e5\3\2\2\2\u0082\u03f1\3\2\2\2\u0084\u03f3") |
| buf.write("\3\2\2\2\u0086\u0404\3\2\2\2\u0088\u0407\3\2\2\2\u008a") |
| buf.write("\u0417\3\2\2\2\u008c\u0419\3\2\2\2\u008e\u044a\3\2\2\2") |
| buf.write("\u0090\u0457\3\2\2\2\u0092\u0459\3\2\2\2\u0094\u045f\3") |
| buf.write("\2\2\2\u0096\u046b\3\2\2\2\u0098\u046e\3\2\2\2\u009a\u0481") |
| buf.write("\3\2\2\2\u009c\u04ad\3\2\2\2\u009e\u04bf\3\2\2\2\u00a0") |
| buf.write("\u04c2\3\2\2\2\u00a2\u04c6\3\2\2\2\u00a4\u04d3\3\2\2\2") |
| buf.write("\u00a6\u04d6\3\2\2\2\u00a8\u04de\3\2\2\2\u00aa\u00cc\7") |
| buf.write("k\2\2\u00ab\u00cc\7l\2\2\u00ac\u00ae\7m\2\2\u00ad\u00ac") |
| buf.write("\3\2\2\2\u00ae\u00af\3\2\2\2\u00af\u00ad\3\2\2\2\u00af") |
| buf.write("\u00b0\3\2\2\2\u00b0\u00cc\3\2\2\2\u00b1\u00b2\7=\2\2") |
| buf.write("\u00b2\u00b3\5.\30\2\u00b3\u00b4\7>\2\2\u00b4\u00cc\3") |
| buf.write("\2\2\2\u00b5\u00cc\5\4\3\2\u00b6\u00b8\7\3\2\2\u00b7\u00b6") |
| buf.write("\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9") |
| buf.write("\u00ba\7=\2\2\u00ba\u00bb\5\u0092J\2\u00bb\u00bc\7>\2") |
| buf.write("\2\u00bc\u00cc\3\2\2\2\u00bd\u00be\7\4\2\2\u00be\u00bf") |
| buf.write("\7=\2\2\u00bf\u00c0\5\16\b\2\u00c0\u00c1\7Z\2\2\u00c1") |
| buf.write("\u00c2\5z>\2\u00c2\u00c3\7>\2\2\u00c3\u00cc\3\2\2\2\u00c4") |
| buf.write("\u00c5\7\5\2\2\u00c5\u00c6\7=\2\2\u00c6\u00c7\5z>\2\u00c7") |
| buf.write("\u00c8\7Z\2\2\u00c8\u00c9\5\16\b\2\u00c9\u00ca\7>\2\2") |
| buf.write("\u00ca\u00cc\3\2\2\2\u00cb\u00aa\3\2\2\2\u00cb\u00ab\3") |
| buf.write("\2\2\2\u00cb\u00ad\3\2\2\2\u00cb\u00b1\3\2\2\2\u00cb\u00b5") |
| buf.write("\3\2\2\2\u00cb\u00b7\3\2\2\2\u00cb\u00bd\3\2\2\2\u00cb") |
| buf.write("\u00c4\3\2\2\2\u00cc\3\3\2\2\2\u00cd\u00ce\78\2\2\u00ce") |
| buf.write("\u00cf\7=\2\2\u00cf\u00d0\5*\26\2\u00d0\u00d1\7Z\2\2\u00d1") |
| buf.write("\u00d2\5\6\4\2\u00d2\u00d3\7>\2\2\u00d3\5\3\2\2\2\u00d4") |
| buf.write("\u00d5\b\4\1\2\u00d5\u00d6\5\b\5\2\u00d6\u00dc\3\2\2\2") |
| buf.write("\u00d7\u00d8\f\3\2\2\u00d8\u00d9\7Z\2\2\u00d9\u00db\5") |
| buf.write("\b\5\2\u00da\u00d7\3\2\2\2\u00db\u00de\3\2\2\2\u00dc\u00da") |
| buf.write("\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\7\3\2\2\2\u00de\u00dc") |
| buf.write("\3\2\2\2\u00df\u00e0\5z>\2\u00e0\u00e1\7X\2\2\u00e1\u00e2") |
| buf.write("\5*\26\2\u00e2\u00e7\3\2\2\2\u00e3\u00e4\7\27\2\2\u00e4") |
| buf.write("\u00e5\7X\2\2\u00e5\u00e7\5*\26\2\u00e6\u00df\3\2\2\2") |
| buf.write("\u00e6\u00e3\3\2\2\2\u00e7\t\3\2\2\2\u00e8\u00e9\b\6\1") |
| buf.write("\2\u00e9\u010b\5\2\2\2\u00ea\u00eb\7=\2\2\u00eb\u00ec") |
| buf.write("\5z>\2\u00ec\u00ed\7>\2\2\u00ed\u00ee\7A\2\2\u00ee\u00ef") |
| buf.write("\5\u0084C\2\u00ef\u00f0\7B\2\2\u00f0\u010b\3\2\2\2\u00f1") |
| buf.write("\u00f2\7=\2\2\u00f2\u00f3\5z>\2\u00f3\u00f4\7>\2\2\u00f4") |
| buf.write("\u00f5\7A\2\2\u00f5\u00f6\5\u0084C\2\u00f6\u00f7\7Z\2") |
| buf.write("\2\u00f7\u00f8\7B\2\2\u00f8\u010b\3\2\2\2\u00f9\u00fa") |
| buf.write("\7\3\2\2\u00fa\u00fb\7=\2\2\u00fb\u00fc\5z>\2\u00fc\u00fd") |
| buf.write("\7>\2\2\u00fd\u00fe\7A\2\2\u00fe\u00ff\5\u0084C\2\u00ff") |
| buf.write("\u0100\7B\2\2\u0100\u010b\3\2\2\2\u0101\u0102\7\3\2\2") |
| buf.write("\u0102\u0103\7=\2\2\u0103\u0104\5z>\2\u0104\u0105\7>\2") |
| buf.write("\2\u0105\u0106\7A\2\2\u0106\u0107\5\u0084C\2\u0107\u0108") |
| buf.write("\7Z\2\2\u0108\u0109\7B\2\2\u0109\u010b\3\2\2\2\u010a\u00e8") |
| buf.write("\3\2\2\2\u010a\u00ea\3\2\2\2\u010a\u00f1\3\2\2\2\u010a") |
| buf.write("\u00f9\3\2\2\2\u010a\u0101\3\2\2\2\u010b\u0123\3\2\2\2") |
| buf.write("\u010c\u010d\f\f\2\2\u010d\u010e\7?\2\2\u010e\u010f\5") |
| buf.write(".\30\2\u010f\u0110\7@\2\2\u0110\u0122\3\2\2\2\u0111\u0112") |
| buf.write("\f\13\2\2\u0112\u0114\7=\2\2\u0113\u0115\5\f\7\2\u0114") |
| buf.write("\u0113\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0116\3\2\2\2") |
| buf.write("\u0116\u0122\7>\2\2\u0117\u0118\f\n\2\2\u0118\u0119\7") |
| buf.write("i\2\2\u0119\u0122\7k\2\2\u011a\u011b\f\t\2\2\u011b\u011c") |
| buf.write("\7h\2\2\u011c\u0122\7k\2\2\u011d\u011e\f\b\2\2\u011e\u0122") |
| buf.write("\7J\2\2\u011f\u0120\f\7\2\2\u0120\u0122\7L\2\2\u0121\u010c") |
| buf.write("\3\2\2\2\u0121\u0111\3\2\2\2\u0121\u0117\3\2\2\2\u0121") |
| buf.write("\u011a\3\2\2\2\u0121\u011d\3\2\2\2\u0121\u011f\3\2\2\2") |
| buf.write("\u0122\u0125\3\2\2\2\u0123\u0121\3\2\2\2\u0123\u0124\3") |
| buf.write("\2\2\2\u0124\13\3\2\2\2\u0125\u0123\3\2\2\2\u0126\u0127") |
| buf.write("\b\7\1\2\u0127\u0128\5*\26\2\u0128\u012e\3\2\2\2\u0129") |
| buf.write("\u012a\f\3\2\2\u012a\u012b\7Z\2\2\u012b\u012d\5*\26\2") |
| buf.write("\u012c\u0129\3\2\2\2\u012d\u0130\3\2\2\2\u012e\u012c\3") |
| buf.write("\2\2\2\u012e\u012f\3\2\2\2\u012f\r\3\2\2\2\u0130\u012e") |
| buf.write("\3\2\2\2\u0131\u0148\5\n\6\2\u0132\u0133\7J\2\2\u0133") |
| buf.write("\u0148\5\16\b\2\u0134\u0135\7L\2\2\u0135\u0148\5\16\b") |
| buf.write("\2\u0136\u0137\5\20\t\2\u0137\u0138\5\22\n\2\u0138\u0148") |
| buf.write("\3\2\2\2\u0139\u013a\7)\2\2\u013a\u0148\5\16\b\2\u013b") |
| buf.write("\u013c\7)\2\2\u013c\u013d\7=\2\2\u013d\u013e\5z>\2\u013e") |
| buf.write("\u013f\7>\2\2\u013f\u0148\3\2\2\2\u0140\u0141\7\64\2\2") |
| buf.write("\u0141\u0142\7=\2\2\u0142\u0143\5z>\2\u0143\u0144\7>\2") |
| buf.write("\2\u0144\u0148\3\2\2\2\u0145\u0146\7R\2\2\u0146\u0148") |
| buf.write("\7k\2\2\u0147\u0131\3\2\2\2\u0147\u0132\3\2\2\2\u0147") |
| buf.write("\u0134\3\2\2\2\u0147\u0136\3\2\2\2\u0147\u0139\3\2\2\2") |
| buf.write("\u0147\u013b\3\2\2\2\u0147\u0140\3\2\2\2\u0147\u0145\3") |
| buf.write("\2\2\2\u0148\17\3\2\2\2\u0149\u014a\t\2\2\2\u014a\21\3") |
| buf.write("\2\2\2\u014b\u0158\5\16\b\2\u014c\u014d\7=\2\2\u014d\u014e") |
| buf.write("\5z>\2\u014e\u014f\7>\2\2\u014f\u0150\5\22\n\2\u0150\u0158") |
| buf.write("\3\2\2\2\u0151\u0152\7\3\2\2\u0152\u0153\7=\2\2\u0153") |
| buf.write("\u0154\5z>\2\u0154\u0155\7>\2\2\u0155\u0156\5\22\n\2\u0156") |
| buf.write("\u0158\3\2\2\2\u0157\u014b\3\2\2\2\u0157\u014c\3\2\2\2") |
| buf.write("\u0157\u0151\3\2\2\2\u0158\23\3\2\2\2\u0159\u015a\b\13") |
| buf.write("\1\2\u015a\u015b\5\22\n\2\u015b\u0167\3\2\2\2\u015c\u015d") |
| buf.write("\f\5\2\2\u015d\u015e\7M\2\2\u015e\u0166\5\22\n\2\u015f") |
| buf.write("\u0160\f\4\2\2\u0160\u0161\7N\2\2\u0161\u0166\5\22\n\2") |
| buf.write("\u0162\u0163\f\3\2\2\u0163\u0164\7O\2\2\u0164\u0166\5") |
| buf.write("\22\n\2\u0165\u015c\3\2\2\2\u0165\u015f\3\2\2\2\u0165") |
| buf.write("\u0162\3\2\2\2\u0166\u0169\3\2\2\2\u0167\u0165\3\2\2\2") |
| buf.write("\u0167\u0168\3\2\2\2\u0168\25\3\2\2\2\u0169\u0167\3\2") |
| buf.write("\2\2\u016a\u016b\b\f\1\2\u016b\u016c\5\24\13\2\u016c\u0175") |
| buf.write("\3\2\2\2\u016d\u016e\f\4\2\2\u016e\u016f\7I\2\2\u016f") |
| buf.write("\u0174\5\24\13\2\u0170\u0171\f\3\2\2\u0171\u0172\7K\2") |
| buf.write("\2\u0172\u0174\5\24\13\2\u0173\u016d\3\2\2\2\u0173\u0170") |
| buf.write("\3\2\2\2\u0174\u0177\3\2\2\2\u0175\u0173\3\2\2\2\u0175") |
| buf.write("\u0176\3\2\2\2\u0176\27\3\2\2\2\u0177\u0175\3\2\2\2\u0178") |
| buf.write("\u0179\b\r\1\2\u0179\u017a\5\26\f\2\u017a\u0183\3\2\2") |
| buf.write("\2\u017b\u017c\f\4\2\2\u017c\u017d\7G\2\2\u017d\u0182") |
| buf.write("\5\26\f\2\u017e\u017f\f\3\2\2\u017f\u0180\7H\2\2\u0180") |
| buf.write("\u0182\5\26\f\2\u0181\u017b\3\2\2\2\u0181\u017e\3\2\2") |
| buf.write("\2\u0182\u0185\3\2\2\2\u0183\u0181\3\2\2\2\u0183\u0184") |
| buf.write("\3\2\2\2\u0184\31\3\2\2\2\u0185\u0183\3\2\2\2\u0186\u0187") |
| buf.write("\b\16\1\2\u0187\u0188\5\30\r\2\u0188\u0197\3\2\2\2\u0189") |
| buf.write("\u018a\f\6\2\2\u018a\u018b\7C\2\2\u018b\u0196\5\30\r\2") |
| buf.write("\u018c\u018d\f\5\2\2\u018d\u018e\7E\2\2\u018e\u0196\5") |
| buf.write("\30\r\2\u018f\u0190\f\4\2\2\u0190\u0191\7D\2\2\u0191\u0196") |
| buf.write("\5\30\r\2\u0192\u0193\f\3\2\2\u0193\u0194\7F\2\2\u0194") |
| buf.write("\u0196\5\30\r\2\u0195\u0189\3\2\2\2\u0195\u018c\3\2\2") |
| buf.write("\2\u0195\u018f\3\2\2\2\u0195\u0192\3\2\2\2\u0196\u0199") |
| buf.write("\3\2\2\2\u0197\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198") |
| buf.write("\33\3\2\2\2\u0199\u0197\3\2\2\2\u019a\u019b\b\17\1\2\u019b") |
| buf.write("\u019c\5\32\16\2\u019c\u01a5\3\2\2\2\u019d\u019e\f\4\2") |
| buf.write("\2\u019e\u019f\7f\2\2\u019f\u01a4\5\32\16\2\u01a0\u01a1") |
| buf.write("\f\3\2\2\u01a1\u01a2\7g\2\2\u01a2\u01a4\5\32\16\2\u01a3") |
| buf.write("\u019d\3\2\2\2\u01a3\u01a0\3\2\2\2\u01a4\u01a7\3\2\2\2") |
| buf.write("\u01a5\u01a3\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\35\3\2") |
| buf.write("\2\2\u01a7\u01a5\3\2\2\2\u01a8\u01a9\b\20\1\2\u01a9\u01aa") |
| buf.write("\5\34\17\2\u01aa\u01b0\3\2\2\2\u01ab\u01ac\f\3\2\2\u01ac") |
| buf.write("\u01ad\7P\2\2\u01ad\u01af\5\34\17\2\u01ae\u01ab\3\2\2") |
| buf.write("\2\u01af\u01b2\3\2\2\2\u01b0\u01ae\3\2\2\2\u01b0\u01b1") |
| buf.write("\3\2\2\2\u01b1\37\3\2\2\2\u01b2\u01b0\3\2\2\2\u01b3\u01b4") |
| buf.write("\b\21\1\2\u01b4\u01b5\5\36\20\2\u01b5\u01bb\3\2\2\2\u01b6") |
| buf.write("\u01b7\f\3\2\2\u01b7\u01b8\7T\2\2\u01b8\u01ba\5\36\20") |
| buf.write("\2\u01b9\u01b6\3\2\2\2\u01ba\u01bd\3\2\2\2\u01bb\u01b9") |
| buf.write("\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc!\3\2\2\2\u01bd\u01bb") |
| buf.write("\3\2\2\2\u01be\u01bf\b\22\1\2\u01bf\u01c0\5 \21\2\u01c0") |
| buf.write("\u01c6\3\2\2\2\u01c1\u01c2\f\3\2\2\u01c2\u01c3\7Q\2\2") |
| buf.write("\u01c3\u01c5\5 \21\2\u01c4\u01c1\3\2\2\2\u01c5\u01c8\3") |
| buf.write("\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7#") |
| buf.write("\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\b\23\1\2\u01ca") |
| buf.write("\u01cb\5\"\22\2\u01cb\u01d1\3\2\2\2\u01cc\u01cd\f\3\2") |
| buf.write("\2\u01cd\u01ce\7R\2\2\u01ce\u01d0\5\"\22\2\u01cf\u01cc") |
| buf.write("\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf\3\2\2\2\u01d1") |
| buf.write("\u01d2\3\2\2\2\u01d2%\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4") |
| buf.write("\u01d5\b\24\1\2\u01d5\u01d6\5$\23\2\u01d6\u01dc\3\2\2") |
| buf.write("\2\u01d7\u01d8\f\3\2\2\u01d8\u01d9\7S\2\2\u01d9\u01db") |
| buf.write("\5$\23\2\u01da\u01d7\3\2\2\2\u01db\u01de\3\2\2\2\u01dc") |
| buf.write("\u01da\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\'\3\2\2\2\u01de") |
| buf.write("\u01dc\3\2\2\2\u01df\u01e5\5&\24\2\u01e0\u01e1\7W\2\2") |
| buf.write("\u01e1\u01e2\5.\30\2\u01e2\u01e3\7X\2\2\u01e3\u01e4\5") |
| buf.write("(\25\2\u01e4\u01e6\3\2\2\2\u01e5\u01e0\3\2\2\2\u01e5\u01e6") |
| buf.write("\3\2\2\2\u01e6)\3\2\2\2\u01e7\u01ed\5(\25\2\u01e8\u01e9") |
| buf.write("\5\16\b\2\u01e9\u01ea\5,\27\2\u01ea\u01eb\5*\26\2\u01eb") |
| buf.write("\u01ed\3\2\2\2\u01ec\u01e7\3\2\2\2\u01ec\u01e8\3\2\2\2") |
| buf.write("\u01ed+\3\2\2\2\u01ee\u01ef\t\3\2\2\u01ef-\3\2\2\2\u01f0") |
| buf.write("\u01f1\b\30\1\2\u01f1\u01f2\5*\26\2\u01f2\u01f8\3\2\2") |
| buf.write("\2\u01f3\u01f4\f\3\2\2\u01f4\u01f5\7Z\2\2\u01f5\u01f7") |
| buf.write("\5*\26\2\u01f6\u01f3\3\2\2\2\u01f7\u01fa\3\2\2\2\u01f8") |
| buf.write("\u01f6\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9/\3\2\2\2\u01fa") |
| buf.write("\u01f8\3\2\2\2\u01fb\u01fc\5(\25\2\u01fc\61\3\2\2\2\u01fd") |
| buf.write("\u01ff\5\64\33\2\u01fe\u0200\5:\36\2\u01ff\u01fe\3\2\2") |
| buf.write("\2\u01ff\u0200\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0202") |
| buf.write("\7Y\2\2\u0202\u0205\3\2\2\2\u0203\u0205\5\u008cG\2\u0204") |
| buf.write("\u01fd\3\2\2\2\u0204\u0203\3\2\2\2\u0205\63\3\2\2\2\u0206") |
| buf.write("\u0208\58\35\2\u0207\u0206\3\2\2\2\u0208\u0209\3\2\2\2") |
| buf.write("\u0209\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020a\65\3\2") |
| buf.write("\2\2\u020b\u020d\58\35\2\u020c\u020b\3\2\2\2\u020d\u020e") |
| buf.write("\3\2\2\2\u020e\u020c\3\2\2\2\u020e\u020f\3\2\2\2\u020f") |
| buf.write("\67\3\2\2\2\u0210\u0216\5> \2\u0211\u0216\5@!\2\u0212") |
| buf.write("\u0216\5Z.\2\u0213\u0216\5\\/\2\u0214\u0216\5^\60\2\u0215") |
| buf.write("\u0210\3\2\2\2\u0215\u0211\3\2\2\2\u0215\u0212\3\2\2\2") |
| buf.write("\u0215\u0213\3\2\2\2\u0215\u0214\3\2\2\2\u02169\3\2\2") |
| buf.write("\2\u0217\u0218\b\36\1\2\u0218\u0219\5<\37\2\u0219\u021f") |
| buf.write("\3\2\2\2\u021a\u021b\f\3\2\2\u021b\u021c\7Z\2\2\u021c") |
| buf.write("\u021e\5<\37\2\u021d\u021a\3\2\2\2\u021e\u0221\3\2\2\2") |
| buf.write("\u021f\u021d\3\2\2\2\u021f\u0220\3\2\2\2\u0220;\3\2\2") |
| buf.write("\2\u0221\u021f\3\2\2\2\u0222\u0228\5`\61\2\u0223\u0224") |
| buf.write("\5`\61\2\u0224\u0225\7[\2\2\u0225\u0226\5\u0082B\2\u0226") |
| buf.write("\u0228\3\2\2\2\u0227\u0222\3\2\2\2\u0227\u0223\3\2\2\2") |
| buf.write("\u0228=\3\2\2\2\u0229\u022a\t\4\2\2\u022a?\3\2\2\2\u022b") |
| buf.write("\u023a\t\5\2\2\u022c\u022d\7\3\2\2\u022d\u022e\7=\2\2") |
| buf.write("\u022e\u022f\t\6\2\2\u022f\u023a\7>\2\2\u0230\u023a\5") |
| buf.write("X-\2\u0231\u023a\5B\"\2\u0232\u023a\5P)\2\u0233\u023a") |
| buf.write("\5\u0080A\2\u0234\u0235\7\t\2\2\u0235\u0236\7=\2\2\u0236") |
| buf.write("\u0237\5\60\31\2\u0237\u0238\7>\2\2\u0238\u023a\3\2\2") |
| buf.write("\2\u0239\u022b\3\2\2\2\u0239\u022c\3\2\2\2\u0239\u0230") |
| buf.write("\3\2\2\2\u0239\u0231\3\2\2\2\u0239\u0232\3\2\2\2\u0239") |
| buf.write("\u0233\3\2\2\2\u0239\u0234\3\2\2\2\u023aA\3\2\2\2\u023b") |
| buf.write("\u023d\5D#\2\u023c\u023e\7k\2\2\u023d\u023c\3\2\2\2\u023d") |
| buf.write("\u023e\3\2\2\2\u023e\u023f\3\2\2\2\u023f\u0240\7A\2\2") |
| buf.write("\u0240\u0241\5F$\2\u0241\u0242\7B\2\2\u0242\u0247\3\2") |
| buf.write("\2\2\u0243\u0244\5D#\2\u0244\u0245\7k\2\2\u0245\u0247") |
| buf.write("\3\2\2\2\u0246\u023b\3\2\2\2\u0246\u0243\3\2\2\2\u0247") |
| buf.write("C\3\2\2\2\u0248\u0249\t\7\2\2\u0249E\3\2\2\2\u024a\u024b") |
| buf.write("\b$\1\2\u024b\u024c\5H%\2\u024c\u0251\3\2\2\2\u024d\u024e") |
| buf.write("\f\3\2\2\u024e\u0250\5H%\2\u024f\u024d\3\2\2\2\u0250\u0253") |
| buf.write("\3\2\2\2\u0251\u024f\3\2\2\2\u0251\u0252\3\2\2\2\u0252") |
| buf.write("G\3\2\2\2\u0253\u0251\3\2\2\2\u0254\u0256\5J&\2\u0255") |
| buf.write("\u0257\5L\'\2\u0256\u0255\3\2\2\2\u0256\u0257\3\2\2\2") |
| buf.write("\u0257\u0258\3\2\2\2\u0258\u0259\7Y\2\2\u0259\u025c\3") |
| buf.write("\2\2\2\u025a\u025c\5\u008cG\2\u025b\u0254\3\2\2\2\u025b") |
| buf.write("\u025a\3\2\2\2\u025cI\3\2\2\2\u025d\u025f\5@!\2\u025e") |
| buf.write("\u0260\5J&\2\u025f\u025e\3\2\2\2\u025f\u0260\3\2\2\2\u0260") |
| buf.write("\u0266\3\2\2\2\u0261\u0263\5Z.\2\u0262\u0264\5J&\2\u0263") |
| buf.write("\u0262\3\2\2\2\u0263\u0264\3\2\2\2\u0264\u0266\3\2\2\2") |
| buf.write("\u0265\u025d\3\2\2\2\u0265\u0261\3\2\2\2\u0266K\3\2\2") |
| buf.write("\2\u0267\u0268\b\'\1\2\u0268\u0269\5N(\2\u0269\u026f\3") |
| buf.write("\2\2\2\u026a\u026b\f\3\2\2\u026b\u026c\7Z\2\2\u026c\u026e") |
| buf.write("\5N(\2\u026d\u026a\3\2\2\2\u026e\u0271\3\2\2\2\u026f\u026d") |
| buf.write("\3\2\2\2\u026f\u0270\3\2\2\2\u0270M\3\2\2\2\u0271\u026f") |
| buf.write("\3\2\2\2\u0272\u0279\5`\61\2\u0273\u0275\5`\61\2\u0274") |
| buf.write("\u0273\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0276\3\2\2\2") |
| buf.write("\u0276\u0277\7X\2\2\u0277\u0279\5\60\31\2\u0278\u0272") |
| buf.write("\3\2\2\2\u0278\u0274\3\2\2\2\u0279O\3\2\2\2\u027a\u027c") |
| buf.write("\7\33\2\2\u027b\u027d\7k\2\2\u027c\u027b\3\2\2\2\u027c") |
| buf.write("\u027d\3\2\2\2\u027d\u027e\3\2\2\2\u027e\u027f\7A\2\2") |
| buf.write("\u027f\u0280\5R*\2\u0280\u0281\7B\2\2\u0281\u028e\3\2") |
| buf.write("\2\2\u0282\u0284\7\33\2\2\u0283\u0285\7k\2\2\u0284\u0283") |
| buf.write("\3\2\2\2\u0284\u0285\3\2\2\2\u0285\u0286\3\2\2\2\u0286") |
| buf.write("\u0287\7A\2\2\u0287\u0288\5R*\2\u0288\u0289\7Z\2\2\u0289") |
| buf.write("\u028a\7B\2\2\u028a\u028e\3\2\2\2\u028b\u028c\7\33\2\2") |
| buf.write("\u028c\u028e\7k\2\2\u028d\u027a\3\2\2\2\u028d\u0282\3") |
| buf.write("\2\2\2\u028d\u028b\3\2\2\2\u028eQ\3\2\2\2\u028f\u0290") |
| buf.write("\b*\1\2\u0290\u0291\5T+\2\u0291\u0297\3\2\2\2\u0292\u0293") |
| buf.write("\f\3\2\2\u0293\u0294\7Z\2\2\u0294\u0296\5T+\2\u0295\u0292") |
| buf.write("\3\2\2\2\u0296\u0299\3\2\2\2\u0297\u0295\3\2\2\2\u0297") |
| buf.write("\u0298\3\2\2\2\u0298S\3\2\2\2\u0299\u0297\3\2\2\2\u029a") |
| buf.write("\u02a0\5V,\2\u029b\u029c\5V,\2\u029c\u029d\7[\2\2\u029d") |
| buf.write("\u029e\5\60\31\2\u029e\u02a0\3\2\2\2\u029f\u029a\3\2\2") |
| buf.write("\2\u029f\u029b\3\2\2\2\u02a0U\3\2\2\2\u02a1\u02a2\7k\2") |
| buf.write("\2\u02a2W\3\2\2\2\u02a3\u02a4\7\65\2\2\u02a4\u02a5\7=") |
| buf.write("\2\2\u02a5\u02a6\5z>\2\u02a6\u02a7\7>\2\2\u02a7Y\3\2\2") |
| buf.write("\2\u02a8\u02a9\t\b\2\2\u02a9[\3\2\2\2\u02aa\u02b1\t\t") |
| buf.write("\2\2\u02ab\u02b1\5f\64\2\u02ac\u02ad\7\f\2\2\u02ad\u02ae") |
| buf.write("\7=\2\2\u02ae\u02af\7k\2\2\u02af\u02b1\7>\2\2\u02b0\u02aa") |
| buf.write("\3\2\2\2\u02b0\u02ab\3\2\2\2\u02b0\u02ac\3\2\2\2\u02b1") |
| buf.write("]\3\2\2\2\u02b2\u02b3\7\63\2\2\u02b3\u02b4\7=\2\2\u02b4") |
| buf.write("\u02b5\5z>\2\u02b5\u02b6\7>\2\2\u02b6\u02bd\3\2\2\2\u02b7") |
| buf.write("\u02b8\7\63\2\2\u02b8\u02b9\7=\2\2\u02b9\u02ba\5\60\31") |
| buf.write("\2\u02ba\u02bb\7>\2\2\u02bb\u02bd\3\2\2\2\u02bc\u02b2") |
| buf.write("\3\2\2\2\u02bc\u02b7\3\2\2\2\u02bd_\3\2\2\2\u02be\u02c0") |
| buf.write("\5n8\2\u02bf\u02be\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0\u02c1") |
| buf.write("\3\2\2\2\u02c1\u02c5\5b\62\2\u02c2\u02c4\5d\63\2\u02c3") |
| buf.write("\u02c2\3\2\2\2\u02c4\u02c7\3\2\2\2\u02c5\u02c3\3\2\2\2") |
| buf.write("\u02c5\u02c6\3\2\2\2\u02c6a\3\2\2\2\u02c7\u02c5\3\2\2") |
| buf.write("\2\u02c8\u02c9\b\62\1\2\u02c9\u02cf\7k\2\2\u02ca\u02cb") |
| buf.write("\7=\2\2\u02cb\u02cc\5`\61\2\u02cc\u02cd\7>\2\2\u02cd\u02cf") |
| buf.write("\3\2\2\2\u02ce\u02c8\3\2\2\2\u02ce\u02ca\3\2\2\2\u02cf") |
| buf.write("\u02fd\3\2\2\2\u02d0\u02d1\f\b\2\2\u02d1\u02d3\7?\2\2") |
| buf.write("\u02d2\u02d4\5p9\2\u02d3\u02d2\3\2\2\2\u02d3\u02d4\3\2") |
| buf.write("\2\2\u02d4\u02d6\3\2\2\2\u02d5\u02d7\5*\26\2\u02d6\u02d5") |
| buf.write("\3\2\2\2\u02d6\u02d7\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8") |
| buf.write("\u02fc\7@\2\2\u02d9\u02da\f\7\2\2\u02da\u02db\7?\2\2\u02db") |
| buf.write("\u02dd\7*\2\2\u02dc\u02de\5p9\2\u02dd\u02dc\3\2\2\2\u02dd") |
| buf.write("\u02de\3\2\2\2\u02de\u02df\3\2\2\2\u02df\u02e0\5*\26\2") |
| buf.write("\u02e0\u02e1\7@\2\2\u02e1\u02fc\3\2\2\2\u02e2\u02e3\f") |
| buf.write("\6\2\2\u02e3\u02e4\7?\2\2\u02e4\u02e5\5p9\2\u02e5\u02e6") |
| buf.write("\7*\2\2\u02e6\u02e7\5*\26\2\u02e7\u02e8\7@\2\2\u02e8\u02fc") |
| buf.write("\3\2\2\2\u02e9\u02ea\f\5\2\2\u02ea\u02ec\7?\2\2\u02eb") |
| buf.write("\u02ed\5p9\2\u02ec\u02eb\3\2\2\2\u02ec\u02ed\3\2\2\2\u02ed") |
| buf.write("\u02ee\3\2\2\2\u02ee\u02ef\7M\2\2\u02ef\u02fc\7@\2\2\u02f0") |
| buf.write("\u02f1\f\4\2\2\u02f1\u02f2\7=\2\2\u02f2\u02f3\5r:\2\u02f3") |
| buf.write("\u02f4\7>\2\2\u02f4\u02fc\3\2\2\2\u02f5\u02f6\f\3\2\2") |
| buf.write("\u02f6\u02f8\7=\2\2\u02f7\u02f9\5x=\2\u02f8\u02f7\3\2") |
| buf.write("\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fc") |
| buf.write("\7>\2\2\u02fb\u02d0\3\2\2\2\u02fb\u02d9\3\2\2\2\u02fb") |
| buf.write("\u02e2\3\2\2\2\u02fb\u02e9\3\2\2\2\u02fb\u02f0\3\2\2\2") |
| buf.write("\u02fb\u02f5\3\2\2\2\u02fc\u02ff\3\2\2\2\u02fd\u02fb\3") |
| buf.write("\2\2\2\u02fd\u02fe\3\2\2\2\u02fec\3\2\2\2\u02ff\u02fd") |
| buf.write("\3\2\2\2\u0300\u0301\7\r\2\2\u0301\u0303\7=\2\2\u0302") |
| buf.write("\u0304\7m\2\2\u0303\u0302\3\2\2\2\u0304\u0305\3\2\2\2") |
| buf.write("\u0305\u0303\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u0307\3") |
| buf.write("\2\2\2\u0307\u030a\7>\2\2\u0308\u030a\5f\64\2\u0309\u0300") |
| buf.write("\3\2\2\2\u0309\u0308\3\2\2\2\u030ae\3\2\2\2\u030b\u030c") |
| buf.write("\7\16\2\2\u030c\u030d\7=\2\2\u030d\u030e\7=\2\2\u030e") |
| buf.write("\u030f\5h\65\2\u030f\u0310\7>\2\2\u0310\u0311\7>\2\2\u0311") |
| buf.write("g\3\2\2\2\u0312\u0317\5j\66\2\u0313\u0314\7Z\2\2\u0314") |
| buf.write("\u0316\5j\66\2\u0315\u0313\3\2\2\2\u0316\u0319\3\2\2\2") |
| buf.write("\u0317\u0315\3\2\2\2\u0317\u0318\3\2\2\2\u0318\u031c\3") |
| buf.write("\2\2\2\u0319\u0317\3\2\2\2\u031a\u031c\3\2\2\2\u031b\u0312") |
| buf.write("\3\2\2\2\u031b\u031a\3\2\2\2\u031ci\3\2\2\2\u031d\u0323") |
| buf.write("\n\n\2\2\u031e\u0320\7=\2\2\u031f\u0321\5\f\7\2\u0320") |
| buf.write("\u031f\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u0322\3\2\2\2") |
| buf.write("\u0322\u0324\7>\2\2\u0323\u031e\3\2\2\2\u0323\u0324\3") |
| buf.write("\2\2\2\u0324\u0327\3\2\2\2\u0325\u0327\3\2\2\2\u0326\u031d") |
| buf.write("\3\2\2\2\u0326\u0325\3\2\2\2\u0327k\3\2\2\2\u0328\u032e") |
| buf.write("\n\13\2\2\u0329\u032a\7=\2\2\u032a\u032b\5l\67\2\u032b") |
| buf.write("\u032c\7>\2\2\u032c\u032e\3\2\2\2\u032d\u0328\3\2\2\2") |
| buf.write("\u032d\u0329\3\2\2\2\u032e\u0331\3\2\2\2\u032f\u032d\3") |
| buf.write("\2\2\2\u032f\u0330\3\2\2\2\u0330m\3\2\2\2\u0331\u032f") |
| buf.write("\3\2\2\2\u0332\u0334\7M\2\2\u0333\u0335\5p9\2\u0334\u0333") |
| buf.write("\3\2\2\2\u0334\u0335\3\2\2\2\u0335\u0345\3\2\2\2\u0336") |
| buf.write("\u0338\7M\2\2\u0337\u0339\5p9\2\u0338\u0337\3\2\2\2\u0338") |
| buf.write("\u0339\3\2\2\2\u0339\u033a\3\2\2\2\u033a\u0345\5n8\2\u033b") |
| buf.write("\u033d\7T\2\2\u033c\u033e\5p9\2\u033d\u033c\3\2\2\2\u033d") |
| buf.write("\u033e\3\2\2\2\u033e\u0345\3\2\2\2\u033f\u0341\7T\2\2") |
| buf.write("\u0340\u0342\5p9\2\u0341\u0340\3\2\2\2\u0341\u0342\3\2") |
| buf.write("\2\2\u0342\u0343\3\2\2\2\u0343\u0345\5n8\2\u0344\u0332") |
| buf.write("\3\2\2\2\u0344\u0336\3\2\2\2\u0344\u033b\3\2\2\2\u0344") |
| buf.write("\u033f\3\2\2\2\u0345o\3\2\2\2\u0346\u0347\b9\1\2\u0347") |
| buf.write("\u0348\5Z.\2\u0348\u034d\3\2\2\2\u0349\u034a\f\3\2\2\u034a") |
| buf.write("\u034c\5Z.\2\u034b\u0349\3\2\2\2\u034c\u034f\3\2\2\2\u034d") |
| buf.write("\u034b\3\2\2\2\u034d\u034e\3\2\2\2\u034eq\3\2\2\2\u034f") |
| buf.write("\u034d\3\2\2\2\u0350\u0356\5t;\2\u0351\u0352\5t;\2\u0352") |
| buf.write("\u0353\7Z\2\2\u0353\u0354\7j\2\2\u0354\u0356\3\2\2\2\u0355") |
| buf.write("\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0356s\3\2\2\2\u0357") |
| buf.write("\u0358\b;\1\2\u0358\u0359\5v<\2\u0359\u035f\3\2\2\2\u035a") |
| buf.write("\u035b\f\3\2\2\u035b\u035c\7Z\2\2\u035c\u035e\5v<\2\u035d") |
| buf.write("\u035a\3\2\2\2\u035e\u0361\3\2\2\2\u035f\u035d\3\2\2\2") |
| buf.write("\u035f\u0360\3\2\2\2\u0360u\3\2\2\2\u0361\u035f\3\2\2") |
| buf.write("\2\u0362\u0363\5\64\33\2\u0363\u0364\5`\61\2\u0364\u036a") |
| buf.write("\3\2\2\2\u0365\u0367\5\66\34\2\u0366\u0368\5|?\2\u0367") |
| buf.write("\u0366\3\2\2\2\u0367\u0368\3\2\2\2\u0368\u036a\3\2\2\2") |
| buf.write("\u0369\u0362\3\2\2\2\u0369\u0365\3\2\2\2\u036aw\3\2\2") |
| buf.write("\2\u036b\u036c\b=\1\2\u036c\u036d\7k\2\2\u036d\u0373\3") |
| buf.write("\2\2\2\u036e\u036f\f\3\2\2\u036f\u0370\7Z\2\2\u0370\u0372") |
| buf.write("\7k\2\2\u0371\u036e\3\2\2\2\u0372\u0375\3\2\2\2\u0373") |
| buf.write("\u0371\3\2\2\2\u0373\u0374\3\2\2\2\u0374y\3\2\2\2\u0375") |
| buf.write("\u0373\3\2\2\2\u0376\u0378\5J&\2\u0377\u0379\5|?\2\u0378") |
| buf.write("\u0377\3\2\2\2\u0378\u0379\3\2\2\2\u0379{\3\2\2\2\u037a") |
| buf.write("\u0386\5n8\2\u037b\u037d\5n8\2\u037c\u037b\3\2\2\2\u037c") |
| buf.write("\u037d\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u0382\5~@\2\u037f") |
| buf.write("\u0381\5d\63\2\u0380\u037f\3\2\2\2\u0381\u0384\3\2\2\2") |
| buf.write("\u0382\u0380\3\2\2\2\u0382\u0383\3\2\2\2\u0383\u0386\3") |
| buf.write("\2\2\2\u0384\u0382\3\2\2\2\u0385\u037a\3\2\2\2\u0385\u037c") |
| buf.write("\3\2\2\2\u0386}\3\2\2\2\u0387\u0388\b@\1\2\u0388\u0389") |
| buf.write("\7=\2\2\u0389\u038a\5|?\2\u038a\u038e\7>\2\2\u038b\u038d") |
| buf.write("\5d\63\2\u038c\u038b\3\2\2\2\u038d\u0390\3\2\2\2\u038e") |
| buf.write("\u038c\3\2\2\2\u038e\u038f\3\2\2\2\u038f\u03b6\3\2\2\2") |
| buf.write("\u0390\u038e\3\2\2\2\u0391\u0393\7?\2\2\u0392\u0394\5") |
| buf.write("p9\2\u0393\u0392\3\2\2\2\u0393\u0394\3\2\2\2\u0394\u0396") |
| buf.write("\3\2\2\2\u0395\u0397\5*\26\2\u0396\u0395\3\2\2\2\u0396") |
| buf.write("\u0397\3\2\2\2\u0397\u0398\3\2\2\2\u0398\u03b6\7@\2\2") |
| buf.write("\u0399\u039a\7?\2\2\u039a\u039c\7*\2\2\u039b\u039d\5p") |
| buf.write("9\2\u039c\u039b\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u039e") |
| buf.write("\3\2\2\2\u039e\u039f\5*\26\2\u039f\u03a0\7@\2\2\u03a0") |
| buf.write("\u03b6\3\2\2\2\u03a1\u03a2\7?\2\2\u03a2\u03a3\5p9\2\u03a3") |
| buf.write("\u03a4\7*\2\2\u03a4\u03a5\5*\26\2\u03a5\u03a6\7@\2\2\u03a6") |
| buf.write("\u03b6\3\2\2\2\u03a7\u03a8\7?\2\2\u03a8\u03a9\7M\2\2\u03a9") |
| buf.write("\u03b6\7@\2\2\u03aa\u03ac\7=\2\2\u03ab\u03ad\5r:\2\u03ac") |
| buf.write("\u03ab\3\2\2\2\u03ac\u03ad\3\2\2\2\u03ad\u03ae\3\2\2\2") |
| buf.write("\u03ae\u03b2\7>\2\2\u03af\u03b1\5d\63\2\u03b0\u03af\3") |
| buf.write("\2\2\2\u03b1\u03b4\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b2\u03b3") |
| buf.write("\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b5") |
| buf.write("\u0387\3\2\2\2\u03b5\u0391\3\2\2\2\u03b5\u0399\3\2\2\2") |
| buf.write("\u03b5\u03a1\3\2\2\2\u03b5\u03a7\3\2\2\2\u03b5\u03aa\3") |
| buf.write("\2\2\2\u03b6\u03e2\3\2\2\2\u03b7\u03b8\f\7\2\2\u03b8\u03ba") |
| buf.write("\7?\2\2\u03b9\u03bb\5p9\2\u03ba\u03b9\3\2\2\2\u03ba\u03bb") |
| buf.write("\3\2\2\2\u03bb\u03bd\3\2\2\2\u03bc\u03be\5*\26\2\u03bd") |
| buf.write("\u03bc\3\2\2\2\u03bd\u03be\3\2\2\2\u03be\u03bf\3\2\2\2") |
| buf.write("\u03bf\u03e1\7@\2\2\u03c0\u03c1\f\6\2\2\u03c1\u03c2\7") |
| buf.write("?\2\2\u03c2\u03c4\7*\2\2\u03c3\u03c5\5p9\2\u03c4\u03c3") |
| buf.write("\3\2\2\2\u03c4\u03c5\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6") |
| buf.write("\u03c7\5*\26\2\u03c7\u03c8\7@\2\2\u03c8\u03e1\3\2\2\2") |
| buf.write("\u03c9\u03ca\f\5\2\2\u03ca\u03cb\7?\2\2\u03cb\u03cc\5") |
| buf.write("p9\2\u03cc\u03cd\7*\2\2\u03cd\u03ce\5*\26\2\u03ce\u03cf") |
| buf.write("\7@\2\2\u03cf\u03e1\3\2\2\2\u03d0\u03d1\f\4\2\2\u03d1") |
| buf.write("\u03d2\7?\2\2\u03d2\u03d3\7M\2\2\u03d3\u03e1\7@\2\2\u03d4") |
| buf.write("\u03d5\f\3\2\2\u03d5\u03d7\7=\2\2\u03d6\u03d8\5r:\2\u03d7") |
| buf.write("\u03d6\3\2\2\2\u03d7\u03d8\3\2\2\2\u03d8\u03d9\3\2\2\2") |
| buf.write("\u03d9\u03dd\7>\2\2\u03da\u03dc\5d\63\2\u03db\u03da\3") |
| buf.write("\2\2\2\u03dc\u03df\3\2\2\2\u03dd\u03db\3\2\2\2\u03dd\u03de") |
| buf.write("\3\2\2\2\u03de\u03e1\3\2\2\2\u03df\u03dd\3\2\2\2\u03e0") |
| buf.write("\u03b7\3\2\2\2\u03e0\u03c0\3\2\2\2\u03e0\u03c9\3\2\2\2") |
| buf.write("\u03e0\u03d0\3\2\2\2\u03e0\u03d4\3\2\2\2\u03e1\u03e4\3") |
| buf.write("\2\2\2\u03e2\u03e0\3\2\2\2\u03e2\u03e3\3\2\2\2\u03e3\177") |
| buf.write("\3\2\2\2\u03e4\u03e2\3\2\2\2\u03e5\u03e6\7k\2\2\u03e6") |
| buf.write("\u0081\3\2\2\2\u03e7\u03f2\5*\26\2\u03e8\u03e9\7A\2\2") |
| buf.write("\u03e9\u03ea\5\u0084C\2\u03ea\u03eb\7B\2\2\u03eb\u03f2") |
| buf.write("\3\2\2\2\u03ec\u03ed\7A\2\2\u03ed\u03ee\5\u0084C\2\u03ee") |
| buf.write("\u03ef\7Z\2\2\u03ef\u03f0\7B\2\2\u03f0\u03f2\3\2\2\2\u03f1") |
| buf.write("\u03e7\3\2\2\2\u03f1\u03e8\3\2\2\2\u03f1\u03ec\3\2\2\2") |
| buf.write("\u03f2\u0083\3\2\2\2\u03f3\u03f5\bC\1\2\u03f4\u03f6\5") |
| buf.write("\u0086D\2\u03f5\u03f4\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6") |
| buf.write("\u03f7\3\2\2\2\u03f7\u03f8\5\u0082B\2\u03f8\u0401\3\2") |
| buf.write("\2\2\u03f9\u03fa\f\3\2\2\u03fa\u03fc\7Z\2\2\u03fb\u03fd") |
| buf.write("\5\u0086D\2\u03fc\u03fb\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd") |
| buf.write("\u03fe\3\2\2\2\u03fe\u0400\5\u0082B\2\u03ff\u03f9\3\2") |
| buf.write("\2\2\u0400\u0403\3\2\2\2\u0401\u03ff\3\2\2\2\u0401\u0402") |
| buf.write("\3\2\2\2\u0402\u0085\3\2\2\2\u0403\u0401\3\2\2\2\u0404") |
| buf.write("\u0405\5\u0088E\2\u0405\u0406\7[\2\2\u0406\u0087\3\2\2") |
| buf.write("\2\u0407\u0408\bE\1\2\u0408\u0409\5\u008aF\2\u0409\u040e") |
| buf.write("\3\2\2\2\u040a\u040b\f\3\2\2\u040b\u040d\5\u008aF\2\u040c") |
| buf.write("\u040a\3\2\2\2\u040d\u0410\3\2\2\2\u040e\u040c\3\2\2\2") |
| buf.write("\u040e\u040f\3\2\2\2\u040f\u0089\3\2\2\2\u0410\u040e\3") |
| buf.write("\2\2\2\u0411\u0412\7?\2\2\u0412\u0413\5\60\31\2\u0413") |
| buf.write("\u0414\7@\2\2\u0414\u0418\3\2\2\2\u0415\u0416\7i\2\2\u0416") |
| buf.write("\u0418\7k\2\2\u0417\u0411\3\2\2\2\u0417\u0415\3\2\2\2") |
| buf.write("\u0418\u008b\3\2\2\2\u0419\u041a\7;\2\2\u041a\u041b\7") |
| buf.write("=\2\2\u041b\u041c\5\60\31\2\u041c\u041e\7Z\2\2\u041d\u041f") |
| buf.write("\7m\2\2\u041e\u041d\3\2\2\2\u041f\u0420\3\2\2\2\u0420") |
| buf.write("\u041e\3\2\2\2\u0420\u0421\3\2\2\2\u0421\u0422\3\2\2\2") |
| buf.write("\u0422\u0423\7>\2\2\u0423\u0424\7Y\2\2\u0424\u008d\3\2") |
| buf.write("\2\2\u0425\u044b\5\u0090I\2\u0426\u044b\5\u0092J\2\u0427") |
| buf.write("\u044b\5\u0098M\2\u0428\u044b\5\u009aN\2\u0429\u044b\5") |
| buf.write("\u009cO\2\u042a\u044b\5\u009eP\2\u042b\u042c\t\f\2\2\u042c") |
| buf.write("\u042d\t\r\2\2\u042d\u0436\7=\2\2\u042e\u0433\5&\24\2") |
| buf.write("\u042f\u0430\7Z\2\2\u0430\u0432\5&\24\2\u0431\u042f\3") |
| buf.write("\2\2\2\u0432\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434") |
| buf.write("\3\2\2\2\u0434\u0437\3\2\2\2\u0435\u0433\3\2\2\2\u0436") |
| buf.write("\u042e\3\2\2\2\u0436\u0437\3\2\2\2\u0437\u0445\3\2\2\2") |
| buf.write("\u0438\u0441\7X\2\2\u0439\u043e\5&\24\2\u043a\u043b\7") |
| buf.write("Z\2\2\u043b\u043d\5&\24\2\u043c\u043a\3\2\2\2\u043d\u0440") |
| buf.write("\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2\2\2\u043f") |
| buf.write("\u0442\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0439\3\2\2\2") |
| buf.write("\u0441\u0442\3\2\2\2\u0442\u0444\3\2\2\2\u0443\u0438\3") |
| buf.write("\2\2\2\u0444\u0447\3\2\2\2\u0445\u0443\3\2\2\2\u0445\u0446") |
| buf.write("\3\2\2\2\u0446\u0448\3\2\2\2\u0447\u0445\3\2\2\2\u0448") |
| buf.write("\u0449\7>\2\2\u0449\u044b\7Y\2\2\u044a\u0425\3\2\2\2\u044a") |
| buf.write("\u0426\3\2\2\2\u044a\u0427\3\2\2\2\u044a\u0428\3\2\2\2") |
| buf.write("\u044a\u0429\3\2\2\2\u044a\u042a\3\2\2\2\u044a\u042b\3") |
| buf.write("\2\2\2\u044b\u008f\3\2\2\2\u044c\u044d\7k\2\2\u044d\u044e") |
| buf.write("\7X\2\2\u044e\u0458\5\u008eH\2\u044f\u0450\7\23\2\2\u0450") |
| buf.write("\u0451\5\60\31\2\u0451\u0452\7X\2\2\u0452\u0453\5\u008e") |
| buf.write("H\2\u0453\u0458\3\2\2\2\u0454\u0455\7\27\2\2\u0455\u0456") |
| buf.write("\7X\2\2\u0456\u0458\5\u008eH\2\u0457\u044c\3\2\2\2\u0457") |
| buf.write("\u044f\3\2\2\2\u0457\u0454\3\2\2\2\u0458\u0091\3\2\2\2") |
| buf.write("\u0459\u045b\7A\2\2\u045a\u045c\5\u0094K\2\u045b\u045a") |
| buf.write("\3\2\2\2\u045b\u045c\3\2\2\2\u045c\u045d\3\2\2\2\u045d") |
| buf.write("\u045e\7B\2\2\u045e\u0093\3\2\2\2\u045f\u0460\bK\1\2\u0460") |
| buf.write("\u0461\5\u0096L\2\u0461\u0466\3\2\2\2\u0462\u0463\f\3") |
| buf.write("\2\2\u0463\u0465\5\u0096L\2\u0464\u0462\3\2\2\2\u0465") |
| buf.write("\u0468\3\2\2\2\u0466\u0464\3\2\2\2\u0466\u0467\3\2\2\2") |
| buf.write("\u0467\u0095\3\2\2\2\u0468\u0466\3\2\2\2\u0469\u046c\5") |
| buf.write("\62\32\2\u046a\u046c\5\u008eH\2\u046b\u0469\3\2\2\2\u046b") |
| buf.write("\u046a\3\2\2\2\u046c\u0097\3\2\2\2\u046d\u046f\5.\30\2") |
| buf.write("\u046e\u046d\3\2\2\2\u046e\u046f\3\2\2\2\u046f\u0470\3") |
| buf.write("\2\2\2\u0470\u0471\7Y\2\2\u0471\u0099\3\2\2\2\u0472\u0473") |
| buf.write("\7 \2\2\u0473\u0474\7=\2\2\u0474\u0475\5.\30\2\u0475\u0476") |
| buf.write("\7>\2\2\u0476\u0479\5\u008eH\2\u0477\u0478\7\32\2\2\u0478") |
| buf.write("\u047a\5\u008eH\2\u0479\u0477\3\2\2\2\u0479\u047a\3\2") |
| buf.write("\2\2\u047a\u0482\3\2\2\2\u047b\u047c\7,\2\2\u047c\u047d") |
| buf.write("\7=\2\2\u047d\u047e\5.\30\2\u047e\u047f\7>\2\2\u047f\u0480") |
| buf.write("\5\u008eH\2\u0480\u0482\3\2\2\2\u0481\u0472\3\2\2\2\u0481") |
| buf.write("\u047b\3\2\2\2\u0482\u009b\3\2\2\2\u0483\u0484\7\62\2") |
| buf.write("\2\u0484\u0485\7=\2\2\u0485\u0486\5.\30\2\u0486\u0487") |
| buf.write("\7>\2\2\u0487\u0488\5\u008eH\2\u0488\u04ae\3\2\2\2\u0489") |
| buf.write("\u048a\7\30\2\2\u048a\u048b\5\u008eH\2\u048b\u048c\7\62") |
| buf.write("\2\2\u048c\u048d\7=\2\2\u048d\u048e\5.\30\2\u048e\u048f") |
| buf.write("\7>\2\2\u048f\u0490\7Y\2\2\u0490\u04ae\3\2\2\2\u0491\u0492") |
| buf.write("\7\36\2\2\u0492\u0494\7=\2\2\u0493\u0495\5.\30\2\u0494") |
| buf.write("\u0493\3\2\2\2\u0494\u0495\3\2\2\2\u0495\u0496\3\2\2\2") |
| buf.write("\u0496\u0498\7Y\2\2\u0497\u0499\5.\30\2\u0498\u0497\3") |
| buf.write("\2\2\2\u0498\u0499\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049c") |
| buf.write("\7Y\2\2\u049b\u049d\5.\30\2\u049c\u049b\3\2\2\2\u049c") |
| buf.write("\u049d\3\2\2\2\u049d\u049e\3\2\2\2\u049e\u049f\7>\2\2") |
| buf.write("\u049f\u04ae\5\u008eH\2\u04a0\u04a1\7\36\2\2\u04a1\u04a2") |
| buf.write("\7=\2\2\u04a2\u04a4\5\62\32\2\u04a3\u04a5\5.\30\2\u04a4") |
| buf.write("\u04a3\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5\u04a6\3\2\2\2") |
| buf.write("\u04a6\u04a8\7Y\2\2\u04a7\u04a9\5.\30\2\u04a8\u04a7\3") |
| buf.write("\2\2\2\u04a8\u04a9\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ab") |
| buf.write("\7>\2\2\u04ab\u04ac\5\u008eH\2\u04ac\u04ae\3\2\2\2\u04ad") |
| buf.write("\u0483\3\2\2\2\u04ad\u0489\3\2\2\2\u04ad\u0491\3\2\2\2") |
| buf.write("\u04ad\u04a0\3\2\2\2\u04ae\u009d\3\2\2\2\u04af\u04b0\7") |
| buf.write("\37\2\2\u04b0\u04b1\7k\2\2\u04b1\u04c0\7Y\2\2\u04b2\u04b3") |
| buf.write("\7\26\2\2\u04b3\u04c0\7Y\2\2\u04b4\u04b5\7\22\2\2\u04b5") |
| buf.write("\u04c0\7Y\2\2\u04b6\u04b8\7&\2\2\u04b7\u04b9\5.\30\2\u04b8") |
| buf.write("\u04b7\3\2\2\2\u04b8\u04b9\3\2\2\2\u04b9\u04ba\3\2\2\2") |
| buf.write("\u04ba\u04c0\7Y\2\2\u04bb\u04bc\7\37\2\2\u04bc\u04bd\5") |
| buf.write("\16\b\2\u04bd\u04be\7Y\2\2\u04be\u04c0\3\2\2\2\u04bf\u04af") |
| buf.write("\3\2\2\2\u04bf\u04b2\3\2\2\2\u04bf\u04b4\3\2\2\2\u04bf") |
| buf.write("\u04b6\3\2\2\2\u04bf\u04bb\3\2\2\2\u04c0\u009f\3\2\2\2") |
| buf.write("\u04c1\u04c3\5\u00a2R\2\u04c2\u04c1\3\2\2\2\u04c2\u04c3") |
| buf.write("\3\2\2\2\u04c3\u04c4\3\2\2\2\u04c4\u04c5\7\2\2\3\u04c5") |
| buf.write("\u00a1\3\2\2\2\u04c6\u04c7\bR\1\2\u04c7\u04c8\5\u00a4") |
| buf.write("S\2\u04c8\u04cd\3\2\2\2\u04c9\u04ca\f\3\2\2\u04ca\u04cc") |
| buf.write("\5\u00a4S\2\u04cb\u04c9\3\2\2\2\u04cc\u04cf\3\2\2\2\u04cd") |
| buf.write("\u04cb\3\2\2\2\u04cd\u04ce\3\2\2\2\u04ce\u00a3\3\2\2\2") |
| buf.write("\u04cf\u04cd\3\2\2\2\u04d0\u04d4\5\u00a6T\2\u04d1\u04d4") |
| buf.write("\5\62\32\2\u04d2\u04d4\7Y\2\2\u04d3\u04d0\3\2\2\2\u04d3") |
| buf.write("\u04d1\3\2\2\2\u04d3\u04d2\3\2\2\2\u04d4\u00a5\3\2\2\2") |
| buf.write("\u04d5\u04d7\5\64\33\2\u04d6\u04d5\3\2\2\2\u04d6\u04d7") |
| buf.write("\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04da\5`\61\2\u04d9") |
| buf.write("\u04db\5\u00a8U\2\u04da\u04d9\3\2\2\2\u04da\u04db\3\2") |
| buf.write("\2\2\u04db\u04dc\3\2\2\2\u04dc\u04dd\5\u0092J\2\u04dd") |
| buf.write("\u00a7\3\2\2\2\u04de\u04df\bU\1\2\u04df\u04e0\5\62\32") |
| buf.write("\2\u04e0\u04e5\3\2\2\2\u04e1\u04e2\f\3\2\2\u04e2\u04e4") |
| buf.write("\5\62\32\2\u04e3\u04e1\3\2\2\2\u04e4\u04e7\3\2\2\2\u04e5") |
| buf.write("\u04e3\3\2\2\2\u04e5\u04e6\3\2\2\2\u04e6\u00a9\3\2\2\2") |
| buf.write("\u04e7\u04e5\3\2\2\2\u008c\u00af\u00b7\u00cb\u00dc\u00e6") |
| buf.write("\u010a\u0114\u0121\u0123\u012e\u0147\u0157\u0165\u0167") |
| buf.write("\u0173\u0175\u0181\u0183\u0195\u0197\u01a3\u01a5\u01b0") |
| buf.write("\u01bb\u01c6\u01d1\u01dc\u01e5\u01ec\u01f8\u01ff\u0204") |
| buf.write("\u0209\u020e\u0215\u021f\u0227\u0239\u023d\u0246\u0251") |
| buf.write("\u0256\u025b\u025f\u0263\u0265\u026f\u0274\u0278\u027c") |
| buf.write("\u0284\u028d\u0297\u029f\u02b0\u02bc\u02bf\u02c5\u02ce") |
| buf.write("\u02d3\u02d6\u02dd\u02ec\u02f8\u02fb\u02fd\u0305\u0309") |
| buf.write("\u0317\u031b\u0320\u0323\u0326\u032d\u032f\u0334\u0338") |
| buf.write("\u033d\u0341\u0344\u034d\u0355\u035f\u0367\u0369\u0373") |
| buf.write("\u0378\u037c\u0382\u0385\u038e\u0393\u0396\u039c\u03ac") |
| buf.write("\u03b2\u03b5\u03ba\u03bd\u03c4\u03d7\u03dd\u03e0\u03e2") |
| buf.write("\u03f1\u03f5\u03fc\u0401\u040e\u0417\u0420\u0433\u0436") |
| buf.write("\u043e\u0441\u0445\u044a\u0457\u045b\u0466\u046b\u046e") |
| buf.write("\u0479\u0481\u0494\u0498\u049c\u04a4\u04a8\u04ad\u04b8") |
| buf.write("\u04bf\u04c2\u04cd\u04d3\u04d6\u04da\u04e5") |
| return buf.getvalue() |
| |
| |
| class CParser ( Parser ): |
| |
| grammarFileName = "C.bnf" |
| |
| atn = ATNDeserializer().deserialize(serializedATN()) |
| |
| decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] |
| |
| sharedContextCache = PredictionContextCache() |
| |
| literalNames = [ "<INVALID>", "'__extension__'", "'__builtin_va_arg'", |
| "'__builtin_offsetof'", "'__m128'", "'__m128d'", "'__m128i'", |
| "'__typeof__'", "'__inline__'", "'__stdcall'", "'__declspec'", |
| "'__asm'", "'__attribute__'", "'__asm__'", "'__volatile__'", |
| "'auto'", "'break'", "'case'", "'char'", "'const'", |
| "'continue'", "'default'", "'do'", "'double'", "'else'", |
| "'enum'", "'extern'", "'float'", "'for'", "'goto'", |
| "'if'", "'inline'", "'int'", "'long'", "'register'", |
| "'restrict'", "'return'", "'short'", "'signed'", "'sizeof'", |
| "'static'", "'struct'", "'switch'", "'typedef'", "'union'", |
| "'unsigned'", "'void'", "'volatile'", "'while'", "'_Alignas'", |
| "'_Alignof'", "'_Atomic'", "'_Bool'", "'_Complex'", |
| "'_Generic'", "'_Imaginary'", "'_Noreturn'", "'_Static_assert'", |
| "'_Thread_local'", "'('", "')'", "'['", "']'", "'{'", |
| "'}'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'", |
| "'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'", |
| "'&'", "'|'", "'&&'", "'||'", "'^'", "'!'", "'~'", |
| "'?'", "':'", "';'", "','", "'='", "'*='", "'/='", |
| "'%='", "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", |
| "'|='", "'=='", "'!='", "'->'", "'.'", "'...'" ] |
| |
| symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", |
| "<INVALID>", "<INVALID>", "<INVALID>", "Auto", "Break", |
| "Case", "Char", "Const", "Continue", "Default", "Do", |
| "Double", "Else", "Enum", "Extern", "Float", "For", |
| "Goto", "If", "Inline", "Int", "Long", "Register", |
| "Restrict", "Return", "Short", "Signed", "Sizeof", |
| "Static", "Struct", "Switch", "Typedef", "Union", |
| "Unsigned", "Void", "Volatile", "While", "Alignas", |
| "Alignof", "Atomic", "Bool", "Complex", "Generic", |
| "Imaginary", "Noreturn", "StaticAssert", "ThreadLocal", |
| "LeftParen", "RightParen", "LeftBracket", "RightBracket", |
| "LeftBrace", "RightBrace", "Less", "LessEqual", "Greater", |
| "GreaterEqual", "LeftShift", "RightShift", "Plus", |
| "PlusPlus", "Minus", "MinusMinus", "Star", "Div", |
| "Mod", "And", "Or", "AndAnd", "OrOr", "Caret", "Not", |
| "Tilde", "Question", "Colon", "Semi", "Comma", "Assign", |
| "StarAssign", "DivAssign", "ModAssign", "PlusAssign", |
| "MinusAssign", "LeftShiftAssign", "RightShiftAssign", |
| "AndAssign", "XorAssign", "OrAssign", "Equal", "NotEqual", |
| "Arrow", "Dot", "Ellipsis", "Identifier", "Constant", |
| "StringLiteral", "LineDirective", "PragmaDirective", |
| "Whitespace", "Newline", "BlockComment", "LineComment" ] |
| |
| RULE_primaryExpression = 0 |
| RULE_genericSelection = 1 |
| RULE_genericAssocList = 2 |
| RULE_genericAssociation = 3 |
| RULE_postfixExpression = 4 |
| RULE_argumentExpressionList = 5 |
| RULE_unaryExpression = 6 |
| RULE_unaryOperator = 7 |
| RULE_castExpression = 8 |
| RULE_multiplicativeExpression = 9 |
| RULE_additiveExpression = 10 |
| RULE_shiftExpression = 11 |
| RULE_relationalExpression = 12 |
| RULE_equalityExpression = 13 |
| RULE_andExpression = 14 |
| RULE_exclusiveOrExpression = 15 |
| RULE_inclusiveOrExpression = 16 |
| RULE_logicalAndExpression = 17 |
| RULE_logicalOrExpression = 18 |
| RULE_conditionalExpression = 19 |
| RULE_assignmentExpression = 20 |
| RULE_assignmentOperator = 21 |
| RULE_expression = 22 |
| RULE_constantExpression = 23 |
| RULE_declaration = 24 |
| RULE_declarationSpecifiers = 25 |
| RULE_declarationSpecifiers2 = 26 |
| RULE_declarationSpecifier = 27 |
| RULE_initDeclaratorList = 28 |
| RULE_initDeclarator = 29 |
| RULE_storageClassSpecifier = 30 |
| RULE_typeSpecifier = 31 |
| RULE_structOrUnionSpecifier = 32 |
| RULE_structOrUnion = 33 |
| RULE_structDeclarationList = 34 |
| RULE_structDeclaration = 35 |
| RULE_specifierQualifierList = 36 |
| RULE_structDeclaratorList = 37 |
| RULE_structDeclarator = 38 |
| RULE_enumSpecifier = 39 |
| RULE_enumeratorList = 40 |
| RULE_enumerator = 41 |
| RULE_enumerationConstant = 42 |
| RULE_atomicTypeSpecifier = 43 |
| RULE_typeQualifier = 44 |
| RULE_functionSpecifier = 45 |
| RULE_alignmentSpecifier = 46 |
| RULE_declarator = 47 |
| RULE_directDeclarator = 48 |
| RULE_gccDeclaratorExtension = 49 |
| RULE_gccAttributeSpecifier = 50 |
| RULE_gccAttributeList = 51 |
| RULE_gccAttribute = 52 |
| RULE_nestedParenthesesBlock = 53 |
| RULE_pointer = 54 |
| RULE_typeQualifierList = 55 |
| RULE_parameterTypeList = 56 |
| RULE_parameterList = 57 |
| RULE_parameterDeclaration = 58 |
| RULE_identifierList = 59 |
| RULE_typeName = 60 |
| RULE_abstractDeclarator = 61 |
| RULE_directAbstractDeclarator = 62 |
| RULE_typedefName = 63 |
| RULE_initializer = 64 |
| RULE_initializerList = 65 |
| RULE_designation = 66 |
| RULE_designatorList = 67 |
| RULE_designator = 68 |
| RULE_staticAssertDeclaration = 69 |
| RULE_statement = 70 |
| RULE_labeledStatement = 71 |
| RULE_compoundStatement = 72 |
| RULE_blockItemList = 73 |
| RULE_blockItem = 74 |
| RULE_expressionStatement = 75 |
| RULE_selectionStatement = 76 |
| RULE_iterationStatement = 77 |
| RULE_jumpStatement = 78 |
| RULE_compilationUnit = 79 |
| RULE_translationUnit = 80 |
| RULE_externalDeclaration = 81 |
| RULE_functionDefinition = 82 |
| RULE_declarationList = 83 |
| |
| ruleNames = [ "primaryExpression", "genericSelection", "genericAssocList", |
| "genericAssociation", "postfixExpression", "argumentExpressionList", |
| "unaryExpression", "unaryOperator", "castExpression", |
| "multiplicativeExpression", "additiveExpression", "shiftExpression", |
| "relationalExpression", "equalityExpression", "andExpression", |
| "exclusiveOrExpression", "inclusiveOrExpression", "logicalAndExpression", |
| "logicalOrExpression", "conditionalExpression", "assignmentExpression", |
| "assignmentOperator", "expression", "constantExpression", |
| "declaration", "declarationSpecifiers", "declarationSpecifiers2", |
| "declarationSpecifier", "initDeclaratorList", "initDeclarator", |
| "storageClassSpecifier", "typeSpecifier", "structOrUnionSpecifier", |
| "structOrUnion", "structDeclarationList", "structDeclaration", |
| "specifierQualifierList", "structDeclaratorList", "structDeclarator", |
| "enumSpecifier", "enumeratorList", "enumerator", "enumerationConstant", |
| "atomicTypeSpecifier", "typeQualifier", "functionSpecifier", |
| "alignmentSpecifier", "declarator", "directDeclarator", |
| "gccDeclaratorExtension", "gccAttributeSpecifier", "gccAttributeList", |
| "gccAttribute", "nestedParenthesesBlock", "pointer", |
| "typeQualifierList", "parameterTypeList", "parameterList", |
| "parameterDeclaration", "identifierList", "typeName", |
| "abstractDeclarator", "directAbstractDeclarator", "typedefName", |
| "initializer", "initializerList", "designation", "designatorList", |
| "designator", "staticAssertDeclaration", "statement", |
| "labeledStatement", "compoundStatement", "blockItemList", |
| "blockItem", "expressionStatement", "selectionStatement", |
| "iterationStatement", "jumpStatement", "compilationUnit", |
| "translationUnit", "externalDeclaration", "functionDefinition", |
| "declarationList" ] |
| |
| EOF = Token.EOF |
| T__0=1 |
| T__1=2 |
| T__2=3 |
| T__3=4 |
| T__4=5 |
| T__5=6 |
| T__6=7 |
| T__7=8 |
| T__8=9 |
| T__9=10 |
| T__10=11 |
| T__11=12 |
| T__12=13 |
| T__13=14 |
| Auto=15 |
| Break=16 |
| Case=17 |
| Char=18 |
| Const=19 |
| Continue=20 |
| Default=21 |
| Do=22 |
| Double=23 |
| Else=24 |
| Enum=25 |
| Extern=26 |
| Float=27 |
| For=28 |
| Goto=29 |
| If=30 |
| Inline=31 |
| Int=32 |
| Long=33 |
| Register=34 |
| Restrict=35 |
| Return=36 |
| Short=37 |
| Signed=38 |
| Sizeof=39 |
| Static=40 |
| Struct=41 |
| Switch=42 |
| Typedef=43 |
| Union=44 |
| Unsigned=45 |
| Void=46 |
| Volatile=47 |
| While=48 |
| Alignas=49 |
| Alignof=50 |
| Atomic=51 |
| Bool=52 |
| Complex=53 |
| Generic=54 |
| Imaginary=55 |
| Noreturn=56 |
| StaticAssert=57 |
| ThreadLocal=58 |
| LeftParen=59 |
| RightParen=60 |
| LeftBracket=61 |
| RightBracket=62 |
| LeftBrace=63 |
| RightBrace=64 |
| Less=65 |
| LessEqual=66 |
| Greater=67 |
| GreaterEqual=68 |
| LeftShift=69 |
| RightShift=70 |
| Plus=71 |
| PlusPlus=72 |
| Minus=73 |
| MinusMinus=74 |
| Star=75 |
| Div=76 |
| Mod=77 |
| And=78 |
| Or=79 |
| AndAnd=80 |
| OrOr=81 |
| Caret=82 |
| Not=83 |
| Tilde=84 |
| Question=85 |
| Colon=86 |
| Semi=87 |
| Comma=88 |
| Assign=89 |
| StarAssign=90 |
| DivAssign=91 |
| ModAssign=92 |
| PlusAssign=93 |
| MinusAssign=94 |
| LeftShiftAssign=95 |
| RightShiftAssign=96 |
| AndAssign=97 |
| XorAssign=98 |
| OrAssign=99 |
| Equal=100 |
| NotEqual=101 |
| Arrow=102 |
| Dot=103 |
| Ellipsis=104 |
| Identifier=105 |
| Constant=106 |
| StringLiteral=107 |
| LineDirective=108 |
| PragmaDirective=109 |
| Whitespace=110 |
| Newline=111 |
| BlockComment=112 |
| LineComment=113 |
| |
| def __init__(self, input:TokenStream): |
| super().__init__(input) |
| self.checkVersion("4.9") |
| self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) |
| self._predicates = None |
| |
| |
| |
| class PrimaryExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def Constant(self): |
| return self.getToken(CParser.Constant, 0) |
| |
| def StringLiteral(self, i:int=None): |
| if i is None: |
| return self.getTokens(CParser.StringLiteral) |
| else: |
| return self.getToken(CParser.StringLiteral, i) |
| |
| def expression(self): |
| return self.getTypedRuleContext(CParser.ExpressionContext,0) |
| |
| |
| def genericSelection(self): |
| return self.getTypedRuleContext(CParser.GenericSelectionContext,0) |
| |
| |
| def compoundStatement(self): |
| return self.getTypedRuleContext(CParser.CompoundStatementContext,0) |
| |
| |
| def unaryExpression(self): |
| return self.getTypedRuleContext(CParser.UnaryExpressionContext,0) |
| |
| |
| def typeName(self): |
| return self.getTypedRuleContext(CParser.TypeNameContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_primaryExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterPrimaryExpression" ): |
| listener.enterPrimaryExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitPrimaryExpression" ): |
| listener.exitPrimaryExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitPrimaryExpression" ): |
| return visitor.visitPrimaryExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def primaryExpression(self): |
| |
| localctx = CParser.PrimaryExpressionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 0, self.RULE_primaryExpression) |
| self._la = 0 # Token type |
| try: |
| self.state = 201 |
| la_ = self._interp.adaptivePredict(self._input,2,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 168 |
| self.match(CParser.Identifier) |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 169 |
| self.match(CParser.Constant) |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 171 |
| self._errHandler.sync(self) |
| _alt = 1 |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt == 1: |
| self.state = 170 |
| self.match(CParser.StringLiteral) |
| |
| else: |
| raise NoViableAltException(self) |
| self.state = 173 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,0,self._ctx) |
| |
| pass |
| |
| elif la_ == 4: |
| self.enterOuterAlt(localctx, 4) |
| self.state = 175 |
| self.match(CParser.LeftParen) |
| self.state = 176 |
| self.expression(0) |
| self.state = 177 |
| self.match(CParser.RightParen) |
| pass |
| |
| elif la_ == 5: |
| self.enterOuterAlt(localctx, 5) |
| self.state = 179 |
| self.genericSelection() |
| pass |
| |
| elif la_ == 6: |
| self.enterOuterAlt(localctx, 6) |
| self.state = 181 |
| _la = self._input.LA(1) |
| if _la==CParser.T__0: |
| self.state = 180 |
| self.match(CParser.T__0) |
| |
| |
| self.state = 183 |
| self.match(CParser.LeftParen) |
| self.state = 184 |
| self.compoundStatement() |
| self.state = 185 |
| self.match(CParser.RightParen) |
| pass |
| |
| elif la_ == 7: |
| self.enterOuterAlt(localctx, 7) |
| self.state = 187 |
| self.match(CParser.T__1) |
| self.state = 188 |
| self.match(CParser.LeftParen) |
| self.state = 189 |
| self.unaryExpression() |
| self.state = 190 |
| self.match(CParser.Comma) |
| self.state = 191 |
| self.typeName() |
| self.state = 192 |
| self.match(CParser.RightParen) |
| pass |
| |
| elif la_ == 8: |
| self.enterOuterAlt(localctx, 8) |
| self.state = 194 |
| self.match(CParser.T__2) |
| self.state = 195 |
| self.match(CParser.LeftParen) |
| self.state = 196 |
| self.typeName() |
| self.state = 197 |
| self.match(CParser.Comma) |
| self.state = 198 |
| self.unaryExpression() |
| self.state = 199 |
| self.match(CParser.RightParen) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class GenericSelectionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def assignmentExpression(self): |
| return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0) |
| |
| |
| def genericAssocList(self): |
| return self.getTypedRuleContext(CParser.GenericAssocListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_genericSelection |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterGenericSelection" ): |
| listener.enterGenericSelection(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitGenericSelection" ): |
| listener.exitGenericSelection(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitGenericSelection" ): |
| return visitor.visitGenericSelection(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def genericSelection(self): |
| |
| localctx = CParser.GenericSelectionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 2, self.RULE_genericSelection) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 203 |
| self.match(CParser.Generic) |
| self.state = 204 |
| self.match(CParser.LeftParen) |
| self.state = 205 |
| self.assignmentExpression() |
| self.state = 206 |
| self.match(CParser.Comma) |
| self.state = 207 |
| self.genericAssocList(0) |
| self.state = 208 |
| self.match(CParser.RightParen) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class GenericAssocListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def genericAssociation(self): |
| return self.getTypedRuleContext(CParser.GenericAssociationContext,0) |
| |
| |
| def genericAssocList(self): |
| return self.getTypedRuleContext(CParser.GenericAssocListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_genericAssocList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterGenericAssocList" ): |
| listener.enterGenericAssocList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitGenericAssocList" ): |
| listener.exitGenericAssocList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitGenericAssocList" ): |
| return visitor.visitGenericAssocList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def genericAssocList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.GenericAssocListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 4 |
| self.enterRecursionRule(localctx, 4, self.RULE_genericAssocList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 211 |
| self.genericAssociation() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 218 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,3,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 = CParser.GenericAssocListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_genericAssocList) |
| self.state = 213 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 214 |
| self.match(CParser.Comma) |
| self.state = 215 |
| self.genericAssociation() |
| self.state = 220 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,3,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 |
| |
| class GenericAssociationContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def typeName(self): |
| return self.getTypedRuleContext(CParser.TypeNameContext,0) |
| |
| |
| def assignmentExpression(self): |
| return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_genericAssociation |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterGenericAssociation" ): |
| listener.enterGenericAssociation(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitGenericAssociation" ): |
| listener.exitGenericAssociation(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitGenericAssociation" ): |
| return visitor.visitGenericAssociation(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def genericAssociation(self): |
| |
| localctx = CParser.GenericAssociationContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 6, self.RULE_genericAssociation) |
| try: |
| self.state = 228 |
| token = self._input.LA(1) |
| if token in [CParser.T__0, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.Char, CParser.Const, CParser.Double, CParser.Enum, CParser.Float, CParser.Int, CParser.Long, CParser.Restrict, CParser.Short, CParser.Signed, CParser.Struct, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Identifier]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 221 |
| self.typeName() |
| self.state = 222 |
| self.match(CParser.Colon) |
| self.state = 223 |
| self.assignmentExpression() |
| |
| elif token in [CParser.Default]: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 225 |
| self.match(CParser.Default) |
| self.state = 226 |
| self.match(CParser.Colon) |
| self.state = 227 |
| self.assignmentExpression() |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class PostfixExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def primaryExpression(self): |
| return self.getTypedRuleContext(CParser.PrimaryExpressionContext,0) |
| |
| |
| def typeName(self): |
| return self.getTypedRuleContext(CParser.TypeNameContext,0) |
| |
| |
| def initializerList(self): |
| return self.getTypedRuleContext(CParser.InitializerListContext,0) |
| |
| |
| def postfixExpression(self): |
| return self.getTypedRuleContext(CParser.PostfixExpressionContext,0) |
| |
| |
| def expression(self): |
| return self.getTypedRuleContext(CParser.ExpressionContext,0) |
| |
| |
| def argumentExpressionList(self): |
| return self.getTypedRuleContext(CParser.ArgumentExpressionListContext,0) |
| |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def getRuleIndex(self): |
| return CParser.RULE_postfixExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterPostfixExpression" ): |
| listener.enterPostfixExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitPostfixExpression" ): |
| listener.exitPostfixExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitPostfixExpression" ): |
| return visitor.visitPostfixExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def postfixExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.PostfixExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 8 |
| self.enterRecursionRule(localctx, 8, self.RULE_postfixExpression, _p) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 264 |
| la_ = self._interp.adaptivePredict(self._input,5,self._ctx) |
| if la_ == 1: |
| self.state = 231 |
| self.primaryExpression() |
| pass |
| |
| elif la_ == 2: |
| self.state = 232 |
| self.match(CParser.LeftParen) |
| self.state = 233 |
| self.typeName() |
| self.state = 234 |
| self.match(CParser.RightParen) |
| self.state = 235 |
| self.match(CParser.LeftBrace) |
| self.state = 236 |
| self.initializerList(0) |
| self.state = 237 |
| self.match(CParser.RightBrace) |
| pass |
| |
| elif la_ == 3: |
| self.state = 239 |
| self.match(CParser.LeftParen) |
| self.state = 240 |
| self.typeName() |
| self.state = 241 |
| self.match(CParser.RightParen) |
| self.state = 242 |
| self.match(CParser.LeftBrace) |
| self.state = 243 |
| self.initializerList(0) |
| self.state = 244 |
| self.match(CParser.Comma) |
| self.state = 245 |
| self.match(CParser.RightBrace) |
| pass |
| |
| elif la_ == 4: |
| self.state = 247 |
| self.match(CParser.T__0) |
| self.state = 248 |
| self.match(CParser.LeftParen) |
| self.state = 249 |
| self.typeName() |
| self.state = 250 |
| self.match(CParser.RightParen) |
| self.state = 251 |
| self.match(CParser.LeftBrace) |
| self.state = 252 |
| self.initializerList(0) |
| self.state = 253 |
| self.match(CParser.RightBrace) |
| pass |
| |
| elif la_ == 5: |
| self.state = 255 |
| self.match(CParser.T__0) |
| self.state = 256 |
| self.match(CParser.LeftParen) |
| self.state = 257 |
| self.typeName() |
| self.state = 258 |
| self.match(CParser.RightParen) |
| self.state = 259 |
| self.match(CParser.LeftBrace) |
| self.state = 260 |
| self.initializerList(0) |
| self.state = 261 |
| self.match(CParser.Comma) |
| self.state = 262 |
| self.match(CParser.RightBrace) |
| pass |
| |
| |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 289 |
| 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 = 287 |
| la_ = self._interp.adaptivePredict(self._input,7,self._ctx) |
| if la_ == 1: |
| localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression) |
| self.state = 266 |
| if not self.precpred(self._ctx, 10): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 10)") |
| self.state = 267 |
| self.match(CParser.LeftBracket) |
| self.state = 268 |
| self.expression(0) |
| self.state = 269 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 2: |
| localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression) |
| self.state = 271 |
| if not self.precpred(self._ctx, 9): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") |
| self.state = 272 |
| self.match(CParser.LeftParen) |
| self.state = 274 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 273 |
| self.argumentExpressionList(0) |
| |
| |
| self.state = 276 |
| self.match(CParser.RightParen) |
| pass |
| |
| elif la_ == 3: |
| localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression) |
| self.state = 277 |
| if not self.precpred(self._ctx, 8): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 8)") |
| self.state = 278 |
| self.match(CParser.Dot) |
| self.state = 279 |
| self.match(CParser.Identifier) |
| pass |
| |
| elif la_ == 4: |
| localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression) |
| self.state = 280 |
| if not self.precpred(self._ctx, 7): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") |
| self.state = 281 |
| self.match(CParser.Arrow) |
| self.state = 282 |
| self.match(CParser.Identifier) |
| pass |
| |
| elif la_ == 5: |
| localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression) |
| self.state = 283 |
| if not self.precpred(self._ctx, 6): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") |
| self.state = 284 |
| self.match(CParser.PlusPlus) |
| pass |
| |
| elif la_ == 6: |
| localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression) |
| self.state = 285 |
| if not self.precpred(self._ctx, 5): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") |
| self.state = 286 |
| self.match(CParser.MinusMinus) |
| pass |
| |
| |
| self.state = 291 |
| 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 |
| |
| class ArgumentExpressionListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def assignmentExpression(self): |
| return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0) |
| |
| |
| def argumentExpressionList(self): |
| return self.getTypedRuleContext(CParser.ArgumentExpressionListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_argumentExpressionList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterArgumentExpressionList" ): |
| listener.enterArgumentExpressionList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitArgumentExpressionList" ): |
| listener.exitArgumentExpressionList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitArgumentExpressionList" ): |
| return visitor.visitArgumentExpressionList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def argumentExpressionList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.ArgumentExpressionListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 10 |
| self.enterRecursionRule(localctx, 10, self.RULE_argumentExpressionList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 293 |
| self.assignmentExpression() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 300 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,9,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 = CParser.ArgumentExpressionListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_argumentExpressionList) |
| self.state = 295 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 296 |
| self.match(CParser.Comma) |
| self.state = 297 |
| self.assignmentExpression() |
| self.state = 302 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,9,self._ctx) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.unrollRecursionContexts(_parentctx) |
| return localctx |
| |
| class UnaryExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def postfixExpression(self): |
| return self.getTypedRuleContext(CParser.PostfixExpressionContext,0) |
| |
| |
| def unaryExpression(self): |
| return self.getTypedRuleContext(CParser.UnaryExpressionContext,0) |
| |
| |
| def unaryOperator(self): |
| return self.getTypedRuleContext(CParser.UnaryOperatorContext,0) |
| |
| |
| def castExpression(self): |
| return self.getTypedRuleContext(CParser.CastExpressionContext,0) |
| |
| |
| def typeName(self): |
| return self.getTypedRuleContext(CParser.TypeNameContext,0) |
| |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def getRuleIndex(self): |
| return CParser.RULE_unaryExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterUnaryExpression" ): |
| listener.enterUnaryExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitUnaryExpression" ): |
| listener.exitUnaryExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitUnaryExpression" ): |
| return visitor.visitUnaryExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def unaryExpression(self): |
| |
| localctx = CParser.UnaryExpressionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 12, self.RULE_unaryExpression) |
| try: |
| self.state = 325 |
| la_ = self._interp.adaptivePredict(self._input,10,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 303 |
| self.postfixExpression(0) |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 304 |
| self.match(CParser.PlusPlus) |
| self.state = 305 |
| self.unaryExpression() |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 306 |
| self.match(CParser.MinusMinus) |
| self.state = 307 |
| self.unaryExpression() |
| pass |
| |
| elif la_ == 4: |
| self.enterOuterAlt(localctx, 4) |
| self.state = 308 |
| self.unaryOperator() |
| self.state = 309 |
| self.castExpression() |
| pass |
| |
| elif la_ == 5: |
| self.enterOuterAlt(localctx, 5) |
| self.state = 311 |
| self.match(CParser.Sizeof) |
| self.state = 312 |
| self.unaryExpression() |
| pass |
| |
| elif la_ == 6: |
| self.enterOuterAlt(localctx, 6) |
| self.state = 313 |
| self.match(CParser.Sizeof) |
| self.state = 314 |
| self.match(CParser.LeftParen) |
| self.state = 315 |
| self.typeName() |
| self.state = 316 |
| self.match(CParser.RightParen) |
| pass |
| |
| elif la_ == 7: |
| self.enterOuterAlt(localctx, 7) |
| self.state = 318 |
| self.match(CParser.Alignof) |
| self.state = 319 |
| self.match(CParser.LeftParen) |
| self.state = 320 |
| self.typeName() |
| self.state = 321 |
| self.match(CParser.RightParen) |
| pass |
| |
| elif la_ == 8: |
| self.enterOuterAlt(localctx, 8) |
| self.state = 323 |
| self.match(CParser.AndAnd) |
| self.state = 324 |
| self.match(CParser.Identifier) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class UnaryOperatorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_unaryOperator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterUnaryOperator" ): |
| listener.enterUnaryOperator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitUnaryOperator" ): |
| listener.exitUnaryOperator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitUnaryOperator" ): |
| return visitor.visitUnaryOperator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def unaryOperator(self): |
| |
| localctx = CParser.UnaryOperatorContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 14, self.RULE_unaryOperator) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 327 |
| _la = self._input.LA(1) |
| if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) != 0)): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class CastExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def unaryExpression(self): |
| return self.getTypedRuleContext(CParser.UnaryExpressionContext,0) |
| |
| |
| def typeName(self): |
| return self.getTypedRuleContext(CParser.TypeNameContext,0) |
| |
| |
| def castExpression(self): |
| return self.getTypedRuleContext(CParser.CastExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_castExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterCastExpression" ): |
| listener.enterCastExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitCastExpression" ): |
| listener.exitCastExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitCastExpression" ): |
| return visitor.visitCastExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def castExpression(self): |
| |
| localctx = CParser.CastExpressionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 16, self.RULE_castExpression) |
| try: |
| self.state = 341 |
| la_ = self._interp.adaptivePredict(self._input,11,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 329 |
| self.unaryExpression() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 330 |
| self.match(CParser.LeftParen) |
| self.state = 331 |
| self.typeName() |
| self.state = 332 |
| self.match(CParser.RightParen) |
| self.state = 333 |
| self.castExpression() |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 335 |
| self.match(CParser.T__0) |
| self.state = 336 |
| self.match(CParser.LeftParen) |
| self.state = 337 |
| self.typeName() |
| self.state = 338 |
| self.match(CParser.RightParen) |
| self.state = 339 |
| 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 |
| |
| class MultiplicativeExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def castExpression(self): |
| return self.getTypedRuleContext(CParser.CastExpressionContext,0) |
| |
| |
| def multiplicativeExpression(self): |
| return self.getTypedRuleContext(CParser.MultiplicativeExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_multiplicativeExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterMultiplicativeExpression" ): |
| listener.enterMultiplicativeExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitMultiplicativeExpression" ): |
| listener.exitMultiplicativeExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitMultiplicativeExpression" ): |
| return visitor.visitMultiplicativeExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def multiplicativeExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.MultiplicativeExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 18 |
| self.enterRecursionRule(localctx, 18, self.RULE_multiplicativeExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 344 |
| self.castExpression() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 357 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,13,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 = 355 |
| la_ = self._interp.adaptivePredict(self._input,12,self._ctx) |
| if la_ == 1: |
| localctx = CParser.MultiplicativeExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression) |
| self.state = 346 |
| if not self.precpred(self._ctx, 3): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") |
| self.state = 347 |
| self.match(CParser.Star) |
| self.state = 348 |
| self.castExpression() |
| pass |
| |
| elif la_ == 2: |
| localctx = CParser.MultiplicativeExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression) |
| self.state = 349 |
| if not self.precpred(self._ctx, 2): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") |
| self.state = 350 |
| self.match(CParser.Div) |
| self.state = 351 |
| self.castExpression() |
| pass |
| |
| elif la_ == 3: |
| localctx = CParser.MultiplicativeExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression) |
| self.state = 352 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 353 |
| self.match(CParser.Mod) |
| self.state = 354 |
| self.castExpression() |
| pass |
| |
| |
| self.state = 359 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,13,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 |
| |
| class AdditiveExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def multiplicativeExpression(self): |
| return self.getTypedRuleContext(CParser.MultiplicativeExpressionContext,0) |
| |
| |
| def additiveExpression(self): |
| return self.getTypedRuleContext(CParser.AdditiveExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_additiveExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterAdditiveExpression" ): |
| listener.enterAdditiveExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitAdditiveExpression" ): |
| listener.exitAdditiveExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitAdditiveExpression" ): |
| return visitor.visitAdditiveExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def additiveExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.AdditiveExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 20 |
| self.enterRecursionRule(localctx, 20, self.RULE_additiveExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 361 |
| self.multiplicativeExpression(0) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 371 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,15,self._ctx) |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt==1: |
| if self._parseListeners is not None: |
| self.triggerExitRuleEvent() |
| _prevctx = localctx |
| self.state = 369 |
| la_ = self._interp.adaptivePredict(self._input,14,self._ctx) |
| if la_ == 1: |
| localctx = CParser.AdditiveExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveExpression) |
| self.state = 363 |
| if not self.precpred(self._ctx, 2): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") |
| self.state = 364 |
| self.match(CParser.Plus) |
| self.state = 365 |
| self.multiplicativeExpression(0) |
| pass |
| |
| elif la_ == 2: |
| localctx = CParser.AdditiveExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveExpression) |
| self.state = 366 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 367 |
| self.match(CParser.Minus) |
| self.state = 368 |
| self.multiplicativeExpression(0) |
| pass |
| |
| |
| self.state = 373 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,15,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 |
| |
| class ShiftExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def additiveExpression(self): |
| return self.getTypedRuleContext(CParser.AdditiveExpressionContext,0) |
| |
| |
| def shiftExpression(self): |
| return self.getTypedRuleContext(CParser.ShiftExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_shiftExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterShiftExpression" ): |
| listener.enterShiftExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitShiftExpression" ): |
| listener.exitShiftExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitShiftExpression" ): |
| return visitor.visitShiftExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def shiftExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.ShiftExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 22 |
| self.enterRecursionRule(localctx, 22, self.RULE_shiftExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 375 |
| self.additiveExpression(0) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 385 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,17,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 = 383 |
| la_ = self._interp.adaptivePredict(self._input,16,self._ctx) |
| if la_ == 1: |
| localctx = CParser.ShiftExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_shiftExpression) |
| self.state = 377 |
| if not self.precpred(self._ctx, 2): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") |
| self.state = 378 |
| self.match(CParser.LeftShift) |
| self.state = 379 |
| self.additiveExpression(0) |
| pass |
| |
| elif la_ == 2: |
| localctx = CParser.ShiftExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_shiftExpression) |
| self.state = 380 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 381 |
| self.match(CParser.RightShift) |
| self.state = 382 |
| self.additiveExpression(0) |
| pass |
| |
| |
| self.state = 387 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,17,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 |
| |
| class RelationalExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def shiftExpression(self): |
| return self.getTypedRuleContext(CParser.ShiftExpressionContext,0) |
| |
| |
| def relationalExpression(self): |
| return self.getTypedRuleContext(CParser.RelationalExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_relationalExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterRelationalExpression" ): |
| listener.enterRelationalExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitRelationalExpression" ): |
| listener.exitRelationalExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitRelationalExpression" ): |
| return visitor.visitRelationalExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def relationalExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.RelationalExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 24 |
| self.enterRecursionRule(localctx, 24, self.RULE_relationalExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 389 |
| self.shiftExpression(0) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 405 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,19,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 = 403 |
| la_ = self._interp.adaptivePredict(self._input,18,self._ctx) |
| if la_ == 1: |
| localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression) |
| self.state = 391 |
| if not self.precpred(self._ctx, 4): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") |
| self.state = 392 |
| self.match(CParser.Less) |
| self.state = 393 |
| self.shiftExpression(0) |
| pass |
| |
| elif la_ == 2: |
| localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression) |
| self.state = 394 |
| if not self.precpred(self._ctx, 3): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") |
| self.state = 395 |
| self.match(CParser.Greater) |
| self.state = 396 |
| self.shiftExpression(0) |
| pass |
| |
| elif la_ == 3: |
| localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression) |
| self.state = 397 |
| if not self.precpred(self._ctx, 2): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") |
| self.state = 398 |
| self.match(CParser.LessEqual) |
| self.state = 399 |
| self.shiftExpression(0) |
| pass |
| |
| elif la_ == 4: |
| localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression) |
| self.state = 400 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 401 |
| self.match(CParser.GreaterEqual) |
| self.state = 402 |
| self.shiftExpression(0) |
| pass |
| |
| |
| self.state = 407 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,19,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 |
| |
| class EqualityExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def relationalExpression(self): |
| return self.getTypedRuleContext(CParser.RelationalExpressionContext,0) |
| |
| |
| def equalityExpression(self): |
| return self.getTypedRuleContext(CParser.EqualityExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_equalityExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterEqualityExpression" ): |
| listener.enterEqualityExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitEqualityExpression" ): |
| listener.exitEqualityExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitEqualityExpression" ): |
| return visitor.visitEqualityExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def equalityExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.EqualityExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 26 |
| self.enterRecursionRule(localctx, 26, self.RULE_equalityExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 409 |
| self.relationalExpression(0) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 419 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,21,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 = 417 |
| la_ = self._interp.adaptivePredict(self._input,20,self._ctx) |
| if la_ == 1: |
| localctx = CParser.EqualityExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_equalityExpression) |
| self.state = 411 |
| if not self.precpred(self._ctx, 2): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") |
| self.state = 412 |
| self.match(CParser.Equal) |
| self.state = 413 |
| self.relationalExpression(0) |
| pass |
| |
| elif la_ == 2: |
| localctx = CParser.EqualityExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_equalityExpression) |
| self.state = 414 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 415 |
| self.match(CParser.NotEqual) |
| self.state = 416 |
| self.relationalExpression(0) |
| pass |
| |
| |
| self.state = 421 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,21,self._ctx) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.unrollRecursionContexts(_parentctx) |
| return localctx |
| |
| class AndExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def equalityExpression(self): |
| return self.getTypedRuleContext(CParser.EqualityExpressionContext,0) |
| |
| |
| def andExpression(self): |
| return self.getTypedRuleContext(CParser.AndExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_andExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterAndExpression" ): |
| listener.enterAndExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitAndExpression" ): |
| listener.exitAndExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitAndExpression" ): |
| return visitor.visitAndExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def andExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.AndExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 28 |
| self.enterRecursionRule(localctx, 28, self.RULE_andExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 423 |
| self.equalityExpression(0) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 430 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,22,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 = CParser.AndExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_andExpression) |
| self.state = 425 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 426 |
| self.match(CParser.And) |
| self.state = 427 |
| self.equalityExpression(0) |
| self.state = 432 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,22,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 |
| |
| class ExclusiveOrExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def andExpression(self): |
| return self.getTypedRuleContext(CParser.AndExpressionContext,0) |
| |
| |
| def exclusiveOrExpression(self): |
| return self.getTypedRuleContext(CParser.ExclusiveOrExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_exclusiveOrExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterExclusiveOrExpression" ): |
| listener.enterExclusiveOrExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitExclusiveOrExpression" ): |
| listener.exitExclusiveOrExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitExclusiveOrExpression" ): |
| return visitor.visitExclusiveOrExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def exclusiveOrExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.ExclusiveOrExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 30 |
| self.enterRecursionRule(localctx, 30, self.RULE_exclusiveOrExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 434 |
| self.andExpression(0) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 441 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,23,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 = CParser.ExclusiveOrExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_exclusiveOrExpression) |
| self.state = 436 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 437 |
| self.match(CParser.Caret) |
| self.state = 438 |
| self.andExpression(0) |
| self.state = 443 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,23,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 |
| |
| class InclusiveOrExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def exclusiveOrExpression(self): |
| return self.getTypedRuleContext(CParser.ExclusiveOrExpressionContext,0) |
| |
| |
| def inclusiveOrExpression(self): |
| return self.getTypedRuleContext(CParser.InclusiveOrExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_inclusiveOrExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterInclusiveOrExpression" ): |
| listener.enterInclusiveOrExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitInclusiveOrExpression" ): |
| listener.exitInclusiveOrExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitInclusiveOrExpression" ): |
| return visitor.visitInclusiveOrExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def inclusiveOrExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.InclusiveOrExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 32 |
| self.enterRecursionRule(localctx, 32, self.RULE_inclusiveOrExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 445 |
| self.exclusiveOrExpression(0) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 452 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,24,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 = CParser.InclusiveOrExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_inclusiveOrExpression) |
| self.state = 447 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 448 |
| self.match(CParser.Or) |
| self.state = 449 |
| self.exclusiveOrExpression(0) |
| self.state = 454 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,24,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 |
| |
| class LogicalAndExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def inclusiveOrExpression(self): |
| return self.getTypedRuleContext(CParser.InclusiveOrExpressionContext,0) |
| |
| |
| def logicalAndExpression(self): |
| return self.getTypedRuleContext(CParser.LogicalAndExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_logicalAndExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterLogicalAndExpression" ): |
| listener.enterLogicalAndExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitLogicalAndExpression" ): |
| listener.exitLogicalAndExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitLogicalAndExpression" ): |
| return visitor.visitLogicalAndExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def logicalAndExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.LogicalAndExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 34 |
| self.enterRecursionRule(localctx, 34, self.RULE_logicalAndExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 456 |
| self.inclusiveOrExpression(0) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 463 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,25,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 = CParser.LogicalAndExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalAndExpression) |
| self.state = 458 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 459 |
| self.match(CParser.AndAnd) |
| self.state = 460 |
| self.inclusiveOrExpression(0) |
| self.state = 465 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,25,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 |
| |
| class LogicalOrExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def logicalAndExpression(self): |
| return self.getTypedRuleContext(CParser.LogicalAndExpressionContext,0) |
| |
| |
| def logicalOrExpression(self): |
| return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_logicalOrExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterLogicalOrExpression" ): |
| listener.enterLogicalOrExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitLogicalOrExpression" ): |
| listener.exitLogicalOrExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitLogicalOrExpression" ): |
| return visitor.visitLogicalOrExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def logicalOrExpression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.LogicalOrExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 36 |
| self.enterRecursionRule(localctx, 36, self.RULE_logicalOrExpression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 467 |
| self.logicalAndExpression(0) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 474 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,26,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 = CParser.LogicalOrExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalOrExpression) |
| self.state = 469 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 470 |
| self.match(CParser.OrOr) |
| self.state = 471 |
| self.logicalAndExpression(0) |
| self.state = 476 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,26,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 |
| |
| class ConditionalExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def logicalOrExpression(self): |
| return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,0) |
| |
| |
| def expression(self): |
| return self.getTypedRuleContext(CParser.ExpressionContext,0) |
| |
| |
| def conditionalExpression(self): |
| return self.getTypedRuleContext(CParser.ConditionalExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_conditionalExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterConditionalExpression" ): |
| listener.enterConditionalExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitConditionalExpression" ): |
| listener.exitConditionalExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitConditionalExpression" ): |
| return visitor.visitConditionalExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def conditionalExpression(self): |
| |
| localctx = CParser.ConditionalExpressionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 38, self.RULE_conditionalExpression) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 477 |
| self.logicalOrExpression(0) |
| self.state = 483 |
| la_ = self._interp.adaptivePredict(self._input,27,self._ctx) |
| if la_ == 1: |
| self.state = 478 |
| self.match(CParser.Question) |
| self.state = 479 |
| self.expression(0) |
| self.state = 480 |
| self.match(CParser.Colon) |
| self.state = 481 |
| self.conditionalExpression() |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class AssignmentExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def conditionalExpression(self): |
| return self.getTypedRuleContext(CParser.ConditionalExpressionContext,0) |
| |
| |
| def unaryExpression(self): |
| return self.getTypedRuleContext(CParser.UnaryExpressionContext,0) |
| |
| |
| def assignmentOperator(self): |
| return self.getTypedRuleContext(CParser.AssignmentOperatorContext,0) |
| |
| |
| def assignmentExpression(self): |
| return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_assignmentExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterAssignmentExpression" ): |
| listener.enterAssignmentExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitAssignmentExpression" ): |
| listener.exitAssignmentExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitAssignmentExpression" ): |
| return visitor.visitAssignmentExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def assignmentExpression(self): |
| |
| localctx = CParser.AssignmentExpressionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 40, self.RULE_assignmentExpression) |
| try: |
| self.state = 490 |
| la_ = self._interp.adaptivePredict(self._input,28,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 485 |
| self.conditionalExpression() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 486 |
| self.unaryExpression() |
| self.state = 487 |
| self.assignmentOperator() |
| self.state = 488 |
| 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 |
| |
| class AssignmentOperatorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_assignmentOperator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterAssignmentOperator" ): |
| listener.enterAssignmentOperator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitAssignmentOperator" ): |
| listener.exitAssignmentOperator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitAssignmentOperator" ): |
| return visitor.visitAssignmentOperator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def assignmentOperator(self): |
| |
| localctx = CParser.AssignmentOperatorContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 42, self.RULE_assignmentOperator) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 492 |
| _la = self._input.LA(1) |
| if not(((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & ((1 << (CParser.Assign - 89)) | (1 << (CParser.StarAssign - 89)) | (1 << (CParser.DivAssign - 89)) | (1 << (CParser.ModAssign - 89)) | (1 << (CParser.PlusAssign - 89)) | (1 << (CParser.MinusAssign - 89)) | (1 << (CParser.LeftShiftAssign - 89)) | (1 << (CParser.RightShiftAssign - 89)) | (1 << (CParser.AndAssign - 89)) | (1 << (CParser.XorAssign - 89)) | (1 << (CParser.OrAssign - 89)))) != 0)): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class ExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def assignmentExpression(self): |
| return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0) |
| |
| |
| def expression(self): |
| return self.getTypedRuleContext(CParser.ExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_expression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterExpression" ): |
| listener.enterExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitExpression" ): |
| listener.exitExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitExpression" ): |
| return visitor.visitExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def expression(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.ExpressionContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 44 |
| self.enterRecursionRule(localctx, 44, self.RULE_expression, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 495 |
| self.assignmentExpression() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 502 |
| 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 |
| localctx = CParser.ExpressionContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) |
| self.state = 497 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 498 |
| self.match(CParser.Comma) |
| self.state = 499 |
| self.assignmentExpression() |
| self.state = 504 |
| 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 |
| |
| class ConstantExpressionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def conditionalExpression(self): |
| return self.getTypedRuleContext(CParser.ConditionalExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_constantExpression |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterConstantExpression" ): |
| listener.enterConstantExpression(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitConstantExpression" ): |
| listener.exitConstantExpression(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitConstantExpression" ): |
| return visitor.visitConstantExpression(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def constantExpression(self): |
| |
| localctx = CParser.ConstantExpressionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 46, self.RULE_constantExpression) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 505 |
| self.conditionalExpression() |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class DeclarationContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def declarationSpecifiers(self): |
| return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0) |
| |
| |
| def initDeclaratorList(self): |
| return self.getTypedRuleContext(CParser.InitDeclaratorListContext,0) |
| |
| |
| def staticAssertDeclaration(self): |
| return self.getTypedRuleContext(CParser.StaticAssertDeclarationContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_declaration |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDeclaration" ): |
| listener.enterDeclaration(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDeclaration" ): |
| listener.exitDeclaration(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDeclaration" ): |
| return visitor.visitDeclaration(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def declaration(self): |
| |
| localctx = CParser.DeclarationContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 48, self.RULE_declaration) |
| self._la = 0 # Token type |
| try: |
| self.state = 514 |
| token = self._input.LA(1) |
| if token in [CParser.T__0, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9, CParser.T__11, CParser.Auto, CParser.Char, CParser.Const, CParser.Double, CParser.Enum, CParser.Extern, CParser.Float, CParser.Inline, CParser.Int, CParser.Long, CParser.Register, CParser.Restrict, CParser.Short, CParser.Signed, CParser.Static, CParser.Struct, CParser.Typedef, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.Alignas, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Noreturn, CParser.ThreadLocal, CParser.Identifier]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 507 |
| self.declarationSpecifiers() |
| self.state = 509 |
| _la = self._input.LA(1) |
| if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)) | (1 << (CParser.Identifier - 59)))) != 0): |
| self.state = 508 |
| self.initDeclaratorList(0) |
| |
| |
| self.state = 511 |
| self.match(CParser.Semi) |
| |
| elif token in [CParser.StaticAssert]: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 513 |
| self.staticAssertDeclaration() |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class DeclarationSpecifiersContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def declarationSpecifier(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.DeclarationSpecifierContext) |
| else: |
| return self.getTypedRuleContext(CParser.DeclarationSpecifierContext,i) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_declarationSpecifiers |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDeclarationSpecifiers" ): |
| listener.enterDeclarationSpecifiers(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDeclarationSpecifiers" ): |
| listener.exitDeclarationSpecifiers(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDeclarationSpecifiers" ): |
| return visitor.visitDeclarationSpecifiers(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def declarationSpecifiers(self): |
| |
| localctx = CParser.DeclarationSpecifiersContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 50, self.RULE_declarationSpecifiers) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 517 |
| self._errHandler.sync(self) |
| _alt = 1 |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt == 1: |
| self.state = 516 |
| self.declarationSpecifier() |
| |
| else: |
| raise NoViableAltException(self) |
| self.state = 519 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,32,self._ctx) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class DeclarationSpecifiers2Context(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def declarationSpecifier(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.DeclarationSpecifierContext) |
| else: |
| return self.getTypedRuleContext(CParser.DeclarationSpecifierContext,i) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_declarationSpecifiers2 |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDeclarationSpecifiers2" ): |
| listener.enterDeclarationSpecifiers2(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDeclarationSpecifiers2" ): |
| listener.exitDeclarationSpecifiers2(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDeclarationSpecifiers2" ): |
| return visitor.visitDeclarationSpecifiers2(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def declarationSpecifiers2(self): |
| |
| localctx = CParser.DeclarationSpecifiers2Context(self, self._ctx, self.state) |
| self.enterRule(localctx, 52, self.RULE_declarationSpecifiers2) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 522 |
| self._errHandler.sync(self) |
| _alt = 1 |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt == 1: |
| self.state = 521 |
| self.declarationSpecifier() |
| |
| else: |
| raise NoViableAltException(self) |
| self.state = 524 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,33,self._ctx) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class DeclarationSpecifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def storageClassSpecifier(self): |
| return self.getTypedRuleContext(CParser.StorageClassSpecifierContext,0) |
| |
| |
| def typeSpecifier(self): |
| return self.getTypedRuleContext(CParser.TypeSpecifierContext,0) |
| |
| |
| def typeQualifier(self): |
| return self.getTypedRuleContext(CParser.TypeQualifierContext,0) |
| |
| |
| def functionSpecifier(self): |
| return self.getTypedRuleContext(CParser.FunctionSpecifierContext,0) |
| |
| |
| def alignmentSpecifier(self): |
| return self.getTypedRuleContext(CParser.AlignmentSpecifierContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_declarationSpecifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDeclarationSpecifier" ): |
| listener.enterDeclarationSpecifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDeclarationSpecifier" ): |
| listener.exitDeclarationSpecifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDeclarationSpecifier" ): |
| return visitor.visitDeclarationSpecifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def declarationSpecifier(self): |
| |
| localctx = CParser.DeclarationSpecifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 54, self.RULE_declarationSpecifier) |
| try: |
| self.state = 531 |
| la_ = self._interp.adaptivePredict(self._input,34,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 526 |
| self.storageClassSpecifier() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 527 |
| self.typeSpecifier() |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 528 |
| self.typeQualifier() |
| pass |
| |
| elif la_ == 4: |
| self.enterOuterAlt(localctx, 4) |
| self.state = 529 |
| self.functionSpecifier() |
| pass |
| |
| elif la_ == 5: |
| self.enterOuterAlt(localctx, 5) |
| self.state = 530 |
| self.alignmentSpecifier() |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class InitDeclaratorListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def initDeclarator(self): |
| return self.getTypedRuleContext(CParser.InitDeclaratorContext,0) |
| |
| |
| def initDeclaratorList(self): |
| return self.getTypedRuleContext(CParser.InitDeclaratorListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_initDeclaratorList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterInitDeclaratorList" ): |
| listener.enterInitDeclaratorList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitInitDeclaratorList" ): |
| listener.exitInitDeclaratorList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitInitDeclaratorList" ): |
| return visitor.visitInitDeclaratorList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def initDeclaratorList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.InitDeclaratorListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 56 |
| self.enterRecursionRule(localctx, 56, self.RULE_initDeclaratorList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 534 |
| self.initDeclarator() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 541 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,35,self._ctx) |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt==1: |
| if self._parseListeners is not None: |
| self.triggerExitRuleEvent() |
| _prevctx = localctx |
| localctx = CParser.InitDeclaratorListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_initDeclaratorList) |
| self.state = 536 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 537 |
| self.match(CParser.Comma) |
| self.state = 538 |
| self.initDeclarator() |
| self.state = 543 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,35,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 |
| |
| class InitDeclaratorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def declarator(self): |
| return self.getTypedRuleContext(CParser.DeclaratorContext,0) |
| |
| |
| def initializer(self): |
| return self.getTypedRuleContext(CParser.InitializerContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_initDeclarator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterInitDeclarator" ): |
| listener.enterInitDeclarator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitInitDeclarator" ): |
| listener.exitInitDeclarator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitInitDeclarator" ): |
| return visitor.visitInitDeclarator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def initDeclarator(self): |
| |
| localctx = CParser.InitDeclaratorContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 58, self.RULE_initDeclarator) |
| try: |
| self.state = 549 |
| la_ = self._interp.adaptivePredict(self._input,36,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 544 |
| self.declarator() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 545 |
| self.declarator() |
| self.state = 546 |
| self.match(CParser.Assign) |
| self.state = 547 |
| self.initializer() |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class StorageClassSpecifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_storageClassSpecifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterStorageClassSpecifier" ): |
| listener.enterStorageClassSpecifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitStorageClassSpecifier" ): |
| listener.exitStorageClassSpecifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitStorageClassSpecifier" ): |
| return visitor.visitStorageClassSpecifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def storageClassSpecifier(self): |
| |
| localctx = CParser.StorageClassSpecifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 60, self.RULE_storageClassSpecifier) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 551 |
| _la = self._input.LA(1) |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Auto) | (1 << CParser.Extern) | (1 << CParser.Register) | (1 << CParser.Static) | (1 << CParser.Typedef) | (1 << CParser.ThreadLocal))) != 0)): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class TypeSpecifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def atomicTypeSpecifier(self): |
| return self.getTypedRuleContext(CParser.AtomicTypeSpecifierContext,0) |
| |
| |
| def structOrUnionSpecifier(self): |
| return self.getTypedRuleContext(CParser.StructOrUnionSpecifierContext,0) |
| |
| |
| def enumSpecifier(self): |
| return self.getTypedRuleContext(CParser.EnumSpecifierContext,0) |
| |
| |
| def typedefName(self): |
| return self.getTypedRuleContext(CParser.TypedefNameContext,0) |
| |
| |
| def constantExpression(self): |
| return self.getTypedRuleContext(CParser.ConstantExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_typeSpecifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterTypeSpecifier" ): |
| listener.enterTypeSpecifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitTypeSpecifier" ): |
| listener.exitTypeSpecifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitTypeSpecifier" ): |
| return visitor.visitTypeSpecifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def typeSpecifier(self): |
| |
| localctx = CParser.TypeSpecifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 62, self.RULE_typeSpecifier) |
| self._la = 0 # Token type |
| try: |
| self.state = 567 |
| token = self._input.LA(1) |
| if token in [CParser.T__3, CParser.T__4, CParser.T__5, CParser.Char, CParser.Double, CParser.Float, CParser.Int, CParser.Long, CParser.Short, CParser.Signed, CParser.Unsigned, CParser.Void, CParser.Bool, CParser.Complex]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 553 |
| _la = self._input.LA(1) |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.Char) | (1 << CParser.Double) | (1 << CParser.Float) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Bool) | (1 << CParser.Complex))) != 0)): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| |
| elif token in [CParser.T__0]: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 554 |
| self.match(CParser.T__0) |
| self.state = 555 |
| self.match(CParser.LeftParen) |
| self.state = 556 |
| _la = self._input.LA(1) |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5))) != 0)): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| self.state = 557 |
| self.match(CParser.RightParen) |
| |
| elif token in [CParser.Atomic]: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 558 |
| self.atomicTypeSpecifier() |
| |
| elif token in [CParser.Struct, CParser.Union]: |
| self.enterOuterAlt(localctx, 4) |
| self.state = 559 |
| self.structOrUnionSpecifier() |
| |
| elif token in [CParser.Enum]: |
| self.enterOuterAlt(localctx, 5) |
| self.state = 560 |
| self.enumSpecifier() |
| |
| elif token in [CParser.Identifier]: |
| self.enterOuterAlt(localctx, 6) |
| self.state = 561 |
| self.typedefName() |
| |
| elif token in [CParser.T__6]: |
| self.enterOuterAlt(localctx, 7) |
| self.state = 562 |
| self.match(CParser.T__6) |
| self.state = 563 |
| self.match(CParser.LeftParen) |
| self.state = 564 |
| self.constantExpression() |
| self.state = 565 |
| self.match(CParser.RightParen) |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class StructOrUnionSpecifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def structOrUnion(self): |
| return self.getTypedRuleContext(CParser.StructOrUnionContext,0) |
| |
| |
| def structDeclarationList(self): |
| return self.getTypedRuleContext(CParser.StructDeclarationListContext,0) |
| |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def getRuleIndex(self): |
| return CParser.RULE_structOrUnionSpecifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterStructOrUnionSpecifier" ): |
| listener.enterStructOrUnionSpecifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitStructOrUnionSpecifier" ): |
| listener.exitStructOrUnionSpecifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitStructOrUnionSpecifier" ): |
| return visitor.visitStructOrUnionSpecifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def structOrUnionSpecifier(self): |
| |
| localctx = CParser.StructOrUnionSpecifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 64, self.RULE_structOrUnionSpecifier) |
| self._la = 0 # Token type |
| try: |
| self.state = 580 |
| la_ = self._interp.adaptivePredict(self._input,39,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 569 |
| self.structOrUnion() |
| self.state = 571 |
| _la = self._input.LA(1) |
| if _la==CParser.Identifier: |
| self.state = 570 |
| self.match(CParser.Identifier) |
| |
| |
| self.state = 573 |
| self.match(CParser.LeftBrace) |
| self.state = 574 |
| self.structDeclarationList(0) |
| self.state = 575 |
| self.match(CParser.RightBrace) |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 577 |
| self.structOrUnion() |
| self.state = 578 |
| self.match(CParser.Identifier) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class StructOrUnionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_structOrUnion |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterStructOrUnion" ): |
| listener.enterStructOrUnion(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitStructOrUnion" ): |
| listener.exitStructOrUnion(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitStructOrUnion" ): |
| return visitor.visitStructOrUnion(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def structOrUnion(self): |
| |
| localctx = CParser.StructOrUnionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 66, self.RULE_structOrUnion) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 582 |
| _la = self._input.LA(1) |
| if not(_la==CParser.Struct or _la==CParser.Union): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class StructDeclarationListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def structDeclaration(self): |
| return self.getTypedRuleContext(CParser.StructDeclarationContext,0) |
| |
| |
| def structDeclarationList(self): |
| return self.getTypedRuleContext(CParser.StructDeclarationListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_structDeclarationList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterStructDeclarationList" ): |
| listener.enterStructDeclarationList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitStructDeclarationList" ): |
| listener.exitStructDeclarationList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitStructDeclarationList" ): |
| return visitor.visitStructDeclarationList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def structDeclarationList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.StructDeclarationListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 68 |
| self.enterRecursionRule(localctx, 68, self.RULE_structDeclarationList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 585 |
| self.structDeclaration() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 591 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,40,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 = CParser.StructDeclarationListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_structDeclarationList) |
| self.state = 587 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 588 |
| self.structDeclaration() |
| self.state = 593 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,40,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 |
| |
| class StructDeclarationContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def specifierQualifierList(self): |
| return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0) |
| |
| |
| def structDeclaratorList(self): |
| return self.getTypedRuleContext(CParser.StructDeclaratorListContext,0) |
| |
| |
| def staticAssertDeclaration(self): |
| return self.getTypedRuleContext(CParser.StaticAssertDeclarationContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_structDeclaration |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterStructDeclaration" ): |
| listener.enterStructDeclaration(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitStructDeclaration" ): |
| listener.exitStructDeclaration(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitStructDeclaration" ): |
| return visitor.visitStructDeclaration(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def structDeclaration(self): |
| |
| localctx = CParser.StructDeclarationContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 70, self.RULE_structDeclaration) |
| self._la = 0 # Token type |
| try: |
| self.state = 601 |
| token = self._input.LA(1) |
| if token in [CParser.T__0, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.Char, CParser.Const, CParser.Double, CParser.Enum, CParser.Float, CParser.Int, CParser.Long, CParser.Restrict, CParser.Short, CParser.Signed, CParser.Struct, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Identifier]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 594 |
| self.specifierQualifierList() |
| self.state = 596 |
| _la = self._input.LA(1) |
| if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)) | (1 << (CParser.Colon - 59)) | (1 << (CParser.Identifier - 59)))) != 0): |
| self.state = 595 |
| self.structDeclaratorList(0) |
| |
| |
| self.state = 598 |
| self.match(CParser.Semi) |
| |
| elif token in [CParser.StaticAssert]: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 600 |
| self.staticAssertDeclaration() |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class SpecifierQualifierListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def typeSpecifier(self): |
| return self.getTypedRuleContext(CParser.TypeSpecifierContext,0) |
| |
| |
| def specifierQualifierList(self): |
| return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0) |
| |
| |
| def typeQualifier(self): |
| return self.getTypedRuleContext(CParser.TypeQualifierContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_specifierQualifierList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterSpecifierQualifierList" ): |
| listener.enterSpecifierQualifierList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitSpecifierQualifierList" ): |
| listener.exitSpecifierQualifierList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitSpecifierQualifierList" ): |
| return visitor.visitSpecifierQualifierList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def specifierQualifierList(self): |
| |
| localctx = CParser.SpecifierQualifierListContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 72, self.RULE_specifierQualifierList) |
| try: |
| self.state = 611 |
| la_ = self._interp.adaptivePredict(self._input,45,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 603 |
| self.typeSpecifier() |
| self.state = 605 |
| la_ = self._interp.adaptivePredict(self._input,43,self._ctx) |
| if la_ == 1: |
| self.state = 604 |
| self.specifierQualifierList() |
| |
| |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 607 |
| self.typeQualifier() |
| self.state = 609 |
| la_ = self._interp.adaptivePredict(self._input,44,self._ctx) |
| if la_ == 1: |
| self.state = 608 |
| self.specifierQualifierList() |
| |
| |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class StructDeclaratorListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def structDeclarator(self): |
| return self.getTypedRuleContext(CParser.StructDeclaratorContext,0) |
| |
| |
| def structDeclaratorList(self): |
| return self.getTypedRuleContext(CParser.StructDeclaratorListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_structDeclaratorList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterStructDeclaratorList" ): |
| listener.enterStructDeclaratorList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitStructDeclaratorList" ): |
| listener.exitStructDeclaratorList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitStructDeclaratorList" ): |
| return visitor.visitStructDeclaratorList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def structDeclaratorList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.StructDeclaratorListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 74 |
| self.enterRecursionRule(localctx, 74, self.RULE_structDeclaratorList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 614 |
| self.structDeclarator() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 621 |
| 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 = CParser.StructDeclaratorListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_structDeclaratorList) |
| self.state = 616 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 617 |
| self.match(CParser.Comma) |
| self.state = 618 |
| self.structDeclarator() |
| self.state = 623 |
| 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 |
| |
| class StructDeclaratorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def declarator(self): |
| return self.getTypedRuleContext(CParser.DeclaratorContext,0) |
| |
| |
| def constantExpression(self): |
| return self.getTypedRuleContext(CParser.ConstantExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_structDeclarator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterStructDeclarator" ): |
| listener.enterStructDeclarator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitStructDeclarator" ): |
| listener.exitStructDeclarator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitStructDeclarator" ): |
| return visitor.visitStructDeclarator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def structDeclarator(self): |
| |
| localctx = CParser.StructDeclaratorContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 76, self.RULE_structDeclarator) |
| self._la = 0 # Token type |
| try: |
| self.state = 630 |
| la_ = self._interp.adaptivePredict(self._input,48,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 624 |
| self.declarator() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 626 |
| _la = self._input.LA(1) |
| if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)) | (1 << (CParser.Identifier - 59)))) != 0): |
| self.state = 625 |
| self.declarator() |
| |
| |
| self.state = 628 |
| self.match(CParser.Colon) |
| self.state = 629 |
| 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 |
| |
| class EnumSpecifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def enumeratorList(self): |
| return self.getTypedRuleContext(CParser.EnumeratorListContext,0) |
| |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def getRuleIndex(self): |
| return CParser.RULE_enumSpecifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterEnumSpecifier" ): |
| listener.enterEnumSpecifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitEnumSpecifier" ): |
| listener.exitEnumSpecifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitEnumSpecifier" ): |
| return visitor.visitEnumSpecifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def enumSpecifier(self): |
| |
| localctx = CParser.EnumSpecifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 78, self.RULE_enumSpecifier) |
| self._la = 0 # Token type |
| try: |
| self.state = 651 |
| la_ = self._interp.adaptivePredict(self._input,51,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 632 |
| self.match(CParser.Enum) |
| self.state = 634 |
| _la = self._input.LA(1) |
| if _la==CParser.Identifier: |
| self.state = 633 |
| self.match(CParser.Identifier) |
| |
| |
| self.state = 636 |
| self.match(CParser.LeftBrace) |
| self.state = 637 |
| self.enumeratorList(0) |
| self.state = 638 |
| self.match(CParser.RightBrace) |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 640 |
| self.match(CParser.Enum) |
| self.state = 642 |
| _la = self._input.LA(1) |
| if _la==CParser.Identifier: |
| self.state = 641 |
| self.match(CParser.Identifier) |
| |
| |
| self.state = 644 |
| self.match(CParser.LeftBrace) |
| self.state = 645 |
| self.enumeratorList(0) |
| self.state = 646 |
| self.match(CParser.Comma) |
| self.state = 647 |
| self.match(CParser.RightBrace) |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 649 |
| self.match(CParser.Enum) |
| self.state = 650 |
| self.match(CParser.Identifier) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class EnumeratorListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def enumerator(self): |
| return self.getTypedRuleContext(CParser.EnumeratorContext,0) |
| |
| |
| def enumeratorList(self): |
| return self.getTypedRuleContext(CParser.EnumeratorListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_enumeratorList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterEnumeratorList" ): |
| listener.enterEnumeratorList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitEnumeratorList" ): |
| listener.exitEnumeratorList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitEnumeratorList" ): |
| return visitor.visitEnumeratorList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def enumeratorList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.EnumeratorListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 80 |
| self.enterRecursionRule(localctx, 80, self.RULE_enumeratorList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 654 |
| self.enumerator() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 661 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,52,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 = CParser.EnumeratorListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_enumeratorList) |
| self.state = 656 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 657 |
| self.match(CParser.Comma) |
| self.state = 658 |
| self.enumerator() |
| self.state = 663 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,52,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 |
| |
| class EnumeratorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def enumerationConstant(self): |
| return self.getTypedRuleContext(CParser.EnumerationConstantContext,0) |
| |
| |
| def constantExpression(self): |
| return self.getTypedRuleContext(CParser.ConstantExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_enumerator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterEnumerator" ): |
| listener.enterEnumerator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitEnumerator" ): |
| listener.exitEnumerator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitEnumerator" ): |
| return visitor.visitEnumerator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def enumerator(self): |
| |
| localctx = CParser.EnumeratorContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 82, self.RULE_enumerator) |
| try: |
| self.state = 669 |
| la_ = self._interp.adaptivePredict(self._input,53,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 664 |
| self.enumerationConstant() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 665 |
| self.enumerationConstant() |
| self.state = 666 |
| self.match(CParser.Assign) |
| self.state = 667 |
| 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 |
| |
| class EnumerationConstantContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def getRuleIndex(self): |
| return CParser.RULE_enumerationConstant |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterEnumerationConstant" ): |
| listener.enterEnumerationConstant(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitEnumerationConstant" ): |
| listener.exitEnumerationConstant(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitEnumerationConstant" ): |
| return visitor.visitEnumerationConstant(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def enumerationConstant(self): |
| |
| localctx = CParser.EnumerationConstantContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 84, self.RULE_enumerationConstant) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 671 |
| self.match(CParser.Identifier) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class AtomicTypeSpecifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def typeName(self): |
| return self.getTypedRuleContext(CParser.TypeNameContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_atomicTypeSpecifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterAtomicTypeSpecifier" ): |
| listener.enterAtomicTypeSpecifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitAtomicTypeSpecifier" ): |
| listener.exitAtomicTypeSpecifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitAtomicTypeSpecifier" ): |
| return visitor.visitAtomicTypeSpecifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def atomicTypeSpecifier(self): |
| |
| localctx = CParser.AtomicTypeSpecifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 86, self.RULE_atomicTypeSpecifier) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 673 |
| self.match(CParser.Atomic) |
| self.state = 674 |
| self.match(CParser.LeftParen) |
| self.state = 675 |
| self.typeName() |
| self.state = 676 |
| self.match(CParser.RightParen) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class TypeQualifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_typeQualifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterTypeQualifier" ): |
| listener.enterTypeQualifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitTypeQualifier" ): |
| listener.exitTypeQualifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitTypeQualifier" ): |
| return visitor.visitTypeQualifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def typeQualifier(self): |
| |
| localctx = CParser.TypeQualifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 88, self.RULE_typeQualifier) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 678 |
| _la = self._input.LA(1) |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0)): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class FunctionSpecifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def gccAttributeSpecifier(self): |
| return self.getTypedRuleContext(CParser.GccAttributeSpecifierContext,0) |
| |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def getRuleIndex(self): |
| return CParser.RULE_functionSpecifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterFunctionSpecifier" ): |
| listener.enterFunctionSpecifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitFunctionSpecifier" ): |
| listener.exitFunctionSpecifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitFunctionSpecifier" ): |
| return visitor.visitFunctionSpecifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def functionSpecifier(self): |
| |
| localctx = CParser.FunctionSpecifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 90, self.RULE_functionSpecifier) |
| self._la = 0 # Token type |
| try: |
| self.state = 686 |
| token = self._input.LA(1) |
| if token in [CParser.T__7, CParser.T__8, CParser.Inline, CParser.Noreturn]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 680 |
| _la = self._input.LA(1) |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.Inline) | (1 << CParser.Noreturn))) != 0)): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| |
| elif token in [CParser.T__11]: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 681 |
| self.gccAttributeSpecifier() |
| |
| elif token in [CParser.T__9]: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 682 |
| self.match(CParser.T__9) |
| self.state = 683 |
| self.match(CParser.LeftParen) |
| self.state = 684 |
| self.match(CParser.Identifier) |
| self.state = 685 |
| self.match(CParser.RightParen) |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class AlignmentSpecifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def typeName(self): |
| return self.getTypedRuleContext(CParser.TypeNameContext,0) |
| |
| |
| def constantExpression(self): |
| return self.getTypedRuleContext(CParser.ConstantExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_alignmentSpecifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterAlignmentSpecifier" ): |
| listener.enterAlignmentSpecifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitAlignmentSpecifier" ): |
| listener.exitAlignmentSpecifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitAlignmentSpecifier" ): |
| return visitor.visitAlignmentSpecifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def alignmentSpecifier(self): |
| |
| localctx = CParser.AlignmentSpecifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 92, self.RULE_alignmentSpecifier) |
| try: |
| self.state = 698 |
| la_ = self._interp.adaptivePredict(self._input,55,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 688 |
| self.match(CParser.Alignas) |
| self.state = 689 |
| self.match(CParser.LeftParen) |
| self.state = 690 |
| self.typeName() |
| self.state = 691 |
| self.match(CParser.RightParen) |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 693 |
| self.match(CParser.Alignas) |
| self.state = 694 |
| self.match(CParser.LeftParen) |
| self.state = 695 |
| self.constantExpression() |
| self.state = 696 |
| self.match(CParser.RightParen) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class DeclaratorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def directDeclarator(self): |
| return self.getTypedRuleContext(CParser.DirectDeclaratorContext,0) |
| |
| |
| def pointer(self): |
| return self.getTypedRuleContext(CParser.PointerContext,0) |
| |
| |
| def gccDeclaratorExtension(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext) |
| else: |
| return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_declarator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDeclarator" ): |
| listener.enterDeclarator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDeclarator" ): |
| listener.exitDeclarator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDeclarator" ): |
| return visitor.visitDeclarator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def declarator(self): |
| |
| localctx = CParser.DeclaratorContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 94, self.RULE_declarator) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 701 |
| _la = self._input.LA(1) |
| if _la==CParser.Star or _la==CParser.Caret: |
| self.state = 700 |
| self.pointer() |
| |
| |
| self.state = 703 |
| self.directDeclarator(0) |
| self.state = 707 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,57,self._ctx) |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt==1: |
| self.state = 704 |
| self.gccDeclaratorExtension() |
| self.state = 709 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,57,self._ctx) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class DirectDeclaratorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def declarator(self): |
| return self.getTypedRuleContext(CParser.DeclaratorContext,0) |
| |
| |
| def directDeclarator(self): |
| return self.getTypedRuleContext(CParser.DirectDeclaratorContext,0) |
| |
| |
| def typeQualifierList(self): |
| return self.getTypedRuleContext(CParser.TypeQualifierListContext,0) |
| |
| |
| def assignmentExpression(self): |
| return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0) |
| |
| |
| def parameterTypeList(self): |
| return self.getTypedRuleContext(CParser.ParameterTypeListContext,0) |
| |
| |
| def identifierList(self): |
| return self.getTypedRuleContext(CParser.IdentifierListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_directDeclarator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDirectDeclarator" ): |
| listener.enterDirectDeclarator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDirectDeclarator" ): |
| listener.exitDirectDeclarator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDirectDeclarator" ): |
| return visitor.visitDirectDeclarator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def directDeclarator(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.DirectDeclaratorContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 96 |
| self.enterRecursionRule(localctx, 96, self.RULE_directDeclarator, _p) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 716 |
| token = self._input.LA(1) |
| if token in [CParser.Identifier]: |
| self.state = 711 |
| self.match(CParser.Identifier) |
| |
| elif token in [CParser.LeftParen]: |
| self.state = 712 |
| self.match(CParser.LeftParen) |
| self.state = 713 |
| self.declarator() |
| self.state = 714 |
| self.match(CParser.RightParen) |
| |
| else: |
| raise NoViableAltException(self) |
| |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 763 |
| 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 |
| self.state = 761 |
| la_ = self._interp.adaptivePredict(self._input,64,self._ctx) |
| if la_ == 1: |
| localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator) |
| self.state = 718 |
| if not self.precpred(self._ctx, 6): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") |
| self.state = 719 |
| self.match(CParser.LeftBracket) |
| self.state = 721 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0): |
| self.state = 720 |
| self.typeQualifierList(0) |
| |
| |
| self.state = 724 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 723 |
| self.assignmentExpression() |
| |
| |
| self.state = 726 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 2: |
| localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator) |
| self.state = 727 |
| if not self.precpred(self._ctx, 5): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") |
| self.state = 728 |
| self.match(CParser.LeftBracket) |
| self.state = 729 |
| self.match(CParser.Static) |
| self.state = 731 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0): |
| self.state = 730 |
| self.typeQualifierList(0) |
| |
| |
| self.state = 733 |
| self.assignmentExpression() |
| self.state = 734 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 3: |
| localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator) |
| self.state = 736 |
| if not self.precpred(self._ctx, 4): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") |
| self.state = 737 |
| self.match(CParser.LeftBracket) |
| self.state = 738 |
| self.typeQualifierList(0) |
| self.state = 739 |
| self.match(CParser.Static) |
| self.state = 740 |
| self.assignmentExpression() |
| self.state = 741 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 4: |
| localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator) |
| self.state = 743 |
| if not self.precpred(self._ctx, 3): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") |
| self.state = 744 |
| self.match(CParser.LeftBracket) |
| self.state = 746 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0): |
| self.state = 745 |
| self.typeQualifierList(0) |
| |
| |
| self.state = 748 |
| self.match(CParser.Star) |
| self.state = 749 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 5: |
| localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator) |
| self.state = 750 |
| if not self.precpred(self._ctx, 2): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") |
| self.state = 751 |
| self.match(CParser.LeftParen) |
| self.state = 752 |
| self.parameterTypeList() |
| self.state = 753 |
| self.match(CParser.RightParen) |
| pass |
| |
| elif la_ == 6: |
| localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator) |
| self.state = 755 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 756 |
| self.match(CParser.LeftParen) |
| self.state = 758 |
| _la = self._input.LA(1) |
| if _la==CParser.Identifier: |
| self.state = 757 |
| self.identifierList(0) |
| |
| |
| self.state = 760 |
| self.match(CParser.RightParen) |
| pass |
| |
| |
| self.state = 765 |
| 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 |
| |
| class GccDeclaratorExtensionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def StringLiteral(self, i:int=None): |
| if i is None: |
| return self.getTokens(CParser.StringLiteral) |
| else: |
| return self.getToken(CParser.StringLiteral, i) |
| |
| def gccAttributeSpecifier(self): |
| return self.getTypedRuleContext(CParser.GccAttributeSpecifierContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_gccDeclaratorExtension |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterGccDeclaratorExtension" ): |
| listener.enterGccDeclaratorExtension(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitGccDeclaratorExtension" ): |
| listener.exitGccDeclaratorExtension(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitGccDeclaratorExtension" ): |
| return visitor.visitGccDeclaratorExtension(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def gccDeclaratorExtension(self): |
| |
| localctx = CParser.GccDeclaratorExtensionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 98, self.RULE_gccDeclaratorExtension) |
| self._la = 0 # Token type |
| try: |
| self.state = 775 |
| token = self._input.LA(1) |
| if token in [CParser.T__10]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 766 |
| self.match(CParser.T__10) |
| self.state = 767 |
| self.match(CParser.LeftParen) |
| self.state = 769 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while True: |
| self.state = 768 |
| self.match(CParser.StringLiteral) |
| self.state = 771 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| if not (_la==CParser.StringLiteral): |
| break |
| |
| self.state = 773 |
| self.match(CParser.RightParen) |
| |
| elif token in [CParser.T__11]: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 774 |
| self.gccAttributeSpecifier() |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class GccAttributeSpecifierContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def gccAttributeList(self): |
| return self.getTypedRuleContext(CParser.GccAttributeListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_gccAttributeSpecifier |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterGccAttributeSpecifier" ): |
| listener.enterGccAttributeSpecifier(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitGccAttributeSpecifier" ): |
| listener.exitGccAttributeSpecifier(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitGccAttributeSpecifier" ): |
| return visitor.visitGccAttributeSpecifier(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def gccAttributeSpecifier(self): |
| |
| localctx = CParser.GccAttributeSpecifierContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 100, self.RULE_gccAttributeSpecifier) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 777 |
| self.match(CParser.T__11) |
| self.state = 778 |
| self.match(CParser.LeftParen) |
| self.state = 779 |
| self.match(CParser.LeftParen) |
| self.state = 780 |
| self.gccAttributeList() |
| self.state = 781 |
| self.match(CParser.RightParen) |
| self.state = 782 |
| self.match(CParser.RightParen) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class GccAttributeListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def gccAttribute(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.GccAttributeContext) |
| else: |
| return self.getTypedRuleContext(CParser.GccAttributeContext,i) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_gccAttributeList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterGccAttributeList" ): |
| listener.enterGccAttributeList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitGccAttributeList" ): |
| listener.exitGccAttributeList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitGccAttributeList" ): |
| return visitor.visitGccAttributeList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def gccAttributeList(self): |
| |
| localctx = CParser.GccAttributeListContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 102, self.RULE_gccAttributeList) |
| self._la = 0 # Token type |
| try: |
| self.state = 793 |
| la_ = self._interp.adaptivePredict(self._input,69,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 784 |
| self.gccAttribute() |
| self.state = 789 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while _la==CParser.Comma: |
| self.state = 785 |
| self.match(CParser.Comma) |
| self.state = 786 |
| self.gccAttribute() |
| self.state = 791 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class GccAttributeContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def argumentExpressionList(self): |
| return self.getTypedRuleContext(CParser.ArgumentExpressionListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_gccAttribute |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterGccAttribute" ): |
| listener.enterGccAttribute(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitGccAttribute" ): |
| listener.exitGccAttribute(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitGccAttribute" ): |
| return visitor.visitGccAttribute(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def gccAttribute(self): |
| |
| localctx = CParser.GccAttributeContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 104, self.RULE_gccAttribute) |
| self._la = 0 # Token type |
| try: |
| self.state = 804 |
| token = self._input.LA(1) |
| if token in [CParser.T__0, CParser.T__1, CParser.T__2, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9, CParser.T__10, CParser.T__11, CParser.T__12, CParser.T__13, CParser.Auto, CParser.Break, CParser.Case, CParser.Char, CParser.Const, CParser.Continue, CParser.Default, CParser.Do, CParser.Double, CParser.Else, CParser.Enum, CParser.Extern, CParser.Float, CParser.For, CParser.Goto, CParser.If, CParser.Inline, CParser.Int, CParser.Long, CParser.Register, CParser.Restrict, CParser.Return, CParser.Short, CParser.Signed, CParser.Sizeof, CParser.Static, CParser.Struct, CParser.Switch, CParser.Typedef, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.While, CParser.Alignas, CParser.Alignof, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Generic, CParser.Imaginary, CParser.Noreturn, CParser.StaticAssert, CParser.ThreadLocal, CParser.LeftBracket, CParser.RightBracket, CParser.LeftBrace, CParser.RightBrace, CParser.Less, CParser.LessEqual, CParser.Greater, CParser.GreaterEqual, CParser.LeftShift, CParser.RightShift, CParser.Plus, CParser.PlusPlus, CParser.Minus, CParser.MinusMinus, CParser.Star, CParser.Div, CParser.Mod, CParser.And, CParser.Or, CParser.AndAnd, CParser.OrOr, CParser.Caret, CParser.Not, CParser.Tilde, CParser.Question, CParser.Colon, CParser.Semi, CParser.Assign, CParser.StarAssign, CParser.DivAssign, CParser.ModAssign, CParser.PlusAssign, CParser.MinusAssign, CParser.LeftShiftAssign, CParser.RightShiftAssign, CParser.AndAssign, CParser.XorAssign, CParser.OrAssign, CParser.Equal, CParser.NotEqual, CParser.Arrow, CParser.Dot, CParser.Ellipsis, CParser.Identifier, CParser.Constant, CParser.StringLiteral, CParser.LineDirective, CParser.PragmaDirective, CParser.Whitespace, CParser.Newline, CParser.BlockComment, CParser.LineComment]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 795 |
| _la = self._input.LA(1) |
| if _la <= 0 or ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.RightParen - 59)) | (1 << (CParser.Comma - 59)))) != 0): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| self.state = 801 |
| _la = self._input.LA(1) |
| if _la==CParser.LeftParen: |
| self.state = 796 |
| self.match(CParser.LeftParen) |
| self.state = 798 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 797 |
| self.argumentExpressionList(0) |
| |
| |
| self.state = 800 |
| self.match(CParser.RightParen) |
| |
| |
| |
| elif token in [CParser.RightParen, CParser.Comma]: |
| self.enterOuterAlt(localctx, 2) |
| |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class NestedParenthesesBlockContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def nestedParenthesesBlock(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.NestedParenthesesBlockContext) |
| else: |
| return self.getTypedRuleContext(CParser.NestedParenthesesBlockContext,i) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_nestedParenthesesBlock |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterNestedParenthesesBlock" ): |
| listener.enterNestedParenthesesBlock(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitNestedParenthesesBlock" ): |
| listener.exitNestedParenthesesBlock(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitNestedParenthesesBlock" ): |
| return visitor.visitNestedParenthesesBlock(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def nestedParenthesesBlock(self): |
| |
| localctx = CParser.NestedParenthesesBlockContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 106, self.RULE_nestedParenthesesBlock) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 813 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.Auto) | (1 << CParser.Break) | (1 << CParser.Case) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Continue) | (1 << CParser.Default) | (1 << CParser.Do) | (1 << CParser.Double) | (1 << CParser.Else) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.For) | (1 << CParser.Goto) | (1 << CParser.If) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Return) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Sizeof) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Switch) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.While) | (1 << CParser.Alignas) | (1 << CParser.Alignof) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Generic) | (1 << CParser.Imaginary) | (1 << CParser.Noreturn) | (1 << CParser.StaticAssert) | (1 << CParser.ThreadLocal) | (1 << CParser.LeftParen) | (1 << CParser.LeftBracket) | (1 << CParser.RightBracket) | (1 << CParser.LeftBrace))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.RightBrace - 64)) | (1 << (CParser.Less - 64)) | (1 << (CParser.LessEqual - 64)) | (1 << (CParser.Greater - 64)) | (1 << (CParser.GreaterEqual - 64)) | (1 << (CParser.LeftShift - 64)) | (1 << (CParser.RightShift - 64)) | (1 << (CParser.Plus - 64)) | (1 << (CParser.PlusPlus - 64)) | (1 << (CParser.Minus - 64)) | (1 << (CParser.MinusMinus - 64)) | (1 << (CParser.Star - 64)) | (1 << (CParser.Div - 64)) | (1 << (CParser.Mod - 64)) | (1 << (CParser.And - 64)) | (1 << (CParser.Or - 64)) | (1 << (CParser.AndAnd - 64)) | (1 << (CParser.OrOr - 64)) | (1 << (CParser.Caret - 64)) | (1 << (CParser.Not - 64)) | (1 << (CParser.Tilde - 64)) | (1 << (CParser.Question - 64)) | (1 << (CParser.Colon - 64)) | (1 << (CParser.Semi - 64)) | (1 << (CParser.Comma - 64)) | (1 << (CParser.Assign - 64)) | (1 << (CParser.StarAssign - 64)) | (1 << (CParser.DivAssign - 64)) | (1 << (CParser.ModAssign - 64)) | (1 << (CParser.PlusAssign - 64)) | (1 << (CParser.MinusAssign - 64)) | (1 << (CParser.LeftShiftAssign - 64)) | (1 << (CParser.RightShiftAssign - 64)) | (1 << (CParser.AndAssign - 64)) | (1 << (CParser.XorAssign - 64)) | (1 << (CParser.OrAssign - 64)) | (1 << (CParser.Equal - 64)) | (1 << (CParser.NotEqual - 64)) | (1 << (CParser.Arrow - 64)) | (1 << (CParser.Dot - 64)) | (1 << (CParser.Ellipsis - 64)) | (1 << (CParser.Identifier - 64)) | (1 << (CParser.Constant - 64)) | (1 << (CParser.StringLiteral - 64)) | (1 << (CParser.LineDirective - 64)) | (1 << (CParser.PragmaDirective - 64)) | (1 << (CParser.Whitespace - 64)) | (1 << (CParser.Newline - 64)) | (1 << (CParser.BlockComment - 64)) | (1 << (CParser.LineComment - 64)))) != 0): |
| self.state = 811 |
| token = self._input.LA(1) |
| if token in [CParser.T__0, CParser.T__1, CParser.T__2, CParser.T__3, CParser.T__4, CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9, CParser.T__10, CParser.T__11, CParser.T__12, CParser.T__13, CParser.Auto, CParser.Break, CParser.Case, CParser.Char, CParser.Const, CParser.Continue, CParser.Default, CParser.Do, CParser.Double, CParser.Else, CParser.Enum, CParser.Extern, CParser.Float, CParser.For, CParser.Goto, CParser.If, CParser.Inline, CParser.Int, CParser.Long, CParser.Register, CParser.Restrict, CParser.Return, CParser.Short, CParser.Signed, CParser.Sizeof, CParser.Static, CParser.Struct, CParser.Switch, CParser.Typedef, CParser.Union, CParser.Unsigned, CParser.Void, CParser.Volatile, CParser.While, CParser.Alignas, CParser.Alignof, CParser.Atomic, CParser.Bool, CParser.Complex, CParser.Generic, CParser.Imaginary, CParser.Noreturn, CParser.StaticAssert, CParser.ThreadLocal, CParser.LeftBracket, CParser.RightBracket, CParser.LeftBrace, CParser.RightBrace, CParser.Less, CParser.LessEqual, CParser.Greater, CParser.GreaterEqual, CParser.LeftShift, CParser.RightShift, CParser.Plus, CParser.PlusPlus, CParser.Minus, CParser.MinusMinus, CParser.Star, CParser.Div, CParser.Mod, CParser.And, CParser.Or, CParser.AndAnd, CParser.OrOr, CParser.Caret, CParser.Not, CParser.Tilde, CParser.Question, CParser.Colon, CParser.Semi, CParser.Comma, CParser.Assign, CParser.StarAssign, CParser.DivAssign, CParser.ModAssign, CParser.PlusAssign, CParser.MinusAssign, CParser.LeftShiftAssign, CParser.RightShiftAssign, CParser.AndAssign, CParser.XorAssign, CParser.OrAssign, CParser.Equal, CParser.NotEqual, CParser.Arrow, CParser.Dot, CParser.Ellipsis, CParser.Identifier, CParser.Constant, CParser.StringLiteral, CParser.LineDirective, CParser.PragmaDirective, CParser.Whitespace, CParser.Newline, CParser.BlockComment, CParser.LineComment]: |
| self.state = 806 |
| _la = self._input.LA(1) |
| if _la <= 0 or _la==CParser.LeftParen or _la==CParser.RightParen: |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| |
| elif token in [CParser.LeftParen]: |
| self.state = 807 |
| self.match(CParser.LeftParen) |
| self.state = 808 |
| self.nestedParenthesesBlock() |
| self.state = 809 |
| self.match(CParser.RightParen) |
| |
| else: |
| raise NoViableAltException(self) |
| |
| self.state = 815 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class PointerContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def typeQualifierList(self): |
| return self.getTypedRuleContext(CParser.TypeQualifierListContext,0) |
| |
| |
| def pointer(self): |
| return self.getTypedRuleContext(CParser.PointerContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_pointer |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterPointer" ): |
| listener.enterPointer(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitPointer" ): |
| listener.exitPointer(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitPointer" ): |
| return visitor.visitPointer(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def pointer(self): |
| |
| localctx = CParser.PointerContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 108, self.RULE_pointer) |
| self._la = 0 # Token type |
| try: |
| self.state = 834 |
| la_ = self._interp.adaptivePredict(self._input,79,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 816 |
| self.match(CParser.Star) |
| self.state = 818 |
| la_ = self._interp.adaptivePredict(self._input,75,self._ctx) |
| if la_ == 1: |
| self.state = 817 |
| self.typeQualifierList(0) |
| |
| |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 820 |
| self.match(CParser.Star) |
| self.state = 822 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0): |
| self.state = 821 |
| self.typeQualifierList(0) |
| |
| |
| self.state = 824 |
| self.pointer() |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 825 |
| self.match(CParser.Caret) |
| self.state = 827 |
| la_ = self._interp.adaptivePredict(self._input,77,self._ctx) |
| if la_ == 1: |
| self.state = 826 |
| self.typeQualifierList(0) |
| |
| |
| pass |
| |
| elif la_ == 4: |
| self.enterOuterAlt(localctx, 4) |
| self.state = 829 |
| self.match(CParser.Caret) |
| self.state = 831 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0): |
| self.state = 830 |
| self.typeQualifierList(0) |
| |
| |
| self.state = 833 |
| self.pointer() |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class TypeQualifierListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def typeQualifier(self): |
| return self.getTypedRuleContext(CParser.TypeQualifierContext,0) |
| |
| |
| def typeQualifierList(self): |
| return self.getTypedRuleContext(CParser.TypeQualifierListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_typeQualifierList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterTypeQualifierList" ): |
| listener.enterTypeQualifierList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitTypeQualifierList" ): |
| listener.exitTypeQualifierList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitTypeQualifierList" ): |
| return visitor.visitTypeQualifierList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def typeQualifierList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.TypeQualifierListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 110 |
| self.enterRecursionRule(localctx, 110, self.RULE_typeQualifierList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 837 |
| self.typeQualifier() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 843 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,80,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 = CParser.TypeQualifierListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_typeQualifierList) |
| self.state = 839 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 840 |
| self.typeQualifier() |
| self.state = 845 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,80,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 |
| |
| class ParameterTypeListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def parameterList(self): |
| return self.getTypedRuleContext(CParser.ParameterListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_parameterTypeList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterParameterTypeList" ): |
| listener.enterParameterTypeList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitParameterTypeList" ): |
| listener.exitParameterTypeList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitParameterTypeList" ): |
| return visitor.visitParameterTypeList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def parameterTypeList(self): |
| |
| localctx = CParser.ParameterTypeListContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 112, self.RULE_parameterTypeList) |
| try: |
| self.state = 851 |
| la_ = self._interp.adaptivePredict(self._input,81,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 846 |
| self.parameterList(0) |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 847 |
| self.parameterList(0) |
| self.state = 848 |
| self.match(CParser.Comma) |
| self.state = 849 |
| self.match(CParser.Ellipsis) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class ParameterListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def parameterDeclaration(self): |
| return self.getTypedRuleContext(CParser.ParameterDeclarationContext,0) |
| |
| |
| def parameterList(self): |
| return self.getTypedRuleContext(CParser.ParameterListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_parameterList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterParameterList" ): |
| listener.enterParameterList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitParameterList" ): |
| listener.exitParameterList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitParameterList" ): |
| return visitor.visitParameterList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def parameterList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.ParameterListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 114 |
| self.enterRecursionRule(localctx, 114, self.RULE_parameterList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 854 |
| self.parameterDeclaration() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 861 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,82,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 = CParser.ParameterListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_parameterList) |
| self.state = 856 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 857 |
| self.match(CParser.Comma) |
| self.state = 858 |
| self.parameterDeclaration() |
| self.state = 863 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,82,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 |
| |
| class ParameterDeclarationContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def declarationSpecifiers(self): |
| return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0) |
| |
| |
| def declarator(self): |
| return self.getTypedRuleContext(CParser.DeclaratorContext,0) |
| |
| |
| def declarationSpecifiers2(self): |
| return self.getTypedRuleContext(CParser.DeclarationSpecifiers2Context,0) |
| |
| |
| def abstractDeclarator(self): |
| return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_parameterDeclaration |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterParameterDeclaration" ): |
| listener.enterParameterDeclaration(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitParameterDeclaration" ): |
| listener.exitParameterDeclaration(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitParameterDeclaration" ): |
| return visitor.visitParameterDeclaration(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def parameterDeclaration(self): |
| |
| localctx = CParser.ParameterDeclarationContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 116, self.RULE_parameterDeclaration) |
| try: |
| self.state = 871 |
| la_ = self._interp.adaptivePredict(self._input,84,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 864 |
| self.declarationSpecifiers() |
| self.state = 865 |
| self.declarator() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 867 |
| self.declarationSpecifiers2() |
| self.state = 869 |
| la_ = self._interp.adaptivePredict(self._input,83,self._ctx) |
| if la_ == 1: |
| self.state = 868 |
| self.abstractDeclarator() |
| |
| |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class IdentifierListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def identifierList(self): |
| return self.getTypedRuleContext(CParser.IdentifierListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_identifierList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterIdentifierList" ): |
| listener.enterIdentifierList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitIdentifierList" ): |
| listener.exitIdentifierList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitIdentifierList" ): |
| return visitor.visitIdentifierList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def identifierList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.IdentifierListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 118 |
| self.enterRecursionRule(localctx, 118, self.RULE_identifierList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 874 |
| self.match(CParser.Identifier) |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 881 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,85,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 = CParser.IdentifierListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_identifierList) |
| self.state = 876 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 877 |
| self.match(CParser.Comma) |
| self.state = 878 |
| self.match(CParser.Identifier) |
| self.state = 883 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,85,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 |
| |
| class TypeNameContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def specifierQualifierList(self): |
| return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0) |
| |
| |
| def abstractDeclarator(self): |
| return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_typeName |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterTypeName" ): |
| listener.enterTypeName(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitTypeName" ): |
| listener.exitTypeName(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitTypeName" ): |
| return visitor.visitTypeName(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def typeName(self): |
| |
| localctx = CParser.TypeNameContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 120, self.RULE_typeName) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 884 |
| self.specifierQualifierList() |
| self.state = 886 |
| _la = self._input.LA(1) |
| if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.LeftBracket - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)))) != 0): |
| self.state = 885 |
| self.abstractDeclarator() |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class AbstractDeclaratorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def pointer(self): |
| return self.getTypedRuleContext(CParser.PointerContext,0) |
| |
| |
| def directAbstractDeclarator(self): |
| return self.getTypedRuleContext(CParser.DirectAbstractDeclaratorContext,0) |
| |
| |
| def gccDeclaratorExtension(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext) |
| else: |
| return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_abstractDeclarator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterAbstractDeclarator" ): |
| listener.enterAbstractDeclarator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitAbstractDeclarator" ): |
| listener.exitAbstractDeclarator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitAbstractDeclarator" ): |
| return visitor.visitAbstractDeclarator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def abstractDeclarator(self): |
| |
| localctx = CParser.AbstractDeclaratorContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 122, self.RULE_abstractDeclarator) |
| self._la = 0 # Token type |
| try: |
| self.state = 899 |
| la_ = self._interp.adaptivePredict(self._input,89,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 888 |
| self.pointer() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 890 |
| _la = self._input.LA(1) |
| if _la==CParser.Star or _la==CParser.Caret: |
| self.state = 889 |
| self.pointer() |
| |
| |
| self.state = 892 |
| self.directAbstractDeclarator(0) |
| self.state = 896 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,88,self._ctx) |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt==1: |
| self.state = 893 |
| self.gccDeclaratorExtension() |
| self.state = 898 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,88,self._ctx) |
| |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class DirectAbstractDeclaratorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def abstractDeclarator(self): |
| return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0) |
| |
| |
| def gccDeclaratorExtension(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext) |
| else: |
| return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i) |
| |
| |
| def typeQualifierList(self): |
| return self.getTypedRuleContext(CParser.TypeQualifierListContext,0) |
| |
| |
| def assignmentExpression(self): |
| return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0) |
| |
| |
| def parameterTypeList(self): |
| return self.getTypedRuleContext(CParser.ParameterTypeListContext,0) |
| |
| |
| def directAbstractDeclarator(self): |
| return self.getTypedRuleContext(CParser.DirectAbstractDeclaratorContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_directAbstractDeclarator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDirectAbstractDeclarator" ): |
| listener.enterDirectAbstractDeclarator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDirectAbstractDeclarator" ): |
| listener.exitDirectAbstractDeclarator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDirectAbstractDeclarator" ): |
| return visitor.visitDirectAbstractDeclarator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def directAbstractDeclarator(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.DirectAbstractDeclaratorContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 124 |
| self.enterRecursionRule(localctx, 124, self.RULE_directAbstractDeclarator, _p) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 947 |
| la_ = self._interp.adaptivePredict(self._input,96,self._ctx) |
| if la_ == 1: |
| self.state = 902 |
| self.match(CParser.LeftParen) |
| self.state = 903 |
| self.abstractDeclarator() |
| self.state = 904 |
| self.match(CParser.RightParen) |
| self.state = 908 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,90,self._ctx) |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt==1: |
| self.state = 905 |
| self.gccDeclaratorExtension() |
| self.state = 910 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,90,self._ctx) |
| |
| pass |
| |
| elif la_ == 2: |
| self.state = 911 |
| self.match(CParser.LeftBracket) |
| self.state = 913 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0): |
| self.state = 912 |
| self.typeQualifierList(0) |
| |
| |
| self.state = 916 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 915 |
| self.assignmentExpression() |
| |
| |
| self.state = 918 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 3: |
| self.state = 919 |
| self.match(CParser.LeftBracket) |
| self.state = 920 |
| self.match(CParser.Static) |
| self.state = 922 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0): |
| self.state = 921 |
| self.typeQualifierList(0) |
| |
| |
| self.state = 924 |
| self.assignmentExpression() |
| self.state = 925 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 4: |
| self.state = 927 |
| self.match(CParser.LeftBracket) |
| self.state = 928 |
| self.typeQualifierList(0) |
| self.state = 929 |
| self.match(CParser.Static) |
| self.state = 930 |
| self.assignmentExpression() |
| self.state = 931 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 5: |
| self.state = 933 |
| self.match(CParser.LeftBracket) |
| self.state = 934 |
| self.match(CParser.Star) |
| self.state = 935 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 6: |
| self.state = 936 |
| self.match(CParser.LeftParen) |
| self.state = 938 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.Alignas) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Noreturn) | (1 << CParser.ThreadLocal))) != 0) or _la==CParser.Identifier: |
| self.state = 937 |
| self.parameterTypeList() |
| |
| |
| self.state = 940 |
| self.match(CParser.RightParen) |
| self.state = 944 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,95,self._ctx) |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt==1: |
| self.state = 941 |
| self.gccDeclaratorExtension() |
| self.state = 946 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,95,self._ctx) |
| |
| pass |
| |
| |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 992 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,103,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 = 990 |
| la_ = self._interp.adaptivePredict(self._input,102,self._ctx) |
| if la_ == 1: |
| localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator) |
| self.state = 949 |
| if not self.precpred(self._ctx, 5): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") |
| self.state = 950 |
| self.match(CParser.LeftBracket) |
| self.state = 952 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0): |
| self.state = 951 |
| self.typeQualifierList(0) |
| |
| |
| self.state = 955 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 954 |
| self.assignmentExpression() |
| |
| |
| self.state = 957 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 2: |
| localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator) |
| self.state = 958 |
| if not self.precpred(self._ctx, 4): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") |
| self.state = 959 |
| self.match(CParser.LeftBracket) |
| self.state = 960 |
| self.match(CParser.Static) |
| self.state = 962 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.Const) | (1 << CParser.Restrict) | (1 << CParser.Volatile) | (1 << CParser.Atomic))) != 0): |
| self.state = 961 |
| self.typeQualifierList(0) |
| |
| |
| self.state = 964 |
| self.assignmentExpression() |
| self.state = 965 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 3: |
| localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator) |
| self.state = 967 |
| if not self.precpred(self._ctx, 3): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") |
| self.state = 968 |
| self.match(CParser.LeftBracket) |
| self.state = 969 |
| self.typeQualifierList(0) |
| self.state = 970 |
| self.match(CParser.Static) |
| self.state = 971 |
| self.assignmentExpression() |
| self.state = 972 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 4: |
| localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator) |
| self.state = 974 |
| if not self.precpred(self._ctx, 2): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") |
| self.state = 975 |
| self.match(CParser.LeftBracket) |
| self.state = 976 |
| self.match(CParser.Star) |
| self.state = 977 |
| self.match(CParser.RightBracket) |
| pass |
| |
| elif la_ == 5: |
| localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator) |
| self.state = 978 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 979 |
| self.match(CParser.LeftParen) |
| self.state = 981 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.Alignas) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Noreturn) | (1 << CParser.ThreadLocal))) != 0) or _la==CParser.Identifier: |
| self.state = 980 |
| self.parameterTypeList() |
| |
| |
| self.state = 983 |
| self.match(CParser.RightParen) |
| self.state = 987 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,101,self._ctx) |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: |
| if _alt==1: |
| self.state = 984 |
| self.gccDeclaratorExtension() |
| self.state = 989 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,101,self._ctx) |
| |
| pass |
| |
| |
| self.state = 994 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,103,self._ctx) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.unrollRecursionContexts(_parentctx) |
| return localctx |
| |
| class TypedefNameContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def getRuleIndex(self): |
| return CParser.RULE_typedefName |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterTypedefName" ): |
| listener.enterTypedefName(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitTypedefName" ): |
| listener.exitTypedefName(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitTypedefName" ): |
| return visitor.visitTypedefName(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def typedefName(self): |
| |
| localctx = CParser.TypedefNameContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 126, self.RULE_typedefName) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 995 |
| self.match(CParser.Identifier) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class InitializerContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def assignmentExpression(self): |
| return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0) |
| |
| |
| def initializerList(self): |
| return self.getTypedRuleContext(CParser.InitializerListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_initializer |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterInitializer" ): |
| listener.enterInitializer(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitInitializer" ): |
| listener.exitInitializer(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitInitializer" ): |
| return visitor.visitInitializer(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def initializer(self): |
| |
| localctx = CParser.InitializerContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 128, self.RULE_initializer) |
| try: |
| self.state = 1007 |
| la_ = self._interp.adaptivePredict(self._input,104,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 997 |
| self.assignmentExpression() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 998 |
| self.match(CParser.LeftBrace) |
| self.state = 999 |
| self.initializerList(0) |
| self.state = 1000 |
| self.match(CParser.RightBrace) |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 1002 |
| self.match(CParser.LeftBrace) |
| self.state = 1003 |
| self.initializerList(0) |
| self.state = 1004 |
| self.match(CParser.Comma) |
| self.state = 1005 |
| self.match(CParser.RightBrace) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class InitializerListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def initializer(self): |
| return self.getTypedRuleContext(CParser.InitializerContext,0) |
| |
| |
| def designation(self): |
| return self.getTypedRuleContext(CParser.DesignationContext,0) |
| |
| |
| def initializerList(self): |
| return self.getTypedRuleContext(CParser.InitializerListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_initializerList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterInitializerList" ): |
| listener.enterInitializerList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitInitializerList" ): |
| listener.exitInitializerList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitInitializerList" ): |
| return visitor.visitInitializerList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def initializerList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.InitializerListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 130 |
| self.enterRecursionRule(localctx, 130, self.RULE_initializerList, _p) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1011 |
| _la = self._input.LA(1) |
| if _la==CParser.LeftBracket or _la==CParser.Dot: |
| self.state = 1010 |
| self.designation() |
| |
| |
| self.state = 1013 |
| self.initializer() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 1023 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,107,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 = CParser.InitializerListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_initializerList) |
| self.state = 1015 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 1016 |
| self.match(CParser.Comma) |
| self.state = 1018 |
| _la = self._input.LA(1) |
| if _la==CParser.LeftBracket or _la==CParser.Dot: |
| self.state = 1017 |
| self.designation() |
| |
| |
| self.state = 1020 |
| self.initializer() |
| self.state = 1025 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,107,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 |
| |
| class DesignationContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def designatorList(self): |
| return self.getTypedRuleContext(CParser.DesignatorListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_designation |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDesignation" ): |
| listener.enterDesignation(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDesignation" ): |
| listener.exitDesignation(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDesignation" ): |
| return visitor.visitDesignation(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def designation(self): |
| |
| localctx = CParser.DesignationContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 132, self.RULE_designation) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1026 |
| self.designatorList(0) |
| self.state = 1027 |
| self.match(CParser.Assign) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class DesignatorListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def designator(self): |
| return self.getTypedRuleContext(CParser.DesignatorContext,0) |
| |
| |
| def designatorList(self): |
| return self.getTypedRuleContext(CParser.DesignatorListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_designatorList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDesignatorList" ): |
| listener.enterDesignatorList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDesignatorList" ): |
| listener.exitDesignatorList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDesignatorList" ): |
| return visitor.visitDesignatorList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def designatorList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.DesignatorListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 134 |
| self.enterRecursionRule(localctx, 134, self.RULE_designatorList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1030 |
| self.designator() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 1036 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,108,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 = CParser.DesignatorListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_designatorList) |
| self.state = 1032 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 1033 |
| self.designator() |
| self.state = 1038 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,108,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 |
| |
| class DesignatorContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def constantExpression(self): |
| return self.getTypedRuleContext(CParser.ConstantExpressionContext,0) |
| |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def getRuleIndex(self): |
| return CParser.RULE_designator |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDesignator" ): |
| listener.enterDesignator(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDesignator" ): |
| listener.exitDesignator(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDesignator" ): |
| return visitor.visitDesignator(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def designator(self): |
| |
| localctx = CParser.DesignatorContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 136, self.RULE_designator) |
| try: |
| self.state = 1045 |
| token = self._input.LA(1) |
| if token in [CParser.LeftBracket]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1039 |
| self.match(CParser.LeftBracket) |
| self.state = 1040 |
| self.constantExpression() |
| self.state = 1041 |
| self.match(CParser.RightBracket) |
| |
| elif token in [CParser.Dot]: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 1043 |
| self.match(CParser.Dot) |
| self.state = 1044 |
| self.match(CParser.Identifier) |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class StaticAssertDeclarationContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def constantExpression(self): |
| return self.getTypedRuleContext(CParser.ConstantExpressionContext,0) |
| |
| |
| def StringLiteral(self, i:int=None): |
| if i is None: |
| return self.getTokens(CParser.StringLiteral) |
| else: |
| return self.getToken(CParser.StringLiteral, i) |
| |
| def getRuleIndex(self): |
| return CParser.RULE_staticAssertDeclaration |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterStaticAssertDeclaration" ): |
| listener.enterStaticAssertDeclaration(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitStaticAssertDeclaration" ): |
| listener.exitStaticAssertDeclaration(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitStaticAssertDeclaration" ): |
| return visitor.visitStaticAssertDeclaration(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def staticAssertDeclaration(self): |
| |
| localctx = CParser.StaticAssertDeclarationContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 138, self.RULE_staticAssertDeclaration) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1047 |
| self.match(CParser.StaticAssert) |
| self.state = 1048 |
| self.match(CParser.LeftParen) |
| self.state = 1049 |
| self.constantExpression() |
| self.state = 1050 |
| self.match(CParser.Comma) |
| self.state = 1052 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while True: |
| self.state = 1051 |
| self.match(CParser.StringLiteral) |
| self.state = 1054 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| if not (_la==CParser.StringLiteral): |
| break |
| |
| self.state = 1056 |
| self.match(CParser.RightParen) |
| self.state = 1057 |
| self.match(CParser.Semi) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class StatementContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def labeledStatement(self): |
| return self.getTypedRuleContext(CParser.LabeledStatementContext,0) |
| |
| |
| def compoundStatement(self): |
| return self.getTypedRuleContext(CParser.CompoundStatementContext,0) |
| |
| |
| def expressionStatement(self): |
| return self.getTypedRuleContext(CParser.ExpressionStatementContext,0) |
| |
| |
| def selectionStatement(self): |
| return self.getTypedRuleContext(CParser.SelectionStatementContext,0) |
| |
| |
| def iterationStatement(self): |
| return self.getTypedRuleContext(CParser.IterationStatementContext,0) |
| |
| |
| def jumpStatement(self): |
| return self.getTypedRuleContext(CParser.JumpStatementContext,0) |
| |
| |
| def logicalOrExpression(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.LogicalOrExpressionContext) |
| else: |
| return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,i) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_statement |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterStatement" ): |
| listener.enterStatement(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitStatement" ): |
| listener.exitStatement(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitStatement" ): |
| return visitor.visitStatement(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def statement(self): |
| |
| localctx = CParser.StatementContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 140, self.RULE_statement) |
| self._la = 0 # Token type |
| try: |
| self.state = 1096 |
| la_ = self._interp.adaptivePredict(self._input,116,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1059 |
| self.labeledStatement() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 1060 |
| self.compoundStatement() |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 1061 |
| self.expressionStatement() |
| pass |
| |
| elif la_ == 4: |
| self.enterOuterAlt(localctx, 4) |
| self.state = 1062 |
| self.selectionStatement() |
| pass |
| |
| elif la_ == 5: |
| self.enterOuterAlt(localctx, 5) |
| self.state = 1063 |
| self.iterationStatement() |
| pass |
| |
| elif la_ == 6: |
| self.enterOuterAlt(localctx, 6) |
| self.state = 1064 |
| self.jumpStatement() |
| pass |
| |
| elif la_ == 7: |
| self.enterOuterAlt(localctx, 7) |
| self.state = 1065 |
| _la = self._input.LA(1) |
| if not(_la==CParser.T__10 or _la==CParser.T__12): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| self.state = 1066 |
| _la = self._input.LA(1) |
| if not(_la==CParser.T__13 or _la==CParser.Volatile): |
| self._errHandler.recoverInline(self) |
| else: |
| self.consume() |
| self.state = 1067 |
| self.match(CParser.LeftParen) |
| self.state = 1076 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1068 |
| self.logicalOrExpression(0) |
| self.state = 1073 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while _la==CParser.Comma: |
| self.state = 1069 |
| self.match(CParser.Comma) |
| self.state = 1070 |
| self.logicalOrExpression(0) |
| self.state = 1075 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| |
| |
| |
| self.state = 1091 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while _la==CParser.Colon: |
| self.state = 1078 |
| self.match(CParser.Colon) |
| self.state = 1087 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1079 |
| self.logicalOrExpression(0) |
| self.state = 1084 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while _la==CParser.Comma: |
| self.state = 1080 |
| self.match(CParser.Comma) |
| self.state = 1081 |
| self.logicalOrExpression(0) |
| self.state = 1086 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| |
| |
| |
| self.state = 1093 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| |
| self.state = 1094 |
| self.match(CParser.RightParen) |
| self.state = 1095 |
| self.match(CParser.Semi) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class LabeledStatementContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def statement(self): |
| return self.getTypedRuleContext(CParser.StatementContext,0) |
| |
| |
| def constantExpression(self): |
| return self.getTypedRuleContext(CParser.ConstantExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_labeledStatement |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterLabeledStatement" ): |
| listener.enterLabeledStatement(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitLabeledStatement" ): |
| listener.exitLabeledStatement(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitLabeledStatement" ): |
| return visitor.visitLabeledStatement(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def labeledStatement(self): |
| |
| localctx = CParser.LabeledStatementContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 142, self.RULE_labeledStatement) |
| try: |
| self.state = 1109 |
| token = self._input.LA(1) |
| if token in [CParser.Identifier]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1098 |
| self.match(CParser.Identifier) |
| self.state = 1099 |
| self.match(CParser.Colon) |
| self.state = 1100 |
| self.statement() |
| |
| elif token in [CParser.Case]: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 1101 |
| self.match(CParser.Case) |
| self.state = 1102 |
| self.constantExpression() |
| self.state = 1103 |
| self.match(CParser.Colon) |
| self.state = 1104 |
| self.statement() |
| |
| elif token in [CParser.Default]: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 1106 |
| self.match(CParser.Default) |
| self.state = 1107 |
| self.match(CParser.Colon) |
| self.state = 1108 |
| self.statement() |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class CompoundStatementContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def blockItemList(self): |
| return self.getTypedRuleContext(CParser.BlockItemListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_compoundStatement |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterCompoundStatement" ): |
| listener.enterCompoundStatement(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitCompoundStatement" ): |
| listener.exitCompoundStatement(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitCompoundStatement" ): |
| return visitor.visitCompoundStatement(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def compoundStatement(self): |
| |
| localctx = CParser.CompoundStatementContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 144, self.RULE_compoundStatement) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1111 |
| self.match(CParser.LeftBrace) |
| self.state = 1113 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.Auto) | (1 << CParser.Break) | (1 << CParser.Case) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Continue) | (1 << CParser.Default) | (1 << CParser.Do) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.For) | (1 << CParser.Goto) | (1 << CParser.If) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Return) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Sizeof) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Switch) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.While) | (1 << CParser.Alignas) | (1 << CParser.Alignof) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Generic) | (1 << CParser.Noreturn) | (1 << CParser.StaticAssert) | (1 << CParser.ThreadLocal) | (1 << CParser.LeftParen) | (1 << CParser.LeftBrace))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Semi - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1112 |
| self.blockItemList(0) |
| |
| |
| self.state = 1115 |
| self.match(CParser.RightBrace) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class BlockItemListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def blockItem(self): |
| return self.getTypedRuleContext(CParser.BlockItemContext,0) |
| |
| |
| def blockItemList(self): |
| return self.getTypedRuleContext(CParser.BlockItemListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_blockItemList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterBlockItemList" ): |
| listener.enterBlockItemList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitBlockItemList" ): |
| listener.exitBlockItemList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitBlockItemList" ): |
| return visitor.visitBlockItemList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def blockItemList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.BlockItemListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 146 |
| self.enterRecursionRule(localctx, 146, self.RULE_blockItemList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1118 |
| self.blockItem() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 1124 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,119,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 = CParser.BlockItemListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_blockItemList) |
| self.state = 1120 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 1121 |
| self.blockItem() |
| self.state = 1126 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,119,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 |
| |
| class BlockItemContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def declaration(self): |
| return self.getTypedRuleContext(CParser.DeclarationContext,0) |
| |
| |
| def statement(self): |
| return self.getTypedRuleContext(CParser.StatementContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_blockItem |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterBlockItem" ): |
| listener.enterBlockItem(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitBlockItem" ): |
| listener.exitBlockItem(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitBlockItem" ): |
| return visitor.visitBlockItem(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def blockItem(self): |
| |
| localctx = CParser.BlockItemContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 148, self.RULE_blockItem) |
| try: |
| self.state = 1129 |
| la_ = self._interp.adaptivePredict(self._input,120,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1127 |
| self.declaration() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 1128 |
| 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 |
| |
| class ExpressionStatementContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def expression(self): |
| return self.getTypedRuleContext(CParser.ExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_expressionStatement |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterExpressionStatement" ): |
| listener.enterExpressionStatement(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitExpressionStatement" ): |
| listener.exitExpressionStatement(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitExpressionStatement" ): |
| return visitor.visitExpressionStatement(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def expressionStatement(self): |
| |
| localctx = CParser.ExpressionStatementContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 150, self.RULE_expressionStatement) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1132 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1131 |
| self.expression(0) |
| |
| |
| self.state = 1134 |
| self.match(CParser.Semi) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class SelectionStatementContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def expression(self): |
| return self.getTypedRuleContext(CParser.ExpressionContext,0) |
| |
| |
| def statement(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.StatementContext) |
| else: |
| return self.getTypedRuleContext(CParser.StatementContext,i) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_selectionStatement |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterSelectionStatement" ): |
| listener.enterSelectionStatement(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitSelectionStatement" ): |
| listener.exitSelectionStatement(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitSelectionStatement" ): |
| return visitor.visitSelectionStatement(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def selectionStatement(self): |
| |
| localctx = CParser.SelectionStatementContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 152, self.RULE_selectionStatement) |
| try: |
| self.state = 1151 |
| token = self._input.LA(1) |
| if token in [CParser.If]: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1136 |
| self.match(CParser.If) |
| self.state = 1137 |
| self.match(CParser.LeftParen) |
| self.state = 1138 |
| self.expression(0) |
| self.state = 1139 |
| self.match(CParser.RightParen) |
| self.state = 1140 |
| self.statement() |
| self.state = 1143 |
| la_ = self._interp.adaptivePredict(self._input,122,self._ctx) |
| if la_ == 1: |
| self.state = 1141 |
| self.match(CParser.Else) |
| self.state = 1142 |
| self.statement() |
| |
| |
| |
| elif token in [CParser.Switch]: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 1145 |
| self.match(CParser.Switch) |
| self.state = 1146 |
| self.match(CParser.LeftParen) |
| self.state = 1147 |
| self.expression(0) |
| self.state = 1148 |
| self.match(CParser.RightParen) |
| self.state = 1149 |
| self.statement() |
| |
| else: |
| raise NoViableAltException(self) |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class IterationStatementContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def expression(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(CParser.ExpressionContext) |
| else: |
| return self.getTypedRuleContext(CParser.ExpressionContext,i) |
| |
| |
| def statement(self): |
| return self.getTypedRuleContext(CParser.StatementContext,0) |
| |
| |
| def declaration(self): |
| return self.getTypedRuleContext(CParser.DeclarationContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_iterationStatement |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterIterationStatement" ): |
| listener.enterIterationStatement(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitIterationStatement" ): |
| listener.exitIterationStatement(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitIterationStatement" ): |
| return visitor.visitIterationStatement(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def iterationStatement(self): |
| |
| localctx = CParser.IterationStatementContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 154, self.RULE_iterationStatement) |
| self._la = 0 # Token type |
| try: |
| self.state = 1195 |
| la_ = self._interp.adaptivePredict(self._input,129,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1153 |
| self.match(CParser.While) |
| self.state = 1154 |
| self.match(CParser.LeftParen) |
| self.state = 1155 |
| self.expression(0) |
| self.state = 1156 |
| self.match(CParser.RightParen) |
| self.state = 1157 |
| self.statement() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 1159 |
| self.match(CParser.Do) |
| self.state = 1160 |
| self.statement() |
| self.state = 1161 |
| self.match(CParser.While) |
| self.state = 1162 |
| self.match(CParser.LeftParen) |
| self.state = 1163 |
| self.expression(0) |
| self.state = 1164 |
| self.match(CParser.RightParen) |
| self.state = 1165 |
| self.match(CParser.Semi) |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 1167 |
| self.match(CParser.For) |
| self.state = 1168 |
| self.match(CParser.LeftParen) |
| self.state = 1170 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1169 |
| self.expression(0) |
| |
| |
| self.state = 1172 |
| self.match(CParser.Semi) |
| self.state = 1174 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1173 |
| self.expression(0) |
| |
| |
| self.state = 1176 |
| self.match(CParser.Semi) |
| self.state = 1178 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1177 |
| self.expression(0) |
| |
| |
| self.state = 1180 |
| self.match(CParser.RightParen) |
| self.state = 1181 |
| self.statement() |
| pass |
| |
| elif la_ == 4: |
| self.enterOuterAlt(localctx, 4) |
| self.state = 1182 |
| self.match(CParser.For) |
| self.state = 1183 |
| self.match(CParser.LeftParen) |
| self.state = 1184 |
| self.declaration() |
| self.state = 1186 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1185 |
| self.expression(0) |
| |
| |
| self.state = 1188 |
| self.match(CParser.Semi) |
| self.state = 1190 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1189 |
| self.expression(0) |
| |
| |
| self.state = 1192 |
| self.match(CParser.RightParen) |
| self.state = 1193 |
| 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 |
| |
| class JumpStatementContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def Identifier(self): |
| return self.getToken(CParser.Identifier, 0) |
| |
| def expression(self): |
| return self.getTypedRuleContext(CParser.ExpressionContext,0) |
| |
| |
| def unaryExpression(self): |
| return self.getTypedRuleContext(CParser.UnaryExpressionContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_jumpStatement |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterJumpStatement" ): |
| listener.enterJumpStatement(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitJumpStatement" ): |
| listener.exitJumpStatement(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitJumpStatement" ): |
| return visitor.visitJumpStatement(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def jumpStatement(self): |
| |
| localctx = CParser.JumpStatementContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 156, self.RULE_jumpStatement) |
| self._la = 0 # Token type |
| try: |
| self.state = 1213 |
| la_ = self._interp.adaptivePredict(self._input,131,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1197 |
| self.match(CParser.Goto) |
| self.state = 1198 |
| self.match(CParser.Identifier) |
| self.state = 1199 |
| self.match(CParser.Semi) |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 1200 |
| self.match(CParser.Continue) |
| self.state = 1201 |
| self.match(CParser.Semi) |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 1202 |
| self.match(CParser.Break) |
| self.state = 1203 |
| self.match(CParser.Semi) |
| pass |
| |
| elif la_ == 4: |
| self.enterOuterAlt(localctx, 4) |
| self.state = 1204 |
| self.match(CParser.Return) |
| self.state = 1206 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.Sizeof) | (1 << CParser.Alignof) | (1 << CParser.Generic) | (1 << CParser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Identifier - 71)) | (1 << (CParser.Constant - 71)) | (1 << (CParser.StringLiteral - 71)))) != 0): |
| self.state = 1205 |
| self.expression(0) |
| |
| |
| self.state = 1208 |
| self.match(CParser.Semi) |
| pass |
| |
| elif la_ == 5: |
| self.enterOuterAlt(localctx, 5) |
| self.state = 1209 |
| self.match(CParser.Goto) |
| self.state = 1210 |
| self.unaryExpression() |
| self.state = 1211 |
| self.match(CParser.Semi) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class CompilationUnitContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def EOF(self): |
| return self.getToken(CParser.EOF, 0) |
| |
| def translationUnit(self): |
| return self.getTypedRuleContext(CParser.TranslationUnitContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_compilationUnit |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterCompilationUnit" ): |
| listener.enterCompilationUnit(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitCompilationUnit" ): |
| listener.exitCompilationUnit(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitCompilationUnit" ): |
| return visitor.visitCompilationUnit(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def compilationUnit(self): |
| |
| localctx = CParser.CompilationUnitContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 158, self.RULE_compilationUnit) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1216 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.Alignas) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Noreturn) | (1 << CParser.StaticAssert) | (1 << CParser.ThreadLocal) | (1 << CParser.LeftParen))) != 0) or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (CParser.Star - 75)) | (1 << (CParser.Caret - 75)) | (1 << (CParser.Semi - 75)) | (1 << (CParser.Identifier - 75)))) != 0): |
| self.state = 1215 |
| self.translationUnit(0) |
| |
| |
| self.state = 1218 |
| self.match(CParser.EOF) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class TranslationUnitContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def externalDeclaration(self): |
| return self.getTypedRuleContext(CParser.ExternalDeclarationContext,0) |
| |
| |
| def translationUnit(self): |
| return self.getTypedRuleContext(CParser.TranslationUnitContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_translationUnit |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterTranslationUnit" ): |
| listener.enterTranslationUnit(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitTranslationUnit" ): |
| listener.exitTranslationUnit(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitTranslationUnit" ): |
| return visitor.visitTranslationUnit(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def translationUnit(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.TranslationUnitContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 160 |
| self.enterRecursionRule(localctx, 160, self.RULE_translationUnit, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1221 |
| self.externalDeclaration() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 1227 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,133,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 = CParser.TranslationUnitContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_translationUnit) |
| self.state = 1223 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 1224 |
| self.externalDeclaration() |
| self.state = 1229 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,133,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 |
| |
| class ExternalDeclarationContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def functionDefinition(self): |
| return self.getTypedRuleContext(CParser.FunctionDefinitionContext,0) |
| |
| |
| def declaration(self): |
| return self.getTypedRuleContext(CParser.DeclarationContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_externalDeclaration |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterExternalDeclaration" ): |
| listener.enterExternalDeclaration(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitExternalDeclaration" ): |
| listener.exitExternalDeclaration(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitExternalDeclaration" ): |
| return visitor.visitExternalDeclaration(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def externalDeclaration(self): |
| |
| localctx = CParser.ExternalDeclarationContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 162, self.RULE_externalDeclaration) |
| try: |
| self.state = 1233 |
| la_ = self._interp.adaptivePredict(self._input,134,self._ctx) |
| if la_ == 1: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1230 |
| self.functionDefinition() |
| pass |
| |
| elif la_ == 2: |
| self.enterOuterAlt(localctx, 2) |
| self.state = 1231 |
| self.declaration() |
| pass |
| |
| elif la_ == 3: |
| self.enterOuterAlt(localctx, 3) |
| self.state = 1232 |
| self.match(CParser.Semi) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class FunctionDefinitionContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def declarator(self): |
| return self.getTypedRuleContext(CParser.DeclaratorContext,0) |
| |
| |
| def compoundStatement(self): |
| return self.getTypedRuleContext(CParser.CompoundStatementContext,0) |
| |
| |
| def declarationSpecifiers(self): |
| return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0) |
| |
| |
| def declarationList(self): |
| return self.getTypedRuleContext(CParser.DeclarationListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_functionDefinition |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterFunctionDefinition" ): |
| listener.enterFunctionDefinition(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitFunctionDefinition" ): |
| listener.exitFunctionDefinition(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitFunctionDefinition" ): |
| return visitor.visitFunctionDefinition(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| |
| def functionDefinition(self): |
| |
| localctx = CParser.FunctionDefinitionContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 164, self.RULE_functionDefinition) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1236 |
| la_ = self._interp.adaptivePredict(self._input,135,self._ctx) |
| if la_ == 1: |
| self.state = 1235 |
| self.declarationSpecifiers() |
| |
| |
| self.state = 1238 |
| self.declarator() |
| self.state = 1240 |
| _la = self._input.LA(1) |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline) | (1 << CParser.Int) | (1 << CParser.Long) | (1 << CParser.Register) | (1 << CParser.Restrict) | (1 << CParser.Short) | (1 << CParser.Signed) | (1 << CParser.Static) | (1 << CParser.Struct) | (1 << CParser.Typedef) | (1 << CParser.Union) | (1 << CParser.Unsigned) | (1 << CParser.Void) | (1 << CParser.Volatile) | (1 << CParser.Alignas) | (1 << CParser.Atomic) | (1 << CParser.Bool) | (1 << CParser.Complex) | (1 << CParser.Noreturn) | (1 << CParser.StaticAssert) | (1 << CParser.ThreadLocal))) != 0) or _la==CParser.Identifier: |
| self.state = 1239 |
| self.declarationList(0) |
| |
| |
| self.state = 1242 |
| self.compoundStatement() |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| class DeclarationListContext(ParserRuleContext): |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def declaration(self): |
| return self.getTypedRuleContext(CParser.DeclarationContext,0) |
| |
| |
| def declarationList(self): |
| return self.getTypedRuleContext(CParser.DeclarationListContext,0) |
| |
| |
| def getRuleIndex(self): |
| return CParser.RULE_declarationList |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterDeclarationList" ): |
| listener.enterDeclarationList(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitDeclarationList" ): |
| listener.exitDeclarationList(self) |
| |
| def accept(self, visitor:ParseTreeVisitor): |
| if hasattr( visitor, "visitDeclarationList" ): |
| return visitor.visitDeclarationList(self) |
| else: |
| return visitor.visitChildren(self) |
| |
| |
| |
| def declarationList(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = CParser.DeclarationListContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 166 |
| self.enterRecursionRule(localctx, 166, self.RULE_declarationList, _p) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 1245 |
| self.declaration() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 1251 |
| 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 = CParser.DeclarationListContext(self, _parentctx, _parentState) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_declarationList) |
| self.state = 1247 |
| if not self.precpred(self._ctx, 1): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") |
| self.state = 1248 |
| self.declaration() |
| self.state = 1253 |
| 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 |
| |
| |
| |
| def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): |
| if self._predicates == None: |
| self._predicates = dict() |
| self._predicates[2] = self.genericAssocList_sempred |
| self._predicates[4] = self.postfixExpression_sempred |
| self._predicates[5] = self.argumentExpressionList_sempred |
| self._predicates[9] = self.multiplicativeExpression_sempred |
| self._predicates[10] = self.additiveExpression_sempred |
| self._predicates[11] = self.shiftExpression_sempred |
| self._predicates[12] = self.relationalExpression_sempred |
| self._predicates[13] = self.equalityExpression_sempred |
| self._predicates[14] = self.andExpression_sempred |
| self._predicates[15] = self.exclusiveOrExpression_sempred |
| self._predicates[16] = self.inclusiveOrExpression_sempred |
| self._predicates[17] = self.logicalAndExpression_sempred |
| self._predicates[18] = self.logicalOrExpression_sempred |
| self._predicates[22] = self.expression_sempred |
| self._predicates[28] = self.initDeclaratorList_sempred |
| self._predicates[34] = self.structDeclarationList_sempred |
| self._predicates[37] = self.structDeclaratorList_sempred |
| self._predicates[40] = self.enumeratorList_sempred |
| self._predicates[48] = self.directDeclarator_sempred |
| self._predicates[55] = self.typeQualifierList_sempred |
| self._predicates[57] = self.parameterList_sempred |
| self._predicates[59] = self.identifierList_sempred |
| self._predicates[62] = self.directAbstractDeclarator_sempred |
| self._predicates[65] = self.initializerList_sempred |
| self._predicates[67] = self.designatorList_sempred |
| self._predicates[73] = self.blockItemList_sempred |
| self._predicates[80] = self.translationUnit_sempred |
| self._predicates[83] = self.declarationList_sempred |
| pred = self._predicates.get(ruleIndex, None) |
| if pred is None: |
| raise Exception("No predicate with index:" + str(ruleIndex)) |
| else: |
| return pred(localctx, predIndex) |
| |
| def genericAssocList_sempred(self, localctx:GenericAssocListContext, predIndex:int): |
| if predIndex == 0: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def postfixExpression_sempred(self, localctx:PostfixExpressionContext, predIndex:int): |
| if predIndex == 1: |
| return self.precpred(self._ctx, 10) |
| |
| |
| if predIndex == 2: |
| return self.precpred(self._ctx, 9) |
| |
| |
| if predIndex == 3: |
| return self.precpred(self._ctx, 8) |
| |
| |
| if predIndex == 4: |
| return self.precpred(self._ctx, 7) |
| |
| |
| if predIndex == 5: |
| return self.precpred(self._ctx, 6) |
| |
| |
| if predIndex == 6: |
| return self.precpred(self._ctx, 5) |
| |
| |
| def argumentExpressionList_sempred(self, localctx:ArgumentExpressionListContext, predIndex:int): |
| if predIndex == 7: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def multiplicativeExpression_sempred(self, localctx:MultiplicativeExpressionContext, predIndex:int): |
| if predIndex == 8: |
| return self.precpred(self._ctx, 3) |
| |
| |
| if predIndex == 9: |
| return self.precpred(self._ctx, 2) |
| |
| |
| if predIndex == 10: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def additiveExpression_sempred(self, localctx:AdditiveExpressionContext, predIndex:int): |
| if predIndex == 11: |
| return self.precpred(self._ctx, 2) |
| |
| |
| if predIndex == 12: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def shiftExpression_sempred(self, localctx:ShiftExpressionContext, predIndex:int): |
| if predIndex == 13: |
| return self.precpred(self._ctx, 2) |
| |
| |
| if predIndex == 14: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def relationalExpression_sempred(self, localctx:RelationalExpressionContext, predIndex:int): |
| if predIndex == 15: |
| return self.precpred(self._ctx, 4) |
| |
| |
| if predIndex == 16: |
| return self.precpred(self._ctx, 3) |
| |
| |
| if predIndex == 17: |
| return self.precpred(self._ctx, 2) |
| |
| |
| if predIndex == 18: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def equalityExpression_sempred(self, localctx:EqualityExpressionContext, predIndex:int): |
| if predIndex == 19: |
| return self.precpred(self._ctx, 2) |
| |
| |
| if predIndex == 20: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def andExpression_sempred(self, localctx:AndExpressionContext, predIndex:int): |
| if predIndex == 21: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def exclusiveOrExpression_sempred(self, localctx:ExclusiveOrExpressionContext, predIndex:int): |
| if predIndex == 22: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def inclusiveOrExpression_sempred(self, localctx:InclusiveOrExpressionContext, predIndex:int): |
| if predIndex == 23: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def logicalAndExpression_sempred(self, localctx:LogicalAndExpressionContext, predIndex:int): |
| if predIndex == 24: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def logicalOrExpression_sempred(self, localctx:LogicalOrExpressionContext, predIndex:int): |
| if predIndex == 25: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def expression_sempred(self, localctx:ExpressionContext, predIndex:int): |
| if predIndex == 26: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def initDeclaratorList_sempred(self, localctx:InitDeclaratorListContext, predIndex:int): |
| if predIndex == 27: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def structDeclarationList_sempred(self, localctx:StructDeclarationListContext, predIndex:int): |
| if predIndex == 28: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def structDeclaratorList_sempred(self, localctx:StructDeclaratorListContext, predIndex:int): |
| if predIndex == 29: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def enumeratorList_sempred(self, localctx:EnumeratorListContext, predIndex:int): |
| if predIndex == 30: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def directDeclarator_sempred(self, localctx:DirectDeclaratorContext, predIndex:int): |
| if predIndex == 31: |
| return self.precpred(self._ctx, 6) |
| |
| |
| if predIndex == 32: |
| return self.precpred(self._ctx, 5) |
| |
| |
| if predIndex == 33: |
| return self.precpred(self._ctx, 4) |
| |
| |
| if predIndex == 34: |
| return self.precpred(self._ctx, 3) |
| |
| |
| if predIndex == 35: |
| return self.precpred(self._ctx, 2) |
| |
| |
| if predIndex == 36: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def typeQualifierList_sempred(self, localctx:TypeQualifierListContext, predIndex:int): |
| if predIndex == 37: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def parameterList_sempred(self, localctx:ParameterListContext, predIndex:int): |
| if predIndex == 38: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def identifierList_sempred(self, localctx:IdentifierListContext, predIndex:int): |
| if predIndex == 39: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def directAbstractDeclarator_sempred(self, localctx:DirectAbstractDeclaratorContext, predIndex:int): |
| if predIndex == 40: |
| return self.precpred(self._ctx, 5) |
| |
| |
| if predIndex == 41: |
| return self.precpred(self._ctx, 4) |
| |
| |
| if predIndex == 42: |
| return self.precpred(self._ctx, 3) |
| |
| |
| if predIndex == 43: |
| return self.precpred(self._ctx, 2) |
| |
| |
| if predIndex == 44: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def initializerList_sempred(self, localctx:InitializerListContext, predIndex:int): |
| if predIndex == 45: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def designatorList_sempred(self, localctx:DesignatorListContext, predIndex:int): |
| if predIndex == 46: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def blockItemList_sempred(self, localctx:BlockItemListContext, predIndex:int): |
| if predIndex == 47: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def translationUnit_sempred(self, localctx:TranslationUnitContext, predIndex:int): |
| if predIndex == 48: |
| return self.precpred(self._ctx, 1) |
| |
| |
| def declarationList_sempred(self, localctx:DeclarationListContext, predIndex:int): |
| if predIndex == 49: |
| return self.precpred(self._ctx, 1) |
| |
