Created
February 26, 2023 10:16
-
-
Save Librechain/b5a2c796736fcd0798a2f7919a695d09 to your computer and use it in GitHub Desktop.
Parser for Solidity (Python) [CC: André Storhaug the genius!]
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # Generated from Solidity.g4 by ANTLR 4.9.3 | |
| # encoding: utf-8 | |
| # CC: André Storhaug; https://github.com/andstor/solidity-universal-parser mwah! | |
| from antlr4 import * | |
| from io import StringIO | |
| import sys | |
| if sys.version_info[1] > 5: | |
| from typing import TextIO | |
| else: | |
| from typing.io import TextIO | |
| def serializedATN(): | |
| with StringIO() as buf: | |
| buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u008a") | |
| buf.write("\u04b6\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") | |
| buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16") | |
| buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") | |
| buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31") | |
| buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36") | |
| buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t") | |
| buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") | |
| buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64") | |
| buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t") | |
| buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t") | |
| buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t") | |
| buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t") | |
| buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4") | |
| buf.write("_\t_\4`\t`\4a\ta\4b\tb\3\2\5\2\u00c6\n\2\3\2\3\2\3\2\3") | |
| buf.write("\2\3\2\3\2\3\2\3\2\7\2\u00d0\n\2\f\2\16\2\u00d3\13\2\3") | |
| buf.write("\2\3\2\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\6\3\6\5\6") | |
| buf.write("\u00e2\n\6\3\7\3\7\5\7\u00e6\n\7\3\b\3\b\3\t\5\t\u00eb") | |
| buf.write("\n\t\3\t\3\t\3\n\3\n\3\n\5\n\u00f2\n\n\3\13\3\13\3\13") | |
| buf.write("\3\13\5\13\u00f8\n\13\3\13\3\13\3\13\3\13\5\13\u00fe\n") | |
| buf.write("\13\3\13\3\13\5\13\u0102\n\13\3\13\3\13\3\13\3\13\3\13") | |
| buf.write("\3\13\3\13\3\13\7\13\u010c\n\13\f\13\16\13\u010f\13\13") | |
| buf.write("\3\13\3\13\3\13\3\13\3\13\5\13\u0116\n\13\3\f\6\f\u0119") | |
| buf.write("\n\f\r\f\16\f\u011a\3\f\5\f\u011e\n\f\3\r\5\r\u0121\n") | |
| buf.write("\r\3\r\5\r\u0124\n\r\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u012c") | |
| buf.write("\n\r\f\r\16\r\u012f\13\r\5\r\u0131\n\r\3\r\3\r\7\r\u0135") | |
| buf.write("\n\r\f\r\16\r\u0138\13\r\3\r\3\r\3\16\3\16\5\16\u013e") | |
| buf.write("\n\16\3\17\3\17\5\17\u0142\n\17\3\17\3\17\7\17\u0146\n") | |
| buf.write("\17\f\17\16\17\u0149\13\17\3\17\3\17\3\17\3\17\3\17\3") | |
| buf.write("\17\3\17\3\17\3\17\3\17\7\17\u0155\n\17\f\17\16\17\u0158") | |
| buf.write("\13\17\7\17\u015a\n\17\f\17\16\17\u015d\13\17\3\17\5\17") | |
| buf.write("\u0160\n\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5") | |
| buf.write("\20\u016a\n\20\3\21\3\21\7\21\u016e\n\21\f\21\16\21\u0171") | |
| buf.write("\13\21\3\21\3\21\3\21\5\21\u0176\n\21\3\21\3\21\3\22\3") | |
| buf.write("\22\3\22\3\22\3\22\5\22\u017f\n\22\3\22\3\22\3\23\3\23") | |
| buf.write("\3\23\3\23\3\23\3\23\3\23\3\23\7\23\u018b\n\23\f\23\16") | |
| buf.write("\23\u018e\13\23\5\23\u0190\n\23\3\23\3\23\3\24\3\24\3") | |
| buf.write("\24\3\24\3\24\3\25\3\25\3\25\5\25\u019c\n\25\3\25\3\25") | |
| buf.write("\3\26\3\26\3\26\5\26\u01a3\n\26\3\26\5\26\u01a6\n\26\3") | |
| buf.write("\27\5\27\u01a9\n\27\3\27\3\27\5\27\u01ad\n\27\3\27\3\27") | |
| buf.write("\3\27\5\27\u01b2\n\27\3\27\3\27\5\27\u01b6\n\27\3\30\3") | |
| buf.write("\30\3\30\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32") | |
| buf.write("\3\32\3\32\3\32\7\32\u01c7\n\32\f\32\16\32\u01ca\13\32") | |
| buf.write("\3\33\5\33\u01cd\n\33\3\33\3\33\3\33\3\33\5\33\u01d3\n") | |
| buf.write("\33\3\33\3\33\3\34\3\34\3\35\3\35\3\35\3\35\5\35\u01dd") | |
| buf.write("\n\35\3\35\3\35\7\35\u01e1\n\35\f\35\16\35\u01e4\13\35") | |
| buf.write("\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u01ec\n\36\f\36\16") | |
| buf.write("\36\u01ef\13\36\5\36\u01f1\n\36\3\36\3\36\3\37\3\37\3") | |
| buf.write("\37\3\37\7\37\u01f9\n\37\f\37\16\37\u01fc\13\37\5\37\u01fe") | |
| buf.write("\n\37\3\37\3\37\3 \3 \5 \u0204\n \3 \5 \u0207\n \3!\3") | |
| buf.write("!\3!\3!\7!\u020d\n!\f!\16!\u0210\13!\5!\u0212\n!\3!\3") | |
| buf.write("!\3\"\3\"\5\"\u0218\n\"\3\"\5\"\u021b\n\"\3#\3#\3#\3#") | |
| buf.write("\7#\u0221\n#\f#\16#\u0224\13#\5#\u0226\n#\3#\3#\3$\3$") | |
| buf.write("\5$\u022c\n$\3%\3%\5%\u0230\n%\3%\3%\3&\3&\3&\3&\3&\3") | |
| buf.write("&\3&\5&\u023b\n&\3&\3&\3&\5&\u0240\n&\3&\7&\u0243\n&\f") | |
| buf.write("&\16&\u0246\13&\3\'\3\'\3\'\7\'\u024b\n\'\f\'\16\'\u024e") | |
| buf.write("\13\'\3(\3(\3(\3(\5(\u0254\n(\3(\3(\3(\3(\3)\3)\3)\3)") | |
| buf.write("\3)\7)\u025f\n)\f)\16)\u0262\13)\3)\3)\5)\u0266\n)\3)") | |
| buf.write("\3)\3)\5)\u026b\n)\3)\3)\3)\7)\u0270\n)\f)\16)\u0273\13") | |
| buf.write(")\3)\3)\3)\3)\3)\5)\u027a\n)\3*\3*\3+\3+\3,\3,\3-\3-\3") | |
| buf.write("-\7-\u0285\n-\f-\16-\u0288\13-\3-\3-\3.\3.\3.\3/\3/\3") | |
| buf.write("/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u029f\n/\3") | |
| buf.write("\60\3\60\3\60\3\60\3\60\3\60\3\60\5\60\u02a8\n\60\3\60") | |
| buf.write("\3\60\7\60\u02ac\n\60\f\60\16\60\u02af\13\60\3\61\3\61") | |
| buf.write("\5\61\u02b3\n\61\3\61\3\61\3\61\5\61\u02b8\n\61\3\61\3") | |
| buf.write("\61\5\61\u02bc\n\61\3\61\3\61\3\61\5\61\u02c1\n\61\3\62") | |
| buf.write("\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u02cd") | |
| buf.write("\n\63\3\64\3\64\3\65\3\65\3\66\3\66\3\67\3\67\3\67\3\67") | |
| buf.write("\3\67\3\67\38\38\58\u02dd\n8\39\39\39\39\59\u02e3\n9\3") | |
| buf.write("9\39\59\u02e7\n9\39\59\u02ea\n9\39\39\39\3:\3:\5:\u02f1") | |
| buf.write("\n:\3:\3:\3;\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3=\3=\3=\3") | |
| buf.write(">\3>\5>\u0305\n>\3>\3>\3?\3?\3?\3@\3@\3@\3@\3A\3A\3A\3") | |
| buf.write("A\3A\3A\3A\5A\u0317\nA\3A\3A\5A\u031b\nA\3A\3A\3B\3B\3") | |
| buf.write("B\3B\3B\3B\3B\3C\5C\u0327\nC\3C\3C\5C\u032b\nC\7C\u032d") | |
| buf.write("\nC\fC\16C\u0330\13C\3D\3D\5D\u0334\nD\3D\7D\u0337\nD") | |
| buf.write("\fD\16D\u033a\13D\3D\5D\u033d\nD\3D\3D\3E\3E\3F\3F\3F") | |
| buf.write("\3F\3F\7F\u0348\nF\fF\16F\u034b\13F\3F\3F\3F\3F\3F\3F") | |
| buf.write("\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3") | |
| buf.write("F\3F\3F\5F\u0367\nF\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3") | |
| buf.write("F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3") | |
| buf.write("F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\5F\u0396") | |
| buf.write("\nF\3F\3F\3F\3F\5F\u039c\nF\3F\3F\5F\u03a0\nF\3F\3F\3") | |
| buf.write("F\3F\3F\5F\u03a7\nF\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\7F\u03b3") | |
| buf.write("\nF\fF\16F\u03b6\13F\5F\u03b8\nF\3F\3F\3F\3F\3F\3F\3F") | |
| buf.write("\3F\7F\u03c2\nF\fF\16F\u03c5\13F\3G\3G\3G\3G\3G\3G\3G") | |
| buf.write("\5G\u03ce\nG\3G\3G\3G\3G\3G\5G\u03d5\nG\5G\u03d7\nG\3") | |
| buf.write("H\3H\3H\7H\u03dc\nH\fH\16H\u03df\13H\3I\3I\3I\7I\u03e4") | |
| buf.write("\nI\fI\16I\u03e7\13I\3I\5I\u03ea\nI\3J\3J\3J\3J\3K\3K") | |
| buf.write("\5K\u03f2\nK\3K\3K\5K\u03f6\nK\5K\u03f8\nK\3L\3L\3L\3") | |
| buf.write("L\3L\3M\3M\7M\u0401\nM\fM\16M\u0404\13M\3M\3M\3N\3N\3") | |
| buf.write("N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\5N\u0419\n") | |
| buf.write("N\3O\3O\5O\u041d\nO\3P\3P\3P\3P\5P\u0423\nP\3P\3P\5P\u0427") | |
| buf.write("\nP\3P\3P\7P\u042b\nP\fP\16P\u042e\13P\3P\5P\u0431\nP") | |
| buf.write("\3Q\3Q\3Q\3Q\5Q\u0437\nQ\3R\3R\3R\3R\3S\3S\3S\3S\3S\5") | |
| buf.write("S\u0442\nS\3T\3T\3T\7T\u0447\nT\fT\16T\u044a\13T\3U\3") | |
| buf.write("U\3U\3V\3V\3V\3W\3W\3W\7W\u0455\nW\fW\16W\u0458\13W\3") | |
| buf.write("X\3X\3X\3X\3X\3X\5X\u0460\nX\3Y\3Y\3Y\3Y\5Y\u0466\nY\3") | |
| buf.write("Y\3Y\5Y\u046a\nY\3Y\3Y\3Z\3Z\3Z\3[\3[\3[\5[\u0474\n[\3") | |
| buf.write("[\3[\3[\5[\u0479\n[\3[\3[\3\\\3\\\3\\\3\\\3]\3]\3^\3^") | |
| buf.write("\3^\3^\3_\3_\5_\u0489\n_\3_\3_\5_\u048d\n_\7_\u048f\n") | |
| buf.write("_\f_\16_\u0492\13_\3_\3_\3_\3_\3_\7_\u0499\n_\f_\16_\u049c") | |
| buf.write("\13_\5_\u049e\n_\3_\5_\u04a1\n_\3`\3`\5`\u04a5\n`\3a\3") | |
| buf.write("a\5a\u04a9\na\3b\3b\3b\3b\7b\u04af\nb\fb\16b\u04b2\13") | |
| buf.write("b\5b\u04b4\nb\3b\2\4J\u008ac\2\4\6\b\n\f\16\20\22\24\26") | |
| buf.write("\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\") | |
| buf.write("^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a") | |
| buf.write("\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c") | |
| buf.write("\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae") | |
| buf.write("\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0") | |
| buf.write("\u00c2\2\26\3\2\5\13\3\2\24\26\5\2vx}}\177\u0080\3\2\"") | |
| buf.write("$\5\2{{}}\177\u0080\3\2.\60\6\2vv~~\u0081\u0081\u0083") | |
| buf.write("\u0083\5\2**<?hl\4\2\6\6@D\4\2DDFF\4\2CCGG\4\2\16\16I") | |
| buf.write("J\3\2KM\3\2\7\n\3\2PQ\4\2\13\13U_\3\2@A\5\2oprr\u0085") | |
| buf.write("\u0085\3\2op\5\2\17\17\60\60\u0084\u0084\2\u0537\2\u00c5") | |
| buf.write("\3\2\2\2\4\u00d6\3\2\2\2\6\u00d8\3\2\2\2\b\u00dd\3\2\2") | |
| buf.write("\2\n\u00e1\3\2\2\2\f\u00e3\3\2\2\2\16\u00e7\3\2\2\2\20") | |
| buf.write("\u00ea\3\2\2\2\22\u00ee\3\2\2\2\24\u0115\3\2\2\2\26\u011d") | |
| buf.write("\3\2\2\2\30\u0120\3\2\2\2\32\u013b\3\2\2\2\34\u015f\3") | |
| buf.write("\2\2\2\36\u0169\3\2\2\2 \u016b\3\2\2\2\"\u0179\3\2\2\2") | |
| buf.write("$\u0182\3\2\2\2&\u0193\3\2\2\2(\u0198\3\2\2\2*\u019f\3") | |
| buf.write("\2\2\2,\u01a8\3\2\2\2.\u01b7\3\2\2\2\60\u01ba\3\2\2\2") | |
| buf.write("\62\u01c8\3\2\2\2\64\u01cc\3\2\2\2\66\u01d6\3\2\2\28\u01d8") | |
| buf.write("\3\2\2\2:\u01e7\3\2\2\2<\u01f4\3\2\2\2>\u0201\3\2\2\2") | |
| buf.write("@\u0208\3\2\2\2B\u0215\3\2\2\2D\u021c\3\2\2\2F\u0229\3") | |
| buf.write("\2\2\2H\u022d\3\2\2\2J\u023a\3\2\2\2L\u0247\3\2\2\2N\u024f") | |
| buf.write("\3\2\2\2P\u0279\3\2\2\2R\u027b\3\2\2\2T\u027d\3\2\2\2") | |
| buf.write("V\u027f\3\2\2\2X\u0281\3\2\2\2Z\u028b\3\2\2\2\\\u029e") | |
| buf.write("\3\2\2\2^\u02a0\3\2\2\2`\u02c0\3\2\2\2b\u02c2\3\2\2\2") | |
| buf.write("d\u02c5\3\2\2\2f\u02ce\3\2\2\2h\u02d0\3\2\2\2j\u02d2\3") | |
| buf.write("\2\2\2l\u02d4\3\2\2\2n\u02dc\3\2\2\2p\u02de\3\2\2\2r\u02ee") | |
| buf.write("\3\2\2\2t\u02f4\3\2\2\2v\u02fc\3\2\2\2x\u02ff\3\2\2\2") | |
| buf.write("z\u0302\3\2\2\2|\u0308\3\2\2\2~\u030b\3\2\2\2\u0080\u0316") | |
| buf.write("\3\2\2\2\u0082\u031e\3\2\2\2\u0084\u0326\3\2\2\2\u0086") | |
| buf.write("\u0331\3\2\2\2\u0088\u0340\3\2\2\2\u008a\u0366\3\2\2\2") | |
| buf.write("\u008c\u03d6\3\2\2\2\u008e\u03d8\3\2\2\2\u0090\u03e0\3") | |
| buf.write("\2\2\2\u0092\u03eb\3\2\2\2\u0094\u03f7\3\2\2\2\u0096\u03f9") | |
| buf.write("\3\2\2\2\u0098\u03fe\3\2\2\2\u009a\u0418\3\2\2\2\u009c") | |
| buf.write("\u041c\3\2\2\2\u009e\u0422\3\2\2\2\u00a0\u0432\3\2\2\2") | |
| buf.write("\u00a2\u0438\3\2\2\2\u00a4\u0441\3\2\2\2\u00a6\u0443\3") | |
| buf.write("\2\2\2\u00a8\u044b\3\2\2\2\u00aa\u044e\3\2\2\2\u00ac\u0451") | |
| buf.write("\3\2\2\2\u00ae\u045f\3\2\2\2\u00b0\u0461\3\2\2\2\u00b2") | |
| buf.write("\u046d\3\2\2\2\u00b4\u0470\3\2\2\2\u00b6\u047c\3\2\2\2") | |
| buf.write("\u00b8\u0480\3\2\2\2\u00ba\u0482\3\2\2\2\u00bc\u04a0\3") | |
| buf.write("\2\2\2\u00be\u04a4\3\2\2\2\u00c0\u04a6\3\2\2\2\u00c2\u04b3") | |
| buf.write("\3\2\2\2\u00c4\u00c6\5\4\3\2\u00c5\u00c4\3\2\2\2\u00c5") | |
| buf.write("\u00c6\3\2\2\2\u00c6\u00d1\3\2\2\2\u00c7\u00d0\5\26\f") | |
| buf.write("\2\u00c8\u00d0\5\6\4\2\u00c9\u00d0\5\24\13\2\u00ca\u00d0") | |
| buf.write("\5\30\r\2\u00cb\u00d0\5,\27\2\u00cc\u00d0\5\u0082B\2\u00cd") | |
| buf.write("\u00d0\5$\23\2\u00ce\u00d0\58\35\2\u00cf\u00c7\3\2\2\2") | |
| buf.write("\u00cf\u00c8\3\2\2\2\u00cf\u00c9\3\2\2\2\u00cf\u00ca\3") | |
| buf.write("\2\2\2\u00cf\u00cb\3\2\2\2\u00cf\u00cc\3\2\2\2\u00cf\u00cd") | |
| buf.write("\3\2\2\2\u00cf\u00ce\3\2\2\2\u00d0\u00d3\3\2\2\2\u00d1") | |
| buf.write("\u00cf\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d4\3\2\2\2") | |
| buf.write("\u00d3\u00d1\3\2\2\2\u00d4\u00d5\7\2\2\3\u00d5\3\3\2\2") | |
| buf.write("\2\u00d6\u00d7\7g\2\2\u00d7\5\3\2\2\2\u00d8\u00d9\7\3") | |
| buf.write("\2\2\u00d9\u00da\5\b\5\2\u00da\u00db\5\n\6\2\u00db\u00dc") | |
| buf.write("\7\4\2\2\u00dc\7\3\2\2\2\u00dd\u00de\5\u00c2b\2\u00de") | |
| buf.write("\t\3\2\2\2\u00df\u00e2\5\f\7\2\u00e0\u00e2\5\u008aF\2") | |
| buf.write("\u00e1\u00df\3\2\2\2\u00e1\u00e0\3\2\2\2\u00e2\13\3\2") | |
| buf.write("\2\2\u00e3\u00e5\5\20\t\2\u00e4\u00e6\5\20\t\2\u00e5\u00e4") | |
| buf.write("\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\r\3\2\2\2\u00e7\u00e8") | |
| buf.write("\t\2\2\2\u00e8\17\3\2\2\2\u00e9\u00eb\5\16\b\2\u00ea\u00e9") | |
| buf.write("\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec") | |
| buf.write("\u00ed\7m\2\2\u00ed\21\3\2\2\2\u00ee\u00f1\5\u00c2b\2") | |
| buf.write("\u00ef\u00f0\7\f\2\2\u00f0\u00f2\5\u00c2b\2\u00f1\u00ef") | |
| buf.write("\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\23\3\2\2\2\u00f3\u00f4") | |
| buf.write("\7\r\2\2\u00f4\u00f7\7\u0085\2\2\u00f5\u00f6\7\f\2\2\u00f6") | |
| buf.write("\u00f8\5\u00c2b\2\u00f7\u00f5\3\2\2\2\u00f7\u00f8\3\2") | |
| buf.write("\2\2\u00f8\u00f9\3\2\2\2\u00f9\u0116\7\4\2\2\u00fa\u00fd") | |
| buf.write("\7\r\2\2\u00fb\u00fe\7\16\2\2\u00fc\u00fe\5\u00c2b\2\u00fd") | |
| buf.write("\u00fb\3\2\2\2\u00fd\u00fc\3\2\2\2\u00fe\u0101\3\2\2\2") | |
| buf.write("\u00ff\u0100\7\f\2\2\u0100\u0102\5\u00c2b\2\u0101\u00ff") | |
| buf.write("\3\2\2\2\u0101\u0102\3\2\2\2\u0102\u0103\3\2\2\2\u0103") | |
| buf.write("\u0104\7\17\2\2\u0104\u0105\7\u0085\2\2\u0105\u0116\7") | |
| buf.write("\4\2\2\u0106\u0107\7\r\2\2\u0107\u0108\7\20\2\2\u0108") | |
| buf.write("\u010d\5\22\n\2\u0109\u010a\7\21\2\2\u010a\u010c\5\22") | |
| buf.write("\n\2\u010b\u0109\3\2\2\2\u010c\u010f\3\2\2\2\u010d\u010b") | |
| buf.write("\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u0110\3\2\2\2\u010f") | |
| buf.write("\u010d\3\2\2\2\u0110\u0111\7\22\2\2\u0111\u0112\7\17\2") | |
| buf.write("\2\u0112\u0113\7\u0085\2\2\u0113\u0114\7\4\2\2\u0114\u0116") | |
| buf.write("\3\2\2\2\u0115\u00f3\3\2\2\2\u0115\u00fa\3\2\2\2\u0115") | |
| buf.write("\u0106\3\2\2\2\u0116\25\3\2\2\2\u0117\u0119\7\u0087\2") | |
| buf.write("\2\u0118\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a\u0118") | |
| buf.write("\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u011e\3\2\2\2\u011c") | |
| buf.write("\u011e\7\u0088\2\2\u011d\u0118\3\2\2\2\u011d\u011c\3\2") | |
| buf.write("\2\2\u011e\27\3\2\2\2\u011f\u0121\5\26\f\2\u0120\u011f") | |
| buf.write("\3\2\2\2\u0120\u0121\3\2\2\2\u0121\u0123\3\2\2\2\u0122") | |
| buf.write("\u0124\7\23\2\2\u0123\u0122\3\2\2\2\u0123\u0124\3\2\2") | |
| buf.write("\2\u0124\u0125\3\2\2\2\u0125\u0126\t\3\2\2\u0126\u0130") | |
| buf.write("\5\u00c2b\2\u0127\u0128\7\27\2\2\u0128\u012d\5\32\16\2") | |
| buf.write("\u0129\u012a\7\21\2\2\u012a\u012c\5\32\16\2\u012b\u0129") | |
| buf.write("\3\2\2\2\u012c\u012f\3\2\2\2\u012d\u012b\3\2\2\2\u012d") | |
| buf.write("\u012e\3\2\2\2\u012e\u0131\3\2\2\2\u012f\u012d\3\2\2\2") | |
| buf.write("\u0130\u0127\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0132\3") | |
| buf.write("\2\2\2\u0132\u0136\7\20\2\2\u0133\u0135\5\36\20\2\u0134") | |
| buf.write("\u0133\3\2\2\2\u0135\u0138\3\2\2\2\u0136\u0134\3\2\2\2") | |
| buf.write("\u0136\u0137\3\2\2\2\u0137\u0139\3\2\2\2\u0138\u0136\3") | |
| buf.write("\2\2\2\u0139\u013a\7\22\2\2\u013a\31\3\2\2\2\u013b\u013d") | |
| buf.write("\5L\'\2\u013c\u013e\5\34\17\2\u013d\u013c\3\2\2\2\u013d") | |
| buf.write("\u013e\3\2\2\2\u013e\33\3\2\2\2\u013f\u0141\7\30\2\2\u0140") | |
| buf.write("\u0142\5\u008aF\2\u0141\u0140\3\2\2\2\u0141\u0142\3\2") | |
| buf.write("\2\2\u0142\u0147\3\2\2\2\u0143\u0144\7\21\2\2\u0144\u0146") | |
| buf.write("\5\u008aF\2\u0145\u0143\3\2\2\2\u0146\u0149\3\2\2\2\u0147") | |
| buf.write("\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2") | |
| buf.write("\u0149\u0147\3\2\2\2\u014a\u0160\7\31\2\2\u014b\u015b") | |
| buf.write("\7\32\2\2\u014c\u014d\5\u00c2b\2\u014d\u014e\7\33\2\2") | |
| buf.write("\u014e\u0156\5\u008aF\2\u014f\u0150\7\21\2\2\u0150\u0151") | |
| buf.write("\5\u00c2b\2\u0151\u0152\7\33\2\2\u0152\u0153\5\u008aF") | |
| buf.write("\2\u0153\u0155\3\2\2\2\u0154\u014f\3\2\2\2\u0155\u0158") | |
| buf.write("\3\2\2\2\u0156\u0154\3\2\2\2\u0156\u0157\3\2\2\2\u0157") | |
| buf.write("\u015a\3\2\2\2\u0158\u0156\3\2\2\2\u0159\u014c\3\2\2\2") | |
| buf.write("\u015a\u015d\3\2\2\2\u015b\u0159\3\2\2\2\u015b\u015c\3") | |
| buf.write("\2\2\2\u015c\u015e\3\2\2\2\u015d\u015b\3\2\2\2\u015e\u0160") | |
| buf.write("\7\34\2\2\u015f\u013f\3\2\2\2\u015f\u014b\3\2\2\2\u0160") | |
| buf.write("\35\3\2\2\2\u0161\u016a\5 \21\2\u0162\u016a\5\"\22\2\u0163") | |
| buf.write("\u016a\5$\23\2\u0164\u016a\5&\24\2\u0165\u016a\5(\25\2") | |
| buf.write("\u0166\u016a\5,\27\2\u0167\u016a\5\64\33\2\u0168\u016a") | |
| buf.write("\58\35\2\u0169\u0161\3\2\2\2\u0169\u0162\3\2\2\2\u0169") | |
| buf.write("\u0163\3\2\2\2\u0169\u0164\3\2\2\2\u0169\u0165\3\2\2\2") | |
| buf.write("\u0169\u0166\3\2\2\2\u0169\u0167\3\2\2\2\u0169\u0168\3") | |
| buf.write("\2\2\2\u016a\37\3\2\2\2\u016b\u016f\5J&\2\u016c\u016e") | |
| buf.write("\t\4\2\2\u016d\u016c\3\2\2\2\u016e\u0171\3\2\2\2\u016f") | |
| buf.write("\u016d\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u0172\3\2\2\2") | |
| buf.write("\u0171\u016f\3\2\2\2\u0172\u0175\5\u00c2b\2\u0173\u0174") | |
| buf.write("\7\13\2\2\u0174\u0176\5\u008aF\2\u0175\u0173\3\2\2\2\u0175") | |
| buf.write("\u0176\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u0178\7\4\2\2") | |
| buf.write("\u0178!\3\2\2\2\u0179\u017a\7\35\2\2\u017a\u017b\5\u00c2") | |
| buf.write("b\2\u017b\u017e\7\36\2\2\u017c\u017f\7\16\2\2\u017d\u017f") | |
| buf.write("\5J&\2\u017e\u017c\3\2\2\2\u017e\u017d\3\2\2\2\u017f\u0180") | |
| buf.write("\3\2\2\2\u0180\u0181\7\4\2\2\u0181#\3\2\2\2\u0182\u0183") | |
| buf.write("\7\37\2\2\u0183\u0184\5\u00c2b\2\u0184\u018f\7\20\2\2") | |
| buf.write("\u0185\u0186\5H%\2\u0186\u018c\7\4\2\2\u0187\u0188\5H") | |
| buf.write("%\2\u0188\u0189\7\4\2\2\u0189\u018b\3\2\2\2\u018a\u0187") | |
| buf.write("\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a\3\2\2\2\u018c") | |
| buf.write("\u018d\3\2\2\2\u018d\u0190\3\2\2\2\u018e\u018c\3\2\2\2") | |
| buf.write("\u018f\u0185\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u0191\3") | |
| buf.write("\2\2\2\u0191\u0192\7\22\2\2\u0192%\3\2\2\2\u0193\u0194") | |
| buf.write("\7 \2\2\u0194\u0195\5:\36\2\u0195\u0196\5\62\32\2\u0196") | |
| buf.write("\u0197\5X-\2\u0197\'\3\2\2\2\u0198\u0199\7!\2\2\u0199") | |
| buf.write("\u019b\5\u00c2b\2\u019a\u019c\5:\36\2\u019b\u019a\3\2") | |
| buf.write("\2\2\u019b\u019c\3\2\2\2\u019c\u019d\3\2\2\2\u019d\u019e") | |
| buf.write("\5X-\2\u019e)\3\2\2\2\u019f\u01a5\5\u00c2b\2\u01a0\u01a2") | |
| buf.write("\7\30\2\2\u01a1\u01a3\5\u008eH\2\u01a2\u01a1\3\2\2\2\u01a2") | |
| buf.write("\u01a3\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4\u01a6\7\31\2") | |
| buf.write("\2\u01a5\u01a0\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6+\3\2") | |
| buf.write("\2\2\u01a7\u01a9\5\26\f\2\u01a8\u01a7\3\2\2\2\u01a8\u01a9") | |
| buf.write("\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ac\t\5\2\2\u01ab") | |
| buf.write("\u01ad\5\u00c2b\2\u01ac\u01ab\3\2\2\2\u01ac\u01ad\3\2") | |
| buf.write("\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01af\5:\36\2\u01af\u01b1") | |
| buf.write("\5\62\32\2\u01b0\u01b2\5.\30\2\u01b1\u01b0\3\2\2\2\u01b1") | |
| buf.write("\u01b2\3\2\2\2\u01b2\u01b5\3\2\2\2\u01b3\u01b6\7\4\2\2") | |
| buf.write("\u01b4\u01b6\5X-\2\u01b5\u01b3\3\2\2\2\u01b5\u01b4\3\2") | |
| buf.write("\2\2\u01b6-\3\2\2\2\u01b7\u01b8\7%\2\2\u01b8\u01b9\5:") | |
| buf.write("\36\2\u01b9/\3\2\2\2\u01ba\u01bb\7w\2\2\u01bb\u01bc\5") | |
| buf.write(":\36\2\u01bc\61\3\2\2\2\u01bd\u01c7\5*\26\2\u01be\u01c7") | |
| buf.write("\5V,\2\u01bf\u01c7\7{\2\2\u01c0\u01c7\7\u0080\2\2\u01c1") | |
| buf.write("\u01c7\7}\2\2\u01c2\u01c7\7\177\2\2\u01c3\u01c7\7w\2\2") | |
| buf.write("\u01c4\u01c7\5\60\31\2\u01c5\u01c7\7y\2\2\u01c6\u01bd") | |
| buf.write("\3\2\2\2\u01c6\u01be\3\2\2\2\u01c6\u01bf\3\2\2\2\u01c6") | |
| buf.write("\u01c0\3\2\2\2\u01c6\u01c1\3\2\2\2\u01c6\u01c2\3\2\2\2") | |
| buf.write("\u01c6\u01c3\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c5\3") | |
| buf.write("\2\2\2\u01c7\u01ca\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c8\u01c9") | |
| buf.write("\3\2\2\2\u01c9\63\3\2\2\2\u01ca\u01c8\3\2\2\2\u01cb\u01cd") | |
| buf.write("\5\26\f\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd") | |
| buf.write("\u01ce\3\2\2\2\u01ce\u01cf\7&\2\2\u01cf\u01d0\5\u00c2") | |
| buf.write("b\2\u01d0\u01d2\5@!\2\u01d1\u01d3\7t\2\2\u01d2\u01d1\3") | |
| buf.write("\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01d5") | |
| buf.write("\7\4\2\2\u01d5\65\3\2\2\2\u01d6\u01d7\5\u00c2b\2\u01d7") | |
| buf.write("\67\3\2\2\2\u01d8\u01d9\7\'\2\2\u01d9\u01da\5\u00c2b\2") | |
| buf.write("\u01da\u01dc\7\20\2\2\u01db\u01dd\5\66\34\2\u01dc\u01db") | |
| buf.write("\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u01e2\3\2\2\2\u01de") | |
| buf.write("\u01df\7\21\2\2\u01df\u01e1\5\66\34\2\u01e0\u01de\3\2") | |
| buf.write("\2\2\u01e1\u01e4\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e2\u01e3") | |
| buf.write("\3\2\2\2\u01e3\u01e5\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e5") | |
| buf.write("\u01e6\7\22\2\2\u01e69\3\2\2\2\u01e7\u01f0\7\30\2\2\u01e8") | |
| buf.write("\u01ed\5> \2\u01e9\u01ea\7\21\2\2\u01ea\u01ec\5> \2\u01eb") | |
| buf.write("\u01e9\3\2\2\2\u01ec\u01ef\3\2\2\2\u01ed\u01eb\3\2\2\2") | |
| buf.write("\u01ed\u01ee\3\2\2\2\u01ee\u01f1\3\2\2\2\u01ef\u01ed\3") | |
| buf.write("\2\2\2\u01f0\u01e8\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1\u01f2") | |
| buf.write("\3\2\2\2\u01f2\u01f3\7\31\2\2\u01f3;\3\2\2\2\u01f4\u01fd") | |
| buf.write("\7\30\2\2\u01f5\u01fa\5> \2\u01f6\u01f7\7\21\2\2\u01f7") | |
| buf.write("\u01f9\5> \2\u01f8\u01f6\3\2\2\2\u01f9\u01fc\3\2\2\2\u01fa") | |
| buf.write("\u01f8\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fe\3\2\2\2") | |
| buf.write("\u01fc\u01fa\3\2\2\2\u01fd\u01f5\3\2\2\2\u01fd\u01fe\3") | |
| buf.write("\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0200\7\31\2\2\u0200") | |
| buf.write("=\3\2\2\2\u0201\u0203\5J&\2\u0202\u0204\5T+\2\u0203\u0202") | |
| buf.write("\3\2\2\2\u0203\u0204\3\2\2\2\u0204\u0206\3\2\2\2\u0205") | |
| buf.write("\u0207\5\u00c2b\2\u0206\u0205\3\2\2\2\u0206\u0207\3\2") | |
| buf.write("\2\2\u0207?\3\2\2\2\u0208\u0211\7\30\2\2\u0209\u020e\5") | |
| buf.write("B\"\2\u020a\u020b\7\21\2\2\u020b\u020d\5B\"\2\u020c\u020a") | |
| buf.write("\3\2\2\2\u020d\u0210\3\2\2\2\u020e\u020c\3\2\2\2\u020e") | |
| buf.write("\u020f\3\2\2\2\u020f\u0212\3\2\2\2\u0210\u020e\3\2\2\2") | |
| buf.write("\u0211\u0209\3\2\2\2\u0211\u0212\3\2\2\2\u0212\u0213\3") | |
| buf.write("\2\2\2\u0213\u0214\7\31\2\2\u0214A\3\2\2\2\u0215\u0217") | |
| buf.write("\5J&\2\u0216\u0218\7|\2\2\u0217\u0216\3\2\2\2\u0217\u0218") | |
| buf.write("\3\2\2\2\u0218\u021a\3\2\2\2\u0219\u021b\5\u00c2b\2\u021a") | |
| buf.write("\u0219\3\2\2\2\u021a\u021b\3\2\2\2\u021bC\3\2\2\2\u021c") | |
| buf.write("\u0225\7\30\2\2\u021d\u0222\5F$\2\u021e\u021f\7\21\2\2") | |
| buf.write("\u021f\u0221\5F$\2\u0220\u021e\3\2\2\2\u0221\u0224\3\2") | |
| buf.write("\2\2\u0222\u0220\3\2\2\2\u0222\u0223\3\2\2\2\u0223\u0226") | |
| buf.write("\3\2\2\2\u0224\u0222\3\2\2\2\u0225\u021d\3\2\2\2\u0225") | |
| buf.write("\u0226\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0228\7\31\2") | |
| buf.write("\2\u0228E\3\2\2\2\u0229\u022b\5J&\2\u022a\u022c\5T+\2") | |
| buf.write("\u022b\u022a\3\2\2\2\u022b\u022c\3\2\2\2\u022cG\3\2\2") | |
| buf.write("\2\u022d\u022f\5J&\2\u022e\u0230\5T+\2\u022f\u022e\3\2") | |
| buf.write("\2\2\u022f\u0230\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0232") | |
| buf.write("\5\u00c2b\2\u0232I\3\2\2\2\u0233\u0234\b&\1\2\u0234\u023b") | |
| buf.write("\5\u0088E\2\u0235\u023b\5L\'\2\u0236\u023b\5N(\2\u0237") | |
| buf.write("\u023b\5P)\2\u0238\u0239\7*\2\2\u0239\u023b\7~\2\2\u023a") | |
| buf.write("\u0233\3\2\2\2\u023a\u0235\3\2\2\2\u023a\u0236\3\2\2\2") | |
| buf.write("\u023a\u0237\3\2\2\2\u023a\u0238\3\2\2\2\u023b\u0244\3") | |
| buf.write("\2\2\2\u023c\u023d\f\5\2\2\u023d\u023f\7(\2\2\u023e\u0240") | |
| buf.write("\5\u008aF\2\u023f\u023e\3\2\2\2\u023f\u0240\3\2\2\2\u0240") | |
| buf.write("\u0241\3\2\2\2\u0241\u0243\7)\2\2\u0242\u023c\3\2\2\2") | |
| buf.write("\u0243\u0246\3\2\2\2\u0244\u0242\3\2\2\2\u0244\u0245\3") | |
| buf.write("\2\2\2\u0245K\3\2\2\2\u0246\u0244\3\2\2\2\u0247\u024c") | |
| buf.write("\5\u00c2b\2\u0248\u0249\7+\2\2\u0249\u024b\5\u00c2b\2") | |
| buf.write("\u024a\u0248\3\2\2\2\u024b\u024e\3\2\2\2\u024c\u024a\3") | |
| buf.write("\2\2\2\u024c\u024d\3\2\2\2\u024dM\3\2\2\2\u024e\u024c") | |
| buf.write("\3\2\2\2\u024f\u0250\7,\2\2\u0250\u0253\7\30\2\2\u0251") | |
| buf.write("\u0254\5\u0088E\2\u0252\u0254\5L\'\2\u0253\u0251\3\2\2") | |
| buf.write("\2\u0253\u0252\3\2\2\2\u0254\u0255\3\2\2\2\u0255\u0256") | |
| buf.write("\7-\2\2\u0256\u0257\5J&\2\u0257\u0258\7\31\2\2\u0258O") | |
| buf.write("\3\2\2\2\u0259\u025a\7\"\2\2\u025a\u0260\5D#\2\u025b\u025f") | |
| buf.write("\7}\2\2\u025c\u025f\7{\2\2\u025d\u025f\5V,\2\u025e\u025b") | |
| buf.write("\3\2\2\2\u025e\u025c\3\2\2\2\u025e\u025d\3\2\2\2\u025f") | |
| buf.write("\u0262\3\2\2\2\u0260\u025e\3\2\2\2\u0260\u0261\3\2\2\2") | |
| buf.write("\u0261\u0265\3\2\2\2\u0262\u0260\3\2\2\2\u0263\u0264\7") | |
| buf.write("%\2\2\u0264\u0266\5D#\2\u0265\u0263\3\2\2\2\u0265\u0266") | |
| buf.write("\3\2\2\2\u0266\u027a\3\2\2\2\u0267\u0268\7\"\2\2\u0268") | |
| buf.write("\u026a\7\30\2\2\u0269\u026b\5:\36\2\u026a\u0269\3\2\2") | |
| buf.write("\2\u026a\u026b\3\2\2\2\u026b\u026c\3\2\2\2\u026c\u0271") | |
| buf.write("\7\31\2\2\u026d\u0270\5R*\2\u026e\u0270\5V,\2\u026f\u026d") | |
| buf.write("\3\2\2\2\u026f\u026e\3\2\2\2\u0270\u0273\3\2\2\2\u0271") | |
| buf.write("\u026f\3\2\2\2\u0271\u0272\3\2\2\2\u0272\u0274\3\2\2\2") | |
| buf.write("\u0273\u0271\3\2\2\2\u0274\u0275\7%\2\2\u0275\u0276\7") | |
| buf.write("\30\2\2\u0276\u0277\5:\36\2\u0277\u0278\7\31\2\2\u0278") | |
| buf.write("\u027a\3\2\2\2\u0279\u0259\3\2\2\2\u0279\u0267\3\2\2\2") | |
| buf.write("\u027aQ\3\2\2\2\u027b\u027c\t\6\2\2\u027cS\3\2\2\2\u027d") | |
| buf.write("\u027e\t\7\2\2\u027eU\3\2\2\2\u027f\u0280\t\b\2\2\u0280") | |
| buf.write("W\3\2\2\2\u0281\u0286\7\20\2\2\u0282\u0285\5\\/\2\u0283") | |
| buf.write("\u0285\5Z.\2\u0284\u0282\3\2\2\2\u0284\u0283\3\2\2\2\u0285") | |
| buf.write("\u0288\3\2\2\2\u0286\u0284\3\2\2\2\u0286\u0287\3\2\2\2") | |
| buf.write("\u0287\u0289\3\2\2\2\u0288\u0286\3\2\2\2\u0289\u028a\7") | |
| buf.write("\22\2\2\u028aY\3\2\2\2\u028b\u028c\7\61\2\2\u028c\u028d") | |
| buf.write("\5X-\2\u028d[\3\2\2\2\u028e\u029f\5d\63\2\u028f\u029f") | |
| buf.write("\5l\67\2\u0290\u029f\5p9\2\u0291\u029f\5X-\2\u0292\u029f") | |
| buf.write("\5r:\2\u0293\u029f\5t;\2\u0294\u029f\5v<\2\u0295\u029f") | |
| buf.write("\5x=\2\u0296\u029f\5z>\2\u0297\u029f\5|?\2\u0298\u029f") | |
| buf.write("\5~@\2\u0299\u029f\5n8\2\u029a\u029f\5^\60\2\u029b\u029f") | |
| buf.write("\5`\61\2\u029c\u029f\7\u0089\2\2\u029d\u029f\7\u008a\2") | |
| buf.write("\2\u029e\u028e\3\2\2\2\u029e\u028f\3\2\2\2\u029e\u0290") | |
| buf.write("\3\2\2\2\u029e\u0291\3\2\2\2\u029e\u0292\3\2\2\2\u029e") | |
| buf.write("\u0293\3\2\2\2\u029e\u0294\3\2\2\2\u029e\u0295\3\2\2\2") | |
| buf.write("\u029e\u0296\3\2\2\2\u029e\u0297\3\2\2\2\u029e\u0298\3") | |
| buf.write("\2\2\2\u029e\u0299\3\2\2\2\u029e\u029a\3\2\2\2\u029e\u029b") | |
| buf.write("\3\2\2\2\u029e\u029c\3\2\2\2\u029e\u029d\3\2\2\2\u029f") | |
| buf.write("]\3\2\2\2\u02a0\u02a1\7\62\2\2\u02a1\u02a7\5\u008aF\2") | |
| buf.write("\u02a2\u02a3\7%\2\2\u02a3\u02a4\7\30\2\2\u02a4\u02a5\5") | |
| buf.write(":\36\2\u02a5\u02a6\7\31\2\2\u02a6\u02a8\3\2\2\2\u02a7") | |
| buf.write("\u02a2\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\u02a9\3\2\2\2") | |
| buf.write("\u02a9\u02ad\5X-\2\u02aa\u02ac\5`\61\2\u02ab\u02aa\3\2") | |
| buf.write("\2\2\u02ac\u02af\3\2\2\2\u02ad\u02ab\3\2\2\2\u02ad\u02ae") | |
| buf.write("\3\2\2\2\u02ae_\3\2\2\2\u02af\u02ad\3\2\2\2\u02b0\u02bb") | |
| buf.write("\7\63\2\2\u02b1\u02b3\5\u00c2b\2\u02b2\u02b1\3\2\2\2\u02b2") | |
| buf.write("\u02b3\3\2\2\2\u02b3\u02b4\3\2\2\2\u02b4\u02b5\7\30\2") | |
| buf.write("\2\u02b5\u02b7\5:\36\2\u02b6\u02b8\5\26\f\2\u02b7\u02b6") | |
| buf.write("\3\2\2\2\u02b7\u02b8\3\2\2\2\u02b8\u02b9\3\2\2\2\u02b9") | |
| buf.write("\u02ba\7\31\2\2\u02ba\u02bc\3\2\2\2\u02bb\u02b2\3\2\2") | |
| buf.write("\2\u02bb\u02bc\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd\u02c1") | |
| buf.write("\5X-\2\u02be\u02bf\7\63\2\2\u02bf\u02c1\5X-\2\u02c0\u02b0") | |
| buf.write("\3\2\2\2\u02c0\u02be\3\2\2\2\u02c1a\3\2\2\2\u02c2\u02c3") | |
| buf.write("\5\u008aF\2\u02c3\u02c4\7\4\2\2\u02c4c\3\2\2\2\u02c5\u02c6") | |
| buf.write("\7\64\2\2\u02c6\u02c7\7\30\2\2\u02c7\u02c8\5f\64\2\u02c8") | |
| buf.write("\u02c9\7\31\2\2\u02c9\u02cc\5h\65\2\u02ca\u02cb\7\65\2") | |
| buf.write("\2\u02cb\u02cd\5j\66\2\u02cc\u02ca\3\2\2\2\u02cc\u02cd") | |
| buf.write("\3\2\2\2\u02cde\3\2\2\2\u02ce\u02cf\5\u008aF\2\u02cfg") | |
| buf.write("\3\2\2\2\u02d0\u02d1\5\\/\2\u02d1i\3\2\2\2\u02d2\u02d3") | |
| buf.write("\5\\/\2\u02d3k\3\2\2\2\u02d4\u02d5\7\66\2\2\u02d5\u02d6") | |
| buf.write("\7\30\2\2\u02d6\u02d7\5\u008aF\2\u02d7\u02d8\7\31\2\2") | |
| buf.write("\u02d8\u02d9\5\\/\2\u02d9m\3\2\2\2\u02da\u02dd\5\u0080") | |
| buf.write("A\2\u02db\u02dd\5b\62\2\u02dc\u02da\3\2\2\2\u02dc\u02db") | |
| buf.write("\3\2\2\2\u02ddo\3\2\2\2\u02de\u02df\7\36\2\2\u02df\u02e2") | |
| buf.write("\7\30\2\2\u02e0\u02e3\5n8\2\u02e1\u02e3\7\4\2\2\u02e2") | |
| buf.write("\u02e0\3\2\2\2\u02e2\u02e1\3\2\2\2\u02e3\u02e6\3\2\2\2") | |
| buf.write("\u02e4\u02e7\5b\62\2\u02e5\u02e7\7\4\2\2\u02e6\u02e4\3") | |
| buf.write("\2\2\2\u02e6\u02e5\3\2\2\2\u02e7\u02e9\3\2\2\2\u02e8\u02ea") | |
| buf.write("\5\u008aF\2\u02e9\u02e8\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea") | |
| buf.write("\u02eb\3\2\2\2\u02eb\u02ec\7\31\2\2\u02ec\u02ed\5\\/\2") | |
| buf.write("\u02edq\3\2\2\2\u02ee\u02f0\7\67\2\2\u02ef\u02f1\7\u0085") | |
| buf.write("\2\2\u02f0\u02ef\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1\u02f2") | |
| buf.write("\3\2\2\2\u02f2\u02f3\5\u0098M\2\u02f3s\3\2\2\2\u02f4\u02f5") | |
| buf.write("\78\2\2\u02f5\u02f6\5\\/\2\u02f6\u02f7\7\66\2\2\u02f7") | |
| buf.write("\u02f8\7\30\2\2\u02f8\u02f9\5\u008aF\2\u02f9\u02fa\7\31") | |
| buf.write("\2\2\u02fa\u02fb\7\4\2\2\u02fbu\3\2\2\2\u02fc\u02fd\7") | |
| buf.write("z\2\2\u02fd\u02fe\7\4\2\2\u02few\3\2\2\2\u02ff\u0300\7") | |
| buf.write("u\2\2\u0300\u0301\7\4\2\2\u0301y\3\2\2\2\u0302\u0304\7") | |
| buf.write("9\2\2\u0303\u0305\5\u008aF\2\u0304\u0303\3\2\2\2\u0304") | |
| buf.write("\u0305\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u0307\7\4\2\2") | |
| buf.write("\u0307{\3\2\2\2\u0308\u0309\7:\2\2\u0309\u030a\7\4\2\2") | |
| buf.write("\u030a}\3\2\2\2\u030b\u030c\7;\2\2\u030c\u030d\5\u0096") | |
| buf.write("L\2\u030d\u030e\7\4\2\2\u030e\177\3\2\2\2\u030f\u0310") | |
| buf.write("\7<\2\2\u0310\u0317\5\u0086D\2\u0311\u0317\5H%\2\u0312") | |
| buf.write("\u0313\7\30\2\2\u0313\u0314\5\u0084C\2\u0314\u0315\7\31") | |
| buf.write("\2\2\u0315\u0317\3\2\2\2\u0316\u030f\3\2\2\2\u0316\u0311") | |
| buf.write("\3\2\2\2\u0316\u0312\3\2\2\2\u0317\u031a\3\2\2\2\u0318") | |
| buf.write("\u0319\7\13\2\2\u0319\u031b\5\u008aF\2\u031a\u0318\3\2") | |
| buf.write("\2\2\u031a\u031b\3\2\2\2\u031b\u031c\3\2\2\2\u031c\u031d") | |
| buf.write("\7\4\2\2\u031d\u0081\3\2\2\2\u031e\u031f\5J&\2\u031f\u0320") | |
| buf.write("\7v\2\2\u0320\u0321\5\u00c2b\2\u0321\u0322\7\13\2\2\u0322") | |
| buf.write("\u0323\5\u008aF\2\u0323\u0324\7\4\2\2\u0324\u0083\3\2") | |
| buf.write("\2\2\u0325\u0327\5H%\2\u0326\u0325\3\2\2\2\u0326\u0327") | |
| buf.write("\3\2\2\2\u0327\u032e\3\2\2\2\u0328\u032a\7\21\2\2\u0329") | |
| buf.write("\u032b\5H%\2\u032a\u0329\3\2\2\2\u032a\u032b\3\2\2\2\u032b") | |
| buf.write("\u032d\3\2\2\2\u032c\u0328\3\2\2\2\u032d\u0330\3\2\2\2") | |
| buf.write("\u032e\u032c\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0085\3") | |
| buf.write("\2\2\2\u0330\u032e\3\2\2\2\u0331\u0338\7\30\2\2\u0332") | |
| buf.write("\u0334\5\u00c2b\2\u0333\u0332\3\2\2\2\u0333\u0334\3\2") | |
| buf.write("\2\2\u0334\u0335\3\2\2\2\u0335\u0337\7\21\2\2\u0336\u0333") | |
| buf.write("\3\2\2\2\u0337\u033a\3\2\2\2\u0338\u0336\3\2\2\2\u0338") | |
| buf.write("\u0339\3\2\2\2\u0339\u033c\3\2\2\2\u033a\u0338\3\2\2\2") | |
| buf.write("\u033b\u033d\5\u00c2b\2\u033c\u033b\3\2\2\2\u033c\u033d") | |
| buf.write("\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u033f\7\31\2\2\u033f") | |
| buf.write("\u0087\3\2\2\2\u0340\u0341\t\t\2\2\u0341\u0089\3\2\2\2") | |
| buf.write("\u0342\u0343\bF\1\2\u0343\u0344\7(\2\2\u0344\u0349\5\u008a") | |
| buf.write("F\2\u0345\u0346\7\21\2\2\u0346\u0348\5\u008aF\2\u0347") | |
| buf.write("\u0345\3\2\2\2\u0348\u034b\3\2\2\2\u0349\u0347\3\2\2\2") | |
| buf.write("\u0349\u034a\3\2\2\2\u034a\u034c\3\2\2\2\u034b\u0349\3") | |
| buf.write("\2\2\2\u034c\u034d\7)\2\2\u034d\u0367\3\2\2\2\u034e\u034f") | |
| buf.write("\7~\2\2\u034f\u0367\5\34\17\2\u0350\u0351\7\u0082\2\2") | |
| buf.write("\u0351\u0352\7\30\2\2\u0352\u0353\5J&\2\u0353\u0354\7") | |
| buf.write("\31\2\2\u0354\u0367\3\2\2\2\u0355\u0356\t\n\2\2\u0356") | |
| buf.write("\u0367\5\u008aF\31\u0357\u0358\7E\2\2\u0358\u0367\5J&") | |
| buf.write("\2\u0359\u035a\7\30\2\2\u035a\u035b\5\u008aF\2\u035b\u035c") | |
| buf.write("\7\31\2\2\u035c\u0367\3\2\2\2\u035d\u035e\t\13\2\2\u035e") | |
| buf.write("\u0367\5\u008aF\24\u035f\u0360\t\f\2\2\u0360\u0367\5\u008a") | |
| buf.write("F\23\u0361\u0362\7B\2\2\u0362\u0367\5\u008aF\22\u0363") | |
| buf.write("\u0364\7\6\2\2\u0364\u0367\5\u008aF\21\u0365\u0367\5\u008c") | |
| buf.write("G\2\u0366\u0342\3\2\2\2\u0366\u034e\3\2\2\2\u0366\u0350") | |
| buf.write("\3\2\2\2\u0366\u0355\3\2\2\2\u0366\u0357\3\2\2\2\u0366") | |
| buf.write("\u0359\3\2\2\2\u0366\u035d\3\2\2\2\u0366\u035f\3\2\2\2") | |
| buf.write("\u0366\u0361\3\2\2\2\u0366\u0363\3\2\2\2\u0366\u0365\3") | |
| buf.write("\2\2\2\u0367\u03c3\3\2\2\2\u0368\u0369\f\20\2\2\u0369") | |
| buf.write("\u036a\7H\2\2\u036a\u03c2\5\u008aF\21\u036b\u036c\f\17") | |
| buf.write("\2\2\u036c\u036d\t\r\2\2\u036d\u03c2\5\u008aF\20\u036e") | |
| buf.write("\u036f\f\16\2\2\u036f\u0370\t\13\2\2\u0370\u03c2\5\u008a") | |
| buf.write("F\17\u0371\u0372\f\r\2\2\u0372\u0373\t\16\2\2\u0373\u03c2") | |
| buf.write("\5\u008aF\16\u0374\u0375\f\f\2\2\u0375\u0376\7N\2\2\u0376") | |
| buf.write("\u03c2\5\u008aF\r\u0377\u0378\f\13\2\2\u0378\u0379\7\5") | |
| buf.write("\2\2\u0379\u03c2\5\u008aF\f\u037a\u037b\f\n\2\2\u037b") | |
| buf.write("\u037c\7O\2\2\u037c\u03c2\5\u008aF\13\u037d\u037e\f\t") | |
| buf.write("\2\2\u037e\u037f\t\17\2\2\u037f\u03c2\5\u008aF\n\u0380") | |
| buf.write("\u0381\f\b\2\2\u0381\u0382\t\20\2\2\u0382\u03c2\5\u008a") | |
| buf.write("F\t\u0383\u0384\f\7\2\2\u0384\u0385\7R\2\2\u0385\u03c2") | |
| buf.write("\5\u008aF\b\u0386\u0387\f\6\2\2\u0387\u0388\7S\2\2\u0388") | |
| buf.write("\u03c2\5\u008aF\7\u0389\u038a\f\5\2\2\u038a\u038b\7T\2") | |
| buf.write("\2\u038b\u038c\5\u008aF\2\u038c\u038d\7\33\2\2\u038d\u038e") | |
| buf.write("\5\u008aF\6\u038e\u03c2\3\2\2\2\u038f\u0390\f\4\2\2\u0390") | |
| buf.write("\u0391\t\21\2\2\u0391\u03c2\5\u008aF\5\u0392\u0393\f ") | |
| buf.write("\2\2\u0393\u0395\7(\2\2\u0394\u0396\5\u008aF\2\u0395\u0394") | |
| buf.write("\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u0397\3\2\2\2\u0397") | |
| buf.write("\u03c2\7)\2\2\u0398\u0399\f\36\2\2\u0399\u039b\7(\2\2") | |
| buf.write("\u039a\u039c\5\u008aF\2\u039b\u039a\3\2\2\2\u039b\u039c") | |
| buf.write("\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u039f\7\33\2\2\u039e") | |
| buf.write("\u03a0\5\u008aF\2\u039f\u039e\3\2\2\2\u039f\u03a0\3\2") | |
| buf.write("\2\2\u03a0\u03a1\3\2\2\2\u03a1\u03c2\7)\2\2\u03a2\u03a3") | |
| buf.write("\f\35\2\2\u03a3\u03a6\7+\2\2\u03a4\u03a7\5\u00c2b\2\u03a5") | |
| buf.write("\u03a7\7*\2\2\u03a6\u03a4\3\2\2\2\u03a6\u03a5\3\2\2\2") | |
| buf.write("\u03a7\u03c2\3\2\2\2\u03a8\u03a9\f\34\2\2\u03a9\u03b7") | |
| buf.write("\7\20\2\2\u03aa\u03ab\5\u00c2b\2\u03ab\u03ac\7\33\2\2") | |
| buf.write("\u03ac\u03b4\5\u008aF\2\u03ad\u03ae\7\21\2\2\u03ae\u03af") | |
| buf.write("\5\u00c2b\2\u03af\u03b0\7\33\2\2\u03b0\u03b1\5\u008aF") | |
| buf.write("\2\u03b1\u03b3\3\2\2\2\u03b2\u03ad\3\2\2\2\u03b3\u03b6") | |
| buf.write("\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2\2\2\u03b5") | |
| buf.write("\u03b8\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03aa\3\2\2\2") | |
| buf.write("\u03b7\u03b8\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03c2\7") | |
| buf.write("\22\2\2\u03ba\u03bb\f\30\2\2\u03bb\u03c2\t\22\2\2\u03bc") | |
| buf.write("\u03bd\f\26\2\2\u03bd\u03be\7\30\2\2\u03be\u03bf\5\u0094") | |
| buf.write("K\2\u03bf\u03c0\7\31\2\2\u03c0\u03c2\3\2\2\2\u03c1\u0368") | |
| buf.write("\3\2\2\2\u03c1\u036b\3\2\2\2\u03c1\u036e\3\2\2\2\u03c1") | |
| buf.write("\u0371\3\2\2\2\u03c1\u0374\3\2\2\2\u03c1\u0377\3\2\2\2") | |
| buf.write("\u03c1\u037a\3\2\2\2\u03c1\u037d\3\2\2\2\u03c1\u0380\3") | |
| buf.write("\2\2\2\u03c1\u0383\3\2\2\2\u03c1\u0386\3\2\2\2\u03c1\u0389") | |
| buf.write("\3\2\2\2\u03c1\u038f\3\2\2\2\u03c1\u0392\3\2\2\2\u03c1") | |
| buf.write("\u0398\3\2\2\2\u03c1\u03a2\3\2\2\2\u03c1\u03a8\3\2\2\2") | |
| buf.write("\u03c1\u03ba\3\2\2\2\u03c1\u03bc\3\2\2\2\u03c2\u03c5\3") | |
| buf.write("\2\2\2\u03c3\u03c1\3\2\2\2\u03c3\u03c4\3\2\2\2\u03c4\u008b") | |
| buf.write("\3\2\2\2\u03c5\u03c3\3\2\2\2\u03c6\u03d7\7n\2\2\u03c7") | |
| buf.write("\u03d7\5\u00c0a\2\u03c8\u03d7\7r\2\2\u03c9\u03d7\7\u0085") | |
| buf.write("\2\2\u03ca\u03cd\5\u00c2b\2\u03cb\u03cc\7(\2\2\u03cc\u03ce") | |
| buf.write("\7)\2\2\u03cd\u03cb\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce") | |
| buf.write("\u03d7\3\2\2\2\u03cf\u03d7\7\u0082\2\2\u03d0\u03d7\5\u00bc") | |
| buf.write("_\2\u03d1\u03d4\5\u00be`\2\u03d2\u03d3\7(\2\2\u03d3\u03d5") | |
| buf.write("\7)\2\2\u03d4\u03d2\3\2\2\2\u03d4\u03d5\3\2\2\2\u03d5") | |
| buf.write("\u03d7\3\2\2\2\u03d6\u03c6\3\2\2\2\u03d6\u03c7\3\2\2\2") | |
| buf.write("\u03d6\u03c8\3\2\2\2\u03d6\u03c9\3\2\2\2\u03d6\u03ca\3") | |
| buf.write("\2\2\2\u03d6\u03cf\3\2\2\2\u03d6\u03d0\3\2\2\2\u03d6\u03d1") | |
| buf.write("\3\2\2\2\u03d7\u008d\3\2\2\2\u03d8\u03dd\5\u008aF\2\u03d9") | |
| buf.write("\u03da\7\21\2\2\u03da\u03dc\5\u008aF\2\u03db\u03d9\3\2") | |
| buf.write("\2\2\u03dc\u03df\3\2\2\2\u03dd\u03db\3\2\2\2\u03dd\u03de") | |
| buf.write("\3\2\2\2\u03de\u008f\3\2\2\2\u03df\u03dd\3\2\2\2\u03e0") | |
| buf.write("\u03e5\5\u0092J\2\u03e1\u03e2\7\21\2\2\u03e2\u03e4\5\u0092") | |
| buf.write("J\2\u03e3\u03e1\3\2\2\2\u03e4\u03e7\3\2\2\2\u03e5\u03e3") | |
| buf.write("\3\2\2\2\u03e5\u03e6\3\2\2\2\u03e6\u03e9\3\2\2\2\u03e7") | |
| buf.write("\u03e5\3\2\2\2\u03e8\u03ea\7\21\2\2\u03e9\u03e8\3\2\2") | |
| buf.write("\2\u03e9\u03ea\3\2\2\2\u03ea\u0091\3\2\2\2\u03eb\u03ec") | |
| buf.write("\5\u00c2b\2\u03ec\u03ed\7\33\2\2\u03ed\u03ee\5\u008aF") | |
| buf.write("\2\u03ee\u0093\3\2\2\2\u03ef\u03f1\7\20\2\2\u03f0\u03f2") | |
| buf.write("\5\u0090I\2\u03f1\u03f0\3\2\2\2\u03f1\u03f2\3\2\2\2\u03f2") | |
| buf.write("\u03f3\3\2\2\2\u03f3\u03f8\7\22\2\2\u03f4\u03f6\5\u008e") | |
| buf.write("H\2\u03f5\u03f4\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6\u03f8") | |
| buf.write("\3\2\2\2\u03f7\u03ef\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f8") | |
| buf.write("\u0095\3\2\2\2\u03f9\u03fa\5\u008aF\2\u03fa\u03fb\7\30") | |
| buf.write("\2\2\u03fb\u03fc\5\u0094K\2\u03fc\u03fd\7\31\2\2\u03fd") | |
| buf.write("\u0097\3\2\2\2\u03fe\u0402\7\20\2\2\u03ff\u0401\5\u009a") | |
| buf.write("N\2\u0400\u03ff\3\2\2\2\u0401\u0404\3\2\2\2\u0402\u0400") | |
| buf.write("\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0405\3\2\2\2\u0404") | |
| buf.write("\u0402\3\2\2\2\u0405\u0406\7\22\2\2\u0406\u0099\3\2\2") | |
| buf.write("\2\u0407\u0419\5\u00c2b\2\u0408\u0419\5\u0098M\2\u0409") | |
| buf.write("\u0419\5\u009cO\2\u040a\u0419\5\u00a0Q\2\u040b\u0419\5") | |
| buf.write("\u00a2R\2\u040c\u0419\5\u00a8U\2\u040d\u0419\5\u00aaV") | |
| buf.write("\2\u040e\u0419\5\u00acW\2\u040f\u0419\5\u00b0Y\2\u0410") | |
| buf.write("\u0419\5\u00b4[\2\u0411\u0419\5\u00b6\\\2\u0412\u0419") | |
| buf.write("\7u\2\2\u0413\u0419\7z\2\2\u0414\u0419\5\u00ba^\2\u0415") | |
| buf.write("\u0419\5\u00c0a\2\u0416\u0419\7\u0085\2\2\u0417\u0419") | |
| buf.write("\7r\2\2\u0418\u0407\3\2\2\2\u0418\u0408\3\2\2\2\u0418") | |
| buf.write("\u0409\3\2\2\2\u0418\u040a\3\2\2\2\u0418\u040b\3\2\2\2") | |
| buf.write("\u0418\u040c\3\2\2\2\u0418\u040d\3\2\2\2\u0418\u040e\3") | |
| buf.write("\2\2\2\u0418\u040f\3\2\2\2\u0418\u0410\3\2\2\2\u0418\u0411") | |
| buf.write("\3\2\2\2\u0418\u0412\3\2\2\2\u0418\u0413\3\2\2\2\u0418") | |
| buf.write("\u0414\3\2\2\2\u0418\u0415\3\2\2\2\u0418\u0416\3\2\2\2") | |
| buf.write("\u0418\u0417\3\2\2\2\u0419\u009b\3\2\2\2\u041a\u041d\5") | |
| buf.write("\u009eP\2\u041b\u041d\5\u00b8]\2\u041c\u041a\3\2\2\2\u041c") | |
| buf.write("\u041b\3\2\2\2\u041d\u009d\3\2\2\2\u041e\u0423\79\2\2") | |
| buf.write("\u041f\u0423\7*\2\2\u0420\u0423\7?\2\2\u0421\u0423\5\u00c2") | |
| buf.write("b\2\u0422\u041e\3\2\2\2\u0422\u041f\3\2\2\2\u0422\u0420") | |
| buf.write("\3\2\2\2\u0422\u0421\3\2\2\2\u0423\u0430\3\2\2\2\u0424") | |
| buf.write("\u0426\7\30\2\2\u0425\u0427\5\u009cO\2\u0426\u0425\3\2") | |
| buf.write("\2\2\u0426\u0427\3\2\2\2\u0427\u042c\3\2\2\2\u0428\u0429") | |
| buf.write("\7\21\2\2\u0429\u042b\5\u009cO\2\u042a\u0428\3\2\2\2\u042b") | |
| buf.write("\u042e\3\2\2\2\u042c\u042a\3\2\2\2\u042c\u042d\3\2\2\2") | |
| buf.write("\u042d\u042f\3\2\2\2\u042e\u042c\3\2\2\2\u042f\u0431\7") | |
| buf.write("\31\2\2\u0430\u0424\3\2\2\2\u0430\u0431\3\2\2\2\u0431") | |
| buf.write("\u009f\3\2\2\2\u0432\u0433\7`\2\2\u0433\u0436\5\u00a4") | |
| buf.write("S\2\u0434\u0435\7a\2\2\u0435\u0437\5\u009cO\2\u0436\u0434") | |
| buf.write("\3\2\2\2\u0436\u0437\3\2\2\2\u0437\u00a1\3\2\2\2\u0438") | |
| buf.write("\u0439\5\u00a4S\2\u0439\u043a\7a\2\2\u043a\u043b\5\u009c") | |
| buf.write("O\2\u043b\u00a3\3\2\2\2\u043c\u0442\5\u00c2b\2\u043d\u043e") | |
| buf.write("\7\30\2\2\u043e\u043f\5\u00a6T\2\u043f\u0440\7\31\2\2") | |
| buf.write("\u0440\u0442\3\2\2\2\u0441\u043c\3\2\2\2\u0441\u043d\3") | |
| buf.write("\2\2\2\u0442\u00a5\3\2\2\2\u0443\u0448\5\u00c2b\2\u0444") | |
| buf.write("\u0445\7\21\2\2\u0445\u0447\5\u00c2b\2\u0446\u0444\3\2") | |
| buf.write("\2\2\u0447\u044a\3\2\2\2\u0448\u0446\3\2\2\2\u0448\u0449") | |
| buf.write("\3\2\2\2\u0449\u00a7\3\2\2\2\u044a\u0448\3\2\2\2\u044b") | |
| buf.write("\u044c\7b\2\2\u044c\u044d\5\u00c2b\2\u044d\u00a9\3\2\2") | |
| buf.write("\2\u044e\u044f\5\u00c2b\2\u044f\u0450\7\33\2\2\u0450\u00ab") | |
| buf.write("\3\2\2\2\u0451\u0452\7c\2\2\u0452\u0456\5\u009cO\2\u0453") | |
| buf.write("\u0455\5\u00aeX\2\u0454\u0453\3\2\2\2\u0455\u0458\3\2") | |
| buf.write("\2\2\u0456\u0454\3\2\2\2\u0456\u0457\3\2\2\2\u0457\u00ad") | |
| buf.write("\3\2\2\2\u0458\u0456\3\2\2\2\u0459\u045a\7d\2\2\u045a") | |
| buf.write("\u045b\5\u00b8]\2\u045b\u045c\5\u0098M\2\u045c\u0460\3") | |
| buf.write("\2\2\2\u045d\u045e\7e\2\2\u045e\u0460\5\u0098M\2\u045f") | |
| buf.write("\u0459\3\2\2\2\u045f\u045d\3\2\2\2\u0460\u00af\3\2\2\2") | |
| buf.write("\u0461\u0462\7\"\2\2\u0462\u0463\5\u00c2b\2\u0463\u0465") | |
| buf.write("\7\30\2\2\u0464\u0466\5\u00a6T\2\u0465\u0464\3\2\2\2\u0465") | |
| buf.write("\u0466\3\2\2\2\u0466\u0467\3\2\2\2\u0467\u0469\7\31\2") | |
| buf.write("\2\u0468\u046a\5\u00b2Z\2\u0469\u0468\3\2\2\2\u0469\u046a") | |
| buf.write("\3\2\2\2\u046a\u046b\3\2\2\2\u046b\u046c\5\u0098M\2\u046c") | |
| buf.write("\u00b1\3\2\2\2\u046d\u046e\7f\2\2\u046e\u046f\5\u00a6") | |
| buf.write("T\2\u046f\u00b3\3\2\2\2\u0470\u0473\7\36\2\2\u0471\u0474") | |
| buf.write("\5\u0098M\2\u0472\u0474\5\u009cO\2\u0473\u0471\3\2\2\2") | |
| buf.write("\u0473\u0472\3\2\2\2\u0474\u0475\3\2\2\2\u0475\u0478\5") | |
| buf.write("\u009cO\2\u0476\u0479\5\u0098M\2\u0477\u0479\5\u009cO") | |
| buf.write("\2\u0478\u0476\3\2\2\2\u0478\u0477\3\2\2\2\u0479\u047a") | |
| buf.write("\3\2\2\2\u047a\u047b\5\u0098M\2\u047b\u00b5\3\2\2\2\u047c") | |
| buf.write("\u047d\7\64\2\2\u047d\u047e\5\u009cO\2\u047e\u047f\5\u0098") | |
| buf.write("M\2\u047f\u00b7\3\2\2\2\u0480\u0481\t\23\2\2\u0481\u00b9") | |
| buf.write("\3\2\2\2\u0482\u0483\7\67\2\2\u0483\u0484\5\u00c2b\2\u0484") | |
| buf.write("\u0485\5\u0098M\2\u0485\u00bb\3\2\2\2\u0486\u0488\7\30") | |
| buf.write("\2\2\u0487\u0489\5\u008aF\2\u0488\u0487\3\2\2\2\u0488") | |
| buf.write("\u0489\3\2\2\2\u0489\u0490\3\2\2\2\u048a\u048c\7\21\2") | |
| buf.write("\2\u048b\u048d\5\u008aF\2\u048c\u048b\3\2\2\2\u048c\u048d") | |
| buf.write("\3\2\2\2\u048d\u048f\3\2\2\2\u048e\u048a\3\2\2\2\u048f") | |
| buf.write("\u0492\3\2\2\2\u0490\u048e\3\2\2\2\u0490\u0491\3\2\2\2") | |
| buf.write("\u0491\u0493\3\2\2\2\u0492\u0490\3\2\2\2\u0493\u04a1\7") | |
| buf.write("\31\2\2\u0494\u049d\7(\2\2\u0495\u049a\5\u008aF\2\u0496") | |
| buf.write("\u0497\7\21\2\2\u0497\u0499\5\u008aF\2\u0498\u0496\3\2") | |
| buf.write("\2\2\u0499\u049c\3\2\2\2\u049a\u0498\3\2\2\2\u049a\u049b") | |
| buf.write("\3\2\2\2\u049b\u049e\3\2\2\2\u049c\u049a\3\2\2\2\u049d") | |
| buf.write("\u0495\3\2\2\2\u049d\u049e\3\2\2\2\u049e\u049f\3\2\2\2") | |
| buf.write("\u049f\u04a1\7)\2\2\u04a0\u0486\3\2\2\2\u04a0\u0494\3") | |
| buf.write("\2\2\2\u04a1\u00bd\3\2\2\2\u04a2\u04a5\5\u0088E\2\u04a3") | |
| buf.write("\u04a5\5L\'\2\u04a4\u04a2\3\2\2\2\u04a4\u04a3\3\2\2\2") | |
| buf.write("\u04a5\u00bf\3\2\2\2\u04a6\u04a8\t\24\2\2\u04a7\u04a9") | |
| buf.write("\7q\2\2\u04a8\u04a7\3\2\2\2\u04a8\u04a9\3\2\2\2\u04a9") | |
| buf.write("\u00c1\3\2\2\2\u04aa\u04b4\t\25\2\2\u04ab\u04b0\7\u0084") | |
| buf.write("\2\2\u04ac\u04ad\7\17\2\2\u04ad\u04af\7\u0084\2\2\u04ae") | |
| buf.write("\u04ac\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2") | |
| buf.write("\u04b0\u04b1\3\2\2\2\u04b1\u04b4\3\2\2\2\u04b2\u04b0\3") | |
| buf.write("\2\2\2\u04b3\u04aa\3\2\2\2\u04b3\u04ab\3\2\2\2\u04b4\u00c3") | |
| buf.write("\3\2\2\2\u008d\u00c5\u00cf\u00d1\u00e1\u00e5\u00ea\u00f1") | |
| buf.write("\u00f7\u00fd\u0101\u010d\u0115\u011a\u011d\u0120\u0123") | |
| buf.write("\u012d\u0130\u0136\u013d\u0141\u0147\u0156\u015b\u015f") | |
| buf.write("\u0169\u016f\u0175\u017e\u018c\u018f\u019b\u01a2\u01a5") | |
| buf.write("\u01a8\u01ac\u01b1\u01b5\u01c6\u01c8\u01cc\u01d2\u01dc") | |
| buf.write("\u01e2\u01ed\u01f0\u01fa\u01fd\u0203\u0206\u020e\u0211") | |
| buf.write("\u0217\u021a\u0222\u0225\u022b\u022f\u023a\u023f\u0244") | |
| buf.write("\u024c\u0253\u025e\u0260\u0265\u026a\u026f\u0271\u0279") | |
| buf.write("\u0284\u0286\u029e\u02a7\u02ad\u02b2\u02b7\u02bb\u02c0") | |
| buf.write("\u02cc\u02dc\u02e2\u02e6\u02e9\u02f0\u0304\u0316\u031a") | |
| buf.write("\u0326\u032a\u032e\u0333\u0338\u033c\u0349\u0366\u0395") | |
| buf.write("\u039b\u039f\u03a6\u03b4\u03b7\u03c1\u03c3\u03cd\u03d4") | |
| buf.write("\u03d6\u03dd\u03e5\u03e9\u03f1\u03f5\u03f7\u0402\u0418") | |
| buf.write("\u041c\u0422\u0426\u042c\u0430\u0436\u0441\u0448\u0456") | |
| buf.write("\u045f\u0465\u0469\u0473\u0478\u0488\u048c\u0490\u049a") | |
| buf.write("\u049d\u04a0\u04a4\u04a8\u04b0\u04b3") | |
| return buf.getvalue() | |
| class SolidityParser ( Parser ): | |
| grammarFileName = "Solidity.g4" | |
| atn = ATNDeserializer().deserialize(serializedATN()) | |
| decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] | |
| sharedContextCache = PredictionContextCache() | |
| literalNames = [ "<INVALID>", "'pragma'", "';'", "'^'", "'~'", "'>='", | |
| "'>'", "'<'", "'<='", "'='", "'as'", "'import'", "'*'", | |
| "'from'", "'{'", "','", "'}'", "'abstract'", "'contract'", | |
| "'interface'", "'library'", "'is'", "'('", "')'", "'({'", | |
| "':'", "'})'", "'using'", "'for'", "'struct'", "'constructor'", | |
| "'modifier'", "'function'", "'receive'", "'fallback'", | |
| "'returns'", "'event'", "'enum'", "'['", "']'", "'address'", | |
| "'.'", "'mapping'", "'=>'", "'memory'", "'storage'", | |
| "'calldata'", "'unchecked'", "'try'", "'catch'", "'if'", | |
| "'else'", "'while'", "'assembly'", "'do'", "'return'", | |
| "'throw'", "'emit'", "'var'", "'bool'", "'string'", | |
| "'byte'", "'++'", "'--'", "'!'", "'delete'", "'-'", | |
| "'new'", "'+'", "'after'", "'**'", "'/'", "'%'", "'<<'", | |
| "'>>'", "'>>>'", "'&'", "'|'", "'=='", "'!='", "'&&'", | |
| "'||'", "'?'", "'|='", "'^='", "'&='", "'<<='", "'>>='", | |
| "'>>>='", "'+='", "'-='", "'*='", "'/='", "'%='", "'let'", | |
| "':='", "'=:'", "'switch'", "'case'", "'default'", | |
| "'->'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "'anonymous'", "'break'", "'constant'", | |
| "'override'", "'immutable'", "'virtual'", "'continue'", | |
| "'external'", "'indexed'", "'internal'", "'payable'", | |
| "'private'", "'public'", "'pure'", "'type'", "'view'" ] | |
| symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", | |
| "<INVALID>", "LicenseIdentifier", "Int", "Uint", "Byte", | |
| "Fixed", "Ufixed", "VersionLiteral", "BooleanLiteral", | |
| "DecimalNumber", "HexNumber", "NumberUnit", "HexLiteral", | |
| "ReservedKeyword", "AnonymousKeyword", "BreakKeyword", | |
| "ConstantKeyword", "OverrideKeyword", "ImmutableKeyword", | |
| "VirtualKeyword", "ContinueKeyword", "ExternalKeyword", | |
| "IndexedKeyword", "InternalKeyword", "PayableKeyword", | |
| "PrivateKeyword", "PublicKeyword", "PureKeyword", | |
| "TypeKeyword", "ViewKeyword", "Identifier", "StringLiteral", | |
| "WS", "NatSpecSingleLine", "NatSpecMultiLine", "LINE_COMMENT", | |
| "COMMENT" ] | |
| RULE_sourceUnit = 0 | |
| RULE_spdxLicenseIdentifier = 1 | |
| RULE_pragmaDirective = 2 | |
| RULE_pragmaName = 3 | |
| RULE_pragmaValue = 4 | |
| RULE_version = 5 | |
| RULE_versionOperator = 6 | |
| RULE_versionConstraint = 7 | |
| RULE_importDeclaration = 8 | |
| RULE_importDirective = 9 | |
| RULE_natSpec = 10 | |
| RULE_contractDefinition = 11 | |
| RULE_inheritanceSpecifier = 12 | |
| RULE_callArgumentList = 13 | |
| RULE_contractPart = 14 | |
| RULE_stateVariableDeclaration = 15 | |
| RULE_usingForDeclaration = 16 | |
| RULE_structDefinition = 17 | |
| RULE_constructorDefinition = 18 | |
| RULE_modifierDefinition = 19 | |
| RULE_modifierInvocation = 20 | |
| RULE_functionDefinition = 21 | |
| RULE_returnParameters = 22 | |
| RULE_overrideParameters = 23 | |
| RULE_modifierList = 24 | |
| RULE_eventDefinition = 25 | |
| RULE_enumValue = 26 | |
| RULE_enumDefinition = 27 | |
| RULE_parameterList = 28 | |
| RULE_objectList = 29 | |
| RULE_parameter = 30 | |
| RULE_eventParameterList = 31 | |
| RULE_eventParameter = 32 | |
| RULE_functionTypeParameterList = 33 | |
| RULE_functionTypeParameter = 34 | |
| RULE_variableDeclaration = 35 | |
| RULE_typeName = 36 | |
| RULE_userDefinedTypeName = 37 | |
| RULE_mapping = 38 | |
| RULE_functionTypeName = 39 | |
| RULE_visibility = 40 | |
| RULE_storageLocation = 41 | |
| RULE_stateMutability = 42 | |
| RULE_block = 43 | |
| RULE_uncheckedBlock = 44 | |
| RULE_statement = 45 | |
| RULE_tryStatement = 46 | |
| RULE_catchClause = 47 | |
| RULE_expressionStatement = 48 | |
| RULE_ifStatement = 49 | |
| RULE_ifCondition = 50 | |
| RULE_ifRight = 51 | |
| RULE_ifWrong = 52 | |
| RULE_whileStatement = 53 | |
| RULE_simpleStatement = 54 | |
| RULE_forStatement = 55 | |
| RULE_inlineAssemblyStatement = 56 | |
| RULE_doWhileStatement = 57 | |
| RULE_continueStatement = 58 | |
| RULE_breakStatement = 59 | |
| RULE_returnStatement = 60 | |
| RULE_throwStatement = 61 | |
| RULE_emitStatement = 62 | |
| RULE_variableDeclarationStatement = 63 | |
| RULE_constantVariableDeclaration = 64 | |
| RULE_variableDeclarationList = 65 | |
| RULE_identifierList = 66 | |
| RULE_elementaryTypeName = 67 | |
| RULE_expression = 68 | |
| RULE_primaryExpression = 69 | |
| RULE_expressionList = 70 | |
| RULE_nameValueList = 71 | |
| RULE_nameValue = 72 | |
| RULE_functionCallArguments = 73 | |
| RULE_functionCall = 74 | |
| RULE_assemblyBlock = 75 | |
| RULE_assemblyItem = 76 | |
| RULE_assemblyExpression = 77 | |
| RULE_assemblyCall = 78 | |
| RULE_assemblyLocalDefinition = 79 | |
| RULE_assemblyAssignment = 80 | |
| RULE_assemblyIdentifierOrList = 81 | |
| RULE_assemblyIdentifierList = 82 | |
| RULE_assemblyStackAssignment = 83 | |
| RULE_labelDefinition = 84 | |
| RULE_assemblySwitch = 85 | |
| RULE_assemblyCase = 86 | |
| RULE_assemblyFunctionDefinition = 87 | |
| RULE_assemblyFunctionReturns = 88 | |
| RULE_assemblyFor = 89 | |
| RULE_assemblyIf = 90 | |
| RULE_assemblyLiteral = 91 | |
| RULE_subAssembly = 92 | |
| RULE_tupleExpression = 93 | |
| RULE_typeNameExpression = 94 | |
| RULE_numberLiteral = 95 | |
| RULE_identifier = 96 | |
| ruleNames = [ "sourceUnit", "spdxLicenseIdentifier", "pragmaDirective", | |
| "pragmaName", "pragmaValue", "version", "versionOperator", | |
| "versionConstraint", "importDeclaration", "importDirective", | |
| "natSpec", "contractDefinition", "inheritanceSpecifier", | |
| "callArgumentList", "contractPart", "stateVariableDeclaration", | |
| "usingForDeclaration", "structDefinition", "constructorDefinition", | |
| "modifierDefinition", "modifierInvocation", "functionDefinition", | |
| "returnParameters", "overrideParameters", "modifierList", | |
| "eventDefinition", "enumValue", "enumDefinition", "parameterList", | |
| "objectList", "parameter", "eventParameterList", "eventParameter", | |
| "functionTypeParameterList", "functionTypeParameter", | |
| "variableDeclaration", "typeName", "userDefinedTypeName", | |
| "mapping", "functionTypeName", "visibility", "storageLocation", | |
| "stateMutability", "block", "uncheckedBlock", "statement", | |
| "tryStatement", "catchClause", "expressionStatement", | |
| "ifStatement", "ifCondition", "ifRight", "ifWrong", "whileStatement", | |
| "simpleStatement", "forStatement", "inlineAssemblyStatement", | |
| "doWhileStatement", "continueStatement", "breakStatement", | |
| "returnStatement", "throwStatement", "emitStatement", | |
| "variableDeclarationStatement", "constantVariableDeclaration", | |
| "variableDeclarationList", "identifierList", "elementaryTypeName", | |
| "expression", "primaryExpression", "expressionList", | |
| "nameValueList", "nameValue", "functionCallArguments", | |
| "functionCall", "assemblyBlock", "assemblyItem", "assemblyExpression", | |
| "assemblyCall", "assemblyLocalDefinition", "assemblyAssignment", | |
| "assemblyIdentifierOrList", "assemblyIdentifierList", | |
| "assemblyStackAssignment", "labelDefinition", "assemblySwitch", | |
| "assemblyCase", "assemblyFunctionDefinition", "assemblyFunctionReturns", | |
| "assemblyFor", "assemblyIf", "assemblyLiteral", "subAssembly", | |
| "tupleExpression", "typeNameExpression", "numberLiteral", | |
| "identifier" ] | |
| EOF = Token.EOF | |
| T__0=1 | |
| T__1=2 | |
| T__2=3 | |
| T__3=4 | |
| T__4=5 | |
| T__5=6 | |
| T__6=7 | |
| T__7=8 | |
| T__8=9 | |
| T__9=10 | |
| T__10=11 | |
| T__11=12 | |
| T__12=13 | |
| T__13=14 | |
| T__14=15 | |
| T__15=16 | |
| T__16=17 | |
| T__17=18 | |
| T__18=19 | |
| T__19=20 | |
| T__20=21 | |
| T__21=22 | |
| T__22=23 | |
| T__23=24 | |
| T__24=25 | |
| T__25=26 | |
| T__26=27 | |
| T__27=28 | |
| T__28=29 | |
| T__29=30 | |
| T__30=31 | |
| T__31=32 | |
| T__32=33 | |
| T__33=34 | |
| T__34=35 | |
| T__35=36 | |
| T__36=37 | |
| T__37=38 | |
| T__38=39 | |
| T__39=40 | |
| T__40=41 | |
| T__41=42 | |
| T__42=43 | |
| T__43=44 | |
| T__44=45 | |
| T__45=46 | |
| T__46=47 | |
| T__47=48 | |
| T__48=49 | |
| T__49=50 | |
| T__50=51 | |
| T__51=52 | |
| T__52=53 | |
| T__53=54 | |
| T__54=55 | |
| T__55=56 | |
| T__56=57 | |
| T__57=58 | |
| T__58=59 | |
| T__59=60 | |
| T__60=61 | |
| T__61=62 | |
| T__62=63 | |
| T__63=64 | |
| T__64=65 | |
| T__65=66 | |
| T__66=67 | |
| T__67=68 | |
| T__68=69 | |
| T__69=70 | |
| T__70=71 | |
| T__71=72 | |
| T__72=73 | |
| T__73=74 | |
| T__74=75 | |
| T__75=76 | |
| T__76=77 | |
| T__77=78 | |
| T__78=79 | |
| T__79=80 | |
| T__80=81 | |
| T__81=82 | |
| T__82=83 | |
| T__83=84 | |
| T__84=85 | |
| T__85=86 | |
| T__86=87 | |
| T__87=88 | |
| T__88=89 | |
| T__89=90 | |
| T__90=91 | |
| T__91=92 | |
| T__92=93 | |
| T__93=94 | |
| T__94=95 | |
| T__95=96 | |
| T__96=97 | |
| T__97=98 | |
| T__98=99 | |
| T__99=100 | |
| LicenseIdentifier=101 | |
| Int=102 | |
| Uint=103 | |
| Byte=104 | |
| Fixed=105 | |
| Ufixed=106 | |
| VersionLiteral=107 | |
| BooleanLiteral=108 | |
| DecimalNumber=109 | |
| HexNumber=110 | |
| NumberUnit=111 | |
| HexLiteral=112 | |
| ReservedKeyword=113 | |
| AnonymousKeyword=114 | |
| BreakKeyword=115 | |
| ConstantKeyword=116 | |
| OverrideKeyword=117 | |
| ImmutableKeyword=118 | |
| VirtualKeyword=119 | |
| ContinueKeyword=120 | |
| ExternalKeyword=121 | |
| IndexedKeyword=122 | |
| InternalKeyword=123 | |
| PayableKeyword=124 | |
| PrivateKeyword=125 | |
| PublicKeyword=126 | |
| PureKeyword=127 | |
| TypeKeyword=128 | |
| ViewKeyword=129 | |
| Identifier=130 | |
| StringLiteral=131 | |
| WS=132 | |
| NatSpecSingleLine=133 | |
| NatSpecMultiLine=134 | |
| LINE_COMMENT=135 | |
| COMMENT=136 | |
| def __init__(self, input:TokenStream, output:TextIO = sys.stdout): | |
| super().__init__(input, output) | |
| self.checkVersion("4.9.3") | |
| self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) | |
| self._predicates = None | |
| class SourceUnitContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def EOF(self): | |
| return self.getToken(SolidityParser.EOF, 0) | |
| def spdxLicenseIdentifier(self): | |
| return self.getTypedRuleContext(SolidityParser.SpdxLicenseIdentifierContext,0) | |
| def natSpec(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.NatSpecContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.NatSpecContext,i) | |
| def pragmaDirective(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.PragmaDirectiveContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.PragmaDirectiveContext,i) | |
| def importDirective(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.ImportDirectiveContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ImportDirectiveContext,i) | |
| def contractDefinition(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.ContractDefinitionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ContractDefinitionContext,i) | |
| def functionDefinition(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.FunctionDefinitionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,i) | |
| def constantVariableDeclaration(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.ConstantVariableDeclarationContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ConstantVariableDeclarationContext,i) | |
| def structDefinition(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.StructDefinitionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,i) | |
| def enumDefinition(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.EnumDefinitionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_sourceUnit | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterSourceUnit" ): | |
| listener.enterSourceUnit(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitSourceUnit" ): | |
| listener.exitSourceUnit(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitSourceUnit" ): | |
| return visitor.visitSourceUnit(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def sourceUnit(self): | |
| localctx = SolidityParser.SourceUnitContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 0, self.RULE_sourceUnit) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 195 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.LicenseIdentifier: | |
| self.state = 194 | |
| self.spdxLicenseIdentifier() | |
| self.state = 207 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__0) | (1 << SolidityParser.T__10) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__16) | (1 << SolidityParser.T__17) | (1 << SolidityParser.T__18) | (1 << SolidityParser.T__19) | (1 << SolidityParser.T__28) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__32) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__36) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)) | (1 << (SolidityParser.NatSpecSingleLine - 102)) | (1 << (SolidityParser.NatSpecMultiLine - 102)))) != 0): | |
| self.state = 205 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,1,self._ctx) | |
| if la_ == 1: | |
| self.state = 197 | |
| self.natSpec() | |
| pass | |
| elif la_ == 2: | |
| self.state = 198 | |
| self.pragmaDirective() | |
| pass | |
| elif la_ == 3: | |
| self.state = 199 | |
| self.importDirective() | |
| pass | |
| elif la_ == 4: | |
| self.state = 200 | |
| self.contractDefinition() | |
| pass | |
| elif la_ == 5: | |
| self.state = 201 | |
| self.functionDefinition() | |
| pass | |
| elif la_ == 6: | |
| self.state = 202 | |
| self.constantVariableDeclaration() | |
| pass | |
| elif la_ == 7: | |
| self.state = 203 | |
| self.structDefinition() | |
| pass | |
| elif la_ == 8: | |
| self.state = 204 | |
| self.enumDefinition() | |
| pass | |
| self.state = 209 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 210 | |
| self.match(SolidityParser.EOF) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class SpdxLicenseIdentifierContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def LicenseIdentifier(self): | |
| return self.getToken(SolidityParser.LicenseIdentifier, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_spdxLicenseIdentifier | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterSpdxLicenseIdentifier" ): | |
| listener.enterSpdxLicenseIdentifier(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitSpdxLicenseIdentifier" ): | |
| listener.exitSpdxLicenseIdentifier(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitSpdxLicenseIdentifier" ): | |
| return visitor.visitSpdxLicenseIdentifier(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def spdxLicenseIdentifier(self): | |
| localctx = SolidityParser.SpdxLicenseIdentifierContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 2, self.RULE_spdxLicenseIdentifier) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 212 | |
| self.match(SolidityParser.LicenseIdentifier) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class PragmaDirectiveContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def pragmaName(self): | |
| return self.getTypedRuleContext(SolidityParser.PragmaNameContext,0) | |
| def pragmaValue(self): | |
| return self.getTypedRuleContext(SolidityParser.PragmaValueContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_pragmaDirective | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterPragmaDirective" ): | |
| listener.enterPragmaDirective(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitPragmaDirective" ): | |
| listener.exitPragmaDirective(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitPragmaDirective" ): | |
| return visitor.visitPragmaDirective(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def pragmaDirective(self): | |
| localctx = SolidityParser.PragmaDirectiveContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 4, self.RULE_pragmaDirective) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 214 | |
| self.match(SolidityParser.T__0) | |
| self.state = 215 | |
| self.pragmaName() | |
| self.state = 216 | |
| self.pragmaValue() | |
| self.state = 217 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class PragmaNameContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_pragmaName | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterPragmaName" ): | |
| listener.enterPragmaName(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitPragmaName" ): | |
| listener.exitPragmaName(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitPragmaName" ): | |
| return visitor.visitPragmaName(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def pragmaName(self): | |
| localctx = SolidityParser.PragmaNameContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 6, self.RULE_pragmaName) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 219 | |
| self.identifier() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class PragmaValueContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def version(self): | |
| return self.getTypedRuleContext(SolidityParser.VersionContext,0) | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_pragmaValue | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterPragmaValue" ): | |
| listener.enterPragmaValue(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitPragmaValue" ): | |
| listener.exitPragmaValue(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitPragmaValue" ): | |
| return visitor.visitPragmaValue(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def pragmaValue(self): | |
| localctx = SolidityParser.PragmaValueContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 8, self.RULE_pragmaValue) | |
| try: | |
| self.state = 223 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,3,self._ctx) | |
| if la_ == 1: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 221 | |
| self.version() | |
| pass | |
| elif la_ == 2: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 222 | |
| self.expression(0) | |
| pass | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class VersionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def versionConstraint(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.VersionConstraintContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.VersionConstraintContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_version | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterVersion" ): | |
| listener.enterVersion(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitVersion" ): | |
| listener.exitVersion(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitVersion" ): | |
| return visitor.visitVersion(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def version(self): | |
| localctx = SolidityParser.VersionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 10, self.RULE_version) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 225 | |
| self.versionConstraint() | |
| self.state = 227 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8))) != 0) or _la==SolidityParser.VersionLiteral: | |
| self.state = 226 | |
| self.versionConstraint() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class VersionOperatorContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_versionOperator | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterVersionOperator" ): | |
| listener.enterVersionOperator(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitVersionOperator" ): | |
| listener.exitVersionOperator(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitVersionOperator" ): | |
| return visitor.visitVersionOperator(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def versionOperator(self): | |
| localctx = SolidityParser.VersionOperatorContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 12, self.RULE_versionOperator) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 229 | |
| _la = self._input.LA(1) | |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class VersionConstraintContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def VersionLiteral(self): | |
| return self.getToken(SolidityParser.VersionLiteral, 0) | |
| def versionOperator(self): | |
| return self.getTypedRuleContext(SolidityParser.VersionOperatorContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_versionConstraint | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterVersionConstraint" ): | |
| listener.enterVersionConstraint(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitVersionConstraint" ): | |
| listener.exitVersionConstraint(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitVersionConstraint" ): | |
| return visitor.visitVersionConstraint(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def versionConstraint(self): | |
| localctx = SolidityParser.VersionConstraintContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 14, self.RULE_versionConstraint) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 232 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8))) != 0): | |
| self.state = 231 | |
| self.versionOperator() | |
| self.state = 234 | |
| self.match(SolidityParser.VersionLiteral) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ImportDeclarationContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.IdentifierContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_importDeclaration | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterImportDeclaration" ): | |
| listener.enterImportDeclaration(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitImportDeclaration" ): | |
| listener.exitImportDeclaration(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitImportDeclaration" ): | |
| return visitor.visitImportDeclaration(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def importDeclaration(self): | |
| localctx = SolidityParser.ImportDeclarationContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 16, self.RULE_importDeclaration) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 236 | |
| self.identifier() | |
| self.state = 239 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__9: | |
| self.state = 237 | |
| self.match(SolidityParser.T__9) | |
| self.state = 238 | |
| self.identifier() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ImportDirectiveContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def StringLiteral(self): | |
| return self.getToken(SolidityParser.StringLiteral, 0) | |
| def identifier(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.IdentifierContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) | |
| def importDeclaration(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.ImportDeclarationContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ImportDeclarationContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_importDirective | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterImportDirective" ): | |
| listener.enterImportDirective(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitImportDirective" ): | |
| listener.exitImportDirective(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitImportDirective" ): | |
| return visitor.visitImportDirective(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def importDirective(self): | |
| localctx = SolidityParser.ImportDirectiveContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 18, self.RULE_importDirective) | |
| self._la = 0 # Token type | |
| try: | |
| self.state = 275 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,11,self._ctx) | |
| if la_ == 1: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 241 | |
| self.match(SolidityParser.T__10) | |
| self.state = 242 | |
| self.match(SolidityParser.StringLiteral) | |
| self.state = 245 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__9: | |
| self.state = 243 | |
| self.match(SolidityParser.T__9) | |
| self.state = 244 | |
| self.identifier() | |
| self.state = 247 | |
| self.match(SolidityParser.T__1) | |
| pass | |
| elif la_ == 2: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 248 | |
| self.match(SolidityParser.T__10) | |
| self.state = 251 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__11]: | |
| self.state = 249 | |
| self.match(SolidityParser.T__11) | |
| pass | |
| elif token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]: | |
| self.state = 250 | |
| self.identifier() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 255 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__9: | |
| self.state = 253 | |
| self.match(SolidityParser.T__9) | |
| self.state = 254 | |
| self.identifier() | |
| self.state = 257 | |
| self.match(SolidityParser.T__12) | |
| self.state = 258 | |
| self.match(SolidityParser.StringLiteral) | |
| self.state = 259 | |
| self.match(SolidityParser.T__1) | |
| pass | |
| elif la_ == 3: | |
| self.enterOuterAlt(localctx, 3) | |
| self.state = 260 | |
| self.match(SolidityParser.T__10) | |
| self.state = 261 | |
| self.match(SolidityParser.T__13) | |
| self.state = 262 | |
| self.importDeclaration() | |
| self.state = 267 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 263 | |
| self.match(SolidityParser.T__14) | |
| self.state = 264 | |
| self.importDeclaration() | |
| self.state = 269 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 270 | |
| self.match(SolidityParser.T__15) | |
| self.state = 271 | |
| self.match(SolidityParser.T__12) | |
| self.state = 272 | |
| self.match(SolidityParser.StringLiteral) | |
| self.state = 273 | |
| self.match(SolidityParser.T__1) | |
| pass | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class NatSpecContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def NatSpecSingleLine(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.NatSpecSingleLine) | |
| else: | |
| return self.getToken(SolidityParser.NatSpecSingleLine, i) | |
| def NatSpecMultiLine(self): | |
| return self.getToken(SolidityParser.NatSpecMultiLine, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_natSpec | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterNatSpec" ): | |
| listener.enterNatSpec(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitNatSpec" ): | |
| listener.exitNatSpec(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitNatSpec" ): | |
| return visitor.visitNatSpec(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def natSpec(self): | |
| localctx = SolidityParser.NatSpecContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 20, self.RULE_natSpec) | |
| try: | |
| self.state = 283 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.NatSpecSingleLine]: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 278 | |
| self._errHandler.sync(self) | |
| _alt = 1 | |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: | |
| if _alt == 1: | |
| self.state = 277 | |
| self.match(SolidityParser.NatSpecSingleLine) | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 280 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,12,self._ctx) | |
| pass | |
| elif token in [SolidityParser.NatSpecMultiLine]: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 282 | |
| self.match(SolidityParser.NatSpecMultiLine) | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ContractDefinitionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def natSpec(self): | |
| return self.getTypedRuleContext(SolidityParser.NatSpecContext,0) | |
| def inheritanceSpecifier(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.InheritanceSpecifierContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.InheritanceSpecifierContext,i) | |
| def contractPart(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.ContractPartContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ContractPartContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_contractDefinition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterContractDefinition" ): | |
| listener.enterContractDefinition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitContractDefinition" ): | |
| listener.exitContractDefinition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitContractDefinition" ): | |
| return visitor.visitContractDefinition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def contractDefinition(self): | |
| localctx = SolidityParser.ContractDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 22, self.RULE_contractDefinition) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 286 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.NatSpecSingleLine or _la==SolidityParser.NatSpecMultiLine: | |
| self.state = 285 | |
| self.natSpec() | |
| self.state = 289 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__16: | |
| self.state = 288 | |
| self.match(SolidityParser.T__16) | |
| self.state = 291 | |
| _la = self._input.LA(1) | |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__17) | (1 << SolidityParser.T__18) | (1 << SolidityParser.T__19))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 292 | |
| self.identifier() | |
| self.state = 302 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__20: | |
| self.state = 293 | |
| self.match(SolidityParser.T__20) | |
| self.state = 294 | |
| self.inheritanceSpecifier() | |
| self.state = 299 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 295 | |
| self.match(SolidityParser.T__14) | |
| self.state = 296 | |
| self.inheritanceSpecifier() | |
| self.state = 301 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 304 | |
| self.match(SolidityParser.T__13) | |
| self.state = 308 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__26) | (1 << SolidityParser.T__28) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__30) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__32) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__36) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)) | (1 << (SolidityParser.NatSpecSingleLine - 102)) | (1 << (SolidityParser.NatSpecMultiLine - 102)))) != 0): | |
| self.state = 305 | |
| self.contractPart() | |
| self.state = 310 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 311 | |
| self.match(SolidityParser.T__15) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class InheritanceSpecifierContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def userDefinedTypeName(self): | |
| return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0) | |
| def callArgumentList(self): | |
| return self.getTypedRuleContext(SolidityParser.CallArgumentListContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_inheritanceSpecifier | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterInheritanceSpecifier" ): | |
| listener.enterInheritanceSpecifier(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitInheritanceSpecifier" ): | |
| listener.exitInheritanceSpecifier(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitInheritanceSpecifier" ): | |
| return visitor.visitInheritanceSpecifier(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def inheritanceSpecifier(self): | |
| localctx = SolidityParser.InheritanceSpecifierContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 24, self.RULE_inheritanceSpecifier) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 313 | |
| self.userDefinedTypeName() | |
| self.state = 315 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__21 or _la==SolidityParser.T__23: | |
| self.state = 314 | |
| self.callArgumentList() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class CallArgumentListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| 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(SolidityParser.ExpressionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,i) | |
| def identifier(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.IdentifierContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_callArgumentList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterCallArgumentList" ): | |
| listener.enterCallArgumentList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitCallArgumentList" ): | |
| listener.exitCallArgumentList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitCallArgumentList" ): | |
| return visitor.visitCallArgumentList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def callArgumentList(self): | |
| localctx = SolidityParser.CallArgumentListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 26, self.RULE_callArgumentList) | |
| self._la = 0 # Token type | |
| try: | |
| self.state = 349 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__21]: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 317 | |
| self.match(SolidityParser.T__21) | |
| self.state = 319 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 318 | |
| self.expression(0) | |
| self.state = 325 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 321 | |
| self.match(SolidityParser.T__14) | |
| self.state = 322 | |
| self.expression(0) | |
| self.state = 327 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 328 | |
| self.match(SolidityParser.T__22) | |
| pass | |
| elif token in [SolidityParser.T__23]: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 329 | |
| self.match(SolidityParser.T__23) | |
| self.state = 345 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 330 | |
| self.identifier() | |
| self.state = 331 | |
| self.match(SolidityParser.T__24) | |
| self.state = 332 | |
| self.expression(0) | |
| self.state = 340 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 333 | |
| self.match(SolidityParser.T__14) | |
| self.state = 334 | |
| self.identifier() | |
| self.state = 335 | |
| self.match(SolidityParser.T__24) | |
| self.state = 336 | |
| self.expression(0) | |
| self.state = 342 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 347 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 348 | |
| self.match(SolidityParser.T__25) | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ContractPartContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def stateVariableDeclaration(self): | |
| return self.getTypedRuleContext(SolidityParser.StateVariableDeclarationContext,0) | |
| def usingForDeclaration(self): | |
| return self.getTypedRuleContext(SolidityParser.UsingForDeclarationContext,0) | |
| def structDefinition(self): | |
| return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,0) | |
| def constructorDefinition(self): | |
| return self.getTypedRuleContext(SolidityParser.ConstructorDefinitionContext,0) | |
| def modifierDefinition(self): | |
| return self.getTypedRuleContext(SolidityParser.ModifierDefinitionContext,0) | |
| def functionDefinition(self): | |
| return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,0) | |
| def eventDefinition(self): | |
| return self.getTypedRuleContext(SolidityParser.EventDefinitionContext,0) | |
| def enumDefinition(self): | |
| return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_contractPart | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterContractPart" ): | |
| listener.enterContractPart(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitContractPart" ): | |
| listener.exitContractPart(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitContractPart" ): | |
| return visitor.visitContractPart(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def contractPart(self): | |
| localctx = SolidityParser.ContractPartContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 28, self.RULE_contractPart) | |
| try: | |
| self.state = 359 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,25,self._ctx) | |
| if la_ == 1: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 351 | |
| self.stateVariableDeclaration() | |
| pass | |
| elif la_ == 2: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 352 | |
| self.usingForDeclaration() | |
| pass | |
| elif la_ == 3: | |
| self.enterOuterAlt(localctx, 3) | |
| self.state = 353 | |
| self.structDefinition() | |
| pass | |
| elif la_ == 4: | |
| self.enterOuterAlt(localctx, 4) | |
| self.state = 354 | |
| self.constructorDefinition() | |
| pass | |
| elif la_ == 5: | |
| self.enterOuterAlt(localctx, 5) | |
| self.state = 355 | |
| self.modifierDefinition() | |
| pass | |
| elif la_ == 6: | |
| self.enterOuterAlt(localctx, 6) | |
| self.state = 356 | |
| self.functionDefinition() | |
| pass | |
| elif la_ == 7: | |
| self.enterOuterAlt(localctx, 7) | |
| self.state = 357 | |
| self.eventDefinition() | |
| pass | |
| elif la_ == 8: | |
| self.enterOuterAlt(localctx, 8) | |
| self.state = 358 | |
| self.enumDefinition() | |
| pass | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class StateVariableDeclarationContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def PublicKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.PublicKeyword) | |
| else: | |
| return self.getToken(SolidityParser.PublicKeyword, i) | |
| def InternalKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.InternalKeyword) | |
| else: | |
| return self.getToken(SolidityParser.InternalKeyword, i) | |
| def PrivateKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.PrivateKeyword) | |
| else: | |
| return self.getToken(SolidityParser.PrivateKeyword, i) | |
| def ConstantKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.ConstantKeyword) | |
| else: | |
| return self.getToken(SolidityParser.ConstantKeyword, i) | |
| def OverrideKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.OverrideKeyword) | |
| else: | |
| return self.getToken(SolidityParser.OverrideKeyword, i) | |
| def ImmutableKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.ImmutableKeyword) | |
| else: | |
| return self.getToken(SolidityParser.ImmutableKeyword, i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_stateVariableDeclaration | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterStateVariableDeclaration" ): | |
| listener.enterStateVariableDeclaration(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitStateVariableDeclaration" ): | |
| listener.exitStateVariableDeclaration(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitStateVariableDeclaration" ): | |
| return visitor.visitStateVariableDeclaration(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def stateVariableDeclaration(self): | |
| localctx = SolidityParser.StateVariableDeclarationContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 30, self.RULE_stateVariableDeclaration) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 361 | |
| self.typeName(0) | |
| self.state = 365 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while ((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.OverrideKeyword - 116)) | (1 << (SolidityParser.ImmutableKeyword - 116)) | (1 << (SolidityParser.InternalKeyword - 116)) | (1 << (SolidityParser.PrivateKeyword - 116)) | (1 << (SolidityParser.PublicKeyword - 116)))) != 0): | |
| self.state = 362 | |
| _la = self._input.LA(1) | |
| if not(((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.OverrideKeyword - 116)) | (1 << (SolidityParser.ImmutableKeyword - 116)) | (1 << (SolidityParser.InternalKeyword - 116)) | (1 << (SolidityParser.PrivateKeyword - 116)) | (1 << (SolidityParser.PublicKeyword - 116)))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 367 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 368 | |
| self.identifier() | |
| self.state = 371 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__8: | |
| self.state = 369 | |
| self.match(SolidityParser.T__8) | |
| self.state = 370 | |
| self.expression(0) | |
| self.state = 373 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class UsingForDeclarationContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_usingForDeclaration | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterUsingForDeclaration" ): | |
| listener.enterUsingForDeclaration(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitUsingForDeclaration" ): | |
| listener.exitUsingForDeclaration(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitUsingForDeclaration" ): | |
| return visitor.visitUsingForDeclaration(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def usingForDeclaration(self): | |
| localctx = SolidityParser.UsingForDeclarationContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 32, self.RULE_usingForDeclaration) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 375 | |
| self.match(SolidityParser.T__26) | |
| self.state = 376 | |
| self.identifier() | |
| self.state = 377 | |
| self.match(SolidityParser.T__27) | |
| self.state = 380 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__11]: | |
| self.state = 378 | |
| self.match(SolidityParser.T__11) | |
| pass | |
| elif token in [SolidityParser.T__12, SolidityParser.T__31, SolidityParser.T__39, SolidityParser.T__41, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.Identifier]: | |
| self.state = 379 | |
| self.typeName(0) | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 382 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class StructDefinitionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def variableDeclaration(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_structDefinition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterStructDefinition" ): | |
| listener.enterStructDefinition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitStructDefinition" ): | |
| listener.exitStructDefinition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitStructDefinition" ): | |
| return visitor.visitStructDefinition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def structDefinition(self): | |
| localctx = SolidityParser.StructDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 34, self.RULE_structDefinition) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 384 | |
| self.match(SolidityParser.T__28) | |
| self.state = 385 | |
| self.identifier() | |
| self.state = 386 | |
| self.match(SolidityParser.T__13) | |
| self.state = 397 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0): | |
| self.state = 387 | |
| self.variableDeclaration() | |
| self.state = 388 | |
| self.match(SolidityParser.T__1) | |
| self.state = 394 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0): | |
| self.state = 389 | |
| self.variableDeclaration() | |
| self.state = 390 | |
| self.match(SolidityParser.T__1) | |
| self.state = 396 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 399 | |
| self.match(SolidityParser.T__15) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ConstructorDefinitionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def parameterList(self): | |
| return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) | |
| def modifierList(self): | |
| return self.getTypedRuleContext(SolidityParser.ModifierListContext,0) | |
| def block(self): | |
| return self.getTypedRuleContext(SolidityParser.BlockContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_constructorDefinition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterConstructorDefinition" ): | |
| listener.enterConstructorDefinition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitConstructorDefinition" ): | |
| listener.exitConstructorDefinition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitConstructorDefinition" ): | |
| return visitor.visitConstructorDefinition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def constructorDefinition(self): | |
| localctx = SolidityParser.ConstructorDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 36, self.RULE_constructorDefinition) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 401 | |
| self.match(SolidityParser.T__29) | |
| self.state = 402 | |
| self.parameterList() | |
| self.state = 403 | |
| self.modifierList() | |
| self.state = 404 | |
| self.block() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ModifierDefinitionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def block(self): | |
| return self.getTypedRuleContext(SolidityParser.BlockContext,0) | |
| def parameterList(self): | |
| return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_modifierDefinition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterModifierDefinition" ): | |
| listener.enterModifierDefinition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitModifierDefinition" ): | |
| listener.exitModifierDefinition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitModifierDefinition" ): | |
| return visitor.visitModifierDefinition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def modifierDefinition(self): | |
| localctx = SolidityParser.ModifierDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 38, self.RULE_modifierDefinition) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 406 | |
| self.match(SolidityParser.T__30) | |
| self.state = 407 | |
| self.identifier() | |
| self.state = 409 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__21: | |
| self.state = 408 | |
| self.parameterList() | |
| self.state = 411 | |
| self.block() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ModifierInvocationContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def expressionList(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_modifierInvocation | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterModifierInvocation" ): | |
| listener.enterModifierInvocation(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitModifierInvocation" ): | |
| listener.exitModifierInvocation(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitModifierInvocation" ): | |
| return visitor.visitModifierInvocation(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def modifierInvocation(self): | |
| localctx = SolidityParser.ModifierInvocationContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 40, self.RULE_modifierInvocation) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 413 | |
| self.identifier() | |
| self.state = 419 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__21: | |
| self.state = 414 | |
| self.match(SolidityParser.T__21) | |
| self.state = 416 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 415 | |
| self.expressionList() | |
| self.state = 418 | |
| self.match(SolidityParser.T__22) | |
| 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): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def parameterList(self): | |
| return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) | |
| def modifierList(self): | |
| return self.getTypedRuleContext(SolidityParser.ModifierListContext,0) | |
| def block(self): | |
| return self.getTypedRuleContext(SolidityParser.BlockContext,0) | |
| def natSpec(self): | |
| return self.getTypedRuleContext(SolidityParser.NatSpecContext,0) | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def returnParameters(self): | |
| return self.getTypedRuleContext(SolidityParser.ReturnParametersContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.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 = SolidityParser.FunctionDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 42, self.RULE_functionDefinition) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 422 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.NatSpecSingleLine or _la==SolidityParser.NatSpecMultiLine: | |
| self.state = 421 | |
| self.natSpec() | |
| self.state = 424 | |
| _la = self._input.LA(1) | |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__31) | (1 << SolidityParser.T__32) | (1 << SolidityParser.T__33))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 426 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 425 | |
| self.identifier() | |
| self.state = 428 | |
| self.parameterList() | |
| self.state = 429 | |
| self.modifierList() | |
| self.state = 431 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__34: | |
| self.state = 430 | |
| self.returnParameters() | |
| self.state = 435 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__1]: | |
| self.state = 433 | |
| self.match(SolidityParser.T__1) | |
| pass | |
| elif token in [SolidityParser.T__13]: | |
| self.state = 434 | |
| self.block() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ReturnParametersContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def parameterList(self): | |
| return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_returnParameters | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterReturnParameters" ): | |
| listener.enterReturnParameters(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitReturnParameters" ): | |
| listener.exitReturnParameters(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitReturnParameters" ): | |
| return visitor.visitReturnParameters(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def returnParameters(self): | |
| localctx = SolidityParser.ReturnParametersContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 44, self.RULE_returnParameters) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 437 | |
| self.match(SolidityParser.T__34) | |
| self.state = 438 | |
| self.parameterList() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class OverrideParametersContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def OverrideKeyword(self): | |
| return self.getToken(SolidityParser.OverrideKeyword, 0) | |
| def parameterList(self): | |
| return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_overrideParameters | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterOverrideParameters" ): | |
| listener.enterOverrideParameters(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitOverrideParameters" ): | |
| listener.exitOverrideParameters(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitOverrideParameters" ): | |
| return visitor.visitOverrideParameters(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def overrideParameters(self): | |
| localctx = SolidityParser.OverrideParametersContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 46, self.RULE_overrideParameters) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 440 | |
| self.match(SolidityParser.OverrideKeyword) | |
| self.state = 441 | |
| self.parameterList() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ModifierListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def modifierInvocation(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.ModifierInvocationContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ModifierInvocationContext,i) | |
| def stateMutability(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i) | |
| def ExternalKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.ExternalKeyword) | |
| else: | |
| return self.getToken(SolidityParser.ExternalKeyword, i) | |
| def PublicKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.PublicKeyword) | |
| else: | |
| return self.getToken(SolidityParser.PublicKeyword, i) | |
| def InternalKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.InternalKeyword) | |
| else: | |
| return self.getToken(SolidityParser.InternalKeyword, i) | |
| def PrivateKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.PrivateKeyword) | |
| else: | |
| return self.getToken(SolidityParser.PrivateKeyword, i) | |
| def OverrideKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.OverrideKeyword) | |
| else: | |
| return self.getToken(SolidityParser.OverrideKeyword, i) | |
| def overrideParameters(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.OverrideParametersContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.OverrideParametersContext,i) | |
| def VirtualKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.VirtualKeyword) | |
| else: | |
| return self.getToken(SolidityParser.VirtualKeyword, i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_modifierList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterModifierList" ): | |
| listener.enterModifierList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitModifierList" ): | |
| listener.exitModifierList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitModifierList" ): | |
| return visitor.visitModifierList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def modifierList(self): | |
| localctx = SolidityParser.ModifierListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 48, self.RULE_modifierList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 454 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or ((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.OverrideKeyword - 116)) | (1 << (SolidityParser.VirtualKeyword - 116)) | (1 << (SolidityParser.ExternalKeyword - 116)) | (1 << (SolidityParser.InternalKeyword - 116)) | (1 << (SolidityParser.PayableKeyword - 116)) | (1 << (SolidityParser.PrivateKeyword - 116)) | (1 << (SolidityParser.PublicKeyword - 116)) | (1 << (SolidityParser.PureKeyword - 116)) | (1 << (SolidityParser.ViewKeyword - 116)) | (1 << (SolidityParser.Identifier - 116)))) != 0): | |
| self.state = 452 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,38,self._ctx) | |
| if la_ == 1: | |
| self.state = 443 | |
| self.modifierInvocation() | |
| pass | |
| elif la_ == 2: | |
| self.state = 444 | |
| self.stateMutability() | |
| pass | |
| elif la_ == 3: | |
| self.state = 445 | |
| self.match(SolidityParser.ExternalKeyword) | |
| pass | |
| elif la_ == 4: | |
| self.state = 446 | |
| self.match(SolidityParser.PublicKeyword) | |
| pass | |
| elif la_ == 5: | |
| self.state = 447 | |
| self.match(SolidityParser.InternalKeyword) | |
| pass | |
| elif la_ == 6: | |
| self.state = 448 | |
| self.match(SolidityParser.PrivateKeyword) | |
| pass | |
| elif la_ == 7: | |
| self.state = 449 | |
| self.match(SolidityParser.OverrideKeyword) | |
| pass | |
| elif la_ == 8: | |
| self.state = 450 | |
| self.overrideParameters() | |
| pass | |
| elif la_ == 9: | |
| self.state = 451 | |
| self.match(SolidityParser.VirtualKeyword) | |
| pass | |
| self.state = 456 | |
| 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 EventDefinitionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def eventParameterList(self): | |
| return self.getTypedRuleContext(SolidityParser.EventParameterListContext,0) | |
| def natSpec(self): | |
| return self.getTypedRuleContext(SolidityParser.NatSpecContext,0) | |
| def AnonymousKeyword(self): | |
| return self.getToken(SolidityParser.AnonymousKeyword, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_eventDefinition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterEventDefinition" ): | |
| listener.enterEventDefinition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitEventDefinition" ): | |
| listener.exitEventDefinition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitEventDefinition" ): | |
| return visitor.visitEventDefinition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def eventDefinition(self): | |
| localctx = SolidityParser.EventDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 50, self.RULE_eventDefinition) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 458 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.NatSpecSingleLine or _la==SolidityParser.NatSpecMultiLine: | |
| self.state = 457 | |
| self.natSpec() | |
| self.state = 460 | |
| self.match(SolidityParser.T__35) | |
| self.state = 461 | |
| self.identifier() | |
| self.state = 462 | |
| self.eventParameterList() | |
| self.state = 464 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.AnonymousKeyword: | |
| self.state = 463 | |
| self.match(SolidityParser.AnonymousKeyword) | |
| self.state = 466 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class EnumValueContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_enumValue | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterEnumValue" ): | |
| listener.enterEnumValue(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitEnumValue" ): | |
| listener.exitEnumValue(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitEnumValue" ): | |
| return visitor.visitEnumValue(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def enumValue(self): | |
| localctx = SolidityParser.EnumValueContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 52, self.RULE_enumValue) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 468 | |
| self.identifier() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class EnumDefinitionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def enumValue(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.EnumValueContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.EnumValueContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_enumDefinition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterEnumDefinition" ): | |
| listener.enterEnumDefinition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitEnumDefinition" ): | |
| listener.exitEnumDefinition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitEnumDefinition" ): | |
| return visitor.visitEnumDefinition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def enumDefinition(self): | |
| localctx = SolidityParser.EnumDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 54, self.RULE_enumDefinition) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 470 | |
| self.match(SolidityParser.T__36) | |
| self.state = 471 | |
| self.identifier() | |
| self.state = 472 | |
| self.match(SolidityParser.T__13) | |
| self.state = 474 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 473 | |
| self.enumValue() | |
| self.state = 480 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 476 | |
| self.match(SolidityParser.T__14) | |
| self.state = 477 | |
| self.enumValue() | |
| self.state = 482 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 483 | |
| self.match(SolidityParser.T__15) | |
| 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): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def parameter(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.ParameterContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ParameterContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.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): | |
| localctx = SolidityParser.ParameterListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 56, self.RULE_parameterList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 485 | |
| self.match(SolidityParser.T__21) | |
| self.state = 494 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0): | |
| self.state = 486 | |
| self.parameter() | |
| self.state = 491 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 487 | |
| self.match(SolidityParser.T__14) | |
| self.state = 488 | |
| self.parameter() | |
| self.state = 493 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 496 | |
| self.match(SolidityParser.T__22) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ObjectListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def parameter(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.ParameterContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ParameterContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_objectList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterObjectList" ): | |
| listener.enterObjectList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitObjectList" ): | |
| listener.exitObjectList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitObjectList" ): | |
| return visitor.visitObjectList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def objectList(self): | |
| localctx = SolidityParser.ObjectListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 58, self.RULE_objectList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 498 | |
| self.match(SolidityParser.T__21) | |
| self.state = 507 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0): | |
| self.state = 499 | |
| self.parameter() | |
| self.state = 504 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 500 | |
| self.match(SolidityParser.T__14) | |
| self.state = 501 | |
| self.parameter() | |
| self.state = 506 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 509 | |
| self.match(SolidityParser.T__22) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ParameterContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def storageLocation(self): | |
| return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0) | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_parameter | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterParameter" ): | |
| listener.enterParameter(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitParameter" ): | |
| listener.exitParameter(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitParameter" ): | |
| return visitor.visitParameter(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def parameter(self): | |
| localctx = SolidityParser.ParameterContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 60, self.RULE_parameter) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 511 | |
| self.typeName(0) | |
| self.state = 513 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,48,self._ctx) | |
| if la_ == 1: | |
| self.state = 512 | |
| self.storageLocation() | |
| self.state = 516 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 515 | |
| self.identifier() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class EventParameterListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def eventParameter(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.EventParameterContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.EventParameterContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_eventParameterList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterEventParameterList" ): | |
| listener.enterEventParameterList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitEventParameterList" ): | |
| listener.exitEventParameterList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitEventParameterList" ): | |
| return visitor.visitEventParameterList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def eventParameterList(self): | |
| localctx = SolidityParser.EventParameterListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 62, self.RULE_eventParameterList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 518 | |
| self.match(SolidityParser.T__21) | |
| self.state = 527 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0): | |
| self.state = 519 | |
| self.eventParameter() | |
| self.state = 524 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 520 | |
| self.match(SolidityParser.T__14) | |
| self.state = 521 | |
| self.eventParameter() | |
| self.state = 526 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 529 | |
| self.match(SolidityParser.T__22) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class EventParameterContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def IndexedKeyword(self): | |
| return self.getToken(SolidityParser.IndexedKeyword, 0) | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_eventParameter | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterEventParameter" ): | |
| listener.enterEventParameter(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitEventParameter" ): | |
| listener.exitEventParameter(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitEventParameter" ): | |
| return visitor.visitEventParameter(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def eventParameter(self): | |
| localctx = SolidityParser.EventParameterContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 64, self.RULE_eventParameter) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 531 | |
| self.typeName(0) | |
| self.state = 533 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.IndexedKeyword: | |
| self.state = 532 | |
| self.match(SolidityParser.IndexedKeyword) | |
| self.state = 536 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 535 | |
| self.identifier() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class FunctionTypeParameterListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def functionTypeParameter(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_functionTypeParameterList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterFunctionTypeParameterList" ): | |
| listener.enterFunctionTypeParameterList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitFunctionTypeParameterList" ): | |
| listener.exitFunctionTypeParameterList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitFunctionTypeParameterList" ): | |
| return visitor.visitFunctionTypeParameterList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def functionTypeParameterList(self): | |
| localctx = SolidityParser.FunctionTypeParameterListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 66, self.RULE_functionTypeParameterList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 538 | |
| self.match(SolidityParser.T__21) | |
| self.state = 547 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0): | |
| self.state = 539 | |
| self.functionTypeParameter() | |
| self.state = 544 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 540 | |
| self.match(SolidityParser.T__14) | |
| self.state = 541 | |
| self.functionTypeParameter() | |
| self.state = 546 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 549 | |
| self.match(SolidityParser.T__22) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class FunctionTypeParameterContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def storageLocation(self): | |
| return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_functionTypeParameter | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterFunctionTypeParameter" ): | |
| listener.enterFunctionTypeParameter(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitFunctionTypeParameter" ): | |
| listener.exitFunctionTypeParameter(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitFunctionTypeParameter" ): | |
| return visitor.visitFunctionTypeParameter(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def functionTypeParameter(self): | |
| localctx = SolidityParser.FunctionTypeParameterContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 68, self.RULE_functionTypeParameter) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 551 | |
| self.typeName(0) | |
| self.state = 553 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__43) | (1 << SolidityParser.T__44) | (1 << SolidityParser.T__45))) != 0): | |
| self.state = 552 | |
| self.storageLocation() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class VariableDeclarationContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def storageLocation(self): | |
| return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_variableDeclaration | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterVariableDeclaration" ): | |
| listener.enterVariableDeclaration(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitVariableDeclaration" ): | |
| listener.exitVariableDeclaration(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitVariableDeclaration" ): | |
| return visitor.visitVariableDeclaration(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def variableDeclaration(self): | |
| localctx = SolidityParser.VariableDeclarationContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 70, self.RULE_variableDeclaration) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 555 | |
| self.typeName(0) | |
| self.state = 557 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,57,self._ctx) | |
| if la_ == 1: | |
| self.state = 556 | |
| self.storageLocation() | |
| self.state = 559 | |
| self.identifier() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class TypeNameContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def elementaryTypeName(self): | |
| return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0) | |
| def userDefinedTypeName(self): | |
| return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0) | |
| def mapping(self): | |
| return self.getTypedRuleContext(SolidityParser.MappingContext,0) | |
| def functionTypeName(self): | |
| return self.getTypedRuleContext(SolidityParser.FunctionTypeNameContext,0) | |
| def PayableKeyword(self): | |
| return self.getToken(SolidityParser.PayableKeyword, 0) | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.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, _p:int=0): | |
| _parentctx = self._ctx | |
| _parentState = self.state | |
| localctx = SolidityParser.TypeNameContext(self, self._ctx, _parentState) | |
| _prevctx = localctx | |
| _startState = 72 | |
| self.enterRecursionRule(localctx, 72, self.RULE_typeName, _p) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 568 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,58,self._ctx) | |
| if la_ == 1: | |
| self.state = 562 | |
| self.elementaryTypeName() | |
| pass | |
| elif la_ == 2: | |
| self.state = 563 | |
| self.userDefinedTypeName() | |
| pass | |
| elif la_ == 3: | |
| self.state = 564 | |
| self.mapping() | |
| pass | |
| elif la_ == 4: | |
| self.state = 565 | |
| self.functionTypeName() | |
| pass | |
| elif la_ == 5: | |
| self.state = 566 | |
| self.match(SolidityParser.T__39) | |
| self.state = 567 | |
| self.match(SolidityParser.PayableKeyword) | |
| pass | |
| self._ctx.stop = self._input.LT(-1) | |
| self.state = 578 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,60,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 = SolidityParser.TypeNameContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_typeName) | |
| self.state = 570 | |
| if not self.precpred(self._ctx, 3): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") | |
| self.state = 571 | |
| self.match(SolidityParser.T__37) | |
| self.state = 573 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 572 | |
| self.expression(0) | |
| self.state = 575 | |
| self.match(SolidityParser.T__38) | |
| self.state = 580 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,60,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 UserDefinedTypeNameContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.IdentifierContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_userDefinedTypeName | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterUserDefinedTypeName" ): | |
| listener.enterUserDefinedTypeName(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitUserDefinedTypeName" ): | |
| listener.exitUserDefinedTypeName(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitUserDefinedTypeName" ): | |
| return visitor.visitUserDefinedTypeName(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def userDefinedTypeName(self): | |
| localctx = SolidityParser.UserDefinedTypeNameContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 74, self.RULE_userDefinedTypeName) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 581 | |
| self.identifier() | |
| self.state = 586 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,61,self._ctx) | |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: | |
| if _alt==1: | |
| self.state = 582 | |
| self.match(SolidityParser.T__40) | |
| self.state = 583 | |
| self.identifier() | |
| self.state = 588 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,61,self._ctx) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class MappingContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def elementaryTypeName(self): | |
| return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0) | |
| def userDefinedTypeName(self): | |
| return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_mapping | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterMapping" ): | |
| listener.enterMapping(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitMapping" ): | |
| listener.exitMapping(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitMapping" ): | |
| return visitor.visitMapping(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def mapping(self): | |
| localctx = SolidityParser.MappingContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 76, self.RULE_mapping) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 589 | |
| self.match(SolidityParser.T__41) | |
| self.state = 590 | |
| self.match(SolidityParser.T__21) | |
| self.state = 593 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__39, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed]: | |
| self.state = 591 | |
| self.elementaryTypeName() | |
| pass | |
| elif token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]: | |
| self.state = 592 | |
| self.userDefinedTypeName() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 595 | |
| self.match(SolidityParser.T__42) | |
| self.state = 596 | |
| self.typeName(0) | |
| self.state = 597 | |
| self.match(SolidityParser.T__22) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class FunctionTypeNameContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def functionTypeParameterList(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterListContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterListContext,i) | |
| def InternalKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.InternalKeyword) | |
| else: | |
| return self.getToken(SolidityParser.InternalKeyword, i) | |
| def ExternalKeyword(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.ExternalKeyword) | |
| else: | |
| return self.getToken(SolidityParser.ExternalKeyword, i) | |
| def stateMutability(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i) | |
| def parameterList(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.ParameterListContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ParameterListContext,i) | |
| def visibility(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.VisibilityContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.VisibilityContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_functionTypeName | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterFunctionTypeName" ): | |
| listener.enterFunctionTypeName(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitFunctionTypeName" ): | |
| listener.exitFunctionTypeName(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitFunctionTypeName" ): | |
| return visitor.visitFunctionTypeName(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def functionTypeName(self): | |
| localctx = SolidityParser.FunctionTypeNameContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 78, self.RULE_functionTypeName) | |
| self._la = 0 # Token type | |
| try: | |
| self.state = 631 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,69,self._ctx) | |
| if la_ == 1: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 599 | |
| self.match(SolidityParser.T__31) | |
| self.state = 600 | |
| self.functionTypeParameterList() | |
| self.state = 606 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,64,self._ctx) | |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: | |
| if _alt==1: | |
| self.state = 604 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.InternalKeyword]: | |
| self.state = 601 | |
| self.match(SolidityParser.InternalKeyword) | |
| pass | |
| elif token in [SolidityParser.ExternalKeyword]: | |
| self.state = 602 | |
| self.match(SolidityParser.ExternalKeyword) | |
| pass | |
| elif token in [SolidityParser.ConstantKeyword, SolidityParser.PayableKeyword, SolidityParser.PureKeyword, SolidityParser.ViewKeyword]: | |
| self.state = 603 | |
| self.stateMutability() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 608 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,64,self._ctx) | |
| self.state = 611 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,65,self._ctx) | |
| if la_ == 1: | |
| self.state = 609 | |
| self.match(SolidityParser.T__34) | |
| self.state = 610 | |
| self.functionTypeParameterList() | |
| pass | |
| elif la_ == 2: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 613 | |
| self.match(SolidityParser.T__31) | |
| self.state = 614 | |
| self.match(SolidityParser.T__21) | |
| self.state = 616 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__21: | |
| self.state = 615 | |
| self.parameterList() | |
| self.state = 618 | |
| self.match(SolidityParser.T__22) | |
| self.state = 623 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while ((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.ExternalKeyword - 116)) | (1 << (SolidityParser.InternalKeyword - 116)) | (1 << (SolidityParser.PayableKeyword - 116)) | (1 << (SolidityParser.PrivateKeyword - 116)) | (1 << (SolidityParser.PublicKeyword - 116)) | (1 << (SolidityParser.PureKeyword - 116)) | (1 << (SolidityParser.ViewKeyword - 116)))) != 0): | |
| self.state = 621 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.ExternalKeyword, SolidityParser.InternalKeyword, SolidityParser.PrivateKeyword, SolidityParser.PublicKeyword]: | |
| self.state = 619 | |
| self.visibility() | |
| pass | |
| elif token in [SolidityParser.ConstantKeyword, SolidityParser.PayableKeyword, SolidityParser.PureKeyword, SolidityParser.ViewKeyword]: | |
| self.state = 620 | |
| self.stateMutability() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 625 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 626 | |
| self.match(SolidityParser.T__34) | |
| self.state = 627 | |
| self.match(SolidityParser.T__21) | |
| self.state = 628 | |
| self.parameterList() | |
| self.state = 629 | |
| self.match(SolidityParser.T__22) | |
| pass | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class VisibilityContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def InternalKeyword(self): | |
| return self.getToken(SolidityParser.InternalKeyword, 0) | |
| def ExternalKeyword(self): | |
| return self.getToken(SolidityParser.ExternalKeyword, 0) | |
| def PrivateKeyword(self): | |
| return self.getToken(SolidityParser.PrivateKeyword, 0) | |
| def PublicKeyword(self): | |
| return self.getToken(SolidityParser.PublicKeyword, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_visibility | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterVisibility" ): | |
| listener.enterVisibility(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitVisibility" ): | |
| listener.exitVisibility(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitVisibility" ): | |
| return visitor.visitVisibility(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def visibility(self): | |
| localctx = SolidityParser.VisibilityContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 80, self.RULE_visibility) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 633 | |
| _la = self._input.LA(1) | |
| if not(((((_la - 121)) & ~0x3f) == 0 and ((1 << (_la - 121)) & ((1 << (SolidityParser.ExternalKeyword - 121)) | (1 << (SolidityParser.InternalKeyword - 121)) | (1 << (SolidityParser.PrivateKeyword - 121)) | (1 << (SolidityParser.PublicKeyword - 121)))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class StorageLocationContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_storageLocation | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterStorageLocation" ): | |
| listener.enterStorageLocation(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitStorageLocation" ): | |
| listener.exitStorageLocation(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitStorageLocation" ): | |
| return visitor.visitStorageLocation(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def storageLocation(self): | |
| localctx = SolidityParser.StorageLocationContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 82, self.RULE_storageLocation) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 635 | |
| _la = self._input.LA(1) | |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__43) | (1 << SolidityParser.T__44) | (1 << SolidityParser.T__45))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class StateMutabilityContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def PureKeyword(self): | |
| return self.getToken(SolidityParser.PureKeyword, 0) | |
| def ConstantKeyword(self): | |
| return self.getToken(SolidityParser.ConstantKeyword, 0) | |
| def ViewKeyword(self): | |
| return self.getToken(SolidityParser.ViewKeyword, 0) | |
| def PayableKeyword(self): | |
| return self.getToken(SolidityParser.PayableKeyword, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_stateMutability | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterStateMutability" ): | |
| listener.enterStateMutability(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitStateMutability" ): | |
| listener.exitStateMutability(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitStateMutability" ): | |
| return visitor.visitStateMutability(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def stateMutability(self): | |
| localctx = SolidityParser.StateMutabilityContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 84, self.RULE_stateMutability) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 637 | |
| _la = self._input.LA(1) | |
| if not(((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.PayableKeyword - 116)) | (1 << (SolidityParser.PureKeyword - 116)) | (1 << (SolidityParser.ViewKeyword - 116)))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class BlockContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def statement(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.StatementContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.StatementContext,i) | |
| def uncheckedBlock(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.UncheckedBlockContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.UncheckedBlockContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_block | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterBlock" ): | |
| listener.enterBlock(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitBlock" ): | |
| listener.exitBlock(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitBlock" ): | |
| return visitor.visitBlock(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def block(self): | |
| localctx = SolidityParser.BlockContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 86, self.RULE_block) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 639 | |
| self.match(SolidityParser.T__13) | |
| self.state = 644 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__13) | (1 << SolidityParser.T__21) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__46) | (1 << SolidityParser.T__47) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60) | (1 << SolidityParser.T__61) | (1 << SolidityParser.T__62))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SolidityParser.T__63 - 64)) | (1 << (SolidityParser.T__64 - 64)) | (1 << (SolidityParser.T__65 - 64)) | (1 << (SolidityParser.T__66 - 64)) | (1 << (SolidityParser.T__67 - 64)) | (1 << (SolidityParser.T__68 - 64)) | (1 << (SolidityParser.Int - 64)) | (1 << (SolidityParser.Uint - 64)) | (1 << (SolidityParser.Byte - 64)) | (1 << (SolidityParser.Fixed - 64)) | (1 << (SolidityParser.Ufixed - 64)) | (1 << (SolidityParser.BooleanLiteral - 64)) | (1 << (SolidityParser.DecimalNumber - 64)) | (1 << (SolidityParser.HexNumber - 64)) | (1 << (SolidityParser.HexLiteral - 64)) | (1 << (SolidityParser.BreakKeyword - 64)) | (1 << (SolidityParser.ContinueKeyword - 64)) | (1 << (SolidityParser.PayableKeyword - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SolidityParser.TypeKeyword - 128)) | (1 << (SolidityParser.Identifier - 128)) | (1 << (SolidityParser.StringLiteral - 128)) | (1 << (SolidityParser.LINE_COMMENT - 128)) | (1 << (SolidityParser.COMMENT - 128)))) != 0): | |
| self.state = 642 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__13, SolidityParser.T__21, SolidityParser.T__27, SolidityParser.T__31, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__41, SolidityParser.T__45, SolidityParser.T__47, SolidityParser.T__48, SolidityParser.T__49, SolidityParser.T__51, SolidityParser.T__52, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.BreakKeyword, SolidityParser.ContinueKeyword, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral, SolidityParser.LINE_COMMENT, SolidityParser.COMMENT]: | |
| self.state = 640 | |
| self.statement() | |
| pass | |
| elif token in [SolidityParser.T__46]: | |
| self.state = 641 | |
| self.uncheckedBlock() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 646 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 647 | |
| self.match(SolidityParser.T__15) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class UncheckedBlockContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def block(self): | |
| return self.getTypedRuleContext(SolidityParser.BlockContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_uncheckedBlock | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterUncheckedBlock" ): | |
| listener.enterUncheckedBlock(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitUncheckedBlock" ): | |
| listener.exitUncheckedBlock(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitUncheckedBlock" ): | |
| return visitor.visitUncheckedBlock(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def uncheckedBlock(self): | |
| localctx = SolidityParser.UncheckedBlockContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 88, self.RULE_uncheckedBlock) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 649 | |
| self.match(SolidityParser.T__46) | |
| self.state = 650 | |
| self.block() | |
| 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): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def ifStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.IfStatementContext,0) | |
| def whileStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.WhileStatementContext,0) | |
| def forStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.ForStatementContext,0) | |
| def block(self): | |
| return self.getTypedRuleContext(SolidityParser.BlockContext,0) | |
| def inlineAssemblyStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.InlineAssemblyStatementContext,0) | |
| def doWhileStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.DoWhileStatementContext,0) | |
| def continueStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.ContinueStatementContext,0) | |
| def breakStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.BreakStatementContext,0) | |
| def returnStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.ReturnStatementContext,0) | |
| def throwStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.ThrowStatementContext,0) | |
| def emitStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.EmitStatementContext,0) | |
| def simpleStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0) | |
| def tryStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.TryStatementContext,0) | |
| def catchClause(self): | |
| return self.getTypedRuleContext(SolidityParser.CatchClauseContext,0) | |
| def LINE_COMMENT(self): | |
| return self.getToken(SolidityParser.LINE_COMMENT, 0) | |
| def COMMENT(self): | |
| return self.getToken(SolidityParser.COMMENT, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.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 = SolidityParser.StatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 90, self.RULE_statement) | |
| try: | |
| self.state = 668 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__49]: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 652 | |
| self.ifStatement() | |
| pass | |
| elif token in [SolidityParser.T__51]: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 653 | |
| self.whileStatement() | |
| pass | |
| elif token in [SolidityParser.T__27]: | |
| self.enterOuterAlt(localctx, 3) | |
| self.state = 654 | |
| self.forStatement() | |
| pass | |
| elif token in [SolidityParser.T__13]: | |
| self.enterOuterAlt(localctx, 4) | |
| self.state = 655 | |
| self.block() | |
| pass | |
| elif token in [SolidityParser.T__52]: | |
| self.enterOuterAlt(localctx, 5) | |
| self.state = 656 | |
| self.inlineAssemblyStatement() | |
| pass | |
| elif token in [SolidityParser.T__53]: | |
| self.enterOuterAlt(localctx, 6) | |
| self.state = 657 | |
| self.doWhileStatement() | |
| pass | |
| elif token in [SolidityParser.ContinueKeyword]: | |
| self.enterOuterAlt(localctx, 7) | |
| self.state = 658 | |
| self.continueStatement() | |
| pass | |
| elif token in [SolidityParser.BreakKeyword]: | |
| self.enterOuterAlt(localctx, 8) | |
| self.state = 659 | |
| self.breakStatement() | |
| pass | |
| elif token in [SolidityParser.T__54]: | |
| self.enterOuterAlt(localctx, 9) | |
| self.state = 660 | |
| self.returnStatement() | |
| pass | |
| elif token in [SolidityParser.T__55]: | |
| self.enterOuterAlt(localctx, 10) | |
| self.state = 661 | |
| self.throwStatement() | |
| pass | |
| elif token in [SolidityParser.T__56]: | |
| self.enterOuterAlt(localctx, 11) | |
| self.state = 662 | |
| self.emitStatement() | |
| pass | |
| elif token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__21, SolidityParser.T__31, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__41, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral]: | |
| self.enterOuterAlt(localctx, 12) | |
| self.state = 663 | |
| self.simpleStatement() | |
| pass | |
| elif token in [SolidityParser.T__47]: | |
| self.enterOuterAlt(localctx, 13) | |
| self.state = 664 | |
| self.tryStatement() | |
| pass | |
| elif token in [SolidityParser.T__48]: | |
| self.enterOuterAlt(localctx, 14) | |
| self.state = 665 | |
| self.catchClause() | |
| pass | |
| elif token in [SolidityParser.LINE_COMMENT]: | |
| self.enterOuterAlt(localctx, 15) | |
| self.state = 666 | |
| self.match(SolidityParser.LINE_COMMENT) | |
| pass | |
| elif token in [SolidityParser.COMMENT]: | |
| self.enterOuterAlt(localctx, 16) | |
| self.state = 667 | |
| self.match(SolidityParser.COMMENT) | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class TryStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def block(self): | |
| return self.getTypedRuleContext(SolidityParser.BlockContext,0) | |
| def parameterList(self): | |
| return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) | |
| def catchClause(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.CatchClauseContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.CatchClauseContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_tryStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterTryStatement" ): | |
| listener.enterTryStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitTryStatement" ): | |
| listener.exitTryStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitTryStatement" ): | |
| return visitor.visitTryStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def tryStatement(self): | |
| localctx = SolidityParser.TryStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 92, self.RULE_tryStatement) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 670 | |
| self.match(SolidityParser.T__47) | |
| self.state = 671 | |
| self.expression(0) | |
| self.state = 677 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__34: | |
| self.state = 672 | |
| self.match(SolidityParser.T__34) | |
| self.state = 673 | |
| self.match(SolidityParser.T__21) | |
| self.state = 674 | |
| self.parameterList() | |
| self.state = 675 | |
| self.match(SolidityParser.T__22) | |
| self.state = 679 | |
| self.block() | |
| self.state = 683 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,74,self._ctx) | |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: | |
| if _alt==1: | |
| self.state = 680 | |
| self.catchClause() | |
| self.state = 685 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,74,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 CatchClauseContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def block(self): | |
| return self.getTypedRuleContext(SolidityParser.BlockContext,0) | |
| def parameterList(self): | |
| return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def natSpec(self): | |
| return self.getTypedRuleContext(SolidityParser.NatSpecContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_catchClause | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterCatchClause" ): | |
| listener.enterCatchClause(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitCatchClause" ): | |
| listener.exitCatchClause(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitCatchClause" ): | |
| return visitor.visitCatchClause(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def catchClause(self): | |
| localctx = SolidityParser.CatchClauseContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 94, self.RULE_catchClause) | |
| self._la = 0 # Token type | |
| try: | |
| self.state = 702 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,78,self._ctx) | |
| if la_ == 1: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 686 | |
| self.match(SolidityParser.T__48) | |
| self.state = 697 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__21) | (1 << SolidityParser.T__45))) != 0) or _la==SolidityParser.Identifier: | |
| self.state = 688 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 687 | |
| self.identifier() | |
| self.state = 690 | |
| self.match(SolidityParser.T__21) | |
| self.state = 691 | |
| self.parameterList() | |
| self.state = 693 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.NatSpecSingleLine or _la==SolidityParser.NatSpecMultiLine: | |
| self.state = 692 | |
| self.natSpec() | |
| self.state = 695 | |
| self.match(SolidityParser.T__22) | |
| self.state = 699 | |
| self.block() | |
| pass | |
| elif la_ == 2: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 700 | |
| self.match(SolidityParser.T__48) | |
| self.state = 701 | |
| self.block() | |
| 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): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.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 = SolidityParser.ExpressionStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 96, self.RULE_expressionStatement) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 704 | |
| self.expression(0) | |
| self.state = 705 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class IfStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def ifCondition(self): | |
| return self.getTypedRuleContext(SolidityParser.IfConditionContext,0) | |
| def ifRight(self): | |
| return self.getTypedRuleContext(SolidityParser.IfRightContext,0) | |
| def ifWrong(self): | |
| return self.getTypedRuleContext(SolidityParser.IfWrongContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_ifStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterIfStatement" ): | |
| listener.enterIfStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitIfStatement" ): | |
| listener.exitIfStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitIfStatement" ): | |
| return visitor.visitIfStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def ifStatement(self): | |
| localctx = SolidityParser.IfStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 98, self.RULE_ifStatement) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 707 | |
| self.match(SolidityParser.T__49) | |
| self.state = 708 | |
| self.match(SolidityParser.T__21) | |
| self.state = 709 | |
| self.ifCondition() | |
| self.state = 710 | |
| self.match(SolidityParser.T__22) | |
| self.state = 711 | |
| self.ifRight() | |
| self.state = 714 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,79,self._ctx) | |
| if la_ == 1: | |
| self.state = 712 | |
| self.match(SolidityParser.T__50) | |
| self.state = 713 | |
| self.ifWrong() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class IfConditionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_ifCondition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterIfCondition" ): | |
| listener.enterIfCondition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitIfCondition" ): | |
| listener.exitIfCondition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitIfCondition" ): | |
| return visitor.visitIfCondition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def ifCondition(self): | |
| localctx = SolidityParser.IfConditionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 100, self.RULE_ifCondition) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 716 | |
| self.expression(0) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class IfRightContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def statement(self): | |
| return self.getTypedRuleContext(SolidityParser.StatementContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_ifRight | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterIfRight" ): | |
| listener.enterIfRight(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitIfRight" ): | |
| listener.exitIfRight(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitIfRight" ): | |
| return visitor.visitIfRight(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def ifRight(self): | |
| localctx = SolidityParser.IfRightContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 102, self.RULE_ifRight) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 718 | |
| self.statement() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class IfWrongContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def statement(self): | |
| return self.getTypedRuleContext(SolidityParser.StatementContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_ifWrong | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterIfWrong" ): | |
| listener.enterIfWrong(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitIfWrong" ): | |
| listener.exitIfWrong(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitIfWrong" ): | |
| return visitor.visitIfWrong(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def ifWrong(self): | |
| localctx = SolidityParser.IfWrongContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 104, self.RULE_ifWrong) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 720 | |
| self.statement() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class WhileStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def statement(self): | |
| return self.getTypedRuleContext(SolidityParser.StatementContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_whileStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterWhileStatement" ): | |
| listener.enterWhileStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitWhileStatement" ): | |
| listener.exitWhileStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitWhileStatement" ): | |
| return visitor.visitWhileStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def whileStatement(self): | |
| localctx = SolidityParser.WhileStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 106, self.RULE_whileStatement) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 722 | |
| self.match(SolidityParser.T__51) | |
| self.state = 723 | |
| self.match(SolidityParser.T__21) | |
| self.state = 724 | |
| self.expression(0) | |
| self.state = 725 | |
| self.match(SolidityParser.T__22) | |
| self.state = 726 | |
| self.statement() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class SimpleStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def variableDeclarationStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.VariableDeclarationStatementContext,0) | |
| def expressionStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_simpleStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterSimpleStatement" ): | |
| listener.enterSimpleStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitSimpleStatement" ): | |
| listener.exitSimpleStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitSimpleStatement" ): | |
| return visitor.visitSimpleStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def simpleStatement(self): | |
| localctx = SolidityParser.SimpleStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 108, self.RULE_simpleStatement) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 730 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,80,self._ctx) | |
| if la_ == 1: | |
| self.state = 728 | |
| self.variableDeclarationStatement() | |
| pass | |
| elif la_ == 2: | |
| self.state = 729 | |
| self.expressionStatement() | |
| pass | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ForStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def statement(self): | |
| return self.getTypedRuleContext(SolidityParser.StatementContext,0) | |
| def simpleStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0) | |
| def expressionStatement(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0) | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_forStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterForStatement" ): | |
| listener.enterForStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitForStatement" ): | |
| listener.exitForStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitForStatement" ): | |
| return visitor.visitForStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def forStatement(self): | |
| localctx = SolidityParser.ForStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 110, self.RULE_forStatement) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 732 | |
| self.match(SolidityParser.T__27) | |
| self.state = 733 | |
| self.match(SolidityParser.T__21) | |
| self.state = 736 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__21, SolidityParser.T__31, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__41, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral]: | |
| self.state = 734 | |
| self.simpleStatement() | |
| pass | |
| elif token in [SolidityParser.T__1]: | |
| self.state = 735 | |
| self.match(SolidityParser.T__1) | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 740 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__21, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral]: | |
| self.state = 738 | |
| self.expressionStatement() | |
| pass | |
| elif token in [SolidityParser.T__1]: | |
| self.state = 739 | |
| self.match(SolidityParser.T__1) | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 743 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 742 | |
| self.expression(0) | |
| self.state = 745 | |
| self.match(SolidityParser.T__22) | |
| self.state = 746 | |
| self.statement() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class InlineAssemblyStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyBlock(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) | |
| def StringLiteral(self): | |
| return self.getToken(SolidityParser.StringLiteral, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_inlineAssemblyStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterInlineAssemblyStatement" ): | |
| listener.enterInlineAssemblyStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitInlineAssemblyStatement" ): | |
| listener.exitInlineAssemblyStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitInlineAssemblyStatement" ): | |
| return visitor.visitInlineAssemblyStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def inlineAssemblyStatement(self): | |
| localctx = SolidityParser.InlineAssemblyStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 112, self.RULE_inlineAssemblyStatement) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 748 | |
| self.match(SolidityParser.T__52) | |
| self.state = 750 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.StringLiteral: | |
| self.state = 749 | |
| self.match(SolidityParser.StringLiteral) | |
| self.state = 752 | |
| self.assemblyBlock() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class DoWhileStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def statement(self): | |
| return self.getTypedRuleContext(SolidityParser.StatementContext,0) | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_doWhileStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterDoWhileStatement" ): | |
| listener.enterDoWhileStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitDoWhileStatement" ): | |
| listener.exitDoWhileStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitDoWhileStatement" ): | |
| return visitor.visitDoWhileStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def doWhileStatement(self): | |
| localctx = SolidityParser.DoWhileStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 114, self.RULE_doWhileStatement) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 754 | |
| self.match(SolidityParser.T__53) | |
| self.state = 755 | |
| self.statement() | |
| self.state = 756 | |
| self.match(SolidityParser.T__51) | |
| self.state = 757 | |
| self.match(SolidityParser.T__21) | |
| self.state = 758 | |
| self.expression(0) | |
| self.state = 759 | |
| self.match(SolidityParser.T__22) | |
| self.state = 760 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ContinueStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def ContinueKeyword(self): | |
| return self.getToken(SolidityParser.ContinueKeyword, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_continueStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterContinueStatement" ): | |
| listener.enterContinueStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitContinueStatement" ): | |
| listener.exitContinueStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitContinueStatement" ): | |
| return visitor.visitContinueStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def continueStatement(self): | |
| localctx = SolidityParser.ContinueStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 116, self.RULE_continueStatement) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 762 | |
| self.match(SolidityParser.ContinueKeyword) | |
| self.state = 763 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class BreakStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def BreakKeyword(self): | |
| return self.getToken(SolidityParser.BreakKeyword, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_breakStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterBreakStatement" ): | |
| listener.enterBreakStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitBreakStatement" ): | |
| listener.exitBreakStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitBreakStatement" ): | |
| return visitor.visitBreakStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def breakStatement(self): | |
| localctx = SolidityParser.BreakStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 118, self.RULE_breakStatement) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 765 | |
| self.match(SolidityParser.BreakKeyword) | |
| self.state = 766 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ReturnStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_returnStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterReturnStatement" ): | |
| listener.enterReturnStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitReturnStatement" ): | |
| listener.exitReturnStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitReturnStatement" ): | |
| return visitor.visitReturnStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def returnStatement(self): | |
| localctx = SolidityParser.ReturnStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 120, self.RULE_returnStatement) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 768 | |
| self.match(SolidityParser.T__54) | |
| self.state = 770 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 769 | |
| self.expression(0) | |
| self.state = 772 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ThrowStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_throwStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterThrowStatement" ): | |
| listener.enterThrowStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitThrowStatement" ): | |
| listener.exitThrowStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitThrowStatement" ): | |
| return visitor.visitThrowStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def throwStatement(self): | |
| localctx = SolidityParser.ThrowStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 122, self.RULE_throwStatement) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 774 | |
| self.match(SolidityParser.T__55) | |
| self.state = 775 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class EmitStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def functionCall(self): | |
| return self.getTypedRuleContext(SolidityParser.FunctionCallContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_emitStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterEmitStatement" ): | |
| listener.enterEmitStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitEmitStatement" ): | |
| listener.exitEmitStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitEmitStatement" ): | |
| return visitor.visitEmitStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def emitStatement(self): | |
| localctx = SolidityParser.EmitStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 124, self.RULE_emitStatement) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 777 | |
| self.match(SolidityParser.T__56) | |
| self.state = 778 | |
| self.functionCall() | |
| self.state = 779 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class VariableDeclarationStatementContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifierList(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierListContext,0) | |
| def variableDeclaration(self): | |
| return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,0) | |
| def variableDeclarationList(self): | |
| return self.getTypedRuleContext(SolidityParser.VariableDeclarationListContext,0) | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_variableDeclarationStatement | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterVariableDeclarationStatement" ): | |
| listener.enterVariableDeclarationStatement(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitVariableDeclarationStatement" ): | |
| listener.exitVariableDeclarationStatement(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitVariableDeclarationStatement" ): | |
| return visitor.visitVariableDeclarationStatement(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def variableDeclarationStatement(self): | |
| localctx = SolidityParser.VariableDeclarationStatementContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 126, self.RULE_variableDeclarationStatement) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 788 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,86,self._ctx) | |
| if la_ == 1: | |
| self.state = 781 | |
| self.match(SolidityParser.T__57) | |
| self.state = 782 | |
| self.identifierList() | |
| pass | |
| elif la_ == 2: | |
| self.state = 783 | |
| self.variableDeclaration() | |
| pass | |
| elif la_ == 3: | |
| self.state = 784 | |
| self.match(SolidityParser.T__21) | |
| self.state = 785 | |
| self.variableDeclarationList() | |
| self.state = 786 | |
| self.match(SolidityParser.T__22) | |
| pass | |
| self.state = 792 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__8: | |
| self.state = 790 | |
| self.match(SolidityParser.T__8) | |
| self.state = 791 | |
| self.expression(0) | |
| self.state = 794 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ConstantVariableDeclarationContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def ConstantKeyword(self): | |
| return self.getToken(SolidityParser.ConstantKeyword, 0) | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_constantVariableDeclaration | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterConstantVariableDeclaration" ): | |
| listener.enterConstantVariableDeclaration(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitConstantVariableDeclaration" ): | |
| listener.exitConstantVariableDeclaration(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitConstantVariableDeclaration" ): | |
| return visitor.visitConstantVariableDeclaration(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def constantVariableDeclaration(self): | |
| localctx = SolidityParser.ConstantVariableDeclarationContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 128, self.RULE_constantVariableDeclaration) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 796 | |
| self.typeName(0) | |
| self.state = 797 | |
| self.match(SolidityParser.ConstantKeyword) | |
| self.state = 798 | |
| self.identifier() | |
| self.state = 799 | |
| self.match(SolidityParser.T__8) | |
| self.state = 800 | |
| self.expression(0) | |
| self.state = 801 | |
| self.match(SolidityParser.T__1) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class VariableDeclarationListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def variableDeclaration(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_variableDeclarationList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterVariableDeclarationList" ): | |
| listener.enterVariableDeclarationList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitVariableDeclarationList" ): | |
| listener.exitVariableDeclarationList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitVariableDeclarationList" ): | |
| return visitor.visitVariableDeclarationList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def variableDeclarationList(self): | |
| localctx = SolidityParser.VariableDeclarationListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 130, self.RULE_variableDeclarationList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 804 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0): | |
| self.state = 803 | |
| self.variableDeclaration() | |
| self.state = 812 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 806 | |
| self.match(SolidityParser.T__14) | |
| self.state = 808 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0): | |
| self.state = 807 | |
| self.variableDeclaration() | |
| self.state = 814 | |
| 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 IdentifierListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.IdentifierContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.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): | |
| localctx = SolidityParser.IdentifierListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 132, self.RULE_identifierList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 815 | |
| self.match(SolidityParser.T__21) | |
| self.state = 822 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,92,self._ctx) | |
| while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: | |
| if _alt==1: | |
| self.state = 817 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 816 | |
| self.identifier() | |
| self.state = 819 | |
| self.match(SolidityParser.T__14) | |
| self.state = 824 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,92,self._ctx) | |
| self.state = 826 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 825 | |
| self.identifier() | |
| self.state = 828 | |
| self.match(SolidityParser.T__22) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ElementaryTypeNameContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def Int(self): | |
| return self.getToken(SolidityParser.Int, 0) | |
| def Uint(self): | |
| return self.getToken(SolidityParser.Uint, 0) | |
| def Byte(self): | |
| return self.getToken(SolidityParser.Byte, 0) | |
| def Fixed(self): | |
| return self.getToken(SolidityParser.Fixed, 0) | |
| def Ufixed(self): | |
| return self.getToken(SolidityParser.Ufixed, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_elementaryTypeName | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterElementaryTypeName" ): | |
| listener.enterElementaryTypeName(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitElementaryTypeName" ): | |
| listener.exitElementaryTypeName(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitElementaryTypeName" ): | |
| return visitor.visitElementaryTypeName(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def elementaryTypeName(self): | |
| localctx = SolidityParser.ElementaryTypeNameContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 134, self.RULE_elementaryTypeName) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 830 | |
| _la = self._input.LA(1) | |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__39) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ExpressionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| 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(SolidityParser.ExpressionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,i) | |
| def PayableKeyword(self): | |
| return self.getToken(SolidityParser.PayableKeyword, 0) | |
| def callArgumentList(self): | |
| return self.getTypedRuleContext(SolidityParser.CallArgumentListContext,0) | |
| def TypeKeyword(self): | |
| return self.getToken(SolidityParser.TypeKeyword, 0) | |
| def typeName(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) | |
| def primaryExpression(self): | |
| return self.getTypedRuleContext(SolidityParser.PrimaryExpressionContext,0) | |
| def identifier(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.IdentifierContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) | |
| def functionCallArguments(self): | |
| return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.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 = SolidityParser.ExpressionContext(self, self._ctx, _parentState) | |
| _prevctx = localctx | |
| _startState = 136 | |
| self.enterRecursionRule(localctx, 136, self.RULE_expression, _p) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 868 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,95,self._ctx) | |
| if la_ == 1: | |
| self.state = 833 | |
| self.match(SolidityParser.T__37) | |
| self.state = 834 | |
| self.expression(0) | |
| self.state = 839 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 835 | |
| self.match(SolidityParser.T__14) | |
| self.state = 836 | |
| self.expression(0) | |
| self.state = 841 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 842 | |
| self.match(SolidityParser.T__38) | |
| pass | |
| elif la_ == 2: | |
| self.state = 844 | |
| self.match(SolidityParser.PayableKeyword) | |
| self.state = 845 | |
| self.callArgumentList() | |
| pass | |
| elif la_ == 3: | |
| self.state = 846 | |
| self.match(SolidityParser.TypeKeyword) | |
| self.state = 847 | |
| self.match(SolidityParser.T__21) | |
| self.state = 848 | |
| self.typeName(0) | |
| self.state = 849 | |
| self.match(SolidityParser.T__22) | |
| pass | |
| elif la_ == 4: | |
| self.state = 851 | |
| _la = self._input.LA(1) | |
| if not(((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 852 | |
| self.expression(23) | |
| pass | |
| elif la_ == 5: | |
| self.state = 853 | |
| self.match(SolidityParser.T__66) | |
| self.state = 854 | |
| self.typeName(0) | |
| pass | |
| elif la_ == 6: | |
| self.state = 855 | |
| self.match(SolidityParser.T__21) | |
| self.state = 856 | |
| self.expression(0) | |
| self.state = 857 | |
| self.match(SolidityParser.T__22) | |
| pass | |
| elif la_ == 7: | |
| self.state = 859 | |
| _la = self._input.LA(1) | |
| if not(_la==SolidityParser.T__65 or _la==SolidityParser.T__67): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 860 | |
| self.expression(18) | |
| pass | |
| elif la_ == 8: | |
| self.state = 861 | |
| _la = self._input.LA(1) | |
| if not(_la==SolidityParser.T__64 or _la==SolidityParser.T__68): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 862 | |
| self.expression(17) | |
| pass | |
| elif la_ == 9: | |
| self.state = 863 | |
| self.match(SolidityParser.T__63) | |
| self.state = 864 | |
| self.expression(16) | |
| pass | |
| elif la_ == 10: | |
| self.state = 865 | |
| self.match(SolidityParser.T__3) | |
| self.state = 866 | |
| self.expression(15) | |
| pass | |
| elif la_ == 11: | |
| self.state = 867 | |
| self.primaryExpression() | |
| pass | |
| self._ctx.stop = self._input.LT(-1) | |
| self.state = 961 | |
| 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 = 959 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,102,self._ctx) | |
| if la_ == 1: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 870 | |
| if not self.precpred(self._ctx, 14): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 14)") | |
| self.state = 871 | |
| self.match(SolidityParser.T__69) | |
| self.state = 872 | |
| self.expression(15) | |
| pass | |
| elif la_ == 2: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 873 | |
| if not self.precpred(self._ctx, 13): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 13)") | |
| self.state = 874 | |
| _la = self._input.LA(1) | |
| if not(((((_la - 12)) & ~0x3f) == 0 and ((1 << (_la - 12)) & ((1 << (SolidityParser.T__11 - 12)) | (1 << (SolidityParser.T__70 - 12)) | (1 << (SolidityParser.T__71 - 12)))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 875 | |
| self.expression(14) | |
| pass | |
| elif la_ == 3: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 876 | |
| if not self.precpred(self._ctx, 12): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 12)") | |
| self.state = 877 | |
| _la = self._input.LA(1) | |
| if not(_la==SolidityParser.T__65 or _la==SolidityParser.T__67): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 878 | |
| self.expression(13) | |
| pass | |
| elif la_ == 4: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 879 | |
| if not self.precpred(self._ctx, 11): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 11)") | |
| self.state = 880 | |
| _la = self._input.LA(1) | |
| if not(((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & ((1 << (SolidityParser.T__72 - 73)) | (1 << (SolidityParser.T__73 - 73)) | (1 << (SolidityParser.T__74 - 73)))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 881 | |
| self.expression(12) | |
| pass | |
| elif la_ == 5: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 882 | |
| if not self.precpred(self._ctx, 10): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 10)") | |
| self.state = 883 | |
| self.match(SolidityParser.T__75) | |
| self.state = 884 | |
| self.expression(11) | |
| pass | |
| elif la_ == 6: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 885 | |
| if not self.precpred(self._ctx, 9): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") | |
| self.state = 886 | |
| self.match(SolidityParser.T__2) | |
| self.state = 887 | |
| self.expression(10) | |
| pass | |
| elif la_ == 7: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 888 | |
| if not self.precpred(self._ctx, 8): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 8)") | |
| self.state = 889 | |
| self.match(SolidityParser.T__76) | |
| self.state = 890 | |
| self.expression(9) | |
| pass | |
| elif la_ == 8: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 891 | |
| if not self.precpred(self._ctx, 7): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") | |
| self.state = 892 | |
| _la = self._input.LA(1) | |
| if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 893 | |
| self.expression(8) | |
| pass | |
| elif la_ == 9: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 894 | |
| if not self.precpred(self._ctx, 6): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") | |
| self.state = 895 | |
| _la = self._input.LA(1) | |
| if not(_la==SolidityParser.T__77 or _la==SolidityParser.T__78): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 896 | |
| self.expression(7) | |
| pass | |
| elif la_ == 10: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 897 | |
| if not self.precpred(self._ctx, 5): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") | |
| self.state = 898 | |
| self.match(SolidityParser.T__79) | |
| self.state = 899 | |
| self.expression(6) | |
| pass | |
| elif la_ == 11: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 900 | |
| if not self.precpred(self._ctx, 4): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") | |
| self.state = 901 | |
| self.match(SolidityParser.T__80) | |
| self.state = 902 | |
| self.expression(5) | |
| pass | |
| elif la_ == 12: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 903 | |
| if not self.precpred(self._ctx, 3): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") | |
| self.state = 904 | |
| self.match(SolidityParser.T__81) | |
| self.state = 905 | |
| self.expression(0) | |
| self.state = 906 | |
| self.match(SolidityParser.T__24) | |
| self.state = 907 | |
| self.expression(4) | |
| pass | |
| elif la_ == 13: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 909 | |
| if not self.precpred(self._ctx, 2): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") | |
| self.state = 910 | |
| _la = self._input.LA(1) | |
| if not(_la==SolidityParser.T__8 or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (SolidityParser.T__82 - 83)) | (1 << (SolidityParser.T__83 - 83)) | (1 << (SolidityParser.T__84 - 83)) | (1 << (SolidityParser.T__85 - 83)) | (1 << (SolidityParser.T__86 - 83)) | (1 << (SolidityParser.T__87 - 83)) | (1 << (SolidityParser.T__88 - 83)) | (1 << (SolidityParser.T__89 - 83)) | (1 << (SolidityParser.T__90 - 83)) | (1 << (SolidityParser.T__91 - 83)) | (1 << (SolidityParser.T__92 - 83)))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 911 | |
| self.expression(3) | |
| pass | |
| elif la_ == 14: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 912 | |
| if not self.precpred(self._ctx, 30): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 30)") | |
| self.state = 913 | |
| self.match(SolidityParser.T__37) | |
| self.state = 915 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 914 | |
| self.expression(0) | |
| self.state = 917 | |
| self.match(SolidityParser.T__38) | |
| pass | |
| elif la_ == 15: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 918 | |
| if not self.precpred(self._ctx, 28): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 28)") | |
| self.state = 919 | |
| self.match(SolidityParser.T__37) | |
| self.state = 921 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 920 | |
| self.expression(0) | |
| self.state = 923 | |
| self.match(SolidityParser.T__24) | |
| self.state = 925 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 924 | |
| self.expression(0) | |
| self.state = 927 | |
| self.match(SolidityParser.T__38) | |
| pass | |
| elif la_ == 16: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 928 | |
| if not self.precpred(self._ctx, 27): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 27)") | |
| self.state = 929 | |
| self.match(SolidityParser.T__40) | |
| self.state = 932 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]: | |
| self.state = 930 | |
| self.identifier() | |
| pass | |
| elif token in [SolidityParser.T__39]: | |
| self.state = 931 | |
| self.match(SolidityParser.T__39) | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| pass | |
| elif la_ == 17: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 934 | |
| if not self.precpred(self._ctx, 26): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 26)") | |
| self.state = 935 | |
| self.match(SolidityParser.T__13) | |
| self.state = 949 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 936 | |
| self.identifier() | |
| self.state = 937 | |
| self.match(SolidityParser.T__24) | |
| self.state = 938 | |
| self.expression(0) | |
| self.state = 946 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 939 | |
| self.match(SolidityParser.T__14) | |
| self.state = 940 | |
| self.identifier() | |
| self.state = 941 | |
| self.match(SolidityParser.T__24) | |
| self.state = 942 | |
| self.expression(0) | |
| self.state = 948 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 951 | |
| self.match(SolidityParser.T__15) | |
| pass | |
| elif la_ == 18: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 952 | |
| if not self.precpred(self._ctx, 22): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 22)") | |
| self.state = 953 | |
| _la = self._input.LA(1) | |
| if not(_la==SolidityParser.T__61 or _la==SolidityParser.T__62): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| pass | |
| elif la_ == 19: | |
| localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) | |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) | |
| self.state = 954 | |
| if not self.precpred(self._ctx, 20): | |
| from antlr4.error.Errors import FailedPredicateException | |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 20)") | |
| self.state = 955 | |
| self.match(SolidityParser.T__21) | |
| self.state = 956 | |
| self.functionCallArguments() | |
| self.state = 957 | |
| self.match(SolidityParser.T__22) | |
| pass | |
| self.state = 963 | |
| 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 PrimaryExpressionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def BooleanLiteral(self): | |
| return self.getToken(SolidityParser.BooleanLiteral, 0) | |
| def numberLiteral(self): | |
| return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0) | |
| def HexLiteral(self): | |
| return self.getToken(SolidityParser.HexLiteral, 0) | |
| def StringLiteral(self): | |
| return self.getToken(SolidityParser.StringLiteral, 0) | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def TypeKeyword(self): | |
| return self.getToken(SolidityParser.TypeKeyword, 0) | |
| def tupleExpression(self): | |
| return self.getTypedRuleContext(SolidityParser.TupleExpressionContext,0) | |
| def typeNameExpression(self): | |
| return self.getTypedRuleContext(SolidityParser.TypeNameExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.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 = SolidityParser.PrimaryExpressionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 138, self.RULE_primaryExpression) | |
| try: | |
| self.state = 980 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,106,self._ctx) | |
| if la_ == 1: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 964 | |
| self.match(SolidityParser.BooleanLiteral) | |
| pass | |
| elif la_ == 2: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 965 | |
| self.numberLiteral() | |
| pass | |
| elif la_ == 3: | |
| self.enterOuterAlt(localctx, 3) | |
| self.state = 966 | |
| self.match(SolidityParser.HexLiteral) | |
| pass | |
| elif la_ == 4: | |
| self.enterOuterAlt(localctx, 4) | |
| self.state = 967 | |
| self.match(SolidityParser.StringLiteral) | |
| pass | |
| elif la_ == 5: | |
| self.enterOuterAlt(localctx, 5) | |
| self.state = 968 | |
| self.identifier() | |
| self.state = 971 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,104,self._ctx) | |
| if la_ == 1: | |
| self.state = 969 | |
| self.match(SolidityParser.T__37) | |
| self.state = 970 | |
| self.match(SolidityParser.T__38) | |
| pass | |
| elif la_ == 6: | |
| self.enterOuterAlt(localctx, 6) | |
| self.state = 973 | |
| self.match(SolidityParser.TypeKeyword) | |
| pass | |
| elif la_ == 7: | |
| self.enterOuterAlt(localctx, 7) | |
| self.state = 974 | |
| self.tupleExpression() | |
| pass | |
| elif la_ == 8: | |
| self.enterOuterAlt(localctx, 8) | |
| self.state = 975 | |
| self.typeNameExpression() | |
| self.state = 978 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,105,self._ctx) | |
| if la_ == 1: | |
| self.state = 976 | |
| self.match(SolidityParser.T__37) | |
| self.state = 977 | |
| self.match(SolidityParser.T__38) | |
| pass | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class ExpressionListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| 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(SolidityParser.ExpressionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_expressionList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterExpressionList" ): | |
| listener.enterExpressionList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitExpressionList" ): | |
| listener.exitExpressionList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitExpressionList" ): | |
| return visitor.visitExpressionList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def expressionList(self): | |
| localctx = SolidityParser.ExpressionListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 140, self.RULE_expressionList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 982 | |
| self.expression(0) | |
| self.state = 987 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 983 | |
| self.match(SolidityParser.T__14) | |
| self.state = 984 | |
| self.expression(0) | |
| self.state = 989 | |
| 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 NameValueListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def nameValue(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.NameValueContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.NameValueContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_nameValueList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterNameValueList" ): | |
| listener.enterNameValueList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitNameValueList" ): | |
| listener.exitNameValueList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitNameValueList" ): | |
| return visitor.visitNameValueList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def nameValueList(self): | |
| localctx = SolidityParser.NameValueListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 142, self.RULE_nameValueList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 990 | |
| self.nameValue() | |
| self.state = 995 | |
| 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: | |
| self.state = 991 | |
| self.match(SolidityParser.T__14) | |
| self.state = 992 | |
| self.nameValue() | |
| self.state = 997 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,108,self._ctx) | |
| self.state = 999 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__14: | |
| self.state = 998 | |
| self.match(SolidityParser.T__14) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class NameValueContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_nameValue | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterNameValue" ): | |
| listener.enterNameValue(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitNameValue" ): | |
| listener.exitNameValue(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitNameValue" ): | |
| return visitor.visitNameValue(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def nameValue(self): | |
| localctx = SolidityParser.NameValueContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 144, self.RULE_nameValue) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1001 | |
| self.identifier() | |
| self.state = 1002 | |
| self.match(SolidityParser.T__24) | |
| self.state = 1003 | |
| self.expression(0) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class FunctionCallArgumentsContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def nameValueList(self): | |
| return self.getTypedRuleContext(SolidityParser.NameValueListContext,0) | |
| def expressionList(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_functionCallArguments | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterFunctionCallArguments" ): | |
| listener.enterFunctionCallArguments(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitFunctionCallArguments" ): | |
| listener.exitFunctionCallArguments(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitFunctionCallArguments" ): | |
| return visitor.visitFunctionCallArguments(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def functionCallArguments(self): | |
| localctx = SolidityParser.FunctionCallArgumentsContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 146, self.RULE_functionCallArguments) | |
| self._la = 0 # Token type | |
| try: | |
| self.state = 1013 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__13]: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1005 | |
| self.match(SolidityParser.T__13) | |
| self.state = 1007 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 1006 | |
| self.nameValueList() | |
| self.state = 1009 | |
| self.match(SolidityParser.T__15) | |
| pass | |
| elif token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__21, SolidityParser.T__22, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral]: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 1011 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 1010 | |
| self.expressionList() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class FunctionCallContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def expression(self): | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) | |
| def functionCallArguments(self): | |
| return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_functionCall | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterFunctionCall" ): | |
| listener.enterFunctionCall(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitFunctionCall" ): | |
| listener.exitFunctionCall(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitFunctionCall" ): | |
| return visitor.visitFunctionCall(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def functionCall(self): | |
| localctx = SolidityParser.FunctionCallContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 148, self.RULE_functionCall) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1015 | |
| self.expression(0) | |
| self.state = 1016 | |
| self.match(SolidityParser.T__21) | |
| self.state = 1017 | |
| self.functionCallArguments() | |
| self.state = 1018 | |
| self.match(SolidityParser.T__22) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyBlockContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyItem(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.AssemblyItemContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.AssemblyItemContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyBlock | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyBlock" ): | |
| listener.enterAssemblyBlock(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyBlock" ): | |
| listener.exitAssemblyBlock(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyBlock" ): | |
| return visitor.visitAssemblyBlock(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyBlock(self): | |
| localctx = SolidityParser.AssemblyBlockContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 150, self.RULE_assemblyBlock) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1020 | |
| self.match(SolidityParser.T__13) | |
| self.state = 1024 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__13) | (1 << SolidityParser.T__21) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 94)) & ~0x3f) == 0 and ((1 << (_la - 94)) & ((1 << (SolidityParser.T__93 - 94)) | (1 << (SolidityParser.T__95 - 94)) | (1 << (SolidityParser.T__96 - 94)) | (1 << (SolidityParser.DecimalNumber - 94)) | (1 << (SolidityParser.HexNumber - 94)) | (1 << (SolidityParser.HexLiteral - 94)) | (1 << (SolidityParser.BreakKeyword - 94)) | (1 << (SolidityParser.ContinueKeyword - 94)) | (1 << (SolidityParser.Identifier - 94)) | (1 << (SolidityParser.StringLiteral - 94)))) != 0): | |
| self.state = 1021 | |
| self.assemblyItem() | |
| self.state = 1026 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 1027 | |
| self.match(SolidityParser.T__15) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyItemContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def assemblyBlock(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) | |
| def assemblyExpression(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0) | |
| def assemblyLocalDefinition(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyLocalDefinitionContext,0) | |
| def assemblyAssignment(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyAssignmentContext,0) | |
| def assemblyStackAssignment(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyStackAssignmentContext,0) | |
| def labelDefinition(self): | |
| return self.getTypedRuleContext(SolidityParser.LabelDefinitionContext,0) | |
| def assemblySwitch(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblySwitchContext,0) | |
| def assemblyFunctionDefinition(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyFunctionDefinitionContext,0) | |
| def assemblyFor(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyForContext,0) | |
| def assemblyIf(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyIfContext,0) | |
| def BreakKeyword(self): | |
| return self.getToken(SolidityParser.BreakKeyword, 0) | |
| def ContinueKeyword(self): | |
| return self.getToken(SolidityParser.ContinueKeyword, 0) | |
| def subAssembly(self): | |
| return self.getTypedRuleContext(SolidityParser.SubAssemblyContext,0) | |
| def numberLiteral(self): | |
| return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0) | |
| def StringLiteral(self): | |
| return self.getToken(SolidityParser.StringLiteral, 0) | |
| def HexLiteral(self): | |
| return self.getToken(SolidityParser.HexLiteral, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyItem | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyItem" ): | |
| listener.enterAssemblyItem(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyItem" ): | |
| listener.exitAssemblyItem(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyItem" ): | |
| return visitor.visitAssemblyItem(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyItem(self): | |
| localctx = SolidityParser.AssemblyItemContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 152, self.RULE_assemblyItem) | |
| try: | |
| self.state = 1046 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,114,self._ctx) | |
| if la_ == 1: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1029 | |
| self.identifier() | |
| pass | |
| elif la_ == 2: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 1030 | |
| self.assemblyBlock() | |
| pass | |
| elif la_ == 3: | |
| self.enterOuterAlt(localctx, 3) | |
| self.state = 1031 | |
| self.assemblyExpression() | |
| pass | |
| elif la_ == 4: | |
| self.enterOuterAlt(localctx, 4) | |
| self.state = 1032 | |
| self.assemblyLocalDefinition() | |
| pass | |
| elif la_ == 5: | |
| self.enterOuterAlt(localctx, 5) | |
| self.state = 1033 | |
| self.assemblyAssignment() | |
| pass | |
| elif la_ == 6: | |
| self.enterOuterAlt(localctx, 6) | |
| self.state = 1034 | |
| self.assemblyStackAssignment() | |
| pass | |
| elif la_ == 7: | |
| self.enterOuterAlt(localctx, 7) | |
| self.state = 1035 | |
| self.labelDefinition() | |
| pass | |
| elif la_ == 8: | |
| self.enterOuterAlt(localctx, 8) | |
| self.state = 1036 | |
| self.assemblySwitch() | |
| pass | |
| elif la_ == 9: | |
| self.enterOuterAlt(localctx, 9) | |
| self.state = 1037 | |
| self.assemblyFunctionDefinition() | |
| pass | |
| elif la_ == 10: | |
| self.enterOuterAlt(localctx, 10) | |
| self.state = 1038 | |
| self.assemblyFor() | |
| pass | |
| elif la_ == 11: | |
| self.enterOuterAlt(localctx, 11) | |
| self.state = 1039 | |
| self.assemblyIf() | |
| pass | |
| elif la_ == 12: | |
| self.enterOuterAlt(localctx, 12) | |
| self.state = 1040 | |
| self.match(SolidityParser.BreakKeyword) | |
| pass | |
| elif la_ == 13: | |
| self.enterOuterAlt(localctx, 13) | |
| self.state = 1041 | |
| self.match(SolidityParser.ContinueKeyword) | |
| pass | |
| elif la_ == 14: | |
| self.enterOuterAlt(localctx, 14) | |
| self.state = 1042 | |
| self.subAssembly() | |
| pass | |
| elif la_ == 15: | |
| self.enterOuterAlt(localctx, 15) | |
| self.state = 1043 | |
| self.numberLiteral() | |
| pass | |
| elif la_ == 16: | |
| self.enterOuterAlt(localctx, 16) | |
| self.state = 1044 | |
| self.match(SolidityParser.StringLiteral) | |
| pass | |
| elif la_ == 17: | |
| self.enterOuterAlt(localctx, 17) | |
| self.state = 1045 | |
| self.match(SolidityParser.HexLiteral) | |
| pass | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyExpressionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyCall(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyCallContext,0) | |
| def assemblyLiteral(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyExpression | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyExpression" ): | |
| listener.enterAssemblyExpression(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyExpression" ): | |
| listener.exitAssemblyExpression(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyExpression" ): | |
| return visitor.visitAssemblyExpression(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyExpression(self): | |
| localctx = SolidityParser.AssemblyExpressionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 154, self.RULE_assemblyExpression) | |
| try: | |
| self.state = 1050 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__54, SolidityParser.T__60, SolidityParser.Identifier]: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1048 | |
| self.assemblyCall() | |
| pass | |
| elif token in [SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.StringLiteral]: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 1049 | |
| self.assemblyLiteral() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyCallContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def assemblyExpression(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyCall | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyCall" ): | |
| listener.enterAssemblyCall(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyCall" ): | |
| listener.exitAssemblyCall(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyCall" ): | |
| return visitor.visitAssemblyCall(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyCall(self): | |
| localctx = SolidityParser.AssemblyCallContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 156, self.RULE_assemblyCall) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1056 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__54]: | |
| self.state = 1052 | |
| self.match(SolidityParser.T__54) | |
| pass | |
| elif token in [SolidityParser.T__39]: | |
| self.state = 1053 | |
| self.match(SolidityParser.T__39) | |
| pass | |
| elif token in [SolidityParser.T__60]: | |
| self.state = 1054 | |
| self.match(SolidityParser.T__60) | |
| pass | |
| elif token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]: | |
| self.state = 1055 | |
| self.identifier() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 1070 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,119,self._ctx) | |
| if la_ == 1: | |
| self.state = 1058 | |
| self.match(SolidityParser.T__21) | |
| self.state = 1060 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 109)) & ~0x3f) == 0 and ((1 << (_la - 109)) & ((1 << (SolidityParser.DecimalNumber - 109)) | (1 << (SolidityParser.HexNumber - 109)) | (1 << (SolidityParser.HexLiteral - 109)) | (1 << (SolidityParser.Identifier - 109)) | (1 << (SolidityParser.StringLiteral - 109)))) != 0): | |
| self.state = 1059 | |
| self.assemblyExpression() | |
| self.state = 1066 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 1062 | |
| self.match(SolidityParser.T__14) | |
| self.state = 1063 | |
| self.assemblyExpression() | |
| self.state = 1068 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 1069 | |
| self.match(SolidityParser.T__22) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyLocalDefinitionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyIdentifierOrList(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0) | |
| def assemblyExpression(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyLocalDefinition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyLocalDefinition" ): | |
| listener.enterAssemblyLocalDefinition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyLocalDefinition" ): | |
| listener.exitAssemblyLocalDefinition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyLocalDefinition" ): | |
| return visitor.visitAssemblyLocalDefinition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyLocalDefinition(self): | |
| localctx = SolidityParser.AssemblyLocalDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 158, self.RULE_assemblyLocalDefinition) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1072 | |
| self.match(SolidityParser.T__93) | |
| self.state = 1073 | |
| self.assemblyIdentifierOrList() | |
| self.state = 1076 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__94: | |
| self.state = 1074 | |
| self.match(SolidityParser.T__94) | |
| self.state = 1075 | |
| self.assemblyExpression() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyAssignmentContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyIdentifierOrList(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0) | |
| def assemblyExpression(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyAssignment | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyAssignment" ): | |
| listener.enterAssemblyAssignment(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyAssignment" ): | |
| listener.exitAssemblyAssignment(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyAssignment" ): | |
| return visitor.visitAssemblyAssignment(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyAssignment(self): | |
| localctx = SolidityParser.AssemblyAssignmentContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 160, self.RULE_assemblyAssignment) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1078 | |
| self.assemblyIdentifierOrList() | |
| self.state = 1079 | |
| self.match(SolidityParser.T__94) | |
| self.state = 1080 | |
| self.assemblyExpression() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyIdentifierOrListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def assemblyIdentifierList(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyIdentifierOrList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyIdentifierOrList" ): | |
| listener.enterAssemblyIdentifierOrList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyIdentifierOrList" ): | |
| listener.exitAssemblyIdentifierOrList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyIdentifierOrList" ): | |
| return visitor.visitAssemblyIdentifierOrList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyIdentifierOrList(self): | |
| localctx = SolidityParser.AssemblyIdentifierOrListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 162, self.RULE_assemblyIdentifierOrList) | |
| try: | |
| self.state = 1087 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1082 | |
| self.identifier() | |
| pass | |
| elif token in [SolidityParser.T__21]: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 1083 | |
| self.match(SolidityParser.T__21) | |
| self.state = 1084 | |
| self.assemblyIdentifierList() | |
| self.state = 1085 | |
| self.match(SolidityParser.T__22) | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyIdentifierListContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.IdentifierContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyIdentifierList | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyIdentifierList" ): | |
| listener.enterAssemblyIdentifierList(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyIdentifierList" ): | |
| listener.exitAssemblyIdentifierList(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyIdentifierList" ): | |
| return visitor.visitAssemblyIdentifierList(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyIdentifierList(self): | |
| localctx = SolidityParser.AssemblyIdentifierListContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 164, self.RULE_assemblyIdentifierList) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1089 | |
| self.identifier() | |
| self.state = 1094 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 1090 | |
| self.match(SolidityParser.T__14) | |
| self.state = 1091 | |
| self.identifier() | |
| self.state = 1096 | |
| 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 AssemblyStackAssignmentContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyStackAssignment | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyStackAssignment" ): | |
| listener.enterAssemblyStackAssignment(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyStackAssignment" ): | |
| listener.exitAssemblyStackAssignment(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyStackAssignment" ): | |
| return visitor.visitAssemblyStackAssignment(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyStackAssignment(self): | |
| localctx = SolidityParser.AssemblyStackAssignmentContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 166, self.RULE_assemblyStackAssignment) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1097 | |
| self.match(SolidityParser.T__95) | |
| self.state = 1098 | |
| self.identifier() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class LabelDefinitionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_labelDefinition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterLabelDefinition" ): | |
| listener.enterLabelDefinition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitLabelDefinition" ): | |
| listener.exitLabelDefinition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitLabelDefinition" ): | |
| return visitor.visitLabelDefinition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def labelDefinition(self): | |
| localctx = SolidityParser.LabelDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 168, self.RULE_labelDefinition) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1100 | |
| self.identifier() | |
| self.state = 1101 | |
| self.match(SolidityParser.T__24) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblySwitchContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyExpression(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0) | |
| def assemblyCase(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.AssemblyCaseContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.AssemblyCaseContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblySwitch | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblySwitch" ): | |
| listener.enterAssemblySwitch(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblySwitch" ): | |
| listener.exitAssemblySwitch(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblySwitch" ): | |
| return visitor.visitAssemblySwitch(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblySwitch(self): | |
| localctx = SolidityParser.AssemblySwitchContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 170, self.RULE_assemblySwitch) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1103 | |
| self.match(SolidityParser.T__96) | |
| self.state = 1104 | |
| self.assemblyExpression() | |
| self.state = 1108 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__97 or _la==SolidityParser.T__98: | |
| self.state = 1105 | |
| self.assemblyCase() | |
| self.state = 1110 | |
| 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 AssemblyCaseContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyLiteral(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0) | |
| def assemblyBlock(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyCase | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyCase" ): | |
| listener.enterAssemblyCase(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyCase" ): | |
| listener.exitAssemblyCase(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyCase" ): | |
| return visitor.visitAssemblyCase(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyCase(self): | |
| localctx = SolidityParser.AssemblyCaseContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 172, self.RULE_assemblyCase) | |
| try: | |
| self.state = 1117 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__97]: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1111 | |
| self.match(SolidityParser.T__97) | |
| self.state = 1112 | |
| self.assemblyLiteral() | |
| self.state = 1113 | |
| self.assemblyBlock() | |
| pass | |
| elif token in [SolidityParser.T__98]: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 1115 | |
| self.match(SolidityParser.T__98) | |
| self.state = 1116 | |
| self.assemblyBlock() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyFunctionDefinitionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def assemblyBlock(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) | |
| def assemblyIdentifierList(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0) | |
| def assemblyFunctionReturns(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyFunctionReturnsContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyFunctionDefinition | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyFunctionDefinition" ): | |
| listener.enterAssemblyFunctionDefinition(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyFunctionDefinition" ): | |
| listener.exitAssemblyFunctionDefinition(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyFunctionDefinition" ): | |
| return visitor.visitAssemblyFunctionDefinition(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyFunctionDefinition(self): | |
| localctx = SolidityParser.AssemblyFunctionDefinitionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 174, self.RULE_assemblyFunctionDefinition) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1119 | |
| self.match(SolidityParser.T__31) | |
| self.state = 1120 | |
| self.identifier() | |
| self.state = 1121 | |
| self.match(SolidityParser.T__21) | |
| self.state = 1123 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier: | |
| self.state = 1122 | |
| self.assemblyIdentifierList() | |
| self.state = 1125 | |
| self.match(SolidityParser.T__22) | |
| self.state = 1127 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if _la==SolidityParser.T__99: | |
| self.state = 1126 | |
| self.assemblyFunctionReturns() | |
| self.state = 1129 | |
| self.assemblyBlock() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyFunctionReturnsContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyIdentifierList(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyFunctionReturns | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyFunctionReturns" ): | |
| listener.enterAssemblyFunctionReturns(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyFunctionReturns" ): | |
| listener.exitAssemblyFunctionReturns(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyFunctionReturns" ): | |
| return visitor.visitAssemblyFunctionReturns(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyFunctionReturns(self): | |
| localctx = SolidityParser.AssemblyFunctionReturnsContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 176, self.RULE_assemblyFunctionReturns) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1131 | |
| self.match(SolidityParser.T__99) | |
| self.state = 1132 | |
| self.assemblyIdentifierList() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyForContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyExpression(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i) | |
| def assemblyBlock(self, i:int=None): | |
| if i is None: | |
| return self.getTypedRuleContexts(SolidityParser.AssemblyBlockContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyFor | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyFor" ): | |
| listener.enterAssemblyFor(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyFor" ): | |
| listener.exitAssemblyFor(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyFor" ): | |
| return visitor.visitAssemblyFor(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyFor(self): | |
| localctx = SolidityParser.AssemblyForContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 178, self.RULE_assemblyFor) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1134 | |
| self.match(SolidityParser.T__27) | |
| self.state = 1137 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__13]: | |
| self.state = 1135 | |
| self.assemblyBlock() | |
| pass | |
| elif token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__54, SolidityParser.T__60, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]: | |
| self.state = 1136 | |
| self.assemblyExpression() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 1139 | |
| self.assemblyExpression() | |
| self.state = 1142 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__13]: | |
| self.state = 1140 | |
| self.assemblyBlock() | |
| pass | |
| elif token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__54, SolidityParser.T__60, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]: | |
| self.state = 1141 | |
| self.assemblyExpression() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| self.state = 1144 | |
| self.assemblyBlock() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyIfContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def assemblyExpression(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0) | |
| def assemblyBlock(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyIf | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyIf" ): | |
| listener.enterAssemblyIf(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyIf" ): | |
| listener.exitAssemblyIf(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyIf" ): | |
| return visitor.visitAssemblyIf(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyIf(self): | |
| localctx = SolidityParser.AssemblyIfContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 180, self.RULE_assemblyIf) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1146 | |
| self.match(SolidityParser.T__49) | |
| self.state = 1147 | |
| self.assemblyExpression() | |
| self.state = 1148 | |
| self.assemblyBlock() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class AssemblyLiteralContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def StringLiteral(self): | |
| return self.getToken(SolidityParser.StringLiteral, 0) | |
| def DecimalNumber(self): | |
| return self.getToken(SolidityParser.DecimalNumber, 0) | |
| def HexNumber(self): | |
| return self.getToken(SolidityParser.HexNumber, 0) | |
| def HexLiteral(self): | |
| return self.getToken(SolidityParser.HexLiteral, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_assemblyLiteral | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterAssemblyLiteral" ): | |
| listener.enterAssemblyLiteral(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitAssemblyLiteral" ): | |
| listener.exitAssemblyLiteral(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitAssemblyLiteral" ): | |
| return visitor.visitAssemblyLiteral(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def assemblyLiteral(self): | |
| localctx = SolidityParser.AssemblyLiteralContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 182, self.RULE_assemblyLiteral) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1150 | |
| _la = self._input.LA(1) | |
| if not(((((_la - 109)) & ~0x3f) == 0 and ((1 << (_la - 109)) & ((1 << (SolidityParser.DecimalNumber - 109)) | (1 << (SolidityParser.HexNumber - 109)) | (1 << (SolidityParser.HexLiteral - 109)) | (1 << (SolidityParser.StringLiteral - 109)))) != 0)): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class SubAssemblyContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def identifier(self): | |
| return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) | |
| def assemblyBlock(self): | |
| return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_subAssembly | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterSubAssembly" ): | |
| listener.enterSubAssembly(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitSubAssembly" ): | |
| listener.exitSubAssembly(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitSubAssembly" ): | |
| return visitor.visitSubAssembly(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def subAssembly(self): | |
| localctx = SolidityParser.SubAssemblyContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 184, self.RULE_subAssembly) | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1152 | |
| self.match(SolidityParser.T__52) | |
| self.state = 1153 | |
| self.identifier() | |
| self.state = 1154 | |
| self.assemblyBlock() | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class TupleExpressionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| 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(SolidityParser.ExpressionContext) | |
| else: | |
| return self.getTypedRuleContext(SolidityParser.ExpressionContext,i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_tupleExpression | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterTupleExpression" ): | |
| listener.enterTupleExpression(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitTupleExpression" ): | |
| listener.exitTupleExpression(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitTupleExpression" ): | |
| return visitor.visitTupleExpression(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def tupleExpression(self): | |
| localctx = SolidityParser.TupleExpressionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 186, self.RULE_tupleExpression) | |
| self._la = 0 # Token type | |
| try: | |
| self.state = 1182 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__21]: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1156 | |
| self.match(SolidityParser.T__21) | |
| self.state = 1158 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 1157 | |
| self.expression(0) | |
| self.state = 1166 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 1160 | |
| self.match(SolidityParser.T__14) | |
| self.state = 1162 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 1161 | |
| self.expression(0) | |
| self.state = 1168 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 1169 | |
| self.match(SolidityParser.T__22) | |
| pass | |
| elif token in [SolidityParser.T__37]: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 1170 | |
| self.match(SolidityParser.T__37) | |
| self.state = 1179 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0): | |
| self.state = 1171 | |
| self.expression(0) | |
| self.state = 1176 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| while _la==SolidityParser.T__14: | |
| self.state = 1172 | |
| self.match(SolidityParser.T__14) | |
| self.state = 1173 | |
| self.expression(0) | |
| self.state = 1178 | |
| self._errHandler.sync(self) | |
| _la = self._input.LA(1) | |
| self.state = 1181 | |
| self.match(SolidityParser.T__38) | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class TypeNameExpressionContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def elementaryTypeName(self): | |
| return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0) | |
| def userDefinedTypeName(self): | |
| return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_typeNameExpression | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterTypeNameExpression" ): | |
| listener.enterTypeNameExpression(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitTypeNameExpression" ): | |
| listener.exitTypeNameExpression(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitTypeNameExpression" ): | |
| return visitor.visitTypeNameExpression(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def typeNameExpression(self): | |
| localctx = SolidityParser.TypeNameExpressionContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 188, self.RULE_typeNameExpression) | |
| try: | |
| self.state = 1186 | |
| self._errHandler.sync(self) | |
| token = self._input.LA(1) | |
| if token in [SolidityParser.T__39, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed]: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1184 | |
| self.elementaryTypeName() | |
| pass | |
| elif token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 1185 | |
| self.userDefinedTypeName() | |
| pass | |
| else: | |
| raise NoViableAltException(self) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class NumberLiteralContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def DecimalNumber(self): | |
| return self.getToken(SolidityParser.DecimalNumber, 0) | |
| def HexNumber(self): | |
| return self.getToken(SolidityParser.HexNumber, 0) | |
| def NumberUnit(self): | |
| return self.getToken(SolidityParser.NumberUnit, 0) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_numberLiteral | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterNumberLiteral" ): | |
| listener.enterNumberLiteral(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitNumberLiteral" ): | |
| listener.exitNumberLiteral(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitNumberLiteral" ): | |
| return visitor.visitNumberLiteral(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def numberLiteral(self): | |
| localctx = SolidityParser.NumberLiteralContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 190, self.RULE_numberLiteral) | |
| self._la = 0 # Token type | |
| try: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1188 | |
| _la = self._input.LA(1) | |
| if not(_la==SolidityParser.DecimalNumber or _la==SolidityParser.HexNumber): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| self.state = 1190 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,136,self._ctx) | |
| if la_ == 1: | |
| self.state = 1189 | |
| self.match(SolidityParser.NumberUnit) | |
| except RecognitionException as re: | |
| localctx.exception = re | |
| self._errHandler.reportError(self, re) | |
| self._errHandler.recover(self, re) | |
| finally: | |
| self.exitRule() | |
| return localctx | |
| class IdentifierContext(ParserRuleContext): | |
| __slots__ = 'parser' | |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): | |
| super().__init__(parent, invokingState) | |
| self.parser = parser | |
| def Identifier(self, i:int=None): | |
| if i is None: | |
| return self.getTokens(SolidityParser.Identifier) | |
| else: | |
| return self.getToken(SolidityParser.Identifier, i) | |
| def getRuleIndex(self): | |
| return SolidityParser.RULE_identifier | |
| def enterRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "enterIdentifier" ): | |
| listener.enterIdentifier(self) | |
| def exitRule(self, listener:ParseTreeListener): | |
| if hasattr( listener, "exitIdentifier" ): | |
| listener.exitIdentifier(self) | |
| def accept(self, visitor:ParseTreeVisitor): | |
| if hasattr( visitor, "visitIdentifier" ): | |
| return visitor.visitIdentifier(self) | |
| else: | |
| return visitor.visitChildren(self) | |
| def identifier(self): | |
| localctx = SolidityParser.IdentifierContext(self, self._ctx, self.state) | |
| self.enterRule(localctx, 192, self.RULE_identifier) | |
| self._la = 0 # Token type | |
| try: | |
| self.state = 1201 | |
| self._errHandler.sync(self) | |
| la_ = self._interp.adaptivePredict(self._input,138,self._ctx) | |
| if la_ == 1: | |
| self.enterOuterAlt(localctx, 1) | |
| self.state = 1192 | |
| _la = self._input.LA(1) | |
| if not(_la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier): | |
| self._errHandler.recoverInline(self) | |
| else: | |
| self._errHandler.reportMatch(self) | |
| self.consume() | |
| pass | |
| elif la_ == 2: | |
| self.enterOuterAlt(localctx, 2) | |
| self.state = 1193 | |
| self.match(SolidityParser.Identifier) | |
| self.state = 1198 | |
| 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: | |
| self.state = 1194 | |
| self.match(SolidityParser.T__12) | |
| self.state = 1195 | |
| self.match(SolidityParser.Identifier) | |
| self.state = 1200 | |
| self._errHandler.sync(self) | |
| _alt = self._interp.adaptivePredict(self._input,137,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 | |
| def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): | |
| if self._predicates == None: | |
| self._predicates = dict() | |
| self._predicates[36] = self.typeName_sempred | |
| self._predicates[68] = self.expression_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 typeName_sempred(self, localctx:TypeNameContext, predIndex:int): | |
| if predIndex == 0: | |
| return self.precpred(self._ctx, 3) | |
| def expression_sempred(self, localctx:ExpressionContext, predIndex:int): | |
| if predIndex == 1: | |
| return self.precpred(self._ctx, 14) | |
| if predIndex == 2: | |
| return self.precpred(self._ctx, 13) | |
| if predIndex == 3: | |
| return self.precpred(self._ctx, 12) | |
| if predIndex == 4: | |
| return self.precpred(self._ctx, 11) | |
| if predIndex == 5: | |
| return self.precpred(self._ctx, 10) | |
| if predIndex == 6: | |
| return self.precpred(self._ctx, 9) | |
| if predIndex == 7: | |
| return self.precpred(self._ctx, 8) | |
| if predIndex == 8: | |
| return self.precpred(self._ctx, 7) | |
| if predIndex == 9: | |
| return self.precpred(self._ctx, 6) | |
| if predIndex == 10: | |
| return self.precpred(self._ctx, 5) | |
| if predIndex == 11: | |
| return self.precpred(self._ctx, 4) | |
| if predIndex == 12: | |
| return self.precpred(self._ctx, 3) | |
| if predIndex == 13: | |
| return self.precpred(self._ctx, 2) | |
| if predIndex == 14: | |
| return self.precpred(self._ctx, 30) | |
| if predIndex == 15: | |
| return self.precpred(self._ctx, 28) | |
| if predIndex == 16: | |
| return self.precpred(self._ctx, 27) | |
| if predIndex == 17: | |
| return self.precpred(self._ctx, 26) | |
| if predIndex == 18: | |
| return self.precpred(self._ctx, 22) | |
| if predIndex == 19: | |
| return self.precpred(self._ctx, 20) | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment