From 7177d8841781b78fe02d1c56e8aa2dd21fa08cb2 Mon Sep 17 00:00:00 2001 From: sam bacha Date: Tue, 15 Aug 2023 09:31:51 -0700 Subject: [PATCH 1/6] feat(lint): fixes --- setup.py | 6 +- solidity_parser/__main__.py | 40 +- solidity_parser/parser.py | 1059 +-- .../solidity_antlr4/SolidityLexer.py | 404 +- .../solidity_antlr4/SolidityListener.py | 579 +- .../solidity_antlr4/SolidityParser.py | 6940 +++++++++++------ .../solidity_antlr4/SolidityVisitor.py | 344 +- 7 files changed, 5709 insertions(+), 3663 deletions(-) diff --git a/setup.py b/setup.py index e962ecf..ac8b1fc 100644 --- a/setup.py +++ b/setup.py @@ -19,7 +19,7 @@ def read(fname): version = "0.1.3" -name = "python-solidity-parser" +name = "solidity-parser" setup( name=name, @@ -32,8 +32,8 @@ def read(fname): ), license="MIT", keywords=["solidity", "parser", "antlr"], - url="https://github.com/consensys/python-%s/" % name, - download_url="https://github.com/consensys/python-%s/tarball/v%s" % (name, version), + url="https://github.com/manifoldfinance/python-%s/" % name, + download_url="https://github.com/manifoldfinance/python-%s/tarball/v%s" % (name, version), long_description=read("README.md") if os.path.isfile("README.md") else "", long_description_content_type="text/markdown", # python setup.py register -r https://testpypi.python.org/pypi diff --git a/solidity_parser/__main__.py b/solidity_parser/__main__.py index a24b3d1..8de7ad7 100644 --- a/solidity_parser/__main__.py +++ b/solidity_parser/__main__.py @@ -6,7 +6,7 @@ from . import parser if __name__ == "__main__": - if not len(sys.argv)>2 or sys.argv[1] not in ("parse","outline"): + if not len(sys.argv) > 2 or sys.argv[1] not in ("parse", "outline"): print("\n- missing subcommand or path to solidity file.\n") print("#> python -m solidity_parser ") print("") @@ -16,26 +16,32 @@ sys.exit(1) node = parser.parse_file(sys.argv[2], loc=False) - if sys.argv[1]=="parse": + if sys.argv[1] == "parse": pprint.pprint(node) - elif sys.argv[1]=="outline": + elif sys.argv[1] == "outline": level = 0 sourceUnitObject = parser.objectify(node) print("=== pragmas ===") - level +=1 + level += 1 for p in sourceUnitObject.pragmas: print(("\t" * level) + "* " + str(p)) - level -=1 + level -= 1 print("=== imports ===") - level +=1 + level += 1 for p in sourceUnitObject.imports: print(("\t" * level) + "* " + str(p)) level = 0 for contract_name, contract_object in sourceUnitObject.contracts.items(): print("=== contract: " + contract_name) - level +=1 + level += 1 - print(("\t" * level) + "=== Inherited Contracts: " + ','.join([bc.baseName.namePath for bc in contract_object._node.baseContracts])) + print( + ("\t" * level) + + "=== Inherited Contracts: " + + ",".join( + [bc.baseName.namePath for bc in contract_object._node.baseContracts] + ) + ) ## statevars print(("\t" * level) + "=== Enums") level += 2 @@ -49,11 +55,11 @@ print(("\t" * level) + "* " + str(name)) level -= 2 ## statevars - print(("\t" * level) + "=== statevars" ) - level +=2 + print(("\t" * level) + "=== statevars") + level += 2 for name in contract_object.stateVars.keys(): - print(("\t" * level) + "* " + str(name) ) - level -=2 + print(("\t" * level) + "* " + str(name)) + level -= 2 ## modifiers print(("\t" * level) + "=== modifiers") level += 2 @@ -69,6 +75,12 @@ txtAttribs.append(funcObj.visibility) if funcObj.stateMutability: txtAttribs.append(funcObj.stateMutability) - print(("\t" * level) + "* " + str(name) + "\t\t (" + ','.join(txtAttribs)+ ")") + print( + ("\t" * level) + + "* " + + str(name) + + "\t\t (" + + ",".join(txtAttribs) + + ")" + ) level -= 2 - diff --git a/solidity_parser/parser.py b/solidity_parser/parser.py index 672786b..8d83f1b 100644 --- a/solidity_parser/parser.py +++ b/solidity_parser/parser.py @@ -16,8 +16,9 @@ class Node(dict): """ provide a dict interface and object attrib access """ + ENABLE_LOC = False - NONCHILD_KEYS = ("type","name","loc") + NONCHILD_KEYS = ("type", "name", "loc") def __init__(self, ctx, **kwargs): for k, v in kwargs.items(): @@ -35,19 +36,12 @@ def __setattr__(self, name, value): @staticmethod def _get_loc(ctx): return { - 'start': { - 'line': ctx.start.line, - 'column': ctx.start.column - }, - 'end': { - 'line': ctx.stop.line, - 'column': ctx.stop.column - } + "start": {"line": ctx.start.line, "column": ctx.start.column}, + "end": {"line": ctx.stop.line, "column": ctx.stop.column}, } class AstVisitor(SolidityVisitor): - def _mapCommasToNulls(self, children): if not children or len(children) == 0: return [] @@ -57,14 +51,14 @@ def _mapCommasToNulls(self, children): for el in children: if comma: - if el.getText() == ',': + if el.getText() == ",": values.append(None) else: values.append(el) comma = False else: - if el.getText() != ',': - raise Exception('expected comma') + if el.getText() != ",": + raise Exception("expected comma") comma = True @@ -109,64 +103,73 @@ def _visit_nodes(self, nodes): # ******************************************************** def visitSourceUnit(self, ctx): - return Node(ctx=ctx, - type="SourceUnit", - children=self.visit(ctx.children[:-1])) # skip EOF + return Node( + ctx=ctx, type="SourceUnit", children=self.visit(ctx.children[:-1]) + ) # skip EOF def visitEnumDefinition(self, ctx): - return Node(ctx=ctx, - type="EnumDefinition", - name=ctx.identifier().getText(), - members=self.visit(ctx.enumValue())) + return Node( + ctx=ctx, + type="EnumDefinition", + name=ctx.identifier().getText(), + members=self.visit(ctx.enumValue()), + ) def visitEnumValue(self, ctx): - return Node(ctx=ctx, - type="EnumValue", - name=ctx.identifier().getText()) + return Node(ctx=ctx, type="EnumValue", name=ctx.identifier().getText()) def visitTypeDefinition(self, ctx): - return Node(ctx=ctx, - type="TypeDefinition", - typeKeyword=ctx.TypeKeyword().getText(), - elementaryTypeName=self.visit(ctx.elementaryTypeName())) - + return Node( + ctx=ctx, + type="TypeDefinition", + typeKeyword=ctx.TypeKeyword().getText(), + elementaryTypeName=self.visit(ctx.elementaryTypeName()), + ) def visitCustomErrorDefinition(self, ctx): - return Node(ctx=ctx, - type="CustomErrorDefinition", - name=self.visit(ctx.identifier()), - parameterList=self.visit(ctx.parameterList())) + return Node( + ctx=ctx, + type="CustomErrorDefinition", + name=self.visit(ctx.identifier()), + parameterList=self.visit(ctx.parameterList()), + ) def visitFileLevelConstant(self, ctx): - return Node(ctx=ctx, - type="FileLevelConstant", - name=self.visit(ctx.identifier()), - typeName=self.visit(ctx.typeName()), - ConstantKeyword=self.visit(ctx.ConstantKeyword())) - + return Node( + ctx=ctx, + type="FileLevelConstant", + name=self.visit(ctx.identifier()), + typeName=self.visit(ctx.typeName()), + ConstantKeyword=self.visit(ctx.ConstantKeyword()), + ) def visitUsingForDeclaration(self, ctx: SolidityParser.UsingForDeclarationContext): typename = None - if ctx.getChild(3) != '*': + if ctx.getChild(3) != "*": typename = self.visit(ctx.getChild(3)) - return Node(ctx=ctx, - type="UsingForDeclaration", - typeName=typename, - libraryName=ctx.identifier().getText()) - - def visitInheritanceSpecifier(self, ctx: SolidityParser.InheritanceSpecifierContext): - return Node(ctx=ctx, - type="InheritanceSpecifier", - baseName=self.visit(ctx.userDefinedTypeName()), - arguments=self.visit(ctx.expressionList())) + return Node( + ctx=ctx, + type="UsingForDeclaration", + typeName=typename, + libraryName=ctx.identifier().getText(), + ) + + def visitInheritanceSpecifier( + self, ctx: SolidityParser.InheritanceSpecifierContext + ): + return Node( + ctx=ctx, + type="InheritanceSpecifier", + baseName=self.visit(ctx.userDefinedTypeName()), + arguments=self.visit(ctx.expressionList()), + ) def visitContractPart(self, ctx: SolidityParser.ContractPartContext): return self.visit(ctx.children[0]) - def visitFunctionDefinition(self, ctx: SolidityParser.FunctionDefinitionContext): - isConstructor = isFallback =isReceive = False + isConstructor = isFallback = isReceive = False fd = ctx.functionDescriptor() if fd.ConstructorKeyword(): @@ -181,11 +184,13 @@ def visitFunctionDefinition(self, ctx: SolidityParser.FunctionDefinitionContext) elif fd.identifier(): name = fd.identifier().getText() else: - name = '' # handle old style fallback function: function(){ ... } + name = "" # handle old style fallback function: function(){ ... } isFallback = True parameters = self.visit(ctx.parameterList()) - returnParameters = self.visit(ctx.returnParameters()) if ctx.returnParameters() else [] + returnParameters = ( + self.visit(ctx.returnParameters()) if ctx.returnParameters() else [] + ) block = self.visit(ctx.block()) if ctx.block() else [] modifiers = [self.visit(i) for i in ctx.modifierList().modifierInvocation()] @@ -198,48 +203,50 @@ def visitFunctionDefinition(self, ctx: SolidityParser.FunctionDefinitionContext) elif ctx.modifierList().PrivateKeyword(0): visibility = "private" else: - visibility = 'default' + visibility = "default" if ctx.modifierList().stateMutability(0): stateMutability = ctx.modifierList().stateMutability(0).getText() else: stateMutability = None - return Node(ctx=ctx, - type="FunctionDefinition", - name=name, - parameters=parameters, - returnParameters=returnParameters, - body=block, - visibility=visibility, - modifiers=modifiers, - isConstructor=isConstructor, - isFallback=isFallback, - isReceive=isReceive, - stateMutability=stateMutability) + return Node( + ctx=ctx, + type="FunctionDefinition", + name=name, + parameters=parameters, + returnParameters=returnParameters, + body=block, + visibility=visibility, + modifiers=modifiers, + isConstructor=isConstructor, + isFallback=isFallback, + isReceive=isReceive, + stateMutability=stateMutability, + ) def visitReturnParameters(self, ctx: SolidityParser.ReturnParametersContext): return self.visit(ctx.parameterList()) def visitParameterList(self, ctx: SolidityParser.ParameterListContext): parameters = [self.visit(p) for p in ctx.parameter()] - return Node(ctx=ctx, - type="ParameterList", - parameters=parameters) + return Node(ctx=ctx, type="ParameterList", parameters=parameters) def visitParameter(self, ctx: SolidityParser.ParameterContext): - - storageLocation = ctx.storageLocation().getText() if ctx.storageLocation() else None + storageLocation = ( + ctx.storageLocation().getText() if ctx.storageLocation() else None + ) name = ctx.identifier().getText() if ctx.identifier() else None - return Node(ctx=ctx, - type="Parameter", - typeName=self.visit(ctx.typeName()), - name=name, - storageLocation=storageLocation, - isStateVar=False, - isIndexed=False - ) + return Node( + ctx=ctx, + type="Parameter", + typeName=self.visit(ctx.typeName()), + name=name, + storageLocation=storageLocation, + isStateVar=False, + isIndexed=False, + ) def visitModifierInvocation(self, ctx): exprList = ctx.expressionList() @@ -249,15 +256,19 @@ def visitModifierInvocation(self, ctx): else: args = [] - return Node(ctx=ctx, - type='ModifierInvocation', - name=ctx.identifier().getText(), - arguments=args) + return Node( + ctx=ctx, + type="ModifierInvocation", + name=ctx.identifier().getText(), + arguments=args, + ) def visitElementaryTypeNameExpression(self, ctx): - return Node(ctx=ctx, - type='ElementaryTypeNameExpression', - typeName=self.visit(ctx.elementaryTypeName())) + return Node( + ctx=ctx, + type="ElementaryTypeNameExpression", + typeName=self.visit(ctx.elementaryTypeName()), + ) def visitTypeName(self, ctx): if len(ctx.children) > 2: @@ -265,42 +276,54 @@ def visitTypeName(self, ctx): if len(ctx.children) == 4: length = self.visit(ctx.getChild(2)) - return Node(ctx=ctx, - type='ArrayTypeName', - baseTypeName=self.visit(ctx.getChild(0)), - length=length) + return Node( + ctx=ctx, + type="ArrayTypeName", + baseTypeName=self.visit(ctx.getChild(0)), + length=length, + ) if len(ctx.children) == 2: - return Node(ctx=ctx, - type='ElementaryTypeName', - name=ctx.getChild(0).getText(), - stateMutability=ctx.getChild(1).getText()) + return Node( + ctx=ctx, + type="ElementaryTypeName", + name=ctx.getChild(0).getText(), + stateMutability=ctx.getChild(1).getText(), + ) return self.visit(ctx.getChild(0)) def visitFunctionTypeName(self, ctx): - parameterTypes = [self.visit(p) for p in ctx.functionTypeParameterList(0).functionTypeParameter()] + parameterTypes = [ + self.visit(p) + for p in ctx.functionTypeParameterList(0).functionTypeParameter() + ] returnTypes = [] if ctx.functionTypeParameterList(1): - returnTypes = [self.visit(p) for p in ctx.functionTypeParameterList(1).functionTypeParameter()] + returnTypes = [ + self.visit(p) + for p in ctx.functionTypeParameterList(1).functionTypeParameter() + ] - visibility = 'default' + visibility = "default" if ctx.InternalKeyword(0): - visibility = 'internal' + visibility = "internal" elif ctx.ExternalKeyword(0): - visibility = 'external' + visibility = "external" stateMutability = None if ctx.stateMutability(0): stateMutability = ctx.stateMutability(0).getText() - return Node(ctx=ctx, - type='FunctionTypeName', - parameterTypes=parameterTypes, - returnTypes=returnTypes, - visibility=visibility, - stateMutability=stateMutability) + return Node( + ctx=ctx, + type="FunctionTypeName", + parameterTypes=parameterTypes, + returnTypes=returnTypes, + visibility=visibility, + stateMutability=stateMutability, + ) def visitFunctionCall(self, ctx): args = [] @@ -316,26 +339,29 @@ def visitFunctionCall(self, ctx): args.append(self.visit(nameValue.expression())) names.append(nameValue.identifier().getText()) - return Node(ctx=ctx, - type='FunctionCall', - expression=self.visit(ctx.expression()), - arguments=args, - names=names) + return Node( + ctx=ctx, + type="FunctionCall", + expression=self.visit(ctx.expression()), + arguments=args, + names=names, + ) def visitEmitStatement(self, ctx): - return Node(ctx=ctx, - type='EmitStatement', - eventCall=self.visit(ctx.getChild(1))) + return Node( + ctx=ctx, type="EmitStatement", eventCall=self.visit(ctx.getChild(1)) + ) def visitThrowStatement(self, ctx): - return Node(ctx=ctx, - type='ThrowStatement') + return Node(ctx=ctx, type="ThrowStatement") def visitStructDefinition(self, ctx): - return Node(ctx=ctx, - type='StructDefinition', - name=ctx.identifier().getText(), - members=self.visit(ctx.variableDeclaration())) + return Node( + ctx=ctx, + type="StructDefinition", + name=ctx.identifier().getText(), + members=self.visit(ctx.variableDeclaration()), + ) def visitVariableDeclaration(self, ctx): storageLocation = None @@ -343,11 +369,13 @@ def visitVariableDeclaration(self, ctx): if ctx.storageLocation(): storageLocation = ctx.storageLocation().getText() - return Node(ctx=ctx, - type='VariableDeclaration', - typeName=self.visit(ctx.typeName()), - name=ctx.identifier().getText(), - storageLocation=storageLocation) + return Node( + ctx=ctx, + type="VariableDeclaration", + typeName=self.visit(ctx.typeName()), + name=ctx.identifier().getText(), + storageLocation=storageLocation, + ) def visitEventParameter(self, ctx): storageLocation = None @@ -357,13 +385,15 @@ def visitEventParameter(self, ctx): # if (ctx.storageLocation(0)): # storageLocation = ctx.storageLocation(0).getText() - return Node(ctx=ctx, - type='VariableDeclaration', - typeName=self.visit(ctx.typeName()), - name=ctx.identifier().getText(), - storageLocation=storageLocation, - isStateVar=False, - isIndexed=not not ctx.IndexedKeyword()) + return Node( + ctx=ctx, + type="VariableDeclaration", + typeName=self.visit(ctx.typeName()), + name=ctx.identifier().getText(), + storageLocation=storageLocation, + isStateVar=False, + isIndexed=not not ctx.IndexedKeyword(), + ) def visitFunctionTypeParameter(self, ctx): storageLocation = None @@ -371,74 +401,79 @@ def visitFunctionTypeParameter(self, ctx): if ctx.storageLocation(): storageLocation = ctx.storageLocation().getText() - return Node(ctx=ctx, - type='VariableDeclaration', - typeName=self.visit(ctx.typeName()), - name=None, - storageLocation=storageLocation, - isStateVar=False, - isIndexed=False) + return Node( + ctx=ctx, + type="VariableDeclaration", + typeName=self.visit(ctx.typeName()), + name=None, + storageLocation=storageLocation, + isStateVar=False, + isIndexed=False, + ) def visitWhileStatement(self, ctx): - return Node(ctx=ctx, - type='WhileStatement', - condition=self.visit(ctx.expression()), - body=self.visit(ctx.statement())) + return Node( + ctx=ctx, + type="WhileStatement", + condition=self.visit(ctx.expression()), + body=self.visit(ctx.statement()), + ) def visitDoWhileStatement(self, ctx): - return Node(ctx=ctx, - type='DoWhileStatement', - condition=self.visit(ctx.expression()), - body=self.visit(ctx.statement())) + return Node( + ctx=ctx, + type="DoWhileStatement", + condition=self.visit(ctx.expression()), + body=self.visit(ctx.statement()), + ) def visitIfStatement(self, ctx): - TrueBody = self.visit(ctx.statement(0)) FalseBody = None if len(ctx.statement()) > 1: FalseBody = self.visit(ctx.statement(1)) - return Node(ctx=ctx, - type='IfStatement', - condition=self.visit(ctx.expression()), - TrueBody=TrueBody, - FalseBody=FalseBody) + return Node( + ctx=ctx, + type="IfStatement", + condition=self.visit(ctx.expression()), + TrueBody=TrueBody, + FalseBody=FalseBody, + ) def visitTryStatement(self, ctx): - return Node(ctx=ctx, - type='TryStatement', - expression=self.visit(ctx.expression()), - block=self.visit(ctx.block()), - returnParameters=self.visit(ctx.returnParameters()), - catchClause=self.visit(ctx.catchClause())) + return Node( + ctx=ctx, + type="TryStatement", + expression=self.visit(ctx.expression()), + block=self.visit(ctx.block()), + returnParameters=self.visit(ctx.returnParameters()), + catchClause=self.visit(ctx.catchClause()), + ) def visitCatchClause(self, ctx): - return Node(ctx=ctx, - type='CatchClause', - identifier=self.visit(ctx.identifier()), - parameterList=self.visit(ctx.parameterList()), - block=self.visit(ctx.block())) + return Node( + ctx=ctx, + type="CatchClause", + identifier=self.visit(ctx.identifier()), + parameterList=self.visit(ctx.parameterList()), + block=self.visit(ctx.block()), + ) def visitUserDefinedTypeName(self, ctx): - return Node(ctx=ctx, - type='UserDefinedTypeName', - namePath=ctx.getText()) + return Node(ctx=ctx, type="UserDefinedTypeName", namePath=ctx.getText()) def visitElementaryTypeName(self, ctx): - return Node(ctx=ctx, - type='ElementaryTypeName', - name=ctx.getText()) + return Node(ctx=ctx, type="ElementaryTypeName", name=ctx.getText()) def visitBlock(self, ctx): - return Node(ctx=ctx, - type='Block', - statements=self.visit(ctx.statement())) + return Node(ctx=ctx, type="Block", statements=self.visit(ctx.statement())) def visitExpressionStatement(self, ctx): - return Node(ctx=ctx, - type='ExpressionStatement', - expression=self.visit(ctx.expression())) + return Node( + ctx=ctx, type="ExpressionStatement", expression=self.visit(ctx.expression()) + ) def visitNumberLiteral(self, ctx): number = ctx.getChild(0).getText() @@ -447,16 +482,20 @@ def visitNumberLiteral(self, ctx): if len(ctx.children) == 2: subdenomination = ctx.getChild(1).getText() - return Node(ctx=ctx, - type='NumberLiteral', - number=number, - subdenomination=subdenomination) + return Node( + ctx=ctx, + type="NumberLiteral", + number=number, + subdenomination=subdenomination, + ) def visitMapping(self, ctx): - return Node(ctx=ctx, - type='Mapping', - keyType=self.visit(ctx.mappingKey()), - valueType=self.visit(ctx.typeName())) + return Node( + ctx=ctx, + type="Mapping", + keyType=self.visit(ctx.mappingKey()), + valueType=self.visit(ctx.typeName()), + ) def visitModifierDefinition(self, ctx): parameters = [] @@ -464,11 +503,13 @@ def visitModifierDefinition(self, ctx): if ctx.parameterList(): parameters = self.visit(ctx.parameterList()) - return Node(ctx=ctx, - type='ModifierDefinition', - name=ctx.identifier().getText(), - parameters=parameters, - body=self.visit(ctx.block())) + return Node( + ctx=ctx, + type="ModifierDefinition", + name=ctx.identifier().getText(), + parameters=parameters, + body=self.visit(ctx.block()), + ) def visitStatement(self, ctx): return self.visit(ctx.getChild(0)) @@ -477,147 +518,161 @@ def visitSimpleStatement(self, ctx): return self.visit(ctx.getChild(0)) def visitUncheckedStatement(self, ctx): - return Node(ctx=ctx, - type='UncheckedStatement', - body=self.visit(ctx.block())) + return Node(ctx=ctx, type="UncheckedStatement", body=self.visit(ctx.block())) def visitRevertStatement(self, ctx): - return Node(ctx=ctx, - type='RevertStatement', - functionCall=self.visit(ctx.functionCall())) + return Node( + ctx=ctx, type="RevertStatement", functionCall=self.visit(ctx.functionCall()) + ) def visitExpression(self, ctx): - children_length = len(ctx.children) if children_length == 1: return self.visit(ctx.getChild(0)) elif children_length == 2: op = ctx.getChild(0).getText() - if op == 'new': - return Node(ctx=ctx, - type='NewExpression', - typeName=self.visit(ctx.typeName())) - - if op in ['+', '-', '++', '--', '!', '~', 'after', 'delete']: - return Node(ctx=ctx, - type='UnaryOperation', - operator=op, - subExpression=self.visit(ctx.getChild(1)), - isPrefix=True) + if op == "new": + return Node( + ctx=ctx, type="NewExpression", typeName=self.visit(ctx.typeName()) + ) + + if op in ["+", "-", "++", "--", "!", "~", "after", "delete"]: + return Node( + ctx=ctx, + type="UnaryOperation", + operator=op, + subExpression=self.visit(ctx.getChild(1)), + isPrefix=True, + ) op = ctx.getChild(1).getText() - if op in ['++', '--']: - return Node(ctx=ctx, - type='UnaryOperation', - operator=op, - subExpression=self.visit(ctx.getChild(0)), - isPrefix=False) + if op in ["++", "--"]: + return Node( + ctx=ctx, + type="UnaryOperation", + operator=op, + subExpression=self.visit(ctx.getChild(0)), + isPrefix=False, + ) elif children_length == 3: - if ctx.getChild(0).getText() == '(' and ctx.getChild(2).getText() == ')': - return Node(ctx=ctx, - type='TupleExpression', - components=[self.visit(ctx.getChild(1))], - isArray=False) + if ctx.getChild(0).getText() == "(" and ctx.getChild(2).getText() == ")": + return Node( + ctx=ctx, + type="TupleExpression", + components=[self.visit(ctx.getChild(1))], + isArray=False, + ) op = ctx.getChild(1).getText() - if op == ',': - return Node(ctx=ctx, - type='TupleExpression', - components=[ - self.visit(ctx.getChild(0)), - self.visit(ctx.getChild(2)) - ], - isArray=False) - - - elif op == '.': + if op == ",": + return Node( + ctx=ctx, + type="TupleExpression", + components=[ + self.visit(ctx.getChild(0)), + self.visit(ctx.getChild(2)), + ], + isArray=False, + ) + + elif op == ".": expression = self.visit(ctx.getChild(0)) memberName = ctx.getChild(2).getText() - return Node(ctx=ctx, - type='MemberAccess', - expression=expression, - memberName=memberName) + return Node( + ctx=ctx, + type="MemberAccess", + expression=expression, + memberName=memberName, + ) binOps = [ - '+', - '-', - '*', - '/', - '**', - '%', - '<<', - '>>', - '&&', - '||', - '&', - '|', - '^', - '<', - '>', - '<=', - '>=', - '==', - '!=', - '=', - '|=', - '^=', - '&=', - '<<=', - '>>=', - '+=', - '-=', - '*=', - '/=', - '%=' + "+", + "-", + "*", + "/", + "**", + "%", + "<<", + ">>", + "&&", + "||", + "&", + "|", + "^", + "<", + ">", + "<=", + ">=", + "==", + "!=", + "=", + "|=", + "^=", + "&=", + "<<=", + ">>=", + "+=", + "-=", + "*=", + "/=", + "%=", ] if op in binOps: - return Node(ctx=ctx, - type='BinaryOperation', - operator=op, - left=self.visit(ctx.getChild(0)), - right=self.visit(ctx.getChild(2))) + return Node( + ctx=ctx, + type="BinaryOperation", + operator=op, + left=self.visit(ctx.getChild(0)), + right=self.visit(ctx.getChild(2)), + ) elif children_length == 4: - - if ctx.getChild(1).getText() == '(' and ctx.getChild(3).getText() == ')': + if ctx.getChild(1).getText() == "(" and ctx.getChild(3).getText() == ")": args = [] names = [] ctxArgs = ctx.functionCallArguments() if ctxArgs.expressionList(): - args = [self.visit(a) for a in ctxArgs.expressionList().expression()] + args = [ + self.visit(a) for a in ctxArgs.expressionList().expression() + ] elif ctxArgs.nameValueList(): for nameValue in ctxArgs.nameValueList().nameValue(): args.append(self.visit(nameValue.expression())) names.append(nameValue.identifier().getText()) - return Node(ctx=ctx, - type='FunctionCall', - expression=self.visit(ctx.getChild(0)), - arguments=args, - names=names) + return Node( + ctx=ctx, + type="FunctionCall", + expression=self.visit(ctx.getChild(0)), + arguments=args, + names=names, + ) - if ctx.getChild(1).getText() == '[' and ctx.getChild(3).getText() == ']': - return Node(ctx=ctx, - type='IndexAccess', - base=self.visit(ctx.getChild(0)), - index=self.visit(ctx.getChild(2))) + if ctx.getChild(1).getText() == "[" and ctx.getChild(3).getText() == "]": + return Node( + ctx=ctx, + type="IndexAccess", + base=self.visit(ctx.getChild(0)), + index=self.visit(ctx.getChild(2)), + ) elif children_length == 5: # ternary - if ctx.getChild(1).getText() == '?' and ctx.getChild(3).getText() == ':': - return Node(ctx=ctx, - type='Conditional', - condition=self.visit(ctx.getChild(0)), - TrueExpression=self.visit(ctx.getChild(2)), - FalseExpression=self.visit(ctx.getChild(4))) + if ctx.getChild(1).getText() == "?" and ctx.getChild(3).getText() == ":": + return Node( + ctx=ctx, + type="Conditional", + condition=self.visit(ctx.getChild(0)), + TrueExpression=self.visit(ctx.getChild(2)), + FalseExpression=self.visit(ctx.getChild(4)), + ) return self.visit(list(ctx.getChildren())) - def visitStateVariableDeclaration(self, ctx): type = self.visit(ctx.typeName()) iden = ctx.identifier() @@ -628,14 +683,14 @@ def visitStateVariableDeclaration(self, ctx): if ctx.expression(): expression = self.visit(ctx.expression()) - visibility = 'default' + visibility = "default" if ctx.InternalKeyword(0): - visibility = 'internal' + visibility = "internal" elif ctx.PublicKeyword(0): - visibility = 'public' + visibility = "public" elif ctx.PrivateKeyword(0): - visibility = 'private' + visibility = "private" isDeclaredConst = False if ctx.ConstantKeyword(0): @@ -643,84 +698,92 @@ def visitStateVariableDeclaration(self, ctx): decl = self._createNode( ctx=ctx, - type='VariableDeclaration', + type="VariableDeclaration", typeName=type, name=name, expression=expression, visibility=visibility, isStateVar=True, isDeclaredConst=isDeclaredConst, - isIndexed=False) + isIndexed=False, + ) - return Node(ctx=ctx, - type='StateVariableDeclaration', - variables=[decl], - initialValue=expression) + return Node( + ctx=ctx, + type="StateVariableDeclaration", + variables=[decl], + initialValue=expression, + ) def visitForStatement(self, ctx): - conditionExpression = self.visit(ctx.expressionStatement()) if ctx.expressionStatement() else None + conditionExpression = ( + self.visit(ctx.expressionStatement()) if ctx.expressionStatement() else None + ) if conditionExpression: conditionExpression = conditionExpression.expression - return Node(ctx=ctx, - type='ForStatement', - initExpression=self.visit(ctx.simpleStatement()), - conditionExpression=conditionExpression, - loopExpression=Node(ctx=ctx, - type='ExpressionStatement', - expression=self.visit(ctx.expression())), - body=self.visit(ctx.statement()) - ) + return Node( + ctx=ctx, + type="ForStatement", + initExpression=self.visit(ctx.simpleStatement()), + conditionExpression=conditionExpression, + loopExpression=Node( + ctx=ctx, + type="ExpressionStatement", + expression=self.visit(ctx.expression()), + ), + body=self.visit(ctx.statement()), + ) def visitPrimaryExpression(self, ctx): if ctx.BooleanLiteral(): - return Node(ctx=ctx, - type='BooleanLiteral', - value=ctx.BooleanLiteral().getText() == 'true') + return Node( + ctx=ctx, + type="BooleanLiteral", + value=ctx.BooleanLiteral().getText() == "true", + ) if ctx.hexLiteral(): - return Node(ctx=ctx, - type='hexLiteral', - value=ctx.hexLiteral().getText()) + return Node(ctx=ctx, type="hexLiteral", value=ctx.hexLiteral().getText()) if ctx.stringLiteral(): text = ctx.getText() - return Node(ctx=ctx, - type='stringLiteral', - value=text[1: len(text) - 1]) + return Node(ctx=ctx, type="stringLiteral", value=text[1 : len(text) - 1]) - if len(ctx.children) == 3 and ctx.getChild(1).getText() == '[' and ctx.getChild(2).getText() == ']': + if ( + len(ctx.children) == 3 + and ctx.getChild(1).getText() == "[" + and ctx.getChild(2).getText() == "]" + ): node = self.visit(ctx.getChild(0)) - if node.type == 'Identifier': - node = Node(ctx=ctx, - type='UserDefinedTypeName', - namePath=node.name) + if node.type == "Identifier": + node = Node(ctx=ctx, type="UserDefinedTypeName", namePath=node.name) else: - node = Node(ctx=ctx, - type='ElementaryTypeName', - name=ctx.getChild(0).getText()) + node = Node( + ctx=ctx, type="ElementaryTypeName", name=ctx.getChild(0).getText() + ) - return Node(ctx=ctx, - type='ArrayTypeName', - baseTypeName=node, - length=None) + return Node(ctx=ctx, type="ArrayTypeName", baseTypeName=node, length=None) return self.visit(ctx.getChild(0)) def visitIdentifier(self, ctx): - return Node(ctx=ctx, - type="Identifier", - name=ctx.getText()) + return Node(ctx=ctx, type="Identifier", name=ctx.getText()) def visitTupleExpression(self, ctx): children = ctx.children[1:-1] - components = [None if e is None else self.visit(e) for e in self._mapCommasToNulls(children)] + components = [ + None if e is None else self.visit(e) + for e in self._mapCommasToNulls(children) + ] - return Node(ctx=ctx, - type='TupleExpression', - components=components, - isArray=ctx.getChild(0).getText() == '[') + return Node( + ctx=ctx, + type="TupleExpression", + components=components, + isArray=ctx.getChild(0).getText() == "[", + ) def visitIdentifierList(self, ctx: SolidityParser.IdentifierListContext): children = ctx.children[1:-1] @@ -730,35 +793,44 @@ def visitIdentifierList(self, ctx: SolidityParser.IdentifierListContext): if iden == None: result.append(None) else: - result.append(self._createNode(ctx=ctx, - type="VariableDeclaration", - name=iden.getText(), - isStateVar=False, - isIndexed=False, - iden=iden)) + result.append( + self._createNode( + ctx=ctx, + type="VariableDeclaration", + name=iden.getText(), + isStateVar=False, + isIndexed=False, + iden=iden, + ) + ) return result - def visitVariableDeclarationList(self, ctx: SolidityParser.VariableDeclarationListContext): + def visitVariableDeclarationList( + self, ctx: SolidityParser.VariableDeclarationListContext + ): result = [] for decl in self._mapCommasToNulls(ctx.children): if decl == None: return None ident = decl.identifier() - name = ident and ident.getText() or '_' - result.append(self._createNode(ctx=ctx, - type='VariableDeclaration', - name=name, - typeName=self.visit(decl.typeName()), - isStateVar=False, - isIndexed=False, - decl=decl)) + name = ident and ident.getText() or "_" + result.append( + self._createNode( + ctx=ctx, + type="VariableDeclaration", + name=name, + typeName=self.visit(decl.typeName()), + isStateVar=False, + isIndexed=False, + decl=decl, + ) + ) return result def visitVariableDeclarationStatement(self, ctx): - if ctx.variableDeclaration(): variables = [self.visit(ctx.variableDeclaration())] elif ctx.identifierList(): @@ -771,17 +843,21 @@ def visitVariableDeclarationStatement(self, ctx): if ctx.expression(): initialValue = self.visit(ctx.expression()) - return Node(ctx=ctx, - type='VariableDeclarationStatement', - variables=variables, - initialValue=initialValue) + return Node( + ctx=ctx, + type="VariableDeclarationStatement", + variables=variables, + initialValue=initialValue, + ) def visitEventDefinition(self, ctx): - return Node(ctx=ctx, - type='EventDefinition', - name=ctx.identifier().getText(), - parameters=self.visit(ctx.eventParameterList()), - isAnonymous=not not ctx.AnonymousKeyword()) + return Node( + ctx=ctx, + type="EventDefinition", + name=ctx.identifier().getText(), + parameters=self.visit(ctx.eventParameterList()), + isAnonymous=not not ctx.AnonymousKeyword(), + ) def visitEventParameterList(self, ctx): parameters = [] @@ -791,56 +867,51 @@ def visitEventParameterList(self, ctx): if paramCtx.identifier(): name = paramCtx.identifier().getText() - parameters.append(self._createNode(ctx=ctx, - type='VariableDeclaration', - typeName=type, - name=name, - isStateVar=False, - isIndexed=not not paramCtx.IndexedKeyword())) + parameters.append( + self._createNode( + ctx=ctx, + type="VariableDeclaration", + typeName=type, + name=name, + isStateVar=False, + isIndexed=not not paramCtx.IndexedKeyword(), + ) + ) - return Node(ctx=ctx, - type='ParameterList', - parameters=parameters) + return Node(ctx=ctx, type="ParameterList", parameters=parameters) def visitInlineAssemblyStatement(self, ctx): language = None if ctx.StringLiteralFragment(): language = ctx.StringLiteralFragment().getText() - language = language[1: len(language) - 1] + language = language[1 : len(language) - 1] - return Node(ctx=ctx, - type='InLineAssemblyStatement', - language=language, - body=self.visit(ctx.assemblyBlock())) + return Node( + ctx=ctx, + type="InLineAssemblyStatement", + language=language, + body=self.visit(ctx.assemblyBlock()), + ) def visitAssemblyBlock(self, ctx): operations = [self.visit(it) for it in ctx.assemblyItem()] - return Node(ctx=ctx, - type='AssemblyBlock', - operations=operations) + return Node(ctx=ctx, type="AssemblyBlock", operations=operations) def visitAssemblyItem(self, ctx): - if ctx.hexLiteral(): - return Node(ctx=ctx, - type='HexLiteral', - value=ctx.hexLiteral().getText()) + return Node(ctx=ctx, type="HexLiteral", value=ctx.hexLiteral().getText()) if ctx.stringLiteral(): text = ctx.stringLiteral().getText() - return Node(ctx=ctx, - type='StringLiteral', - value=text[1: len(text) - 1]) + return Node(ctx=ctx, type="StringLiteral", value=text[1 : len(text) - 1]) if ctx.BreakKeyword(): - return Node(ctx=ctx, - type='Break') + return Node(ctx=ctx, type="Break") if ctx.ContinueKeyword(): - return Node(ctx=ctx, - type='Continue') + return Node(ctx=ctx, type="Continue") return self.visit(ctx.getChild(0)) @@ -853,64 +924,61 @@ def visitAssemblyMember(self, ctx): name = ctx.identifier()[0].getText() else: name = ctx.identifier().getText() - return Node(ctx=ctx, - type='AssemblyMember', - name=name) + return Node(ctx=ctx, type="AssemblyMember", name=name) def visitAssemblyCall(self, ctx): functionName = ctx.getChild(0).getText() args = [self.visit(arg) for arg in ctx.assemblyExpression()] - return Node(ctx=ctx, - type='AssemblyExpression', - functionName=functionName, - arguments=args) + return Node( + ctx=ctx, + type="AssemblyExpression", + functionName=functionName, + arguments=args, + ) def visitAssemblyLiteral(self, ctx): - if ctx.stringLiteral(): text = ctx.getText() - return Node(ctx=ctx, - type='StringLiteral', - value=text[1: len(text) - 1]) + return Node(ctx=ctx, type="StringLiteral", value=text[1 : len(text) - 1]) if ctx.DecimalNumber(): - return Node(ctx=ctx, - type='DecimalNumber', - value=ctx.getText()) + return Node(ctx=ctx, type="DecimalNumber", value=ctx.getText()) if ctx.HexNumber(): - return Node(ctx=ctx, - type='HexNumber', - value=ctx.getText()) + return Node(ctx=ctx, type="HexNumber", value=ctx.getText()) if ctx.hexLiteral(): - return Node(ctx=ctx, - type='HexLiteral', - value=ctx.getText()) + return Node(ctx=ctx, type="HexLiteral", value=ctx.getText()) def visitAssemblySwitch(self, ctx): - return Node(ctx=ctx, - type='AssemblySwitch', - expression=self.visit(ctx.assemblyExpression()), - cases=[self.visit(c) for c in ctx.assemblyCase()]) + return Node( + ctx=ctx, + type="AssemblySwitch", + expression=self.visit(ctx.assemblyExpression()), + cases=[self.visit(c) for c in ctx.assemblyCase()], + ) def visitAssemblyCase(self, ctx): value = None - if ctx.getChild(0).getText() == 'case': + if ctx.getChild(0).getText() == "case": value = self.visit(ctx.assemblyLiteral()) if value != None: - node = Node(ctx=ctx, - type="AssemblyCase", - block=self.visit(ctx.assemblyBlock()), - value=value) + node = Node( + ctx=ctx, + type="AssemblyCase", + block=self.visit(ctx.assemblyBlock()), + value=value, + ) else: - node = Node(ctx=ctx, - type="AssemblyCase", - block=self.visit(ctx.assemblyBlock()), - default=True) + node = Node( + ctx=ctx, + type="AssemblyCase", + block=self.visit(ctx.assemblyBlock()), + default=True, + ) return node @@ -922,21 +990,25 @@ def visitAssemblyLocalDefinition(self, ctx): else: names = self.visit(names.assemblyIdentifierList().identifier()) - return Node(ctx=ctx, - type='AssemblyLocalDefinition', - names=names, - expression=self.visit(ctx.assemblyExpression())) + return Node( + ctx=ctx, + type="AssemblyLocalDefinition", + names=names, + expression=self.visit(ctx.assemblyExpression()), + ) def visitAssemblyFunctionDefinition(self, ctx): args = ctx.assemblyIdentifierList().identifier() returnArgs = ctx.assemblyFunctionReturns().assemblyIdentifierList().identifier() - return Node(ctx=ctx, - type='AssemblyFunctionDefinition', - name=ctx.identifier().getText(), - arguments=self.visit(args), - returnArguments=self.visit(returnArgs), - body=self.visit(ctx.assemblyBlock())) + return Node( + ctx=ctx, + type="AssemblyFunctionDefinition", + name=ctx.identifier().getText(), + arguments=self.visit(args), + returnArguments=self.visit(returnArgs), + body=self.visit(ctx.assemblyBlock()), + ) def visitAssemblyAssignment(self, ctx): names = ctx.assemblyIdentifierOrList() @@ -946,42 +1018,48 @@ def visitAssemblyAssignment(self, ctx): else: names = self.visit(names.assemblyIdentifierList().identifier()) - return Node(ctx=ctx, - type='AssemblyAssignment', - names=names, - expression=self.visit(ctx.assemblyExpression())) + return Node( + ctx=ctx, + type="AssemblyAssignment", + names=names, + expression=self.visit(ctx.assemblyExpression()), + ) def visitLabelDefinition(self, ctx): - return Node(ctx=ctx, - type='LabelDefinition', - name=ctx.identifier().getText()) + return Node(ctx=ctx, type="LabelDefinition", name=ctx.identifier().getText()) def visitAssemblyStackAssignment(self, ctx): - return Node(ctx=ctx, - type='AssemblyStackAssignment', - name=ctx.identifier().getText()) + return Node( + ctx=ctx, type="AssemblyStackAssignment", name=ctx.identifier().getText() + ) def visitAssemblyFor(self, ctx): - return Node(ctx=ctx, - type='AssemblyFor', - pre=self.visit(ctx.getChild(1)), - condition=self.visit(ctx.getChild(2)), - post=self.visit(ctx.getChild(3)), - body=self.visit(ctx.getChild(4))) + return Node( + ctx=ctx, + type="AssemblyFor", + pre=self.visit(ctx.getChild(1)), + condition=self.visit(ctx.getChild(2)), + post=self.visit(ctx.getChild(3)), + body=self.visit(ctx.getChild(4)), + ) def visitAssemblyIf(self, ctx): - return Node(ctx=ctx, - type='AssemblyIf', - condition=self.visit(ctx.assemblyExpression()), - body=self.visit(ctx.assemblyBlock())) + return Node( + ctx=ctx, + type="AssemblyIf", + condition=self.visit(ctx.assemblyExpression()), + body=self.visit(ctx.assemblyBlock()), + ) ### /*************************************************** def visitPragmaDirective(self, ctx): - return Node(ctx=ctx, - type="PragmaDirective", - name=ctx.pragmaName().getText(), - value=ctx.pragmaValue().getText()) + return Node( + ctx=ctx, + type="PragmaDirective", + name=ctx.pragmaName().getText(), + value=ctx.pragmaValue().getText(), + ) def visitImportDirective(self, ctx): symbol_aliases = {} @@ -989,7 +1067,6 @@ def visitImportDirective(self, ctx): if len(ctx.importDeclaration()) > 0: for item in ctx.importDeclaration(): - try: alias = item.identifier(1).getText() except: @@ -1002,26 +1079,27 @@ def visitImportDirective(self, ctx): elif len(ctx.children) == 5: unit_alias = ctx.getChild(3).getText() - return Node(ctx=ctx, - type="ImportDirective", - path=ctx.importPath().getText().strip('"'), - symbolAliases=symbol_aliases, - unitAlias=unit_alias - ) + return Node( + ctx=ctx, + type="ImportDirective", + path=ctx.importPath().getText().strip('"'), + symbolAliases=symbol_aliases, + unitAlias=unit_alias, + ) def visitContractDefinition(self, ctx): self._currentContract = ctx.identifier().getText() - return Node(ctx=ctx, - type="ContractDefinition", - name=ctx.identifier().getText(), - baseContracts=self.visit(ctx.inheritanceSpecifier()), - subNodes=self.visit(ctx.contractPart()), - kind=ctx.getChild(0).getText()) + return Node( + ctx=ctx, + type="ContractDefinition", + name=ctx.identifier().getText(), + baseContracts=self.visit(ctx.inheritanceSpecifier()), + subNodes=self.visit(ctx.contractPart()), + kind=ctx.getChild(0).getText(), + ) def visitUserDefinedTypename(self, ctx): - return Node(ctx=ctx, - type="UserDefinedTypename", - name=ctx.getText()) + return Node(ctx=ctx, type="UserDefinedTypename", name=ctx.getText()) def visitReturnStatement(self, ctx): return self.visit(ctx.expression()) @@ -1047,7 +1125,7 @@ def parse(text, start="sourceUnit", loc=False, strict=False): def parse_file(path, start="sourceUnit", loc=False, strict=False): - with open(path, 'r', encoding="utf-8") as f: + with open(path, "r", encoding="utf-8") as f: return parse(f.read(), start=start, loc=loc, strict=strict) @@ -1065,10 +1143,10 @@ def visit(node, callback_object): return node # call callback if it is available - if hasattr(callback_object, "visit"+node.type): - getattr(callback_object, "visit"+node.type)(node) + if hasattr(callback_object, "visit" + node.type): + getattr(callback_object, "visit" + node.type)(node) - for k,v in node.items(): + for k, v in node.items(): if k in node.NONCHILD_KEYS: # skip non child items continue @@ -1103,7 +1181,6 @@ def objectify(start_node): current_function = None class ObjectifyContractVisitor(object): - def __init__(self, node): self._node = node self.name = node.name @@ -1120,19 +1197,16 @@ def __init__(self, node): self.constructor = None self.inherited_names = {} - def visitEnumDefinition(self, _node): - self.enums[_node.name]=_node - self.names[_node.name]=_node + self.enums[_node.name] = _node + self.names[_node.name] = _node def visitStructDefinition(self, _node): - self.structs[_node.name]=_node - self.names[_node.name]=_node + self.structs[_node.name] = _node + self.names[_node.name] = _node def visitStateVariableDeclaration(self, _node): - class VarDecVisitor(object): - def __init__(self, current_contract): self._current_contract = current_contract @@ -1143,7 +1217,6 @@ def visitVariableDeclaration(self, __node): visit(_node, VarDecVisitor(self)) def visitEventDefinition(self, _node): - class EventFunctionVisitor(object): def __init__(self, node): self.arguments = {} @@ -1159,14 +1232,11 @@ def visitVariableDeclaration(self, __node): self.names[_node.name] = current_function self.events[_node.name] = current_function - def visitFunctionDefinition(self, _node, _definition_type=None): - class FunctionObject(object): - def __init__(self, node): self._node = node - if(node.type=="FunctionDefinition"): + if node.type == "FunctionDefinition": self.visibility = node.visibility self.stateMutability = node.stateMutability self.isConstructor = node.isConstructor @@ -1176,11 +1246,8 @@ def __init__(self, node): self.returns = {} self.declarations = {} self.identifiers = [] - - class FunctionArgumentVisitor(object): - def __init__(self): self.parameters = {} @@ -1188,7 +1255,6 @@ def visitParameter(self, __node): self.parameters[__node.name] = __node class VarDecVisitor(object): - def __init__(self): self.variable_declarations = {} @@ -1196,7 +1262,6 @@ def visitVariableDeclaration(self, __node): self.variable_declarations[__node.name] = __node class IdentifierDecVisitor(object): - def __init__(self): self.idents = [] @@ -1208,7 +1273,7 @@ def visitAssemblyCall(self, __node): current_function = FunctionObject(_node) self.names[_node.name] = current_function - if _definition_type=="ModifierDefinition": + if _definition_type == "ModifierDefinition": self.modifiers[_node.name] = current_function else: self.functions[_node.name] = current_function @@ -1221,7 +1286,6 @@ def visitAssemblyCall(self, __node): current_function.arguments = funcargvisitor.parameters current_function.declarations.update(current_function.arguments) - ## get returnParams if _node.get("returnParameters"): # because modifiers dont @@ -1230,7 +1294,6 @@ def visitAssemblyCall(self, __node): current_function.returns = funcargvisitor.parameters current_function.declarations.update(current_function.returns) - ## get vardecs in body vardecs = VarDecVisitor() visit(_node.body, vardecs) @@ -1244,9 +1307,7 @@ def visitAssemblyCall(self, __node): def visitModifierDefinition(self, _node): return self.visitFunctionDefinition(_node, "ModifierDefinition") - class ObjectifySourceUnitVisitor(object): - def __init__(self, node): self._node = node self.imports = [] diff --git a/solidity_parser/solidity_antlr4/SolidityLexer.py b/solidity_parser/solidity_antlr4/SolidityLexer.py index 22ba59c..5577c9e 100644 --- a/solidity_parser/solidity_antlr4/SolidityLexer.py +++ b/solidity_parser/solidity_antlr4/SolidityLexer.py @@ -5,7 +5,6 @@ import sys - def serializedATN(): with StringIO() as buf: buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u0087") @@ -14,8 +13,8 @@ def serializedATN(): buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23") buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30") buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36") - buf.write("\t\36\4\37\t\37\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\36\4\37\t\37\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/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64") buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:") buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t") @@ -40,9 +39,9 @@ def serializedATN(): buf.write("\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30") buf.write("\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33") buf.write("\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\35\3\35\3\36\3\36") - buf.write("\3\37\3\37\3 \3 \3!\3!\3\"\3\"\3#\3#\3#\3$\3$\3$\3%\3") - buf.write("%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3&\3&\3&\3\'\3\'\3") - buf.write("\'\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3)") + buf.write('\3\37\3\37\3 \3 \3!\3!\3"\3"\3#\3#\3#\3$\3$\3$\3%\3') + buf.write("%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3&\3&\3&\3'\3'\3") + buf.write("'\3'\3'\3'\3'\3'\3'\3(\3(\3(\3(\3(\3(\3(\3(\3)") buf.write("\3)\3)\3)\3)\3)\3*\3*\3*\3*\3*\3+\3+\3,\3,\3-\3-\3-\3") buf.write("-\3-\3-\3-\3-\3.\3.\3/\3/\3/\3/\3/\3/\3/\3/\3\60\3\60") buf.write("\3\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62") @@ -145,9 +144,9 @@ def serializedATN(): buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\7\u008e\u0749\n\u008e") buf.write("\f\u008e\16\u008e\u074c\13\u008e\3\u008e\3\u008e\3\u073c") buf.write("\2\u008f\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f") - buf.write("\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27") - buf.write("-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%") - buf.write("I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g\65i\66k\67") + buf.write("\27\r\31\16\33\17\35\20\37\21!\22#\23%\24'\25)\26+\27") + buf.write('-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A"C#E$G%') + buf.write("I&K'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g\65i\66k\67") buf.write("m8o9q:s;u{?}@\177A\u0081B\u0083C\u0085D\u0087E\u0089") buf.write("F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099") buf.write("N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9") @@ -161,12 +160,12 @@ def serializedATN(): buf.write("\u0113\2\u0115\u0084\u0117\u0085\u0119\u0086\u011b\u0087") buf.write("\3\2\f\3\2\62;\4\2GGgg\4\2ZZzz\5\2\62;CHch\6\2&&C\\aa") buf.write("c|\7\2&&\62;C\\aac|\6\2\f\f\17\17$$^^\6\2\f\f\17\17))") - buf.write("^^\5\2\13\f\16\17\"\"\4\2\f\f\17\17\2\u07e0\2\3\3\2\2") + buf.write('^^\5\2\13\f\16\17""\4\2\f\f\17\17\2\u07e0\2\3\3\2\2') buf.write("\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2") buf.write("\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25") buf.write("\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3") buf.write("\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2") - buf.write("\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2") + buf.write("'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2") buf.write("\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\2") buf.write("9\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2") buf.write("\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2") @@ -201,7 +200,7 @@ def serializedATN(): buf.write("\23\u0134\3\2\2\2\25\u0136\3\2\2\2\27\u0139\3\2\2\2\31") buf.write("\u013b\3\2\2\2\33\u013e\3\2\2\2\35\u0145\3\2\2\2\37\u014a") buf.write("\3\2\2\2!\u014c\3\2\2\2#\u014e\3\2\2\2%\u0150\3\2\2\2") - buf.write("\'\u0159\3\2\2\2)\u0162\3\2\2\2+\u016c\3\2\2\2-\u0174") + buf.write("'\u0159\3\2\2\2)\u0162\3\2\2\2+\u016c\3\2\2\2-\u0174") buf.write("\3\2\2\2/\u0177\3\2\2\2\61\u0179\3\2\2\2\63\u017b\3\2") buf.write("\2\2\65\u0181\3\2\2\2\67\u0187\3\2\2\29\u018b\3\2\2\2") buf.write(";\u018d\3\2\2\2=\u018f\3\2\2\2?\u0191\3\2\2\2A\u0193\3") @@ -258,7 +257,7 @@ def serializedATN(): buf.write("\7v\2\2\u0144\34\3\2\2\2\u0145\u0146\7h\2\2\u0146\u0147") buf.write("\7t\2\2\u0147\u0148\7q\2\2\u0148\u0149\7o\2\2\u0149\36") buf.write("\3\2\2\2\u014a\u014b\7}\2\2\u014b \3\2\2\2\u014c\u014d") - buf.write("\7.\2\2\u014d\"\3\2\2\2\u014e\u014f\7\177\2\2\u014f$\3") + buf.write('\7.\2\2\u014d"\3\2\2\2\u014e\u014f\7\177\2\2\u014f$\3') buf.write("\2\2\2\u0150\u0151\7c\2\2\u0151\u0152\7d\2\2\u0152\u0153") buf.write("\7u\2\2\u0153\u0154\7v\2\2\u0154\u0155\7t\2\2\u0155\u0156") buf.write("\7c\2\2\u0156\u0157\7e\2\2\u0157\u0158\7v\2\2\u0158&\3") @@ -282,7 +281,7 @@ def serializedATN(): buf.write("\7~\2\2\u018c:\3\2\2\2\u018d\u018e\7(\2\2\u018e<\3\2\2") buf.write("\2\u018f\u0190\7-\2\2\u0190>\3\2\2\2\u0191\u0192\7/\2") buf.write("\2\u0192@\3\2\2\2\u0193\u0194\7\61\2\2\u0194B\3\2\2\2") - buf.write("\u0195\u0196\7\'\2\2\u0196D\3\2\2\2\u0197\u0198\7?\2\2") + buf.write("\u0195\u0196\7'\2\2\u0196D\3\2\2\2\u0197\u0198\7?\2\2") buf.write("\u0198\u0199\7?\2\2\u0199F\3\2\2\2\u019a\u019b\7#\2\2") buf.write("\u019b\u019c\7?\2\2\u019cH\3\2\2\2\u019d\u019e\7u\2\2") buf.write("\u019e\u019f\7v\2\2\u019f\u01a0\7t\2\2\u01a0\u01a1\7w") @@ -368,7 +367,7 @@ def serializedATN(): buf.write("\7/\2\2\u028e\u028f\7?\2\2\u028f\u00aa\3\2\2\2\u0290\u0291") buf.write("\7,\2\2\u0291\u0292\7?\2\2\u0292\u00ac\3\2\2\2\u0293\u0294") buf.write("\7\61\2\2\u0294\u0295\7?\2\2\u0295\u00ae\3\2\2\2\u0296") - buf.write("\u0297\7\'\2\2\u0297\u0298\7?\2\2\u0298\u00b0\3\2\2\2") + buf.write("\u0297\7'\2\2\u0297\u0298\7?\2\2\u0298\u00b0\3\2\2\2") buf.write("\u0299\u029a\7n\2\2\u029a\u029b\7g\2\2\u029b\u029c\7v") buf.write("\2\2\u029c\u00b2\3\2\2\2\u029d\u029e\7<\2\2\u029e\u029f") buf.write("\7?\2\2\u029f\u00b4\3\2\2\2\u02a0\u02a1\7?\2\2\u02a1\u02a2") @@ -858,10 +857,9 @@ def serializedATN(): class SolidityLexer(Lexer): - atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] T__0 = 1 T__1 = 2 @@ -997,78 +995,322 @@ class SolidityLexer(Lexer): COMMENT = 132 LINE_COMMENT = 133 - channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] - modeNames = [ "DEFAULT_MODE" ] + modeNames = ["DEFAULT_MODE"] - literalNames = [ "", - "'pragma'", "';'", "'*'", "'||'", "'^'", "'~'", "'>='", "'>'", - "'<'", "'<='", "'='", "'as'", "'import'", "'from'", "'{'", "','", - "'}'", "'abstract'", "'contract'", "'interface'", "'library'", - "'is'", "'('", "')'", "'error'", "'using'", "'for'", "'|'", - "'&'", "'+'", "'-'", "'/'", "'%'", "'=='", "'!='", "'struct'", - "'modifier'", "'function'", "'returns'", "'event'", "'enum'", - "'['", "']'", "'address'", "'.'", "'mapping'", "'=>'", "'memory'", - "'storage'", "'calldata'", "'if'", "'else'", "'try'", "'catch'", - "'while'", "'unchecked'", "'assembly'", "'do'", "'return'", - "'throw'", "'emit'", "'revert'", "'var'", "'bool'", "'string'", - "'byte'", "'++'", "'--'", "'new'", "':'", "'delete'", "'!'", - "'**'", "'<<'", "'>>'", "'&&'", "'?'", "'|='", "'^='", "'&='", - "'<<='", "'>>='", "'+='", "'-='", "'*='", "'/='", "'%='", "'let'", - "':='", "'=:'", "'switch'", "'case'", "'default'", "'->'", "'callback'", - "'override'", "'anonymous'", "'break'", "'constant'", "'immutable'", - "'continue'", "'leave'", "'external'", "'indexed'", "'internal'", - "'payable'", "'private'", "'public'", "'virtual'", "'pure'", - "'type'", "'view'", "'global'", "'constructor'", "'fallback'", - "'receive'" ] + literalNames = [ + "", + "'pragma'", + "';'", + "'*'", + "'||'", + "'^'", + "'~'", + "'>='", + "'>'", + "'<'", + "'<='", + "'='", + "'as'", + "'import'", + "'from'", + "'{'", + "','", + "'}'", + "'abstract'", + "'contract'", + "'interface'", + "'library'", + "'is'", + "'('", + "')'", + "'error'", + "'using'", + "'for'", + "'|'", + "'&'", + "'+'", + "'-'", + "'/'", + "'%'", + "'=='", + "'!='", + "'struct'", + "'modifier'", + "'function'", + "'returns'", + "'event'", + "'enum'", + "'['", + "']'", + "'address'", + "'.'", + "'mapping'", + "'=>'", + "'memory'", + "'storage'", + "'calldata'", + "'if'", + "'else'", + "'try'", + "'catch'", + "'while'", + "'unchecked'", + "'assembly'", + "'do'", + "'return'", + "'throw'", + "'emit'", + "'revert'", + "'var'", + "'bool'", + "'string'", + "'byte'", + "'++'", + "'--'", + "'new'", + "':'", + "'delete'", + "'!'", + "'**'", + "'<<'", + "'>>'", + "'&&'", + "'?'", + "'|='", + "'^='", + "'&='", + "'<<='", + "'>>='", + "'+='", + "'-='", + "'*='", + "'/='", + "'%='", + "'let'", + "':='", + "'=:'", + "'switch'", + "'case'", + "'default'", + "'->'", + "'callback'", + "'override'", + "'anonymous'", + "'break'", + "'constant'", + "'immutable'", + "'continue'", + "'leave'", + "'external'", + "'indexed'", + "'internal'", + "'payable'", + "'private'", + "'public'", + "'virtual'", + "'pure'", + "'type'", + "'view'", + "'global'", + "'constructor'", + "'fallback'", + "'receive'", + ] - symbolicNames = [ "", - "Int", "Uint", "Byte", "Fixed", "Ufixed", "BooleanLiteral", - "DecimalNumber", "HexNumber", "NumberUnit", "HexLiteralFragment", - "ReservedKeyword", "AnonymousKeyword", "BreakKeyword", "ConstantKeyword", - "ImmutableKeyword", "ContinueKeyword", "LeaveKeyword", "ExternalKeyword", - "IndexedKeyword", "InternalKeyword", "PayableKeyword", "PrivateKeyword", - "PublicKeyword", "VirtualKeyword", "PureKeyword", "TypeKeyword", - "ViewKeyword", "GlobalKeyword", "ConstructorKeyword", "FallbackKeyword", - "ReceiveKeyword", "Identifier", "StringLiteralFragment", "VersionLiteral", - "WS", "COMMENT", "LINE_COMMENT" ] + symbolicNames = [ + "", + "Int", + "Uint", + "Byte", + "Fixed", + "Ufixed", + "BooleanLiteral", + "DecimalNumber", + "HexNumber", + "NumberUnit", + "HexLiteralFragment", + "ReservedKeyword", + "AnonymousKeyword", + "BreakKeyword", + "ConstantKeyword", + "ImmutableKeyword", + "ContinueKeyword", + "LeaveKeyword", + "ExternalKeyword", + "IndexedKeyword", + "InternalKeyword", + "PayableKeyword", + "PrivateKeyword", + "PublicKeyword", + "VirtualKeyword", + "PureKeyword", + "TypeKeyword", + "ViewKeyword", + "GlobalKeyword", + "ConstructorKeyword", + "FallbackKeyword", + "ReceiveKeyword", + "Identifier", + "StringLiteralFragment", + "VersionLiteral", + "WS", + "COMMENT", + "LINE_COMMENT", + ] - ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", - "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", - "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", - "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", - "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", - "T__32", "T__33", "T__34", "T__35", "T__36", "T__37", - "T__38", "T__39", "T__40", "T__41", "T__42", "T__43", - "T__44", "T__45", "T__46", "T__47", "T__48", "T__49", - "T__50", "T__51", "T__52", "T__53", "T__54", "T__55", - "T__56", "T__57", "T__58", "T__59", "T__60", "T__61", - "T__62", "T__63", "T__64", "T__65", "T__66", "T__67", - "T__68", "T__69", "T__70", "T__71", "T__72", "T__73", - "T__74", "T__75", "T__76", "T__77", "T__78", "T__79", - "T__80", "T__81", "T__82", "T__83", "T__84", "T__85", - "T__86", "T__87", "T__88", "T__89", "T__90", "T__91", - "T__92", "T__93", "T__94", "T__95", "Int", "Uint", "Byte", - "Fixed", "Ufixed", "BooleanLiteral", "DecimalNumber", - "DecimalDigits", "HexNumber", "HexDigits", "NumberUnit", - "HexLiteralFragment", "HexPair", "HexCharacter", "ReservedKeyword", - "AnonymousKeyword", "BreakKeyword", "ConstantKeyword", - "ImmutableKeyword", "ContinueKeyword", "LeaveKeyword", - "ExternalKeyword", "IndexedKeyword", "InternalKeyword", - "PayableKeyword", "PrivateKeyword", "PublicKeyword", "VirtualKeyword", - "PureKeyword", "TypeKeyword", "ViewKeyword", "GlobalKeyword", - "ConstructorKeyword", "FallbackKeyword", "ReceiveKeyword", - "Identifier", "IdentifierStart", "IdentifierPart", "StringLiteralFragment", - "DoubleQuotedStringCharacter", "SingleQuotedStringCharacter", - "VersionLiteral", "WS", "COMMENT", "LINE_COMMENT" ] + ruleNames = [ + "T__0", + "T__1", + "T__2", + "T__3", + "T__4", + "T__5", + "T__6", + "T__7", + "T__8", + "T__9", + "T__10", + "T__11", + "T__12", + "T__13", + "T__14", + "T__15", + "T__16", + "T__17", + "T__18", + "T__19", + "T__20", + "T__21", + "T__22", + "T__23", + "T__24", + "T__25", + "T__26", + "T__27", + "T__28", + "T__29", + "T__30", + "T__31", + "T__32", + "T__33", + "T__34", + "T__35", + "T__36", + "T__37", + "T__38", + "T__39", + "T__40", + "T__41", + "T__42", + "T__43", + "T__44", + "T__45", + "T__46", + "T__47", + "T__48", + "T__49", + "T__50", + "T__51", + "T__52", + "T__53", + "T__54", + "T__55", + "T__56", + "T__57", + "T__58", + "T__59", + "T__60", + "T__61", + "T__62", + "T__63", + "T__64", + "T__65", + "T__66", + "T__67", + "T__68", + "T__69", + "T__70", + "T__71", + "T__72", + "T__73", + "T__74", + "T__75", + "T__76", + "T__77", + "T__78", + "T__79", + "T__80", + "T__81", + "T__82", + "T__83", + "T__84", + "T__85", + "T__86", + "T__87", + "T__88", + "T__89", + "T__90", + "T__91", + "T__92", + "T__93", + "T__94", + "T__95", + "Int", + "Uint", + "Byte", + "Fixed", + "Ufixed", + "BooleanLiteral", + "DecimalNumber", + "DecimalDigits", + "HexNumber", + "HexDigits", + "NumberUnit", + "HexLiteralFragment", + "HexPair", + "HexCharacter", + "ReservedKeyword", + "AnonymousKeyword", + "BreakKeyword", + "ConstantKeyword", + "ImmutableKeyword", + "ContinueKeyword", + "LeaveKeyword", + "ExternalKeyword", + "IndexedKeyword", + "InternalKeyword", + "PayableKeyword", + "PrivateKeyword", + "PublicKeyword", + "VirtualKeyword", + "PureKeyword", + "TypeKeyword", + "ViewKeyword", + "GlobalKeyword", + "ConstructorKeyword", + "FallbackKeyword", + "ReceiveKeyword", + "Identifier", + "IdentifierStart", + "IdentifierPart", + "StringLiteralFragment", + "DoubleQuotedStringCharacter", + "SingleQuotedStringCharacter", + "VersionLiteral", + "WS", + "COMMENT", + "LINE_COMMENT", + ] grammarFileName = "Solidity.g4" - def __init__(self, input=None, output:TextIO = sys.stdout): + def __init__(self, input=None, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.7.2") - self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._interp = LexerATNSimulator( + self, self.atn, self.decisionsToDFA, PredictionContextCache() + ) self._actions = None self._predicates = None - - diff --git a/solidity_parser/solidity_antlr4/SolidityListener.py b/solidity_parser/solidity_antlr4/SolidityListener.py index 4bd3369..c249ad6 100644 --- a/solidity_parser/solidity_antlr4/SolidityListener.py +++ b/solidity_parser/solidity_antlr4/SolidityListener.py @@ -1,919 +1,888 @@ # Generated from solidity-antlr4/Solidity.g4 by ANTLR 4.7.2 from antlr4 import * + if __name__ is not None and "." in __name__: from .SolidityParser import SolidityParser else: from SolidityParser import SolidityParser + # This class defines a complete listener for a parse tree produced by SolidityParser. class SolidityListener(ParseTreeListener): - # Enter a parse tree produced by SolidityParser#sourceUnit. - def enterSourceUnit(self, ctx:SolidityParser.SourceUnitContext): + def enterSourceUnit(self, ctx: SolidityParser.SourceUnitContext): pass # Exit a parse tree produced by SolidityParser#sourceUnit. - def exitSourceUnit(self, ctx:SolidityParser.SourceUnitContext): + def exitSourceUnit(self, ctx: SolidityParser.SourceUnitContext): pass - # Enter a parse tree produced by SolidityParser#pragmaDirective. - def enterPragmaDirective(self, ctx:SolidityParser.PragmaDirectiveContext): + def enterPragmaDirective(self, ctx: SolidityParser.PragmaDirectiveContext): pass # Exit a parse tree produced by SolidityParser#pragmaDirective. - def exitPragmaDirective(self, ctx:SolidityParser.PragmaDirectiveContext): + def exitPragmaDirective(self, ctx: SolidityParser.PragmaDirectiveContext): pass - # Enter a parse tree produced by SolidityParser#pragmaName. - def enterPragmaName(self, ctx:SolidityParser.PragmaNameContext): + def enterPragmaName(self, ctx: SolidityParser.PragmaNameContext): pass # Exit a parse tree produced by SolidityParser#pragmaName. - def exitPragmaName(self, ctx:SolidityParser.PragmaNameContext): + def exitPragmaName(self, ctx: SolidityParser.PragmaNameContext): pass - # Enter a parse tree produced by SolidityParser#pragmaValue. - def enterPragmaValue(self, ctx:SolidityParser.PragmaValueContext): + def enterPragmaValue(self, ctx: SolidityParser.PragmaValueContext): pass # Exit a parse tree produced by SolidityParser#pragmaValue. - def exitPragmaValue(self, ctx:SolidityParser.PragmaValueContext): + def exitPragmaValue(self, ctx: SolidityParser.PragmaValueContext): pass - # Enter a parse tree produced by SolidityParser#version. - def enterVersion(self, ctx:SolidityParser.VersionContext): + def enterVersion(self, ctx: SolidityParser.VersionContext): pass # Exit a parse tree produced by SolidityParser#version. - def exitVersion(self, ctx:SolidityParser.VersionContext): + def exitVersion(self, ctx: SolidityParser.VersionContext): pass - # Enter a parse tree produced by SolidityParser#versionOperator. - def enterVersionOperator(self, ctx:SolidityParser.VersionOperatorContext): + def enterVersionOperator(self, ctx: SolidityParser.VersionOperatorContext): pass # Exit a parse tree produced by SolidityParser#versionOperator. - def exitVersionOperator(self, ctx:SolidityParser.VersionOperatorContext): + def exitVersionOperator(self, ctx: SolidityParser.VersionOperatorContext): pass - # Enter a parse tree produced by SolidityParser#versionConstraint. - def enterVersionConstraint(self, ctx:SolidityParser.VersionConstraintContext): + def enterVersionConstraint(self, ctx: SolidityParser.VersionConstraintContext): pass # Exit a parse tree produced by SolidityParser#versionConstraint. - def exitVersionConstraint(self, ctx:SolidityParser.VersionConstraintContext): + def exitVersionConstraint(self, ctx: SolidityParser.VersionConstraintContext): pass - # Enter a parse tree produced by SolidityParser#importDeclaration. - def enterImportDeclaration(self, ctx:SolidityParser.ImportDeclarationContext): + def enterImportDeclaration(self, ctx: SolidityParser.ImportDeclarationContext): pass # Exit a parse tree produced by SolidityParser#importDeclaration. - def exitImportDeclaration(self, ctx:SolidityParser.ImportDeclarationContext): + def exitImportDeclaration(self, ctx: SolidityParser.ImportDeclarationContext): pass - # Enter a parse tree produced by SolidityParser#importDirective. - def enterImportDirective(self, ctx:SolidityParser.ImportDirectiveContext): + def enterImportDirective(self, ctx: SolidityParser.ImportDirectiveContext): pass # Exit a parse tree produced by SolidityParser#importDirective. - def exitImportDirective(self, ctx:SolidityParser.ImportDirectiveContext): + def exitImportDirective(self, ctx: SolidityParser.ImportDirectiveContext): pass - # Enter a parse tree produced by SolidityParser#importPath. - def enterImportPath(self, ctx:SolidityParser.ImportPathContext): + def enterImportPath(self, ctx: SolidityParser.ImportPathContext): pass # Exit a parse tree produced by SolidityParser#importPath. - def exitImportPath(self, ctx:SolidityParser.ImportPathContext): + def exitImportPath(self, ctx: SolidityParser.ImportPathContext): pass - # Enter a parse tree produced by SolidityParser#contractDefinition. - def enterContractDefinition(self, ctx:SolidityParser.ContractDefinitionContext): + def enterContractDefinition(self, ctx: SolidityParser.ContractDefinitionContext): pass # Exit a parse tree produced by SolidityParser#contractDefinition. - def exitContractDefinition(self, ctx:SolidityParser.ContractDefinitionContext): + def exitContractDefinition(self, ctx: SolidityParser.ContractDefinitionContext): pass - # Enter a parse tree produced by SolidityParser#inheritanceSpecifier. - def enterInheritanceSpecifier(self, ctx:SolidityParser.InheritanceSpecifierContext): + def enterInheritanceSpecifier( + self, ctx: SolidityParser.InheritanceSpecifierContext + ): pass # Exit a parse tree produced by SolidityParser#inheritanceSpecifier. - def exitInheritanceSpecifier(self, ctx:SolidityParser.InheritanceSpecifierContext): + def exitInheritanceSpecifier(self, ctx: SolidityParser.InheritanceSpecifierContext): pass - # Enter a parse tree produced by SolidityParser#contractPart. - def enterContractPart(self, ctx:SolidityParser.ContractPartContext): + def enterContractPart(self, ctx: SolidityParser.ContractPartContext): pass # Exit a parse tree produced by SolidityParser#contractPart. - def exitContractPart(self, ctx:SolidityParser.ContractPartContext): + def exitContractPart(self, ctx: SolidityParser.ContractPartContext): pass - # Enter a parse tree produced by SolidityParser#stateVariableDeclaration. - def enterStateVariableDeclaration(self, ctx:SolidityParser.StateVariableDeclarationContext): + def enterStateVariableDeclaration( + self, ctx: SolidityParser.StateVariableDeclarationContext + ): pass # Exit a parse tree produced by SolidityParser#stateVariableDeclaration. - def exitStateVariableDeclaration(self, ctx:SolidityParser.StateVariableDeclarationContext): + def exitStateVariableDeclaration( + self, ctx: SolidityParser.StateVariableDeclarationContext + ): pass - # Enter a parse tree produced by SolidityParser#fileLevelConstant. - def enterFileLevelConstant(self, ctx:SolidityParser.FileLevelConstantContext): + def enterFileLevelConstant(self, ctx: SolidityParser.FileLevelConstantContext): pass # Exit a parse tree produced by SolidityParser#fileLevelConstant. - def exitFileLevelConstant(self, ctx:SolidityParser.FileLevelConstantContext): + def exitFileLevelConstant(self, ctx: SolidityParser.FileLevelConstantContext): pass - # Enter a parse tree produced by SolidityParser#customErrorDefinition. - def enterCustomErrorDefinition(self, ctx:SolidityParser.CustomErrorDefinitionContext): + def enterCustomErrorDefinition( + self, ctx: SolidityParser.CustomErrorDefinitionContext + ): pass # Exit a parse tree produced by SolidityParser#customErrorDefinition. - def exitCustomErrorDefinition(self, ctx:SolidityParser.CustomErrorDefinitionContext): + def exitCustomErrorDefinition( + self, ctx: SolidityParser.CustomErrorDefinitionContext + ): pass - # Enter a parse tree produced by SolidityParser#typeDefinition. - def enterTypeDefinition(self, ctx:SolidityParser.TypeDefinitionContext): + def enterTypeDefinition(self, ctx: SolidityParser.TypeDefinitionContext): pass # Exit a parse tree produced by SolidityParser#typeDefinition. - def exitTypeDefinition(self, ctx:SolidityParser.TypeDefinitionContext): + def exitTypeDefinition(self, ctx: SolidityParser.TypeDefinitionContext): pass - # Enter a parse tree produced by SolidityParser#usingForDeclaration. - def enterUsingForDeclaration(self, ctx:SolidityParser.UsingForDeclarationContext): + def enterUsingForDeclaration(self, ctx: SolidityParser.UsingForDeclarationContext): pass # Exit a parse tree produced by SolidityParser#usingForDeclaration. - def exitUsingForDeclaration(self, ctx:SolidityParser.UsingForDeclarationContext): + def exitUsingForDeclaration(self, ctx: SolidityParser.UsingForDeclarationContext): pass - # Enter a parse tree produced by SolidityParser#usingForObject. - def enterUsingForObject(self, ctx:SolidityParser.UsingForObjectContext): + def enterUsingForObject(self, ctx: SolidityParser.UsingForObjectContext): pass # Exit a parse tree produced by SolidityParser#usingForObject. - def exitUsingForObject(self, ctx:SolidityParser.UsingForObjectContext): + def exitUsingForObject(self, ctx: SolidityParser.UsingForObjectContext): pass - # Enter a parse tree produced by SolidityParser#usingForObjectDirective. - def enterUsingForObjectDirective(self, ctx:SolidityParser.UsingForObjectDirectiveContext): + def enterUsingForObjectDirective( + self, ctx: SolidityParser.UsingForObjectDirectiveContext + ): pass # Exit a parse tree produced by SolidityParser#usingForObjectDirective. - def exitUsingForObjectDirective(self, ctx:SolidityParser.UsingForObjectDirectiveContext): + def exitUsingForObjectDirective( + self, ctx: SolidityParser.UsingForObjectDirectiveContext + ): pass - # Enter a parse tree produced by SolidityParser#userDefinableOperators. - def enterUserDefinableOperators(self, ctx:SolidityParser.UserDefinableOperatorsContext): + def enterUserDefinableOperators( + self, ctx: SolidityParser.UserDefinableOperatorsContext + ): pass # Exit a parse tree produced by SolidityParser#userDefinableOperators. - def exitUserDefinableOperators(self, ctx:SolidityParser.UserDefinableOperatorsContext): + def exitUserDefinableOperators( + self, ctx: SolidityParser.UserDefinableOperatorsContext + ): pass - # Enter a parse tree produced by SolidityParser#structDefinition. - def enterStructDefinition(self, ctx:SolidityParser.StructDefinitionContext): + def enterStructDefinition(self, ctx: SolidityParser.StructDefinitionContext): pass # Exit a parse tree produced by SolidityParser#structDefinition. - def exitStructDefinition(self, ctx:SolidityParser.StructDefinitionContext): + def exitStructDefinition(self, ctx: SolidityParser.StructDefinitionContext): pass - # Enter a parse tree produced by SolidityParser#modifierDefinition. - def enterModifierDefinition(self, ctx:SolidityParser.ModifierDefinitionContext): + def enterModifierDefinition(self, ctx: SolidityParser.ModifierDefinitionContext): pass # Exit a parse tree produced by SolidityParser#modifierDefinition. - def exitModifierDefinition(self, ctx:SolidityParser.ModifierDefinitionContext): + def exitModifierDefinition(self, ctx: SolidityParser.ModifierDefinitionContext): pass - # Enter a parse tree produced by SolidityParser#modifierInvocation. - def enterModifierInvocation(self, ctx:SolidityParser.ModifierInvocationContext): + def enterModifierInvocation(self, ctx: SolidityParser.ModifierInvocationContext): pass # Exit a parse tree produced by SolidityParser#modifierInvocation. - def exitModifierInvocation(self, ctx:SolidityParser.ModifierInvocationContext): + def exitModifierInvocation(self, ctx: SolidityParser.ModifierInvocationContext): pass - # Enter a parse tree produced by SolidityParser#functionDefinition. - def enterFunctionDefinition(self, ctx:SolidityParser.FunctionDefinitionContext): + def enterFunctionDefinition(self, ctx: SolidityParser.FunctionDefinitionContext): pass # Exit a parse tree produced by SolidityParser#functionDefinition. - def exitFunctionDefinition(self, ctx:SolidityParser.FunctionDefinitionContext): + def exitFunctionDefinition(self, ctx: SolidityParser.FunctionDefinitionContext): pass - # Enter a parse tree produced by SolidityParser#functionDescriptor. - def enterFunctionDescriptor(self, ctx:SolidityParser.FunctionDescriptorContext): + def enterFunctionDescriptor(self, ctx: SolidityParser.FunctionDescriptorContext): pass # Exit a parse tree produced by SolidityParser#functionDescriptor. - def exitFunctionDescriptor(self, ctx:SolidityParser.FunctionDescriptorContext): + def exitFunctionDescriptor(self, ctx: SolidityParser.FunctionDescriptorContext): pass - # Enter a parse tree produced by SolidityParser#returnParameters. - def enterReturnParameters(self, ctx:SolidityParser.ReturnParametersContext): + def enterReturnParameters(self, ctx: SolidityParser.ReturnParametersContext): pass # Exit a parse tree produced by SolidityParser#returnParameters. - def exitReturnParameters(self, ctx:SolidityParser.ReturnParametersContext): + def exitReturnParameters(self, ctx: SolidityParser.ReturnParametersContext): pass - # Enter a parse tree produced by SolidityParser#modifierList. - def enterModifierList(self, ctx:SolidityParser.ModifierListContext): + def enterModifierList(self, ctx: SolidityParser.ModifierListContext): pass # Exit a parse tree produced by SolidityParser#modifierList. - def exitModifierList(self, ctx:SolidityParser.ModifierListContext): + def exitModifierList(self, ctx: SolidityParser.ModifierListContext): pass - # Enter a parse tree produced by SolidityParser#eventDefinition. - def enterEventDefinition(self, ctx:SolidityParser.EventDefinitionContext): + def enterEventDefinition(self, ctx: SolidityParser.EventDefinitionContext): pass # Exit a parse tree produced by SolidityParser#eventDefinition. - def exitEventDefinition(self, ctx:SolidityParser.EventDefinitionContext): + def exitEventDefinition(self, ctx: SolidityParser.EventDefinitionContext): pass - # Enter a parse tree produced by SolidityParser#enumValue. - def enterEnumValue(self, ctx:SolidityParser.EnumValueContext): + def enterEnumValue(self, ctx: SolidityParser.EnumValueContext): pass # Exit a parse tree produced by SolidityParser#enumValue. - def exitEnumValue(self, ctx:SolidityParser.EnumValueContext): + def exitEnumValue(self, ctx: SolidityParser.EnumValueContext): pass - # Enter a parse tree produced by SolidityParser#enumDefinition. - def enterEnumDefinition(self, ctx:SolidityParser.EnumDefinitionContext): + def enterEnumDefinition(self, ctx: SolidityParser.EnumDefinitionContext): pass # Exit a parse tree produced by SolidityParser#enumDefinition. - def exitEnumDefinition(self, ctx:SolidityParser.EnumDefinitionContext): + def exitEnumDefinition(self, ctx: SolidityParser.EnumDefinitionContext): pass - # Enter a parse tree produced by SolidityParser#parameterList. - def enterParameterList(self, ctx:SolidityParser.ParameterListContext): + def enterParameterList(self, ctx: SolidityParser.ParameterListContext): pass # Exit a parse tree produced by SolidityParser#parameterList. - def exitParameterList(self, ctx:SolidityParser.ParameterListContext): + def exitParameterList(self, ctx: SolidityParser.ParameterListContext): pass - # Enter a parse tree produced by SolidityParser#parameter. - def enterParameter(self, ctx:SolidityParser.ParameterContext): + def enterParameter(self, ctx: SolidityParser.ParameterContext): pass # Exit a parse tree produced by SolidityParser#parameter. - def exitParameter(self, ctx:SolidityParser.ParameterContext): + def exitParameter(self, ctx: SolidityParser.ParameterContext): pass - # Enter a parse tree produced by SolidityParser#eventParameterList. - def enterEventParameterList(self, ctx:SolidityParser.EventParameterListContext): + def enterEventParameterList(self, ctx: SolidityParser.EventParameterListContext): pass # Exit a parse tree produced by SolidityParser#eventParameterList. - def exitEventParameterList(self, ctx:SolidityParser.EventParameterListContext): + def exitEventParameterList(self, ctx: SolidityParser.EventParameterListContext): pass - # Enter a parse tree produced by SolidityParser#eventParameter. - def enterEventParameter(self, ctx:SolidityParser.EventParameterContext): + def enterEventParameter(self, ctx: SolidityParser.EventParameterContext): pass # Exit a parse tree produced by SolidityParser#eventParameter. - def exitEventParameter(self, ctx:SolidityParser.EventParameterContext): + def exitEventParameter(self, ctx: SolidityParser.EventParameterContext): pass - # Enter a parse tree produced by SolidityParser#functionTypeParameterList. - def enterFunctionTypeParameterList(self, ctx:SolidityParser.FunctionTypeParameterListContext): + def enterFunctionTypeParameterList( + self, ctx: SolidityParser.FunctionTypeParameterListContext + ): pass # Exit a parse tree produced by SolidityParser#functionTypeParameterList. - def exitFunctionTypeParameterList(self, ctx:SolidityParser.FunctionTypeParameterListContext): + def exitFunctionTypeParameterList( + self, ctx: SolidityParser.FunctionTypeParameterListContext + ): pass - # Enter a parse tree produced by SolidityParser#functionTypeParameter. - def enterFunctionTypeParameter(self, ctx:SolidityParser.FunctionTypeParameterContext): + def enterFunctionTypeParameter( + self, ctx: SolidityParser.FunctionTypeParameterContext + ): pass # Exit a parse tree produced by SolidityParser#functionTypeParameter. - def exitFunctionTypeParameter(self, ctx:SolidityParser.FunctionTypeParameterContext): + def exitFunctionTypeParameter( + self, ctx: SolidityParser.FunctionTypeParameterContext + ): pass - # Enter a parse tree produced by SolidityParser#variableDeclaration. - def enterVariableDeclaration(self, ctx:SolidityParser.VariableDeclarationContext): + def enterVariableDeclaration(self, ctx: SolidityParser.VariableDeclarationContext): pass # Exit a parse tree produced by SolidityParser#variableDeclaration. - def exitVariableDeclaration(self, ctx:SolidityParser.VariableDeclarationContext): + def exitVariableDeclaration(self, ctx: SolidityParser.VariableDeclarationContext): pass - # Enter a parse tree produced by SolidityParser#typeName. - def enterTypeName(self, ctx:SolidityParser.TypeNameContext): + def enterTypeName(self, ctx: SolidityParser.TypeNameContext): pass # Exit a parse tree produced by SolidityParser#typeName. - def exitTypeName(self, ctx:SolidityParser.TypeNameContext): + def exitTypeName(self, ctx: SolidityParser.TypeNameContext): pass - # Enter a parse tree produced by SolidityParser#userDefinedTypeName. - def enterUserDefinedTypeName(self, ctx:SolidityParser.UserDefinedTypeNameContext): + def enterUserDefinedTypeName(self, ctx: SolidityParser.UserDefinedTypeNameContext): pass # Exit a parse tree produced by SolidityParser#userDefinedTypeName. - def exitUserDefinedTypeName(self, ctx:SolidityParser.UserDefinedTypeNameContext): + def exitUserDefinedTypeName(self, ctx: SolidityParser.UserDefinedTypeNameContext): pass - # Enter a parse tree produced by SolidityParser#mappingKey. - def enterMappingKey(self, ctx:SolidityParser.MappingKeyContext): + def enterMappingKey(self, ctx: SolidityParser.MappingKeyContext): pass # Exit a parse tree produced by SolidityParser#mappingKey. - def exitMappingKey(self, ctx:SolidityParser.MappingKeyContext): + def exitMappingKey(self, ctx: SolidityParser.MappingKeyContext): pass - # Enter a parse tree produced by SolidityParser#mapping. - def enterMapping(self, ctx:SolidityParser.MappingContext): + def enterMapping(self, ctx: SolidityParser.MappingContext): pass # Exit a parse tree produced by SolidityParser#mapping. - def exitMapping(self, ctx:SolidityParser.MappingContext): + def exitMapping(self, ctx: SolidityParser.MappingContext): pass - # Enter a parse tree produced by SolidityParser#mappingKeyName. - def enterMappingKeyName(self, ctx:SolidityParser.MappingKeyNameContext): + def enterMappingKeyName(self, ctx: SolidityParser.MappingKeyNameContext): pass # Exit a parse tree produced by SolidityParser#mappingKeyName. - def exitMappingKeyName(self, ctx:SolidityParser.MappingKeyNameContext): + def exitMappingKeyName(self, ctx: SolidityParser.MappingKeyNameContext): pass - # Enter a parse tree produced by SolidityParser#mappingValueName. - def enterMappingValueName(self, ctx:SolidityParser.MappingValueNameContext): + def enterMappingValueName(self, ctx: SolidityParser.MappingValueNameContext): pass # Exit a parse tree produced by SolidityParser#mappingValueName. - def exitMappingValueName(self, ctx:SolidityParser.MappingValueNameContext): + def exitMappingValueName(self, ctx: SolidityParser.MappingValueNameContext): pass - # Enter a parse tree produced by SolidityParser#functionTypeName. - def enterFunctionTypeName(self, ctx:SolidityParser.FunctionTypeNameContext): + def enterFunctionTypeName(self, ctx: SolidityParser.FunctionTypeNameContext): pass # Exit a parse tree produced by SolidityParser#functionTypeName. - def exitFunctionTypeName(self, ctx:SolidityParser.FunctionTypeNameContext): + def exitFunctionTypeName(self, ctx: SolidityParser.FunctionTypeNameContext): pass - # Enter a parse tree produced by SolidityParser#storageLocation. - def enterStorageLocation(self, ctx:SolidityParser.StorageLocationContext): + def enterStorageLocation(self, ctx: SolidityParser.StorageLocationContext): pass # Exit a parse tree produced by SolidityParser#storageLocation. - def exitStorageLocation(self, ctx:SolidityParser.StorageLocationContext): + def exitStorageLocation(self, ctx: SolidityParser.StorageLocationContext): pass - # Enter a parse tree produced by SolidityParser#stateMutability. - def enterStateMutability(self, ctx:SolidityParser.StateMutabilityContext): + def enterStateMutability(self, ctx: SolidityParser.StateMutabilityContext): pass # Exit a parse tree produced by SolidityParser#stateMutability. - def exitStateMutability(self, ctx:SolidityParser.StateMutabilityContext): + def exitStateMutability(self, ctx: SolidityParser.StateMutabilityContext): pass - # Enter a parse tree produced by SolidityParser#block. - def enterBlock(self, ctx:SolidityParser.BlockContext): + def enterBlock(self, ctx: SolidityParser.BlockContext): pass # Exit a parse tree produced by SolidityParser#block. - def exitBlock(self, ctx:SolidityParser.BlockContext): + def exitBlock(self, ctx: SolidityParser.BlockContext): pass - # Enter a parse tree produced by SolidityParser#statement. - def enterStatement(self, ctx:SolidityParser.StatementContext): + def enterStatement(self, ctx: SolidityParser.StatementContext): pass # Exit a parse tree produced by SolidityParser#statement. - def exitStatement(self, ctx:SolidityParser.StatementContext): + def exitStatement(self, ctx: SolidityParser.StatementContext): pass - # Enter a parse tree produced by SolidityParser#expressionStatement. - def enterExpressionStatement(self, ctx:SolidityParser.ExpressionStatementContext): + def enterExpressionStatement(self, ctx: SolidityParser.ExpressionStatementContext): pass # Exit a parse tree produced by SolidityParser#expressionStatement. - def exitExpressionStatement(self, ctx:SolidityParser.ExpressionStatementContext): + def exitExpressionStatement(self, ctx: SolidityParser.ExpressionStatementContext): pass - # Enter a parse tree produced by SolidityParser#ifStatement. - def enterIfStatement(self, ctx:SolidityParser.IfStatementContext): + def enterIfStatement(self, ctx: SolidityParser.IfStatementContext): pass # Exit a parse tree produced by SolidityParser#ifStatement. - def exitIfStatement(self, ctx:SolidityParser.IfStatementContext): + def exitIfStatement(self, ctx: SolidityParser.IfStatementContext): pass - # Enter a parse tree produced by SolidityParser#tryStatement. - def enterTryStatement(self, ctx:SolidityParser.TryStatementContext): + def enterTryStatement(self, ctx: SolidityParser.TryStatementContext): pass # Exit a parse tree produced by SolidityParser#tryStatement. - def exitTryStatement(self, ctx:SolidityParser.TryStatementContext): + def exitTryStatement(self, ctx: SolidityParser.TryStatementContext): pass - # Enter a parse tree produced by SolidityParser#catchClause. - def enterCatchClause(self, ctx:SolidityParser.CatchClauseContext): + def enterCatchClause(self, ctx: SolidityParser.CatchClauseContext): pass # Exit a parse tree produced by SolidityParser#catchClause. - def exitCatchClause(self, ctx:SolidityParser.CatchClauseContext): + def exitCatchClause(self, ctx: SolidityParser.CatchClauseContext): pass - # Enter a parse tree produced by SolidityParser#whileStatement. - def enterWhileStatement(self, ctx:SolidityParser.WhileStatementContext): + def enterWhileStatement(self, ctx: SolidityParser.WhileStatementContext): pass # Exit a parse tree produced by SolidityParser#whileStatement. - def exitWhileStatement(self, ctx:SolidityParser.WhileStatementContext): + def exitWhileStatement(self, ctx: SolidityParser.WhileStatementContext): pass - # Enter a parse tree produced by SolidityParser#simpleStatement. - def enterSimpleStatement(self, ctx:SolidityParser.SimpleStatementContext): + def enterSimpleStatement(self, ctx: SolidityParser.SimpleStatementContext): pass # Exit a parse tree produced by SolidityParser#simpleStatement. - def exitSimpleStatement(self, ctx:SolidityParser.SimpleStatementContext): + def exitSimpleStatement(self, ctx: SolidityParser.SimpleStatementContext): pass - # Enter a parse tree produced by SolidityParser#uncheckedStatement. - def enterUncheckedStatement(self, ctx:SolidityParser.UncheckedStatementContext): + def enterUncheckedStatement(self, ctx: SolidityParser.UncheckedStatementContext): pass # Exit a parse tree produced by SolidityParser#uncheckedStatement. - def exitUncheckedStatement(self, ctx:SolidityParser.UncheckedStatementContext): + def exitUncheckedStatement(self, ctx: SolidityParser.UncheckedStatementContext): pass - # Enter a parse tree produced by SolidityParser#forStatement. - def enterForStatement(self, ctx:SolidityParser.ForStatementContext): + def enterForStatement(self, ctx: SolidityParser.ForStatementContext): pass # Exit a parse tree produced by SolidityParser#forStatement. - def exitForStatement(self, ctx:SolidityParser.ForStatementContext): + def exitForStatement(self, ctx: SolidityParser.ForStatementContext): pass - # Enter a parse tree produced by SolidityParser#inlineAssemblyStatement. - def enterInlineAssemblyStatement(self, ctx:SolidityParser.InlineAssemblyStatementContext): + def enterInlineAssemblyStatement( + self, ctx: SolidityParser.InlineAssemblyStatementContext + ): pass # Exit a parse tree produced by SolidityParser#inlineAssemblyStatement. - def exitInlineAssemblyStatement(self, ctx:SolidityParser.InlineAssemblyStatementContext): + def exitInlineAssemblyStatement( + self, ctx: SolidityParser.InlineAssemblyStatementContext + ): pass - # Enter a parse tree produced by SolidityParser#inlineAssemblyStatementFlag. - def enterInlineAssemblyStatementFlag(self, ctx:SolidityParser.InlineAssemblyStatementFlagContext): + def enterInlineAssemblyStatementFlag( + self, ctx: SolidityParser.InlineAssemblyStatementFlagContext + ): pass # Exit a parse tree produced by SolidityParser#inlineAssemblyStatementFlag. - def exitInlineAssemblyStatementFlag(self, ctx:SolidityParser.InlineAssemblyStatementFlagContext): + def exitInlineAssemblyStatementFlag( + self, ctx: SolidityParser.InlineAssemblyStatementFlagContext + ): pass - # Enter a parse tree produced by SolidityParser#doWhileStatement. - def enterDoWhileStatement(self, ctx:SolidityParser.DoWhileStatementContext): + def enterDoWhileStatement(self, ctx: SolidityParser.DoWhileStatementContext): pass # Exit a parse tree produced by SolidityParser#doWhileStatement. - def exitDoWhileStatement(self, ctx:SolidityParser.DoWhileStatementContext): + def exitDoWhileStatement(self, ctx: SolidityParser.DoWhileStatementContext): pass - # Enter a parse tree produced by SolidityParser#continueStatement. - def enterContinueStatement(self, ctx:SolidityParser.ContinueStatementContext): + def enterContinueStatement(self, ctx: SolidityParser.ContinueStatementContext): pass # Exit a parse tree produced by SolidityParser#continueStatement. - def exitContinueStatement(self, ctx:SolidityParser.ContinueStatementContext): + def exitContinueStatement(self, ctx: SolidityParser.ContinueStatementContext): pass - # Enter a parse tree produced by SolidityParser#breakStatement. - def enterBreakStatement(self, ctx:SolidityParser.BreakStatementContext): + def enterBreakStatement(self, ctx: SolidityParser.BreakStatementContext): pass # Exit a parse tree produced by SolidityParser#breakStatement. - def exitBreakStatement(self, ctx:SolidityParser.BreakStatementContext): + def exitBreakStatement(self, ctx: SolidityParser.BreakStatementContext): pass - # Enter a parse tree produced by SolidityParser#returnStatement. - def enterReturnStatement(self, ctx:SolidityParser.ReturnStatementContext): + def enterReturnStatement(self, ctx: SolidityParser.ReturnStatementContext): pass # Exit a parse tree produced by SolidityParser#returnStatement. - def exitReturnStatement(self, ctx:SolidityParser.ReturnStatementContext): + def exitReturnStatement(self, ctx: SolidityParser.ReturnStatementContext): pass - # Enter a parse tree produced by SolidityParser#throwStatement. - def enterThrowStatement(self, ctx:SolidityParser.ThrowStatementContext): + def enterThrowStatement(self, ctx: SolidityParser.ThrowStatementContext): pass # Exit a parse tree produced by SolidityParser#throwStatement. - def exitThrowStatement(self, ctx:SolidityParser.ThrowStatementContext): + def exitThrowStatement(self, ctx: SolidityParser.ThrowStatementContext): pass - # Enter a parse tree produced by SolidityParser#emitStatement. - def enterEmitStatement(self, ctx:SolidityParser.EmitStatementContext): + def enterEmitStatement(self, ctx: SolidityParser.EmitStatementContext): pass # Exit a parse tree produced by SolidityParser#emitStatement. - def exitEmitStatement(self, ctx:SolidityParser.EmitStatementContext): + def exitEmitStatement(self, ctx: SolidityParser.EmitStatementContext): pass - # Enter a parse tree produced by SolidityParser#revertStatement. - def enterRevertStatement(self, ctx:SolidityParser.RevertStatementContext): + def enterRevertStatement(self, ctx: SolidityParser.RevertStatementContext): pass # Exit a parse tree produced by SolidityParser#revertStatement. - def exitRevertStatement(self, ctx:SolidityParser.RevertStatementContext): + def exitRevertStatement(self, ctx: SolidityParser.RevertStatementContext): pass - # Enter a parse tree produced by SolidityParser#variableDeclarationStatement. - def enterVariableDeclarationStatement(self, ctx:SolidityParser.VariableDeclarationStatementContext): + def enterVariableDeclarationStatement( + self, ctx: SolidityParser.VariableDeclarationStatementContext + ): pass # Exit a parse tree produced by SolidityParser#variableDeclarationStatement. - def exitVariableDeclarationStatement(self, ctx:SolidityParser.VariableDeclarationStatementContext): + def exitVariableDeclarationStatement( + self, ctx: SolidityParser.VariableDeclarationStatementContext + ): pass - # Enter a parse tree produced by SolidityParser#variableDeclarationList. - def enterVariableDeclarationList(self, ctx:SolidityParser.VariableDeclarationListContext): + def enterVariableDeclarationList( + self, ctx: SolidityParser.VariableDeclarationListContext + ): pass # Exit a parse tree produced by SolidityParser#variableDeclarationList. - def exitVariableDeclarationList(self, ctx:SolidityParser.VariableDeclarationListContext): + def exitVariableDeclarationList( + self, ctx: SolidityParser.VariableDeclarationListContext + ): pass - # Enter a parse tree produced by SolidityParser#identifierList. - def enterIdentifierList(self, ctx:SolidityParser.IdentifierListContext): + def enterIdentifierList(self, ctx: SolidityParser.IdentifierListContext): pass # Exit a parse tree produced by SolidityParser#identifierList. - def exitIdentifierList(self, ctx:SolidityParser.IdentifierListContext): + def exitIdentifierList(self, ctx: SolidityParser.IdentifierListContext): pass - # Enter a parse tree produced by SolidityParser#elementaryTypeName. - def enterElementaryTypeName(self, ctx:SolidityParser.ElementaryTypeNameContext): + def enterElementaryTypeName(self, ctx: SolidityParser.ElementaryTypeNameContext): pass # Exit a parse tree produced by SolidityParser#elementaryTypeName. - def exitElementaryTypeName(self, ctx:SolidityParser.ElementaryTypeNameContext): + def exitElementaryTypeName(self, ctx: SolidityParser.ElementaryTypeNameContext): pass - # Enter a parse tree produced by SolidityParser#expression. - def enterExpression(self, ctx:SolidityParser.ExpressionContext): + def enterExpression(self, ctx: SolidityParser.ExpressionContext): pass # Exit a parse tree produced by SolidityParser#expression. - def exitExpression(self, ctx:SolidityParser.ExpressionContext): + def exitExpression(self, ctx: SolidityParser.ExpressionContext): pass - # Enter a parse tree produced by SolidityParser#primaryExpression. - def enterPrimaryExpression(self, ctx:SolidityParser.PrimaryExpressionContext): + def enterPrimaryExpression(self, ctx: SolidityParser.PrimaryExpressionContext): pass # Exit a parse tree produced by SolidityParser#primaryExpression. - def exitPrimaryExpression(self, ctx:SolidityParser.PrimaryExpressionContext): + def exitPrimaryExpression(self, ctx: SolidityParser.PrimaryExpressionContext): pass - # Enter a parse tree produced by SolidityParser#expressionList. - def enterExpressionList(self, ctx:SolidityParser.ExpressionListContext): + def enterExpressionList(self, ctx: SolidityParser.ExpressionListContext): pass # Exit a parse tree produced by SolidityParser#expressionList. - def exitExpressionList(self, ctx:SolidityParser.ExpressionListContext): + def exitExpressionList(self, ctx: SolidityParser.ExpressionListContext): pass - # Enter a parse tree produced by SolidityParser#nameValueList. - def enterNameValueList(self, ctx:SolidityParser.NameValueListContext): + def enterNameValueList(self, ctx: SolidityParser.NameValueListContext): pass # Exit a parse tree produced by SolidityParser#nameValueList. - def exitNameValueList(self, ctx:SolidityParser.NameValueListContext): + def exitNameValueList(self, ctx: SolidityParser.NameValueListContext): pass - # Enter a parse tree produced by SolidityParser#nameValue. - def enterNameValue(self, ctx:SolidityParser.NameValueContext): + def enterNameValue(self, ctx: SolidityParser.NameValueContext): pass # Exit a parse tree produced by SolidityParser#nameValue. - def exitNameValue(self, ctx:SolidityParser.NameValueContext): + def exitNameValue(self, ctx: SolidityParser.NameValueContext): pass - # Enter a parse tree produced by SolidityParser#functionCallArguments. - def enterFunctionCallArguments(self, ctx:SolidityParser.FunctionCallArgumentsContext): + def enterFunctionCallArguments( + self, ctx: SolidityParser.FunctionCallArgumentsContext + ): pass # Exit a parse tree produced by SolidityParser#functionCallArguments. - def exitFunctionCallArguments(self, ctx:SolidityParser.FunctionCallArgumentsContext): + def exitFunctionCallArguments( + self, ctx: SolidityParser.FunctionCallArgumentsContext + ): pass - # Enter a parse tree produced by SolidityParser#functionCall. - def enterFunctionCall(self, ctx:SolidityParser.FunctionCallContext): + def enterFunctionCall(self, ctx: SolidityParser.FunctionCallContext): pass # Exit a parse tree produced by SolidityParser#functionCall. - def exitFunctionCall(self, ctx:SolidityParser.FunctionCallContext): + def exitFunctionCall(self, ctx: SolidityParser.FunctionCallContext): pass - # Enter a parse tree produced by SolidityParser#assemblyBlock. - def enterAssemblyBlock(self, ctx:SolidityParser.AssemblyBlockContext): + def enterAssemblyBlock(self, ctx: SolidityParser.AssemblyBlockContext): pass # Exit a parse tree produced by SolidityParser#assemblyBlock. - def exitAssemblyBlock(self, ctx:SolidityParser.AssemblyBlockContext): + def exitAssemblyBlock(self, ctx: SolidityParser.AssemblyBlockContext): pass - # Enter a parse tree produced by SolidityParser#assemblyItem. - def enterAssemblyItem(self, ctx:SolidityParser.AssemblyItemContext): + def enterAssemblyItem(self, ctx: SolidityParser.AssemblyItemContext): pass # Exit a parse tree produced by SolidityParser#assemblyItem. - def exitAssemblyItem(self, ctx:SolidityParser.AssemblyItemContext): + def exitAssemblyItem(self, ctx: SolidityParser.AssemblyItemContext): pass - # Enter a parse tree produced by SolidityParser#assemblyExpression. - def enterAssemblyExpression(self, ctx:SolidityParser.AssemblyExpressionContext): + def enterAssemblyExpression(self, ctx: SolidityParser.AssemblyExpressionContext): pass # Exit a parse tree produced by SolidityParser#assemblyExpression. - def exitAssemblyExpression(self, ctx:SolidityParser.AssemblyExpressionContext): + def exitAssemblyExpression(self, ctx: SolidityParser.AssemblyExpressionContext): pass - # Enter a parse tree produced by SolidityParser#assemblyMember. - def enterAssemblyMember(self, ctx:SolidityParser.AssemblyMemberContext): + def enterAssemblyMember(self, ctx: SolidityParser.AssemblyMemberContext): pass # Exit a parse tree produced by SolidityParser#assemblyMember. - def exitAssemblyMember(self, ctx:SolidityParser.AssemblyMemberContext): + def exitAssemblyMember(self, ctx: SolidityParser.AssemblyMemberContext): pass - # Enter a parse tree produced by SolidityParser#assemblyCall. - def enterAssemblyCall(self, ctx:SolidityParser.AssemblyCallContext): + def enterAssemblyCall(self, ctx: SolidityParser.AssemblyCallContext): pass # Exit a parse tree produced by SolidityParser#assemblyCall. - def exitAssemblyCall(self, ctx:SolidityParser.AssemblyCallContext): + def exitAssemblyCall(self, ctx: SolidityParser.AssemblyCallContext): pass - # Enter a parse tree produced by SolidityParser#assemblyLocalDefinition. - def enterAssemblyLocalDefinition(self, ctx:SolidityParser.AssemblyLocalDefinitionContext): + def enterAssemblyLocalDefinition( + self, ctx: SolidityParser.AssemblyLocalDefinitionContext + ): pass # Exit a parse tree produced by SolidityParser#assemblyLocalDefinition. - def exitAssemblyLocalDefinition(self, ctx:SolidityParser.AssemblyLocalDefinitionContext): + def exitAssemblyLocalDefinition( + self, ctx: SolidityParser.AssemblyLocalDefinitionContext + ): pass - # Enter a parse tree produced by SolidityParser#assemblyAssignment. - def enterAssemblyAssignment(self, ctx:SolidityParser.AssemblyAssignmentContext): + def enterAssemblyAssignment(self, ctx: SolidityParser.AssemblyAssignmentContext): pass # Exit a parse tree produced by SolidityParser#assemblyAssignment. - def exitAssemblyAssignment(self, ctx:SolidityParser.AssemblyAssignmentContext): + def exitAssemblyAssignment(self, ctx: SolidityParser.AssemblyAssignmentContext): pass - # Enter a parse tree produced by SolidityParser#assemblyIdentifierOrList. - def enterAssemblyIdentifierOrList(self, ctx:SolidityParser.AssemblyIdentifierOrListContext): + def enterAssemblyIdentifierOrList( + self, ctx: SolidityParser.AssemblyIdentifierOrListContext + ): pass # Exit a parse tree produced by SolidityParser#assemblyIdentifierOrList. - def exitAssemblyIdentifierOrList(self, ctx:SolidityParser.AssemblyIdentifierOrListContext): + def exitAssemblyIdentifierOrList( + self, ctx: SolidityParser.AssemblyIdentifierOrListContext + ): pass - # Enter a parse tree produced by SolidityParser#assemblyIdentifierList. - def enterAssemblyIdentifierList(self, ctx:SolidityParser.AssemblyIdentifierListContext): + def enterAssemblyIdentifierList( + self, ctx: SolidityParser.AssemblyIdentifierListContext + ): pass # Exit a parse tree produced by SolidityParser#assemblyIdentifierList. - def exitAssemblyIdentifierList(self, ctx:SolidityParser.AssemblyIdentifierListContext): + def exitAssemblyIdentifierList( + self, ctx: SolidityParser.AssemblyIdentifierListContext + ): pass - # Enter a parse tree produced by SolidityParser#assemblyStackAssignment. - def enterAssemblyStackAssignment(self, ctx:SolidityParser.AssemblyStackAssignmentContext): + def enterAssemblyStackAssignment( + self, ctx: SolidityParser.AssemblyStackAssignmentContext + ): pass # Exit a parse tree produced by SolidityParser#assemblyStackAssignment. - def exitAssemblyStackAssignment(self, ctx:SolidityParser.AssemblyStackAssignmentContext): + def exitAssemblyStackAssignment( + self, ctx: SolidityParser.AssemblyStackAssignmentContext + ): pass - # Enter a parse tree produced by SolidityParser#labelDefinition. - def enterLabelDefinition(self, ctx:SolidityParser.LabelDefinitionContext): + def enterLabelDefinition(self, ctx: SolidityParser.LabelDefinitionContext): pass # Exit a parse tree produced by SolidityParser#labelDefinition. - def exitLabelDefinition(self, ctx:SolidityParser.LabelDefinitionContext): + def exitLabelDefinition(self, ctx: SolidityParser.LabelDefinitionContext): pass - # Enter a parse tree produced by SolidityParser#assemblySwitch. - def enterAssemblySwitch(self, ctx:SolidityParser.AssemblySwitchContext): + def enterAssemblySwitch(self, ctx: SolidityParser.AssemblySwitchContext): pass # Exit a parse tree produced by SolidityParser#assemblySwitch. - def exitAssemblySwitch(self, ctx:SolidityParser.AssemblySwitchContext): + def exitAssemblySwitch(self, ctx: SolidityParser.AssemblySwitchContext): pass - # Enter a parse tree produced by SolidityParser#assemblyCase. - def enterAssemblyCase(self, ctx:SolidityParser.AssemblyCaseContext): + def enterAssemblyCase(self, ctx: SolidityParser.AssemblyCaseContext): pass # Exit a parse tree produced by SolidityParser#assemblyCase. - def exitAssemblyCase(self, ctx:SolidityParser.AssemblyCaseContext): + def exitAssemblyCase(self, ctx: SolidityParser.AssemblyCaseContext): pass - # Enter a parse tree produced by SolidityParser#assemblyFunctionDefinition. - def enterAssemblyFunctionDefinition(self, ctx:SolidityParser.AssemblyFunctionDefinitionContext): + def enterAssemblyFunctionDefinition( + self, ctx: SolidityParser.AssemblyFunctionDefinitionContext + ): pass # Exit a parse tree produced by SolidityParser#assemblyFunctionDefinition. - def exitAssemblyFunctionDefinition(self, ctx:SolidityParser.AssemblyFunctionDefinitionContext): + def exitAssemblyFunctionDefinition( + self, ctx: SolidityParser.AssemblyFunctionDefinitionContext + ): pass - # Enter a parse tree produced by SolidityParser#assemblyFunctionReturns. - def enterAssemblyFunctionReturns(self, ctx:SolidityParser.AssemblyFunctionReturnsContext): + def enterAssemblyFunctionReturns( + self, ctx: SolidityParser.AssemblyFunctionReturnsContext + ): pass # Exit a parse tree produced by SolidityParser#assemblyFunctionReturns. - def exitAssemblyFunctionReturns(self, ctx:SolidityParser.AssemblyFunctionReturnsContext): + def exitAssemblyFunctionReturns( + self, ctx: SolidityParser.AssemblyFunctionReturnsContext + ): pass - # Enter a parse tree produced by SolidityParser#assemblyFor. - def enterAssemblyFor(self, ctx:SolidityParser.AssemblyForContext): + def enterAssemblyFor(self, ctx: SolidityParser.AssemblyForContext): pass # Exit a parse tree produced by SolidityParser#assemblyFor. - def exitAssemblyFor(self, ctx:SolidityParser.AssemblyForContext): + def exitAssemblyFor(self, ctx: SolidityParser.AssemblyForContext): pass - # Enter a parse tree produced by SolidityParser#assemblyIf. - def enterAssemblyIf(self, ctx:SolidityParser.AssemblyIfContext): + def enterAssemblyIf(self, ctx: SolidityParser.AssemblyIfContext): pass # Exit a parse tree produced by SolidityParser#assemblyIf. - def exitAssemblyIf(self, ctx:SolidityParser.AssemblyIfContext): + def exitAssemblyIf(self, ctx: SolidityParser.AssemblyIfContext): pass - # Enter a parse tree produced by SolidityParser#assemblyLiteral. - def enterAssemblyLiteral(self, ctx:SolidityParser.AssemblyLiteralContext): + def enterAssemblyLiteral(self, ctx: SolidityParser.AssemblyLiteralContext): pass # Exit a parse tree produced by SolidityParser#assemblyLiteral. - def exitAssemblyLiteral(self, ctx:SolidityParser.AssemblyLiteralContext): + def exitAssemblyLiteral(self, ctx: SolidityParser.AssemblyLiteralContext): pass - # Enter a parse tree produced by SolidityParser#tupleExpression. - def enterTupleExpression(self, ctx:SolidityParser.TupleExpressionContext): + def enterTupleExpression(self, ctx: SolidityParser.TupleExpressionContext): pass # Exit a parse tree produced by SolidityParser#tupleExpression. - def exitTupleExpression(self, ctx:SolidityParser.TupleExpressionContext): + def exitTupleExpression(self, ctx: SolidityParser.TupleExpressionContext): pass - # Enter a parse tree produced by SolidityParser#numberLiteral. - def enterNumberLiteral(self, ctx:SolidityParser.NumberLiteralContext): + def enterNumberLiteral(self, ctx: SolidityParser.NumberLiteralContext): pass # Exit a parse tree produced by SolidityParser#numberLiteral. - def exitNumberLiteral(self, ctx:SolidityParser.NumberLiteralContext): + def exitNumberLiteral(self, ctx: SolidityParser.NumberLiteralContext): pass - # Enter a parse tree produced by SolidityParser#identifier. - def enterIdentifier(self, ctx:SolidityParser.IdentifierContext): + def enterIdentifier(self, ctx: SolidityParser.IdentifierContext): pass # Exit a parse tree produced by SolidityParser#identifier. - def exitIdentifier(self, ctx:SolidityParser.IdentifierContext): + def exitIdentifier(self, ctx: SolidityParser.IdentifierContext): pass - # Enter a parse tree produced by SolidityParser#hexLiteral. - def enterHexLiteral(self, ctx:SolidityParser.HexLiteralContext): + def enterHexLiteral(self, ctx: SolidityParser.HexLiteralContext): pass # Exit a parse tree produced by SolidityParser#hexLiteral. - def exitHexLiteral(self, ctx:SolidityParser.HexLiteralContext): + def exitHexLiteral(self, ctx: SolidityParser.HexLiteralContext): pass - # Enter a parse tree produced by SolidityParser#overrideSpecifier. - def enterOverrideSpecifier(self, ctx:SolidityParser.OverrideSpecifierContext): + def enterOverrideSpecifier(self, ctx: SolidityParser.OverrideSpecifierContext): pass # Exit a parse tree produced by SolidityParser#overrideSpecifier. - def exitOverrideSpecifier(self, ctx:SolidityParser.OverrideSpecifierContext): + def exitOverrideSpecifier(self, ctx: SolidityParser.OverrideSpecifierContext): pass - # Enter a parse tree produced by SolidityParser#stringLiteral. - def enterStringLiteral(self, ctx:SolidityParser.StringLiteralContext): + def enterStringLiteral(self, ctx: SolidityParser.StringLiteralContext): pass # Exit a parse tree produced by SolidityParser#stringLiteral. - def exitStringLiteral(self, ctx:SolidityParser.StringLiteralContext): + def exitStringLiteral(self, ctx: SolidityParser.StringLiteralContext): pass - - diff --git a/solidity_parser/solidity_antlr4/SolidityParser.py b/solidity_parser/solidity_antlr4/SolidityParser.py index 86f2246..387aa3c 100644 --- a/solidity_parser/solidity_antlr4/SolidityParser.py +++ b/solidity_parser/solidity_antlr4/SolidityParser.py @@ -14,8 +14,8 @@ def serializedATN(): 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('\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") @@ -55,12 +55,12 @@ def serializedATN(): buf.write("\35\16\35\u01e9\13\35\3\36\3\36\3\36\3\36\5\36\u01ef\n") buf.write("\36\3\36\3\36\3\37\3\37\3 \3 \3 \3 \5 \u01f9\n \3 \3 ") buf.write("\7 \u01fd\n \f \16 \u0200\13 \3 \3 \3!\3!\3!\3!\7!\u0208") - buf.write("\n!\f!\16!\u020b\13!\5!\u020d\n!\3!\3!\3\"\3\"\5\"\u0213") - buf.write("\n\"\3\"\5\"\u0216\n\"\3#\3#\3#\3#\7#\u021c\n#\f#\16#") + buf.write('\n!\f!\16!\u020b\13!\5!\u020d\n!\3!\3!\3"\3"\5"\u0213') + buf.write('\n"\3"\5"\u0216\n"\3#\3#\3#\3#\7#\u021c\n#\f#\16#') buf.write("\u021f\13#\5#\u0221\n#\3#\3#\3$\3$\5$\u0227\n$\3$\5$\u022a") buf.write("\n$\3%\3%\3%\3%\7%\u0230\n%\f%\16%\u0233\13%\5%\u0235") - buf.write("\n%\3%\3%\3&\3&\5&\u023b\n&\3\'\3\'\5\'\u023f\n\'\3\'") - buf.write("\3\'\3(\3(\3(\3(\3(\3(\3(\5(\u024a\n(\3(\3(\3(\5(\u024f") + buf.write("\n%\3%\3%\3&\3&\5&\u023b\n&\3'\3'\5'\u023f\n'\3'") + buf.write("\3'\3(\3(\3(\3(\3(\3(\3(\5(\u024a\n(\3(\3(\3(\5(\u024f") buf.write("\n(\3(\7(\u0252\n(\f(\16(\u0255\13(\3)\3)\3)\7)\u025a") buf.write("\n)\f)\16)\u025d\13)\3*\3*\5*\u0261\n*\3+\3+\3+\3+\5+") buf.write("\u0267\n+\3+\3+\3+\5+\u026c\n+\3+\3+\3,\3,\3-\3-\3.\3") @@ -106,21 +106,21 @@ def serializedATN(): buf.write("\na\3a\5a\u0473\na\3b\3b\5b\u0477\nb\3c\3c\3d\6d\u047c") buf.write("\nd\rd\16d\u047d\3e\3e\3e\3e\3e\7e\u0485\ne\fe\16e\u0488") buf.write("\13e\3e\3e\5e\u048c\ne\3f\6f\u048f\nf\rf\16f\u0490\3f") - buf.write("\2\4N\u008eg\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"") + buf.write('\2\4N\u008eg\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 "') buf.write("$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz") buf.write("|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090") buf.write("\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2") buf.write("\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4") buf.write("\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6") buf.write("\u00c8\u00ca\2\21\3\2\7\r\3\2\25\27\5\2\5\5\7\f\36%\3") - buf.write("\2\62\64\6\2ppww{{}}\5\2..ADcg\3\2EF\3\2 !\4\2\5\5\"#") + buf.write('\2\62\64\6\2ppww{{}}\5\2..ADcg\3\2EF\3\2 !\4\2\5\5"#') buf.write("\3\2LM\3\2\t\f\3\2$%\4\2\r\rPY\3\2ij\f\2\20\20\33\33.") buf.write(".\64\64@@aassww~\177\u0081\u0082\2\u0513\2\u00d8\3\2\2") buf.write("\2\4\u00dd\3\2\2\2\6\u00e2\3\2\2\2\b\u00e7\3\2\2\2\n\u00e9") buf.write("\3\2\2\2\f\u00f3\3\2\2\2\16\u00fd\3\2\2\2\20\u00ff\3\2") buf.write("\2\2\22\u0128\3\2\2\2\24\u012a\3\2\2\2\26\u012d\3\2\2") buf.write("\2\30\u0145\3\2\2\2\32\u0156\3\2\2\2\34\u0158\3\2\2\2") - buf.write("\36\u016b\3\2\2\2 \u0172\3\2\2\2\"\u0177\3\2\2\2$\u017d") + buf.write('\36\u016b\3\2\2\2 \u0172\3\2\2\2"\u0177\3\2\2\2$\u017d') buf.write("\3\2\2\2&\u0195\3\2\2\2(\u0197\3\2\2\2*\u019c\3\2\2\2") buf.write(",\u019e\3\2\2\2.\u01af\3\2\2\2\60\u01bf\3\2\2\2\62\u01c7") buf.write("\3\2\2\2\64\u01d8\3\2\2\2\66\u01da\3\2\2\28\u01e7\3\2") @@ -150,7 +150,7 @@ def serializedATN(): buf.write("\3\2\2\2\u00ca\u048e\3\2\2\2\u00cc\u00d7\5\4\3\2\u00cd") buf.write("\u00d7\5\22\n\2\u00ce\u00d7\5\26\f\2\u00cf\u00d7\5> \2") buf.write("\u00d0\u00d7\5,\27\2\u00d1\u00d7\5\62\32\2\u00d2\u00d7") - buf.write("\5\36\20\2\u00d3\u00d7\5 \21\2\u00d4\u00d7\5\"\22\2\u00d5") + buf.write('\5\36\20\2\u00d3\u00d7\5 \21\2\u00d4\u00d7\5"\22\2\u00d5') buf.write("\u00d7\5$\23\2\u00d6\u00cc\3\2\2\2\u00d6\u00cd\3\2\2\2") buf.write("\u00d6\u00ce\3\2\2\2\u00d6\u00cf\3\2\2\2\u00d6\u00d0\3") buf.write("\2\2\2\u00d6\u00d1\3\2\2\2\u00d6\u00d2\3\2\2\2\u00d6\u00d3") @@ -209,7 +209,7 @@ def serializedATN(): buf.write("\2\2\2\u014d\u0157\5\34\17\2\u014e\u0157\5$\23\2\u014f") buf.write("\u0157\5,\27\2\u0150\u0157\5.\30\2\u0151\u0157\5\62\32") buf.write("\2\u0152\u0157\5:\36\2\u0153\u0157\5> \2\u0154\u0157\5") - buf.write(" \21\2\u0155\u0157\5\"\22\2\u0156\u014d\3\2\2\2\u0156") + buf.write(' \21\2\u0155\u0157\5"\22\2\u0156\u014d\3\2\2\2\u0156') buf.write("\u014e\3\2\2\2\u0156\u014f\3\2\2\2\u0156\u0150\3\2\2\2") buf.write("\u0156\u0151\3\2\2\2\u0156\u0152\3\2\2\2\u0156\u0153\3") buf.write("\2\2\2\u0156\u0154\3\2\2\2\u0156\u0155\3\2\2\2\u0157\33") @@ -239,17 +239,17 @@ def serializedATN(): buf.write("\3\2\2\2\u018f\u0192\3\2\2\2\u0190\u018e\3\2\2\2\u0190") buf.write("\u0191\3\2\2\2\u0191\u0193\3\2\2\2\u0192\u0190\3\2\2\2") buf.write("\u0193\u0194\7\23\2\2\u0194\u0196\3\2\2\2\u0195\u0189") - buf.write("\3\2\2\2\u0195\u018a\3\2\2\2\u0196\'\3\2\2\2\u0197\u019a") + buf.write("\3\2\2\2\u0195\u018a\3\2\2\2\u0196'\3\2\2\2\u0197\u019a") buf.write("\5P)\2\u0198\u0199\7\16\2\2\u0199\u019b\5*\26\2\u019a") buf.write("\u0198\3\2\2\2\u019a\u019b\3\2\2\2\u019b)\3\2\2\2\u019c") buf.write("\u019d\t\4\2\2\u019d+\3\2\2\2\u019e\u019f\7&\2\2\u019f") buf.write("\u01a0\5\u00c4c\2\u01a0\u01ab\7\21\2\2\u01a1\u01a2\5L") - buf.write("\'\2\u01a2\u01a8\7\4\2\2\u01a3\u01a4\5L\'\2\u01a4\u01a5") + buf.write("'\2\u01a2\u01a8\7\4\2\2\u01a3\u01a4\5L'\2\u01a4\u01a5") buf.write("\7\4\2\2\u01a5\u01a7\3\2\2\2\u01a6\u01a3\3\2\2\2\u01a7") buf.write("\u01aa\3\2\2\2\u01a8\u01a6\3\2\2\2\u01a8\u01a9\3\2\2\2") buf.write("\u01a9\u01ac\3\2\2\2\u01aa\u01a8\3\2\2\2\u01ab\u01a1\3") buf.write("\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\u01ae") - buf.write("\7\23\2\2\u01ae-\3\2\2\2\u01af\u01b0\7\'\2\2\u01b0\u01b2") + buf.write("\7\23\2\2\u01ae-\3\2\2\2\u01af\u01b0\7'\2\2\u01b0\u01b2") buf.write("\5\u00c4c\2\u01b1\u01b3\5@!\2\u01b2\u01b1\3\2\2\2\u01b2") buf.write("\u01b3\3\2\2\2\u01b3\u01b8\3\2\2\2\u01b4\u01b7\7z\2\2") buf.write("\u01b5\u01b7\5\u00c8e\2\u01b6\u01b4\3\2\2\2\u01b6\u01b5") @@ -289,7 +289,7 @@ def serializedATN(): buf.write("\u0200\3\2\2\2\u01fe\u01fc\3\2\2\2\u01fe\u01ff\3\2\2\2") buf.write("\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201\u0202\7") buf.write("\23\2\2\u0202?\3\2\2\2\u0203\u020c\7\31\2\2\u0204\u0209") - buf.write("\5B\"\2\u0205\u0206\7\22\2\2\u0206\u0208\5B\"\2\u0207") + buf.write('\5B"\2\u0205\u0206\7\22\2\2\u0206\u0208\5B"\2\u0207') buf.write("\u0205\3\2\2\2\u0208\u020b\3\2\2\2\u0209\u0207\3\2\2\2") buf.write("\u0209\u020a\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3") buf.write("\2\2\2\u020c\u0204\3\2\2\2\u020c\u020d\3\2\2\2\u020d\u020e") @@ -402,14 +402,14 @@ def serializedATN(): buf.write("\7\4\2\2\u0304\u0083\3\2\2\2\u0305\u0306\7@\2\2\u0306") buf.write("\u0307\5\u009aN\2\u0307\u0308\7\4\2\2\u0308\u0085\3\2") buf.write("\2\2\u0309\u030a\7A\2\2\u030a\u0311\5\u008aF\2\u030b\u0311") - buf.write("\5L\'\2\u030c\u030d\7\31\2\2\u030d\u030e\5\u0088E\2\u030e") + buf.write("\5L'\2\u030c\u030d\7\31\2\2\u030d\u030e\5\u0088E\2\u030e") buf.write("\u030f\7\32\2\2\u030f\u0311\3\2\2\2\u0310\u0309\3\2\2") buf.write("\2\u0310\u030b\3\2\2\2\u0310\u030c\3\2\2\2\u0311\u0314") buf.write("\3\2\2\2\u0312\u0313\7\r\2\2\u0313\u0315\5\u008eH\2\u0314") buf.write("\u0312\3\2\2\2\u0314\u0315\3\2\2\2\u0315\u0316\3\2\2\2") buf.write("\u0316\u0317\7\4\2\2\u0317\u0087\3\2\2\2\u0318\u031a\5") - buf.write("L\'\2\u0319\u0318\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u0321") - buf.write("\3\2\2\2\u031b\u031d\7\22\2\2\u031c\u031e\5L\'\2\u031d") + buf.write("L'\2\u0319\u0318\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u0321") + buf.write("\3\2\2\2\u031b\u031d\7\22\2\2\u031c\u031e\5L'\2\u031d") buf.write("\u031c\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u0320\3\2\2\2") buf.write("\u031f\u031b\3\2\2\2\u0320\u0323\3\2\2\2\u0321\u031f\3") buf.write("\2\2\2\u0321\u0322\3\2\2\2\u0322\u0089\3\2\2\2\u0323\u0321") @@ -606,77 +606,282 @@ def serializedATN(): return buf.getvalue() -class SolidityParser ( Parser ): - +class SolidityParser(Parser): grammarFileName = "Solidity.g4" atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] sharedContextCache = PredictionContextCache() - literalNames = [ "", "'pragma'", "';'", "'*'", "'||'", "'^'", - "'~'", "'>='", "'>'", "'<'", "'<='", "'='", "'as'", - "'import'", "'from'", "'{'", "','", "'}'", "'abstract'", - "'contract'", "'interface'", "'library'", "'is'", "'('", - "')'", "'error'", "'using'", "'for'", "'|'", "'&'", - "'+'", "'-'", "'/'", "'%'", "'=='", "'!='", "'struct'", - "'modifier'", "'function'", "'returns'", "'event'", - "'enum'", "'['", "']'", "'address'", "'.'", "'mapping'", - "'=>'", "'memory'", "'storage'", "'calldata'", "'if'", - "'else'", "'try'", "'catch'", "'while'", "'unchecked'", - "'assembly'", "'do'", "'return'", "'throw'", "'emit'", - "'revert'", "'var'", "'bool'", "'string'", "'byte'", - "'++'", "'--'", "'new'", "':'", "'delete'", "'!'", - "'**'", "'<<'", "'>>'", "'&&'", "'?'", "'|='", "'^='", - "'&='", "'<<='", "'>>='", "'+='", "'-='", "'*='", "'/='", - "'%='", "'let'", "':='", "'=:'", "'switch'", "'case'", - "'default'", "'->'", "'callback'", "'override'", "", - "", "", "", "", - "", "", "", "", - "", "", "'anonymous'", "'break'", - "'constant'", "'immutable'", "'continue'", "'leave'", - "'external'", "'indexed'", "'internal'", "'payable'", - "'private'", "'public'", "'virtual'", "'pure'", "'type'", - "'view'", "'global'", "'constructor'", "'fallback'", - "'receive'" ] - - symbolicNames = [ "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "Int", "Uint", "Byte", "Fixed", "Ufixed", - "BooleanLiteral", "DecimalNumber", "HexNumber", "NumberUnit", - "HexLiteralFragment", "ReservedKeyword", "AnonymousKeyword", - "BreakKeyword", "ConstantKeyword", "ImmutableKeyword", - "ContinueKeyword", "LeaveKeyword", "ExternalKeyword", - "IndexedKeyword", "InternalKeyword", "PayableKeyword", - "PrivateKeyword", "PublicKeyword", "VirtualKeyword", - "PureKeyword", "TypeKeyword", "ViewKeyword", "GlobalKeyword", - "ConstructorKeyword", "FallbackKeyword", "ReceiveKeyword", - "Identifier", "StringLiteralFragment", "VersionLiteral", - "WS", "COMMENT", "LINE_COMMENT" ] + literalNames = [ + "", + "'pragma'", + "';'", + "'*'", + "'||'", + "'^'", + "'~'", + "'>='", + "'>'", + "'<'", + "'<='", + "'='", + "'as'", + "'import'", + "'from'", + "'{'", + "','", + "'}'", + "'abstract'", + "'contract'", + "'interface'", + "'library'", + "'is'", + "'('", + "')'", + "'error'", + "'using'", + "'for'", + "'|'", + "'&'", + "'+'", + "'-'", + "'/'", + "'%'", + "'=='", + "'!='", + "'struct'", + "'modifier'", + "'function'", + "'returns'", + "'event'", + "'enum'", + "'['", + "']'", + "'address'", + "'.'", + "'mapping'", + "'=>'", + "'memory'", + "'storage'", + "'calldata'", + "'if'", + "'else'", + "'try'", + "'catch'", + "'while'", + "'unchecked'", + "'assembly'", + "'do'", + "'return'", + "'throw'", + "'emit'", + "'revert'", + "'var'", + "'bool'", + "'string'", + "'byte'", + "'++'", + "'--'", + "'new'", + "':'", + "'delete'", + "'!'", + "'**'", + "'<<'", + "'>>'", + "'&&'", + "'?'", + "'|='", + "'^='", + "'&='", + "'<<='", + "'>>='", + "'+='", + "'-='", + "'*='", + "'/='", + "'%='", + "'let'", + "':='", + "'=:'", + "'switch'", + "'case'", + "'default'", + "'->'", + "'callback'", + "'override'", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "'anonymous'", + "'break'", + "'constant'", + "'immutable'", + "'continue'", + "'leave'", + "'external'", + "'indexed'", + "'internal'", + "'payable'", + "'private'", + "'public'", + "'virtual'", + "'pure'", + "'type'", + "'view'", + "'global'", + "'constructor'", + "'fallback'", + "'receive'", + ] + + symbolicNames = [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "Int", + "Uint", + "Byte", + "Fixed", + "Ufixed", + "BooleanLiteral", + "DecimalNumber", + "HexNumber", + "NumberUnit", + "HexLiteralFragment", + "ReservedKeyword", + "AnonymousKeyword", + "BreakKeyword", + "ConstantKeyword", + "ImmutableKeyword", + "ContinueKeyword", + "LeaveKeyword", + "ExternalKeyword", + "IndexedKeyword", + "InternalKeyword", + "PayableKeyword", + "PrivateKeyword", + "PublicKeyword", + "VirtualKeyword", + "PureKeyword", + "TypeKeyword", + "ViewKeyword", + "GlobalKeyword", + "ConstructorKeyword", + "FallbackKeyword", + "ReceiveKeyword", + "Identifier", + "StringLiteralFragment", + "VersionLiteral", + "WS", + "COMMENT", + "LINE_COMMENT", + ] RULE_sourceUnit = 0 RULE_pragmaDirective = 1 @@ -780,296 +985,429 @@ class SolidityParser ( Parser ): RULE_overrideSpecifier = 99 RULE_stringLiteral = 100 - ruleNames = [ "sourceUnit", "pragmaDirective", "pragmaName", "pragmaValue", - "version", "versionOperator", "versionConstraint", "importDeclaration", - "importDirective", "importPath", "contractDefinition", - "inheritanceSpecifier", "contractPart", "stateVariableDeclaration", - "fileLevelConstant", "customErrorDefinition", "typeDefinition", - "usingForDeclaration", "usingForObject", "usingForObjectDirective", - "userDefinableOperators", "structDefinition", "modifierDefinition", - "modifierInvocation", "functionDefinition", "functionDescriptor", - "returnParameters", "modifierList", "eventDefinition", - "enumValue", "enumDefinition", "parameterList", "parameter", - "eventParameterList", "eventParameter", "functionTypeParameterList", - "functionTypeParameter", "variableDeclaration", "typeName", - "userDefinedTypeName", "mappingKey", "mapping", "mappingKeyName", - "mappingValueName", "functionTypeName", "storageLocation", - "stateMutability", "block", "statement", "expressionStatement", - "ifStatement", "tryStatement", "catchClause", "whileStatement", - "simpleStatement", "uncheckedStatement", "forStatement", - "inlineAssemblyStatement", "inlineAssemblyStatementFlag", - "doWhileStatement", "continueStatement", "breakStatement", - "returnStatement", "throwStatement", "emitStatement", - "revertStatement", "variableDeclarationStatement", "variableDeclarationList", - "identifierList", "elementaryTypeName", "expression", - "primaryExpression", "expressionList", "nameValueList", - "nameValue", "functionCallArguments", "functionCall", - "assemblyBlock", "assemblyItem", "assemblyExpression", - "assemblyMember", "assemblyCall", "assemblyLocalDefinition", - "assemblyAssignment", "assemblyIdentifierOrList", "assemblyIdentifierList", - "assemblyStackAssignment", "labelDefinition", "assemblySwitch", - "assemblyCase", "assemblyFunctionDefinition", "assemblyFunctionReturns", - "assemblyFor", "assemblyIf", "assemblyLiteral", "tupleExpression", - "numberLiteral", "identifier", "hexLiteral", "overrideSpecifier", - "stringLiteral" ] + ruleNames = [ + "sourceUnit", + "pragmaDirective", + "pragmaName", + "pragmaValue", + "version", + "versionOperator", + "versionConstraint", + "importDeclaration", + "importDirective", + "importPath", + "contractDefinition", + "inheritanceSpecifier", + "contractPart", + "stateVariableDeclaration", + "fileLevelConstant", + "customErrorDefinition", + "typeDefinition", + "usingForDeclaration", + "usingForObject", + "usingForObjectDirective", + "userDefinableOperators", + "structDefinition", + "modifierDefinition", + "modifierInvocation", + "functionDefinition", + "functionDescriptor", + "returnParameters", + "modifierList", + "eventDefinition", + "enumValue", + "enumDefinition", + "parameterList", + "parameter", + "eventParameterList", + "eventParameter", + "functionTypeParameterList", + "functionTypeParameter", + "variableDeclaration", + "typeName", + "userDefinedTypeName", + "mappingKey", + "mapping", + "mappingKeyName", + "mappingValueName", + "functionTypeName", + "storageLocation", + "stateMutability", + "block", + "statement", + "expressionStatement", + "ifStatement", + "tryStatement", + "catchClause", + "whileStatement", + "simpleStatement", + "uncheckedStatement", + "forStatement", + "inlineAssemblyStatement", + "inlineAssemblyStatementFlag", + "doWhileStatement", + "continueStatement", + "breakStatement", + "returnStatement", + "throwStatement", + "emitStatement", + "revertStatement", + "variableDeclarationStatement", + "variableDeclarationList", + "identifierList", + "elementaryTypeName", + "expression", + "primaryExpression", + "expressionList", + "nameValueList", + "nameValue", + "functionCallArguments", + "functionCall", + "assemblyBlock", + "assemblyItem", + "assemblyExpression", + "assemblyMember", + "assemblyCall", + "assemblyLocalDefinition", + "assemblyAssignment", + "assemblyIdentifierOrList", + "assemblyIdentifierList", + "assemblyStackAssignment", + "labelDefinition", + "assemblySwitch", + "assemblyCase", + "assemblyFunctionDefinition", + "assemblyFunctionReturns", + "assemblyFor", + "assemblyIf", + "assemblyLiteral", + "tupleExpression", + "numberLiteral", + "identifier", + "hexLiteral", + "overrideSpecifier", + "stringLiteral", + ] 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 - Int=97 - Uint=98 - Byte=99 - Fixed=100 - Ufixed=101 - BooleanLiteral=102 - DecimalNumber=103 - HexNumber=104 - NumberUnit=105 - HexLiteralFragment=106 - ReservedKeyword=107 - AnonymousKeyword=108 - BreakKeyword=109 - ConstantKeyword=110 - ImmutableKeyword=111 - ContinueKeyword=112 - LeaveKeyword=113 - ExternalKeyword=114 - IndexedKeyword=115 - InternalKeyword=116 - PayableKeyword=117 - PrivateKeyword=118 - PublicKeyword=119 - VirtualKeyword=120 - PureKeyword=121 - TypeKeyword=122 - ViewKeyword=123 - GlobalKeyword=124 - ConstructorKeyword=125 - FallbackKeyword=126 - ReceiveKeyword=127 - Identifier=128 - StringLiteralFragment=129 - VersionLiteral=130 - WS=131 - COMMENT=132 - LINE_COMMENT=133 - - def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + 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 + Int = 97 + Uint = 98 + Byte = 99 + Fixed = 100 + Ufixed = 101 + BooleanLiteral = 102 + DecimalNumber = 103 + HexNumber = 104 + NumberUnit = 105 + HexLiteralFragment = 106 + ReservedKeyword = 107 + AnonymousKeyword = 108 + BreakKeyword = 109 + ConstantKeyword = 110 + ImmutableKeyword = 111 + ContinueKeyword = 112 + LeaveKeyword = 113 + ExternalKeyword = 114 + IndexedKeyword = 115 + InternalKeyword = 116 + PayableKeyword = 117 + PrivateKeyword = 118 + PublicKeyword = 119 + VirtualKeyword = 120 + PureKeyword = 121 + TypeKeyword = 122 + ViewKeyword = 123 + GlobalKeyword = 124 + ConstructorKeyword = 125 + FallbackKeyword = 126 + ReceiveKeyword = 127 + Identifier = 128 + StringLiteralFragment = 129 + VersionLiteral = 130 + WS = 131 + COMMENT = 132 + LINE_COMMENT = 133 + + def __init__(self, input: TokenStream, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.7.2") - self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._interp = ParserATNSimulator( + self, self.atn, self.decisionsToDFA, self.sharedContextCache + ) self._predicates = None - - - class SourceUnitContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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 pragmaDirective(self, i:int=None): + def pragmaDirective(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.PragmaDirectiveContext) else: - return self.getTypedRuleContext(SolidityParser.PragmaDirectiveContext,i) - + return self.getTypedRuleContext( + SolidityParser.PragmaDirectiveContext, i + ) - def importDirective(self, i:int=None): + def importDirective(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.ImportDirectiveContext) else: - return self.getTypedRuleContext(SolidityParser.ImportDirectiveContext,i) + return self.getTypedRuleContext( + SolidityParser.ImportDirectiveContext, i + ) - - def contractDefinition(self, i:int=None): + def contractDefinition(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.ContractDefinitionContext) + return self.getTypedRuleContexts( + SolidityParser.ContractDefinitionContext + ) else: - return self.getTypedRuleContext(SolidityParser.ContractDefinitionContext,i) - + return self.getTypedRuleContext( + SolidityParser.ContractDefinitionContext, i + ) - def enumDefinition(self, i:int=None): + def enumDefinition(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.EnumDefinitionContext) else: - return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,i) + return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext, i) - - def structDefinition(self, i:int=None): + def structDefinition(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.StructDefinitionContext) else: - return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,i) - + return self.getTypedRuleContext( + SolidityParser.StructDefinitionContext, i + ) - def functionDefinition(self, i:int=None): + def functionDefinition(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.FunctionDefinitionContext) + return self.getTypedRuleContexts( + SolidityParser.FunctionDefinitionContext + ) else: - return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,i) + return self.getTypedRuleContext( + SolidityParser.FunctionDefinitionContext, i + ) - - def fileLevelConstant(self, i:int=None): + def fileLevelConstant(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.FileLevelConstantContext) + return self.getTypedRuleContexts( + SolidityParser.FileLevelConstantContext + ) else: - return self.getTypedRuleContext(SolidityParser.FileLevelConstantContext,i) - + return self.getTypedRuleContext( + SolidityParser.FileLevelConstantContext, i + ) - def customErrorDefinition(self, i:int=None): + def customErrorDefinition(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.CustomErrorDefinitionContext) + return self.getTypedRuleContexts( + SolidityParser.CustomErrorDefinitionContext + ) else: - return self.getTypedRuleContext(SolidityParser.CustomErrorDefinitionContext,i) + return self.getTypedRuleContext( + SolidityParser.CustomErrorDefinitionContext, i + ) - - def typeDefinition(self, i:int=None): + def typeDefinition(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.TypeDefinitionContext) else: - return self.getTypedRuleContext(SolidityParser.TypeDefinitionContext,i) - + return self.getTypedRuleContext(SolidityParser.TypeDefinitionContext, i) - def usingForDeclaration(self, i:int=None): + def usingForDeclaration(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.UsingForDeclarationContext) + return self.getTypedRuleContexts( + SolidityParser.UsingForDeclarationContext + ) else: - return self.getTypedRuleContext(SolidityParser.UsingForDeclarationContext,i) - + return self.getTypedRuleContext( + SolidityParser.UsingForDeclarationContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_sourceUnit - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSourceUnit" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSourceUnit"): listener.enterSourceUnit(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSourceUnit" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSourceUnit"): listener.exitSourceUnit(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSourceUnit" ): + 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 + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 214 self._errHandler.sync(self) _la = self._input.LA(1) - while ((((_la - 1)) & ~0x3f) == 0 and ((1 << (_la - 1)) & ((1 << (SolidityParser.T__0 - 1)) | (1 << (SolidityParser.T__12 - 1)) | (1 << (SolidityParser.T__13 - 1)) | (1 << (SolidityParser.T__17 - 1)) | (1 << (SolidityParser.T__18 - 1)) | (1 << (SolidityParser.T__19 - 1)) | (1 << (SolidityParser.T__20 - 1)) | (1 << (SolidityParser.T__24 - 1)) | (1 << (SolidityParser.T__25 - 1)) | (1 << (SolidityParser.T__35 - 1)) | (1 << (SolidityParser.T__37 - 1)) | (1 << (SolidityParser.T__40 - 1)) | (1 << (SolidityParser.T__43 - 1)) | (1 << (SolidityParser.T__45 - 1)) | (1 << (SolidityParser.T__49 - 1)) | (1 << (SolidityParser.T__61 - 1)) | (1 << (SolidityParser.T__62 - 1)) | (1 << (SolidityParser.T__63 - 1)))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (SolidityParser.T__64 - 65)) | (1 << (SolidityParser.T__65 - 65)) | (1 << (SolidityParser.T__94 - 65)) | (1 << (SolidityParser.Int - 65)) | (1 << (SolidityParser.Uint - 65)) | (1 << (SolidityParser.Byte - 65)) | (1 << (SolidityParser.Fixed - 65)) | (1 << (SolidityParser.Ufixed - 65)) | (1 << (SolidityParser.LeaveKeyword - 65)) | (1 << (SolidityParser.PayableKeyword - 65)) | (1 << (SolidityParser.TypeKeyword - 65)) | (1 << (SolidityParser.GlobalKeyword - 65)) | (1 << (SolidityParser.ConstructorKeyword - 65)) | (1 << (SolidityParser.FallbackKeyword - 65)) | (1 << (SolidityParser.ReceiveKeyword - 65)) | (1 << (SolidityParser.Identifier - 65)))) != 0): + while ( + (((_la - 1)) & ~0x3F) == 0 + and ( + (1 << (_la - 1)) + & ( + (1 << (SolidityParser.T__0 - 1)) + | (1 << (SolidityParser.T__12 - 1)) + | (1 << (SolidityParser.T__13 - 1)) + | (1 << (SolidityParser.T__17 - 1)) + | (1 << (SolidityParser.T__18 - 1)) + | (1 << (SolidityParser.T__19 - 1)) + | (1 << (SolidityParser.T__20 - 1)) + | (1 << (SolidityParser.T__24 - 1)) + | (1 << (SolidityParser.T__25 - 1)) + | (1 << (SolidityParser.T__35 - 1)) + | (1 << (SolidityParser.T__37 - 1)) + | (1 << (SolidityParser.T__40 - 1)) + | (1 << (SolidityParser.T__43 - 1)) + | (1 << (SolidityParser.T__45 - 1)) + | (1 << (SolidityParser.T__49 - 1)) + | (1 << (SolidityParser.T__61 - 1)) + | (1 << (SolidityParser.T__62 - 1)) + | (1 << (SolidityParser.T__63 - 1)) + ) + ) + != 0 + ) or ( + (((_la - 65)) & ~0x3F) == 0 + and ( + (1 << (_la - 65)) + & ( + (1 << (SolidityParser.T__64 - 65)) + | (1 << (SolidityParser.T__65 - 65)) + | (1 << (SolidityParser.T__94 - 65)) + | (1 << (SolidityParser.Int - 65)) + | (1 << (SolidityParser.Uint - 65)) + | (1 << (SolidityParser.Byte - 65)) + | (1 << (SolidityParser.Fixed - 65)) + | (1 << (SolidityParser.Ufixed - 65)) + | (1 << (SolidityParser.LeaveKeyword - 65)) + | (1 << (SolidityParser.PayableKeyword - 65)) + | (1 << (SolidityParser.TypeKeyword - 65)) + | (1 << (SolidityParser.GlobalKeyword - 65)) + | (1 << (SolidityParser.ConstructorKeyword - 65)) + | (1 << (SolidityParser.FallbackKeyword - 65)) + | (1 << (SolidityParser.ReceiveKeyword - 65)) + | (1 << (SolidityParser.Identifier - 65)) + ) + ) + != 0 + ): self.state = 212 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,0,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 0, self._ctx) if la_ == 1: self.state = 202 self.pragmaDirective() @@ -1120,7 +1458,6 @@ def sourceUnit(self): self.usingForDeclaration() pass - self.state = 216 self._errHandler.sync(self) _la = self._input.LA(1) @@ -1135,43 +1472,37 @@ def sourceUnit(self): self.exitRule() return localctx - class PragmaDirectiveContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.PragmaNameContext, 0) def pragmaValue(self): - return self.getTypedRuleContext(SolidityParser.PragmaValueContext,0) - + return self.getTypedRuleContext(SolidityParser.PragmaValueContext, 0) def getRuleIndex(self): return SolidityParser.RULE_pragmaDirective - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPragmaDirective" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPragmaDirective"): listener.enterPragmaDirective(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPragmaDirective" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPragmaDirective"): listener.exitPragmaDirective(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPragmaDirective" ): + 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, 2, self.RULE_pragmaDirective) try: @@ -1192,39 +1523,34 @@ def pragmaDirective(self): self.exitRule() return localctx - class PragmaNameContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def getRuleIndex(self): return SolidityParser.RULE_pragmaName - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPragmaName" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPragmaName"): listener.enterPragmaName(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPragmaName" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPragmaName"): listener.exitPragmaName(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPragmaName" ): + 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, 4, self.RULE_pragmaName) try: @@ -1239,49 +1565,43 @@ def pragmaName(self): self.exitRule() return localctx - class PragmaValueContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.VersionContext, 0) def expression(self): - return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_pragmaValue - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPragmaValue" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPragmaValue"): listener.enterPragmaValue(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPragmaValue" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPragmaValue"): listener.exitPragmaValue(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPragmaValue" ): + 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, 6, self.RULE_pragmaValue) try: self.state = 229 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,2,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 2, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 226 @@ -1300,7 +1620,6 @@ def pragmaValue(self): self.expression(0) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -1309,45 +1628,44 @@ def pragmaValue(self): self.exitRule() return localctx - class VersionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def versionConstraint(self, i:int=None): + def versionConstraint(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.VersionConstraintContext) + return self.getTypedRuleContexts( + SolidityParser.VersionConstraintContext + ) else: - return self.getTypedRuleContext(SolidityParser.VersionConstraintContext,i) - + return self.getTypedRuleContext( + SolidityParser.VersionConstraintContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_version - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVersion" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVersion"): listener.enterVersion(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVersion" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVersion"): listener.exitVersion(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVersion" ): + 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, 8, self.RULE_version) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 231 @@ -1355,15 +1673,34 @@ def version(self): self.state = 238 self._errHandler.sync(self) _la = self._input.LA(1) - while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9) | (1 << SolidityParser.T__10))) != 0) or _la==SolidityParser.DecimalNumber or _la==SolidityParser.VersionLiteral: + while ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__3) + | (1 << SolidityParser.T__4) + | (1 << SolidityParser.T__5) + | (1 << SolidityParser.T__6) + | (1 << SolidityParser.T__7) + | (1 << SolidityParser.T__8) + | (1 << SolidityParser.T__9) + | (1 << SolidityParser.T__10) + ) + ) + != 0 + ) + or _la == SolidityParser.DecimalNumber + or _la == SolidityParser.VersionLiteral + ): self.state = 233 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__3: + if _la == SolidityParser.T__3: self.state = 232 self.match(SolidityParser.T__3) - self.state = 235 self.versionConstraint() self.state = 240 @@ -1378,44 +1715,56 @@ def version(self): self.exitRule() return localctx - class VersionOperatorContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVersionOperator"): listener.enterVersionOperator(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVersionOperator" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVersionOperator"): listener.exitVersionOperator(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVersionOperator" ): + 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, 10, self.RULE_versionOperator) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 241 _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) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9) | (1 << SolidityParser.T__10))) != 0)): + if not ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__4) + | (1 << SolidityParser.T__5) + | (1 << SolidityParser.T__6) + | (1 << SolidityParser.T__7) + | (1 << SolidityParser.T__8) + | (1 << SolidityParser.T__9) + | (1 << SolidityParser.T__10) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -1428,10 +1777,10 @@ def versionOperator(self): self.exitRule() return localctx - class VersionConstraintContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1439,8 +1788,7 @@ def VersionLiteral(self): return self.getToken(SolidityParser.VersionLiteral, 0) def versionOperator(self): - return self.getTypedRuleContext(SolidityParser.VersionOperatorContext,0) - + return self.getTypedRuleContext(SolidityParser.VersionOperatorContext, 0) def DecimalNumber(self): return self.getToken(SolidityParser.DecimalNumber, 0) @@ -1448,42 +1796,48 @@ def DecimalNumber(self): def getRuleIndex(self): return SolidityParser.RULE_versionConstraint - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVersionConstraint" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVersionConstraint"): listener.enterVersionConstraint(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVersionConstraint" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVersionConstraint"): listener.exitVersionConstraint(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVersionConstraint" ): + 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, 12, self.RULE_versionConstraint) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 251 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,7,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 7, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 244 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9) | (1 << SolidityParser.T__10))) != 0): + if ((_la) & ~0x3F) == 0 and ( + (1 << _la) + & ( + (1 << SolidityParser.T__4) + | (1 << SolidityParser.T__5) + | (1 << SolidityParser.T__6) + | (1 << SolidityParser.T__7) + | (1 << SolidityParser.T__8) + | (1 << SolidityParser.T__9) + | (1 << SolidityParser.T__10) + ) + ) != 0: self.state = 243 self.versionOperator() - self.state = 246 self.match(SolidityParser.VersionLiteral) pass @@ -1493,16 +1847,25 @@ def versionConstraint(self): self.state = 248 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9) | (1 << SolidityParser.T__10))) != 0): + if ((_la) & ~0x3F) == 0 and ( + (1 << _la) + & ( + (1 << SolidityParser.T__4) + | (1 << SolidityParser.T__5) + | (1 << SolidityParser.T__6) + | (1 << SolidityParser.T__7) + | (1 << SolidityParser.T__8) + | (1 << SolidityParser.T__9) + | (1 << SolidityParser.T__10) + ) + ) != 0: self.state = 247 self.versionOperator() - self.state = 250 self.match(SolidityParser.DecimalNumber) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -1511,45 +1874,40 @@ def versionConstraint(self): self.exitRule() return localctx - class ImportDeclarationContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def identifier(self, i:int=None): + def identifier(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.IdentifierContext) else: - return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, i) def getRuleIndex(self): return SolidityParser.RULE_importDeclaration - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterImportDeclaration" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterImportDeclaration"): listener.enterImportDeclaration(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitImportDeclaration" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitImportDeclaration"): listener.exitImportDeclaration(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitImportDeclaration" ): + 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, 14, self.RULE_importDeclaration) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 253 @@ -1557,13 +1915,12 @@ def importDeclaration(self): self.state = 256 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__11: + if _la == SolidityParser.T__11: self.state = 254 self.match(SolidityParser.T__11) self.state = 255 self.identifier() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -1572,60 +1929,57 @@ def importDeclaration(self): self.exitRule() return localctx - class ImportDirectiveContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def importPath(self): - return self.getTypedRuleContext(SolidityParser.ImportPathContext,0) - + return self.getTypedRuleContext(SolidityParser.ImportPathContext, 0) - def identifier(self, i:int=None): + def identifier(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.IdentifierContext) else: - return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) + return self.getTypedRuleContext(SolidityParser.IdentifierContext, i) - - def importDeclaration(self, i:int=None): + def importDeclaration(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.ImportDeclarationContext) + return self.getTypedRuleContexts( + SolidityParser.ImportDeclarationContext + ) else: - return self.getTypedRuleContext(SolidityParser.ImportDeclarationContext,i) - + return self.getTypedRuleContext( + SolidityParser.ImportDeclarationContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_importDirective - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterImportDirective" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterImportDirective"): listener.enterImportDirective(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitImportDirective" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitImportDirective"): listener.exitImportDirective(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitImportDirective" ): + 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, 16, self.RULE_importDirective) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 294 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,13,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 13, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 258 @@ -1635,13 +1989,12 @@ def importDirective(self): self.state = 262 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__11: + if _la == SolidityParser.T__11: self.state = 260 self.match(SolidityParser.T__11) self.state = 261 self.identifier() - self.state = 264 self.match(SolidityParser.T__1) pass @@ -1657,7 +2010,20 @@ def importDirective(self): self.state = 267 self.match(SolidityParser.T__2) pass - elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__43, SolidityParser.T__49, SolidityParser.T__61, SolidityParser.T__94, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.GlobalKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier]: + elif token in [ + SolidityParser.T__13, + SolidityParser.T__24, + SolidityParser.T__43, + SolidityParser.T__49, + SolidityParser.T__61, + SolidityParser.T__94, + SolidityParser.LeaveKeyword, + SolidityParser.PayableKeyword, + SolidityParser.GlobalKeyword, + SolidityParser.ConstructorKeyword, + SolidityParser.ReceiveKeyword, + SolidityParser.Identifier, + ]: self.state = 268 self.identifier() pass @@ -1667,13 +2033,12 @@ def importDirective(self): self.state = 273 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__11: + if _la == SolidityParser.T__11: self.state = 271 self.match(SolidityParser.T__11) self.state = 272 self.identifier() - self.state = 275 self.match(SolidityParser.T__13) self.state = 276 @@ -1693,7 +2058,7 @@ def importDirective(self): self.state = 286 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 282 self.match(SolidityParser.T__15) self.state = 283 @@ -1712,7 +2077,6 @@ def importDirective(self): self.match(SolidityParser.T__1) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -1721,10 +2085,10 @@ def importDirective(self): self.exitRule() return localctx - class ImportPathContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1734,25 +2098,21 @@ def StringLiteralFragment(self): def getRuleIndex(self): return SolidityParser.RULE_importPath - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterImportPath" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterImportPath"): listener.enterImportPath(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitImportPath" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitImportPath"): listener.exitImportPath(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitImportPath" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitImportPath"): return visitor.visitImportPath(self) else: return visitor.visitChildren(self) - - - def importPath(self): - localctx = SolidityParser.ImportPathContext(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_importPath) try: @@ -1767,69 +2127,78 @@ def importPath(self): self.exitRule() return localctx - class ContractDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) - def inheritanceSpecifier(self, i:int=None): + def inheritanceSpecifier(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.InheritanceSpecifierContext) + return self.getTypedRuleContexts( + SolidityParser.InheritanceSpecifierContext + ) else: - return self.getTypedRuleContext(SolidityParser.InheritanceSpecifierContext,i) + return self.getTypedRuleContext( + SolidityParser.InheritanceSpecifierContext, i + ) - - def contractPart(self, i:int=None): + def contractPart(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.ContractPartContext) else: - return self.getTypedRuleContext(SolidityParser.ContractPartContext,i) - + return self.getTypedRuleContext(SolidityParser.ContractPartContext, i) def getRuleIndex(self): return SolidityParser.RULE_contractDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterContractDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterContractDefinition"): listener.enterContractDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitContractDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitContractDefinition"): listener.exitContractDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitContractDefinition" ): + 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, 20, self.RULE_contractDefinition) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 299 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__17: + if _la == SolidityParser.T__17: self.state = 298 self.match(SolidityParser.T__17) - self.state = 301 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__18) | (1 << SolidityParser.T__19) | (1 << SolidityParser.T__20))) != 0)): + if not ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__18) + | (1 << SolidityParser.T__19) + | (1 << SolidityParser.T__20) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -1839,7 +2208,7 @@ def contractDefinition(self): self.state = 312 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__21: + if _la == SolidityParser.T__21: self.state = 303 self.match(SolidityParser.T__21) self.state = 304 @@ -1847,7 +2216,7 @@ def contractDefinition(self): self.state = 309 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 305 self.match(SolidityParser.T__15) self.state = 306 @@ -1856,14 +2225,58 @@ def contractDefinition(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 314 self.match(SolidityParser.T__14) self.state = 318 self._errHandler.sync(self) _la = self._input.LA(1) - while ((((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & ((1 << (SolidityParser.T__13 - 14)) | (1 << (SolidityParser.T__24 - 14)) | (1 << (SolidityParser.T__25 - 14)) | (1 << (SolidityParser.T__35 - 14)) | (1 << (SolidityParser.T__36 - 14)) | (1 << (SolidityParser.T__37 - 14)) | (1 << (SolidityParser.T__39 - 14)) | (1 << (SolidityParser.T__40 - 14)) | (1 << (SolidityParser.T__43 - 14)) | (1 << (SolidityParser.T__45 - 14)) | (1 << (SolidityParser.T__49 - 14)) | (1 << (SolidityParser.T__61 - 14)) | (1 << (SolidityParser.T__62 - 14)) | (1 << (SolidityParser.T__63 - 14)) | (1 << (SolidityParser.T__64 - 14)) | (1 << (SolidityParser.T__65 - 14)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.Int - 95)) | (1 << (SolidityParser.Uint - 95)) | (1 << (SolidityParser.Byte - 95)) | (1 << (SolidityParser.Fixed - 95)) | (1 << (SolidityParser.Ufixed - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.TypeKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.FallbackKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + while ( + (((_la - 14)) & ~0x3F) == 0 + and ( + (1 << (_la - 14)) + & ( + (1 << (SolidityParser.T__13 - 14)) + | (1 << (SolidityParser.T__24 - 14)) + | (1 << (SolidityParser.T__25 - 14)) + | (1 << (SolidityParser.T__35 - 14)) + | (1 << (SolidityParser.T__36 - 14)) + | (1 << (SolidityParser.T__37 - 14)) + | (1 << (SolidityParser.T__39 - 14)) + | (1 << (SolidityParser.T__40 - 14)) + | (1 << (SolidityParser.T__43 - 14)) + | (1 << (SolidityParser.T__45 - 14)) + | (1 << (SolidityParser.T__49 - 14)) + | (1 << (SolidityParser.T__61 - 14)) + | (1 << (SolidityParser.T__62 - 14)) + | (1 << (SolidityParser.T__63 - 14)) + | (1 << (SolidityParser.T__64 - 14)) + | (1 << (SolidityParser.T__65 - 14)) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.Int - 95)) + | (1 << (SolidityParser.Uint - 95)) + | (1 << (SolidityParser.Byte - 95)) + | (1 << (SolidityParser.Fixed - 95)) + | (1 << (SolidityParser.Ufixed - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.TypeKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.FallbackKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 315 self.contractPart() self.state = 320 @@ -1880,46 +2293,44 @@ def contractDefinition(self): self.exitRule() return localctx - class InheritanceSpecifierContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext( + SolidityParser.UserDefinedTypeNameContext, 0 + ) def expressionList(self): - return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionListContext, 0) def getRuleIndex(self): return SolidityParser.RULE_inheritanceSpecifier - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInheritanceSpecifier" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInheritanceSpecifier"): listener.enterInheritanceSpecifier(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInheritanceSpecifier" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInheritanceSpecifier"): listener.exitInheritanceSpecifier(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInheritanceSpecifier" ): + 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) + localctx = SolidityParser.InheritanceSpecifierContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 22, self.RULE_inheritanceSpecifier) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 323 @@ -1927,21 +2338,74 @@ def inheritanceSpecifier(self): self.state = 329 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__22: + if _la == SolidityParser.T__22: self.state = 324 self.match(SolidityParser.T__22) self.state = 326 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 325 self.expressionList() - self.state = 328 self.match(SolidityParser.T__23) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -1950,77 +2414,70 @@ def inheritanceSpecifier(self): self.exitRule() return localctx - class ContractPartContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext( + SolidityParser.StateVariableDeclarationContext, 0 + ) def usingForDeclaration(self): - return self.getTypedRuleContext(SolidityParser.UsingForDeclarationContext,0) - + return self.getTypedRuleContext( + SolidityParser.UsingForDeclarationContext, 0 + ) def structDefinition(self): - return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,0) - + return self.getTypedRuleContext(SolidityParser.StructDefinitionContext, 0) def modifierDefinition(self): - return self.getTypedRuleContext(SolidityParser.ModifierDefinitionContext,0) - + return self.getTypedRuleContext(SolidityParser.ModifierDefinitionContext, 0) def functionDefinition(self): - return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,0) - + return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext, 0) def eventDefinition(self): - return self.getTypedRuleContext(SolidityParser.EventDefinitionContext,0) - + return self.getTypedRuleContext(SolidityParser.EventDefinitionContext, 0) def enumDefinition(self): - return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,0) - + return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext, 0) def customErrorDefinition(self): - return self.getTypedRuleContext(SolidityParser.CustomErrorDefinitionContext,0) - + return self.getTypedRuleContext( + SolidityParser.CustomErrorDefinitionContext, 0 + ) def typeDefinition(self): - return self.getTypedRuleContext(SolidityParser.TypeDefinitionContext,0) - + return self.getTypedRuleContext(SolidityParser.TypeDefinitionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_contractPart - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterContractPart" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterContractPart"): listener.enterContractPart(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitContractPart" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitContractPart"): listener.exitContractPart(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitContractPart" ): + 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, 24, self.RULE_contractPart) try: self.state = 340 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,20,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 20, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 331 @@ -2075,7 +2532,6 @@ def contractPart(self): self.typeDefinition() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2084,87 +2540,85 @@ def contractPart(self): self.exitRule() return localctx - class StateVariableDeclarationContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) - - def PublicKeyword(self, i:int=None): + 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): + 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): + 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): + def ConstantKeyword(self, i: int = None): if i is None: return self.getTokens(SolidityParser.ConstantKeyword) else: return self.getToken(SolidityParser.ConstantKeyword, i) - def ImmutableKeyword(self, i:int=None): + def ImmutableKeyword(self, i: int = None): if i is None: return self.getTokens(SolidityParser.ImmutableKeyword) else: return self.getToken(SolidityParser.ImmutableKeyword, i) - def overrideSpecifier(self, i:int=None): + def overrideSpecifier(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.OverrideSpecifierContext) + return self.getTypedRuleContexts( + SolidityParser.OverrideSpecifierContext + ) else: - return self.getTypedRuleContext(SolidityParser.OverrideSpecifierContext,i) - + return self.getTypedRuleContext( + SolidityParser.OverrideSpecifierContext, i + ) def expression(self): - return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_stateVariableDeclaration - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStateVariableDeclaration" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStateVariableDeclaration"): listener.enterStateVariableDeclaration(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStateVariableDeclaration" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStateVariableDeclaration"): listener.exitStateVariableDeclaration(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStateVariableDeclaration" ): + 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) + localctx = SolidityParser.StateVariableDeclarationContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 26, self.RULE_stateVariableDeclaration) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 342 @@ -2172,7 +2626,17 @@ def stateVariableDeclaration(self): self.state = 351 self._errHandler.sync(self) _la = self._input.LA(1) - while ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.ConstantKeyword - 96)) | (1 << (SolidityParser.ImmutableKeyword - 96)) | (1 << (SolidityParser.InternalKeyword - 96)) | (1 << (SolidityParser.PrivateKeyword - 96)) | (1 << (SolidityParser.PublicKeyword - 96)))) != 0): + while (((_la - 96)) & ~0x3F) == 0 and ( + (1 << (_la - 96)) + & ( + (1 << (SolidityParser.T__95 - 96)) + | (1 << (SolidityParser.ConstantKeyword - 96)) + | (1 << (SolidityParser.ImmutableKeyword - 96)) + | (1 << (SolidityParser.InternalKeyword - 96)) + | (1 << (SolidityParser.PrivateKeyword - 96)) + | (1 << (SolidityParser.PublicKeyword - 96)) + ) + ) != 0: self.state = 349 self._errHandler.sync(self) token = self._input.LA(1) @@ -2212,13 +2676,12 @@ def stateVariableDeclaration(self): self.state = 357 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__10: + if _la == SolidityParser.T__10: self.state = 355 self.match(SolidityParser.T__10) self.state = 356 self.expression(0) - self.state = 359 self.match(SolidityParser.T__1) except RecognitionException as re: @@ -2229,50 +2692,43 @@ def stateVariableDeclaration(self): self.exitRule() return localctx - class FileLevelConstantContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def ConstantKeyword(self): return self.getToken(SolidityParser.ConstantKeyword, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def expression(self): - return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_fileLevelConstant - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFileLevelConstant" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFileLevelConstant"): listener.enterFileLevelConstant(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFileLevelConstant" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFileLevelConstant"): listener.exitFileLevelConstant(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFileLevelConstant" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFileLevelConstant"): return visitor.visitFileLevelConstant(self) else: return visitor.visitChildren(self) - - - def fileLevelConstant(self): - localctx = SolidityParser.FileLevelConstantContext(self, self._ctx, self.state) self.enterRule(localctx, 28, self.RULE_fileLevelConstant) try: @@ -2297,44 +2753,40 @@ def fileLevelConstant(self): self.exitRule() return localctx - class CustomErrorDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def parameterList(self): - return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) - + return self.getTypedRuleContext(SolidityParser.ParameterListContext, 0) def getRuleIndex(self): return SolidityParser.RULE_customErrorDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCustomErrorDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCustomErrorDefinition"): listener.enterCustomErrorDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCustomErrorDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCustomErrorDefinition"): listener.exitCustomErrorDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCustomErrorDefinition" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCustomErrorDefinition"): return visitor.visitCustomErrorDefinition(self) else: return visitor.visitChildren(self) - - - def customErrorDefinition(self): - - localctx = SolidityParser.CustomErrorDefinitionContext(self, self._ctx, self.state) + localctx = SolidityParser.CustomErrorDefinitionContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 30, self.RULE_customErrorDefinition) try: self.enterOuterAlt(localctx, 1) @@ -2354,10 +2806,10 @@ def customErrorDefinition(self): self.exitRule() return localctx - class TypeDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -2365,35 +2817,29 @@ def TypeKeyword(self): return self.getToken(SolidityParser.TypeKeyword, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def elementaryTypeName(self): - return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0) - + return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext, 0) def getRuleIndex(self): return SolidityParser.RULE_typeDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTypeDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTypeDefinition"): listener.enterTypeDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTypeDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTypeDefinition"): listener.exitTypeDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTypeDefinition" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTypeDefinition"): return visitor.visitTypeDefinition(self) else: return visitor.visitChildren(self) - - - def typeDefinition(self): - localctx = SolidityParser.TypeDefinitionContext(self, self._ctx, self.state) self.enterRule(localctx, 32, self.RULE_typeDefinition) try: @@ -2416,20 +2862,18 @@ def typeDefinition(self): self.exitRule() return localctx - class UsingForDeclarationContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def usingForObject(self): - return self.getTypedRuleContext(SolidityParser.UsingForObjectContext,0) - + return self.getTypedRuleContext(SolidityParser.UsingForObjectContext, 0) def typeName(self): - return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def GlobalKeyword(self): return self.getToken(SolidityParser.GlobalKeyword, 0) @@ -2437,28 +2881,26 @@ def GlobalKeyword(self): def getRuleIndex(self): return SolidityParser.RULE_usingForDeclaration - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUsingForDeclaration" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUsingForDeclaration"): listener.enterUsingForDeclaration(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUsingForDeclaration" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUsingForDeclaration"): listener.exitUsingForDeclaration(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUsingForDeclaration" ): + 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) + localctx = SolidityParser.UsingForDeclarationContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 34, self.RULE_usingForDeclaration) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 379 @@ -2474,7 +2916,31 @@ def usingForDeclaration(self): self.state = 382 self.match(SolidityParser.T__2) pass - elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__37, SolidityParser.T__43, SolidityParser.T__45, SolidityParser.T__49, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__94, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.GlobalKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier]: + elif token in [ + SolidityParser.T__13, + SolidityParser.T__24, + SolidityParser.T__37, + SolidityParser.T__43, + SolidityParser.T__45, + SolidityParser.T__49, + SolidityParser.T__61, + SolidityParser.T__62, + SolidityParser.T__63, + SolidityParser.T__64, + SolidityParser.T__65, + SolidityParser.T__94, + SolidityParser.Int, + SolidityParser.Uint, + SolidityParser.Byte, + SolidityParser.Fixed, + SolidityParser.Ufixed, + SolidityParser.LeaveKeyword, + SolidityParser.PayableKeyword, + SolidityParser.GlobalKeyword, + SolidityParser.ConstructorKeyword, + SolidityParser.ReceiveKeyword, + SolidityParser.Identifier, + ]: self.state = 383 self.typeName(0) pass @@ -2484,11 +2950,10 @@ def usingForDeclaration(self): self.state = 387 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.GlobalKeyword: + if _la == SolidityParser.GlobalKeyword: self.state = 386 self.match(SolidityParser.GlobalKeyword) - self.state = 389 self.match(SolidityParser.T__1) except RecognitionException as re: @@ -2499,54 +2964,67 @@ def usingForDeclaration(self): self.exitRule() return localctx - class UsingForObjectContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) + return self.getTypedRuleContext( + SolidityParser.UserDefinedTypeNameContext, 0 + ) - - def usingForObjectDirective(self, i:int=None): + def usingForObjectDirective(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.UsingForObjectDirectiveContext) + return self.getTypedRuleContexts( + SolidityParser.UsingForObjectDirectiveContext + ) else: - return self.getTypedRuleContext(SolidityParser.UsingForObjectDirectiveContext,i) - + return self.getTypedRuleContext( + SolidityParser.UsingForObjectDirectiveContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_usingForObject - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUsingForObject" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUsingForObject"): listener.enterUsingForObject(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUsingForObject" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUsingForObject"): listener.exitUsingForObject(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUsingForObject" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUsingForObject"): return visitor.visitUsingForObject(self) else: return visitor.visitChildren(self) - - - def usingForObject(self): - localctx = SolidityParser.UsingForObjectContext(self, self._ctx, self.state) self.enterRule(localctx, 36, self.RULE_usingForObject) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 403 self._errHandler.sync(self) token = self._input.LA(1) - if token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__43, SolidityParser.T__49, SolidityParser.T__61, SolidityParser.T__94, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.GlobalKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier]: + if token in [ + SolidityParser.T__13, + SolidityParser.T__24, + SolidityParser.T__43, + SolidityParser.T__49, + SolidityParser.T__61, + SolidityParser.T__94, + SolidityParser.LeaveKeyword, + SolidityParser.PayableKeyword, + SolidityParser.GlobalKeyword, + SolidityParser.ConstructorKeyword, + SolidityParser.ReceiveKeyword, + SolidityParser.Identifier, + ]: self.enterOuterAlt(localctx, 1) self.state = 391 self.userDefinedTypeName() @@ -2560,7 +3038,7 @@ def usingForObject(self): self.state = 398 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 394 self.match(SolidityParser.T__15) self.state = 395 @@ -2583,46 +3061,46 @@ def usingForObject(self): self.exitRule() return localctx - class UsingForObjectDirectiveContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext( + SolidityParser.UserDefinedTypeNameContext, 0 + ) def userDefinableOperators(self): - return self.getTypedRuleContext(SolidityParser.UserDefinableOperatorsContext,0) - + return self.getTypedRuleContext( + SolidityParser.UserDefinableOperatorsContext, 0 + ) def getRuleIndex(self): return SolidityParser.RULE_usingForObjectDirective - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUsingForObjectDirective" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUsingForObjectDirective"): listener.enterUsingForObjectDirective(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUsingForObjectDirective" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUsingForObjectDirective"): listener.exitUsingForObjectDirective(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUsingForObjectDirective" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUsingForObjectDirective"): return visitor.visitUsingForObjectDirective(self) else: return visitor.visitChildren(self) - - - def usingForObjectDirective(self): - - localctx = SolidityParser.UsingForObjectDirectiveContext(self, self._ctx, self.state) + localctx = SolidityParser.UsingForObjectDirectiveContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 38, self.RULE_usingForObjectDirective) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 405 @@ -2630,13 +3108,12 @@ def usingForObjectDirective(self): self.state = 408 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__11: + if _la == SolidityParser.T__11: self.state = 406 self.match(SolidityParser.T__11) self.state = 407 self.userDefinableOperators() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2645,44 +3122,66 @@ def usingForObjectDirective(self): self.exitRule() return localctx - class UserDefinableOperatorsContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return SolidityParser.RULE_userDefinableOperators - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUserDefinableOperators" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUserDefinableOperators"): listener.enterUserDefinableOperators(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUserDefinableOperators" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUserDefinableOperators"): listener.exitUserDefinableOperators(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUserDefinableOperators" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUserDefinableOperators"): return visitor.visitUserDefinableOperators(self) else: return visitor.visitChildren(self) - - - def userDefinableOperators(self): - - localctx = SolidityParser.UserDefinableOperatorsContext(self, self._ctx, self.state) + localctx = SolidityParser.UserDefinableOperatorsContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 40, self.RULE_userDefinableOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 410 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9) | (1 << SolidityParser.T__27) | (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__34))) != 0)): + if not ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__2) + | (1 << SolidityParser.T__4) + | (1 << SolidityParser.T__5) + | (1 << SolidityParser.T__6) + | (1 << SolidityParser.T__7) + | (1 << SolidityParser.T__8) + | (1 << SolidityParser.T__9) + | (1 << SolidityParser.T__27) + | (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__34) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2695,49 +3194,47 @@ def userDefinableOperators(self): self.exitRule() return localctx - class StructDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) - - def variableDeclaration(self, i:int=None): + def variableDeclaration(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext) + return self.getTypedRuleContexts( + SolidityParser.VariableDeclarationContext + ) else: - return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i) - + return self.getTypedRuleContext( + SolidityParser.VariableDeclarationContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_structDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStructDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStructDefinition"): listener.enterStructDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStructDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStructDefinition"): listener.exitStructDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStructDefinition" ): + 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, 42, self.RULE_structDefinition) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 412 @@ -2749,7 +3246,46 @@ def structDefinition(self): self.state = 425 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & ((1 << (SolidityParser.T__13 - 14)) | (1 << (SolidityParser.T__24 - 14)) | (1 << (SolidityParser.T__37 - 14)) | (1 << (SolidityParser.T__43 - 14)) | (1 << (SolidityParser.T__45 - 14)) | (1 << (SolidityParser.T__49 - 14)) | (1 << (SolidityParser.T__61 - 14)) | (1 << (SolidityParser.T__62 - 14)) | (1 << (SolidityParser.T__63 - 14)) | (1 << (SolidityParser.T__64 - 14)) | (1 << (SolidityParser.T__65 - 14)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.Int - 95)) | (1 << (SolidityParser.Uint - 95)) | (1 << (SolidityParser.Byte - 95)) | (1 << (SolidityParser.Fixed - 95)) | (1 << (SolidityParser.Ufixed - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + (((_la - 14)) & ~0x3F) == 0 + and ( + (1 << (_la - 14)) + & ( + (1 << (SolidityParser.T__13 - 14)) + | (1 << (SolidityParser.T__24 - 14)) + | (1 << (SolidityParser.T__37 - 14)) + | (1 << (SolidityParser.T__43 - 14)) + | (1 << (SolidityParser.T__45 - 14)) + | (1 << (SolidityParser.T__49 - 14)) + | (1 << (SolidityParser.T__61 - 14)) + | (1 << (SolidityParser.T__62 - 14)) + | (1 << (SolidityParser.T__63 - 14)) + | (1 << (SolidityParser.T__64 - 14)) + | (1 << (SolidityParser.T__65 - 14)) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.Int - 95)) + | (1 << (SolidityParser.Uint - 95)) + | (1 << (SolidityParser.Byte - 95)) + | (1 << (SolidityParser.Fixed - 95)) + | (1 << (SolidityParser.Ufixed - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 415 self.variableDeclaration() self.state = 416 @@ -2757,7 +3293,46 @@ def structDefinition(self): self.state = 422 self._errHandler.sync(self) _la = self._input.LA(1) - while ((((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & ((1 << (SolidityParser.T__13 - 14)) | (1 << (SolidityParser.T__24 - 14)) | (1 << (SolidityParser.T__37 - 14)) | (1 << (SolidityParser.T__43 - 14)) | (1 << (SolidityParser.T__45 - 14)) | (1 << (SolidityParser.T__49 - 14)) | (1 << (SolidityParser.T__61 - 14)) | (1 << (SolidityParser.T__62 - 14)) | (1 << (SolidityParser.T__63 - 14)) | (1 << (SolidityParser.T__64 - 14)) | (1 << (SolidityParser.T__65 - 14)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.Int - 95)) | (1 << (SolidityParser.Uint - 95)) | (1 << (SolidityParser.Byte - 95)) | (1 << (SolidityParser.Fixed - 95)) | (1 << (SolidityParser.Ufixed - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + while ( + (((_la - 14)) & ~0x3F) == 0 + and ( + (1 << (_la - 14)) + & ( + (1 << (SolidityParser.T__13 - 14)) + | (1 << (SolidityParser.T__24 - 14)) + | (1 << (SolidityParser.T__37 - 14)) + | (1 << (SolidityParser.T__43 - 14)) + | (1 << (SolidityParser.T__45 - 14)) + | (1 << (SolidityParser.T__49 - 14)) + | (1 << (SolidityParser.T__61 - 14)) + | (1 << (SolidityParser.T__62 - 14)) + | (1 << (SolidityParser.T__63 - 14)) + | (1 << (SolidityParser.T__64 - 14)) + | (1 << (SolidityParser.T__65 - 14)) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.Int - 95)) + | (1 << (SolidityParser.Uint - 95)) + | (1 << (SolidityParser.Byte - 95)) + | (1 << (SolidityParser.Fixed - 95)) + | (1 << (SolidityParser.Ufixed - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 417 self.variableDeclaration() self.state = 418 @@ -2766,8 +3341,6 @@ def structDefinition(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 427 self.match(SolidityParser.T__16) except RecognitionException as re: @@ -2778,63 +3351,59 @@ def structDefinition(self): self.exitRule() return localctx - class ModifierDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def block(self): - return self.getTypedRuleContext(SolidityParser.BlockContext,0) - + return self.getTypedRuleContext(SolidityParser.BlockContext, 0) def parameterList(self): - return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) + return self.getTypedRuleContext(SolidityParser.ParameterListContext, 0) - - def VirtualKeyword(self, i:int=None): + def VirtualKeyword(self, i: int = None): if i is None: return self.getTokens(SolidityParser.VirtualKeyword) else: return self.getToken(SolidityParser.VirtualKeyword, i) - def overrideSpecifier(self, i:int=None): + def overrideSpecifier(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.OverrideSpecifierContext) + return self.getTypedRuleContexts( + SolidityParser.OverrideSpecifierContext + ) else: - return self.getTypedRuleContext(SolidityParser.OverrideSpecifierContext,i) - + return self.getTypedRuleContext( + SolidityParser.OverrideSpecifierContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_modifierDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterModifierDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterModifierDefinition"): listener.enterModifierDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitModifierDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitModifierDefinition"): listener.exitModifierDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitModifierDefinition" ): + 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, 44, self.RULE_modifierDefinition) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 429 @@ -2844,15 +3413,14 @@ def modifierDefinition(self): self.state = 432 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__22: + if _la == SolidityParser.T__22: self.state = 431 self.parameterList() - self.state = 438 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__95 or _la==SolidityParser.VirtualKeyword: + while _la == SolidityParser.T__95 or _la == SolidityParser.VirtualKeyword: self.state = 436 self._errHandler.sync(self) token = self._input.LA(1) @@ -2893,46 +3461,40 @@ def modifierDefinition(self): self.exitRule() return localctx - class ModifierInvocationContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def expressionList(self): - return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionListContext, 0) def getRuleIndex(self): return SolidityParser.RULE_modifierInvocation - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterModifierInvocation" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterModifierInvocation"): listener.enterModifierInvocation(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitModifierInvocation" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitModifierInvocation"): listener.exitModifierInvocation(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitModifierInvocation" ): + 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, 46, self.RULE_modifierInvocation) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 445 @@ -2940,21 +3502,74 @@ def modifierInvocation(self): self.state = 451 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__22: + if _la == SolidityParser.T__22: self.state = 446 self.match(SolidityParser.T__22) self.state = 448 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 447 self.expressionList() - self.state = 450 self.match(SolidityParser.T__23) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2963,58 +3578,49 @@ def modifierInvocation(self): self.exitRule() return localctx - class FunctionDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def functionDescriptor(self): - return self.getTypedRuleContext(SolidityParser.FunctionDescriptorContext,0) - + return self.getTypedRuleContext(SolidityParser.FunctionDescriptorContext, 0) def parameterList(self): - return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) - + return self.getTypedRuleContext(SolidityParser.ParameterListContext, 0) def modifierList(self): - return self.getTypedRuleContext(SolidityParser.ModifierListContext,0) - + return self.getTypedRuleContext(SolidityParser.ModifierListContext, 0) def block(self): - return self.getTypedRuleContext(SolidityParser.BlockContext,0) - + return self.getTypedRuleContext(SolidityParser.BlockContext, 0) def returnParameters(self): - return self.getTypedRuleContext(SolidityParser.ReturnParametersContext,0) - + return self.getTypedRuleContext(SolidityParser.ReturnParametersContext, 0) def getRuleIndex(self): return SolidityParser.RULE_functionDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunctionDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunctionDefinition"): listener.enterFunctionDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunctionDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunctionDefinition"): listener.exitFunctionDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunctionDefinition" ): + 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, 48, self.RULE_functionDefinition) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 453 @@ -3026,11 +3632,10 @@ def functionDefinition(self): self.state = 457 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__38: + if _la == SolidityParser.T__38: self.state = 456 self.returnParameters() - self.state = 461 self._errHandler.sync(self) token = self._input.LA(1) @@ -3053,16 +3658,15 @@ def functionDefinition(self): self.exitRule() return localctx - class FunctionDescriptorContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def ConstructorKeyword(self): return self.getToken(SolidityParser.ConstructorKeyword, 0) @@ -3076,28 +3680,24 @@ def ReceiveKeyword(self): def getRuleIndex(self): return SolidityParser.RULE_functionDescriptor - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunctionDescriptor" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunctionDescriptor"): listener.enterFunctionDescriptor(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunctionDescriptor" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunctionDescriptor"): listener.exitFunctionDescriptor(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunctionDescriptor" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFunctionDescriptor"): return visitor.visitFunctionDescriptor(self) else: return visitor.visitChildren(self) - - - def functionDescriptor(self): - localctx = SolidityParser.FunctionDescriptorContext(self, self._ctx, self.state) self.enterRule(localctx, 50, self.RULE_functionDescriptor) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 470 self._errHandler.sync(self) @@ -3109,11 +3709,38 @@ def functionDescriptor(self): self.state = 465 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 464 self.identifier() - pass elif token in [SolidityParser.ConstructorKeyword]: self.enterOuterAlt(localctx, 2) @@ -3141,39 +3768,34 @@ def functionDescriptor(self): self.exitRule() return localctx - class ReturnParametersContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.ParameterListContext, 0) def getRuleIndex(self): return SolidityParser.RULE_returnParameters - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterReturnParameters" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterReturnParameters"): listener.enterReturnParameters(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitReturnParameters" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitReturnParameters"): listener.exitReturnParameters(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitReturnParameters" ): + 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, 52, self.RULE_returnParameters) try: @@ -3190,98 +3812,138 @@ def returnParameters(self): self.exitRule() return localctx - class ModifierListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def ExternalKeyword(self, i:int=None): + 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): + 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): + 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): + def PrivateKeyword(self, i: int = None): if i is None: return self.getTokens(SolidityParser.PrivateKeyword) else: return self.getToken(SolidityParser.PrivateKeyword, i) - def VirtualKeyword(self, i:int=None): + def VirtualKeyword(self, i: int = None): if i is None: return self.getTokens(SolidityParser.VirtualKeyword) else: return self.getToken(SolidityParser.VirtualKeyword, i) - def stateMutability(self, i:int=None): + def stateMutability(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext) else: - return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i) - + return self.getTypedRuleContext( + SolidityParser.StateMutabilityContext, i + ) - def modifierInvocation(self, i:int=None): + def modifierInvocation(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.ModifierInvocationContext) + return self.getTypedRuleContexts( + SolidityParser.ModifierInvocationContext + ) else: - return self.getTypedRuleContext(SolidityParser.ModifierInvocationContext,i) + return self.getTypedRuleContext( + SolidityParser.ModifierInvocationContext, i + ) - - def overrideSpecifier(self, i:int=None): + def overrideSpecifier(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.OverrideSpecifierContext) + return self.getTypedRuleContexts( + SolidityParser.OverrideSpecifierContext + ) else: - return self.getTypedRuleContext(SolidityParser.OverrideSpecifierContext,i) - + return self.getTypedRuleContext( + SolidityParser.OverrideSpecifierContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_modifierList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterModifierList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterModifierList"): listener.enterModifierList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitModifierList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitModifierList"): listener.exitModifierList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitModifierList" ): + 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, 54, self.RULE_modifierList) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 485 self._errHandler.sync(self) _la = self._input.LA(1) - while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.T__95 - 95)) | (1 << (SolidityParser.ConstantKeyword - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.ExternalKeyword - 95)) | (1 << (SolidityParser.InternalKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.PrivateKeyword - 95)) | (1 << (SolidityParser.PublicKeyword - 95)) | (1 << (SolidityParser.VirtualKeyword - 95)) | (1 << (SolidityParser.PureKeyword - 95)) | (1 << (SolidityParser.ViewKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + while ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.T__95 - 95)) + | (1 << (SolidityParser.ConstantKeyword - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.ExternalKeyword - 95)) + | (1 << (SolidityParser.InternalKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.PrivateKeyword - 95)) + | (1 << (SolidityParser.PublicKeyword - 95)) + | (1 << (SolidityParser.VirtualKeyword - 95)) + | (1 << (SolidityParser.PureKeyword - 95)) + | (1 << (SolidityParser.ViewKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 483 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,41,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 41, self._ctx) if la_ == 1: self.state = 475 self.match(SolidityParser.ExternalKeyword) @@ -3322,7 +3984,6 @@ def modifierList(self): self.overrideSpecifier() pass - self.state = 487 self._errHandler.sync(self) _la = self._input.LA(1) @@ -3335,20 +3996,18 @@ def modifierList(self): self.exitRule() return localctx - class EventDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def eventParameterList(self): - return self.getTypedRuleContext(SolidityParser.EventParameterListContext,0) - + return self.getTypedRuleContext(SolidityParser.EventParameterListContext, 0) def AnonymousKeyword(self): return self.getToken(SolidityParser.AnonymousKeyword, 0) @@ -3356,28 +4015,24 @@ def AnonymousKeyword(self): def getRuleIndex(self): return SolidityParser.RULE_eventDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEventDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEventDefinition"): listener.enterEventDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEventDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEventDefinition"): listener.exitEventDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitEventDefinition" ): + 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, 56, self.RULE_eventDefinition) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 488 @@ -3389,11 +4044,10 @@ def eventDefinition(self): self.state = 492 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.AnonymousKeyword: + if _la == SolidityParser.AnonymousKeyword: self.state = 491 self.match(SolidityParser.AnonymousKeyword) - self.state = 494 self.match(SolidityParser.T__1) except RecognitionException as re: @@ -3404,39 +4058,34 @@ def eventDefinition(self): self.exitRule() return localctx - class EnumValueContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def getRuleIndex(self): return SolidityParser.RULE_enumValue - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEnumValue" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEnumValue"): listener.enterEnumValue(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEnumValue" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEnumValue"): listener.exitEnumValue(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitEnumValue" ): + 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, 58, self.RULE_enumValue) try: @@ -3451,49 +4100,43 @@ def enumValue(self): self.exitRule() return localctx - class EnumDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) - - def enumValue(self, i:int=None): + def enumValue(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.EnumValueContext) else: - return self.getTypedRuleContext(SolidityParser.EnumValueContext,i) - + return self.getTypedRuleContext(SolidityParser.EnumValueContext, i) def getRuleIndex(self): return SolidityParser.RULE_enumDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEnumDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEnumDefinition"): listener.enterEnumDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEnumDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEnumDefinition"): listener.exitEnumDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitEnumDefinition" ): + 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, 60, self.RULE_enumDefinition) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 498 @@ -3505,15 +4148,42 @@ def enumDefinition(self): self.state = 502 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 501 self.enumValue() - self.state = 508 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 504 self.match(SolidityParser.T__15) self.state = 505 @@ -3532,45 +4202,40 @@ def enumDefinition(self): self.exitRule() return localctx - class ParameterListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def parameter(self, i:int=None): + def parameter(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.ParameterContext) else: - return self.getTypedRuleContext(SolidityParser.ParameterContext,i) - + return self.getTypedRuleContext(SolidityParser.ParameterContext, i) def getRuleIndex(self): return SolidityParser.RULE_parameterList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParameterList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterParameterList"): listener.enterParameterList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParameterList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitParameterList"): listener.exitParameterList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitParameterList" ): + 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, 62, self.RULE_parameterList) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 513 @@ -3578,13 +4243,52 @@ def parameterList(self): self.state = 522 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & ((1 << (SolidityParser.T__13 - 14)) | (1 << (SolidityParser.T__24 - 14)) | (1 << (SolidityParser.T__37 - 14)) | (1 << (SolidityParser.T__43 - 14)) | (1 << (SolidityParser.T__45 - 14)) | (1 << (SolidityParser.T__49 - 14)) | (1 << (SolidityParser.T__61 - 14)) | (1 << (SolidityParser.T__62 - 14)) | (1 << (SolidityParser.T__63 - 14)) | (1 << (SolidityParser.T__64 - 14)) | (1 << (SolidityParser.T__65 - 14)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.Int - 95)) | (1 << (SolidityParser.Uint - 95)) | (1 << (SolidityParser.Byte - 95)) | (1 << (SolidityParser.Fixed - 95)) | (1 << (SolidityParser.Ufixed - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + (((_la - 14)) & ~0x3F) == 0 + and ( + (1 << (_la - 14)) + & ( + (1 << (SolidityParser.T__13 - 14)) + | (1 << (SolidityParser.T__24 - 14)) + | (1 << (SolidityParser.T__37 - 14)) + | (1 << (SolidityParser.T__43 - 14)) + | (1 << (SolidityParser.T__45 - 14)) + | (1 << (SolidityParser.T__49 - 14)) + | (1 << (SolidityParser.T__61 - 14)) + | (1 << (SolidityParser.T__62 - 14)) + | (1 << (SolidityParser.T__63 - 14)) + | (1 << (SolidityParser.T__64 - 14)) + | (1 << (SolidityParser.T__65 - 14)) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.Int - 95)) + | (1 << (SolidityParser.Uint - 95)) + | (1 << (SolidityParser.Byte - 95)) + | (1 << (SolidityParser.Fixed - 95)) + | (1 << (SolidityParser.Ufixed - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 514 self.parameter() self.state = 519 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 515 self.match(SolidityParser.T__15) self.state = 516 @@ -3593,8 +4297,6 @@ def parameterList(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 524 self.match(SolidityParser.T__23) except RecognitionException as re: @@ -3605,70 +4307,89 @@ def parameterList(self): self.exitRule() return localctx - class ParameterContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def storageLocation(self): - return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0) - + return self.getTypedRuleContext(SolidityParser.StorageLocationContext, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def getRuleIndex(self): return SolidityParser.RULE_parameter - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParameter" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterParameter"): listener.enterParameter(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParameter" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitParameter"): listener.exitParameter(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitParameter" ): + 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, 64, self.RULE_parameter) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 526 self.typeName(0) self.state = 528 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,48,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 48, self._ctx) if la_ == 1: self.state = 527 self.storageLocation() - self.state = 531 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 530 self.identifier() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3677,45 +4398,40 @@ def parameter(self): self.exitRule() return localctx - class EventParameterListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def eventParameter(self, i:int=None): + def eventParameter(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.EventParameterContext) else: - return self.getTypedRuleContext(SolidityParser.EventParameterContext,i) - + return self.getTypedRuleContext(SolidityParser.EventParameterContext, i) def getRuleIndex(self): return SolidityParser.RULE_eventParameterList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEventParameterList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEventParameterList"): listener.enterEventParameterList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEventParameterList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEventParameterList"): listener.exitEventParameterList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitEventParameterList" ): + 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, 66, self.RULE_eventParameterList) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 533 @@ -3723,13 +4439,52 @@ def eventParameterList(self): self.state = 542 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & ((1 << (SolidityParser.T__13 - 14)) | (1 << (SolidityParser.T__24 - 14)) | (1 << (SolidityParser.T__37 - 14)) | (1 << (SolidityParser.T__43 - 14)) | (1 << (SolidityParser.T__45 - 14)) | (1 << (SolidityParser.T__49 - 14)) | (1 << (SolidityParser.T__61 - 14)) | (1 << (SolidityParser.T__62 - 14)) | (1 << (SolidityParser.T__63 - 14)) | (1 << (SolidityParser.T__64 - 14)) | (1 << (SolidityParser.T__65 - 14)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.Int - 95)) | (1 << (SolidityParser.Uint - 95)) | (1 << (SolidityParser.Byte - 95)) | (1 << (SolidityParser.Fixed - 95)) | (1 << (SolidityParser.Ufixed - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + (((_la - 14)) & ~0x3F) == 0 + and ( + (1 << (_la - 14)) + & ( + (1 << (SolidityParser.T__13 - 14)) + | (1 << (SolidityParser.T__24 - 14)) + | (1 << (SolidityParser.T__37 - 14)) + | (1 << (SolidityParser.T__43 - 14)) + | (1 << (SolidityParser.T__45 - 14)) + | (1 << (SolidityParser.T__49 - 14)) + | (1 << (SolidityParser.T__61 - 14)) + | (1 << (SolidityParser.T__62 - 14)) + | (1 << (SolidityParser.T__63 - 14)) + | (1 << (SolidityParser.T__64 - 14)) + | (1 << (SolidityParser.T__65 - 14)) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.Int - 95)) + | (1 << (SolidityParser.Uint - 95)) + | (1 << (SolidityParser.Byte - 95)) + | (1 << (SolidityParser.Fixed - 95)) + | (1 << (SolidityParser.Ufixed - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 534 self.eventParameter() self.state = 539 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 535 self.match(SolidityParser.T__15) self.state = 536 @@ -3738,8 +4493,6 @@ def eventParameterList(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 544 self.match(SolidityParser.T__23) except RecognitionException as re: @@ -3750,49 +4503,43 @@ def eventParameterList(self): self.exitRule() return localctx - class EventParameterContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def IndexedKeyword(self): return self.getToken(SolidityParser.IndexedKeyword, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def getRuleIndex(self): return SolidityParser.RULE_eventParameter - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEventParameter" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEventParameter"): listener.enterEventParameter(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEventParameter" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEventParameter"): listener.exitEventParameter(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitEventParameter" ): + 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, 68, self.RULE_eventParameter) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 546 @@ -3800,19 +4547,45 @@ def eventParameter(self): self.state = 548 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.IndexedKeyword: + if _la == SolidityParser.IndexedKeyword: self.state = 547 self.match(SolidityParser.IndexedKeyword) - self.state = 551 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 550 self.identifier() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3821,45 +4594,46 @@ def eventParameter(self): self.exitRule() return localctx - class FunctionTypeParameterListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def functionTypeParameter(self, i:int=None): + def functionTypeParameter(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterContext) + return self.getTypedRuleContexts( + SolidityParser.FunctionTypeParameterContext + ) else: - return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterContext,i) - + return self.getTypedRuleContext( + SolidityParser.FunctionTypeParameterContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_functionTypeParameterList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunctionTypeParameterList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunctionTypeParameterList"): listener.enterFunctionTypeParameterList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunctionTypeParameterList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunctionTypeParameterList"): listener.exitFunctionTypeParameterList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunctionTypeParameterList" ): + 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) + localctx = SolidityParser.FunctionTypeParameterListContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 70, self.RULE_functionTypeParameterList) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 553 @@ -3867,13 +4641,52 @@ def functionTypeParameterList(self): self.state = 562 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & ((1 << (SolidityParser.T__13 - 14)) | (1 << (SolidityParser.T__24 - 14)) | (1 << (SolidityParser.T__37 - 14)) | (1 << (SolidityParser.T__43 - 14)) | (1 << (SolidityParser.T__45 - 14)) | (1 << (SolidityParser.T__49 - 14)) | (1 << (SolidityParser.T__61 - 14)) | (1 << (SolidityParser.T__62 - 14)) | (1 << (SolidityParser.T__63 - 14)) | (1 << (SolidityParser.T__64 - 14)) | (1 << (SolidityParser.T__65 - 14)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.Int - 95)) | (1 << (SolidityParser.Uint - 95)) | (1 << (SolidityParser.Byte - 95)) | (1 << (SolidityParser.Fixed - 95)) | (1 << (SolidityParser.Ufixed - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + (((_la - 14)) & ~0x3F) == 0 + and ( + (1 << (_la - 14)) + & ( + (1 << (SolidityParser.T__13 - 14)) + | (1 << (SolidityParser.T__24 - 14)) + | (1 << (SolidityParser.T__37 - 14)) + | (1 << (SolidityParser.T__43 - 14)) + | (1 << (SolidityParser.T__45 - 14)) + | (1 << (SolidityParser.T__49 - 14)) + | (1 << (SolidityParser.T__61 - 14)) + | (1 << (SolidityParser.T__62 - 14)) + | (1 << (SolidityParser.T__63 - 14)) + | (1 << (SolidityParser.T__64 - 14)) + | (1 << (SolidityParser.T__65 - 14)) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.Int - 95)) + | (1 << (SolidityParser.Uint - 95)) + | (1 << (SolidityParser.Byte - 95)) + | (1 << (SolidityParser.Fixed - 95)) + | (1 << (SolidityParser.Ufixed - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 554 self.functionTypeParameter() self.state = 559 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 555 self.match(SolidityParser.T__15) self.state = 556 @@ -3882,8 +4695,6 @@ def functionTypeParameterList(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 564 self.match(SolidityParser.T__23) except RecognitionException as re: @@ -3894,46 +4705,42 @@ def functionTypeParameterList(self): self.exitRule() return localctx - class FunctionTypeParameterContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def storageLocation(self): - return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0) - + return self.getTypedRuleContext(SolidityParser.StorageLocationContext, 0) def getRuleIndex(self): return SolidityParser.RULE_functionTypeParameter - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunctionTypeParameter" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunctionTypeParameter"): listener.enterFunctionTypeParameter(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunctionTypeParameter" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunctionTypeParameter"): listener.exitFunctionTypeParameter(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunctionTypeParameter" ): + 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) + localctx = SolidityParser.FunctionTypeParameterContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 72, self.RULE_functionTypeParameter) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 566 @@ -3941,11 +4748,17 @@ def functionTypeParameter(self): self.state = 568 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__47) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49))) != 0): + if ((_la) & ~0x3F) == 0 and ( + (1 << _la) + & ( + (1 << SolidityParser.T__47) + | (1 << SolidityParser.T__48) + | (1 << SolidityParser.T__49) + ) + ) != 0: self.state = 567 self.storageLocation() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3954,48 +4767,43 @@ def functionTypeParameter(self): self.exitRule() return localctx - class VariableDeclarationContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def storageLocation(self): - return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0) - + return self.getTypedRuleContext(SolidityParser.StorageLocationContext, 0) def getRuleIndex(self): return SolidityParser.RULE_variableDeclaration - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVariableDeclaration" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVariableDeclaration"): listener.enterVariableDeclaration(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVariableDeclaration" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVariableDeclaration"): listener.exitVariableDeclaration(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVariableDeclaration" ): + 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) + localctx = SolidityParser.VariableDeclarationContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 74, self.RULE_variableDeclaration) try: self.enterOuterAlt(localctx, 1) @@ -4003,12 +4811,11 @@ def variableDeclaration(self): self.typeName(0) self.state = 572 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,57,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 57, self._ctx) if la_ == 1: self.state = 571 self.storageLocation() - self.state = 574 self.identifier() except RecognitionException as re: @@ -4019,72 +4826,66 @@ def variableDeclaration(self): self.exitRule() return localctx - class TypeNameContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext, 0) def userDefinedTypeName(self): - return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0) - + return self.getTypedRuleContext( + SolidityParser.UserDefinedTypeNameContext, 0 + ) def mapping(self): - return self.getTypedRuleContext(SolidityParser.MappingContext,0) - + return self.getTypedRuleContext(SolidityParser.MappingContext, 0) def functionTypeName(self): - return self.getTypedRuleContext(SolidityParser.FunctionTypeNameContext,0) - + return self.getTypedRuleContext(SolidityParser.FunctionTypeNameContext, 0) def PayableKeyword(self): return self.getToken(SolidityParser.PayableKeyword, 0) def typeName(self): - return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def expression(self): - return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_typeName - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTypeName" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTypeName"): listener.enterTypeName(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTypeName" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTypeName"): listener.exitTypeName(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTypeName" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTypeName"): return visitor.visitTypeName(self) else: return visitor.visitChildren(self) - - - def typeName(self, _p:int=0): + def typeName(self, _p: int = 0): _parentctx = self._ctx _parentState = self.state localctx = SolidityParser.TypeNameContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 76 self.enterRecursionRule(localctx, 76, self.RULE_typeName, _p) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 583 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,58,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 58, self._ctx) if la_ == 1: self.state = 577 self.elementaryTypeName() @@ -4112,37 +4913,97 @@ def typeName(self, _p:int=0): self.match(SolidityParser.PayableKeyword) pass - self._ctx.stop = self._input.LT(-1) self.state = 593 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: + _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) + localctx = SolidityParser.TypeNameContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_typeName + ) self.state = 585 if not self.precpred(self._ctx, 3): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 3)" + ) self.state = 586 self.match(SolidityParser.T__41) self.state = 588 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 587 self.expression(0) - self.state = 590 - self.match(SolidityParser.T__42) + self.match(SolidityParser.T__42) self.state = 595 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,60,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 60, self._ctx) except RecognitionException as re: localctx.exception = re @@ -4152,43 +5013,40 @@ def typeName(self, _p:int=0): self.unrollRecursionContexts(_parentctx) return localctx - class UserDefinedTypeNameContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def identifier(self, i:int=None): + def identifier(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.IdentifierContext) else: - return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, i) def getRuleIndex(self): return SolidityParser.RULE_userDefinedTypeName - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUserDefinedTypeName" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUserDefinedTypeName"): listener.enterUserDefinedTypeName(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUserDefinedTypeName" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUserDefinedTypeName"): listener.exitUserDefinedTypeName(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUserDefinedTypeName" ): + 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) + localctx = SolidityParser.UserDefinedTypeNameContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 78, self.RULE_userDefinedTypeName) try: self.enterOuterAlt(localctx, 1) @@ -4196,16 +5054,16 @@ def userDefinedTypeName(self): self.identifier() self.state = 601 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: + _alt = self._interp.adaptivePredict(self._input, 61, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: self.state = 597 self.match(SolidityParser.T__44) self.state = 598 - self.identifier() + self.identifier() self.state = 603 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,61,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 61, self._ctx) except RecognitionException as re: localctx.exception = re @@ -4215,49 +5073,45 @@ def userDefinedTypeName(self): self.exitRule() return localctx - class MappingKeyContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext, 0) def userDefinedTypeName(self): - return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0) - + return self.getTypedRuleContext( + SolidityParser.UserDefinedTypeNameContext, 0 + ) def getRuleIndex(self): return SolidityParser.RULE_mappingKey - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMappingKey" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMappingKey"): listener.enterMappingKey(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMappingKey" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMappingKey"): listener.exitMappingKey(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMappingKey" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMappingKey"): return visitor.visitMappingKey(self) else: return visitor.visitChildren(self) - - - def mappingKey(self): - localctx = SolidityParser.MappingKeyContext(self, self._ctx, self.state) self.enterRule(localctx, 80, self.RULE_mappingKey) try: self.state = 606 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,62,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 62, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 604 @@ -4270,7 +5124,6 @@ def mappingKey(self): self.userDefinedTypeName() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4279,54 +5132,46 @@ def mappingKey(self): self.exitRule() return localctx - class MappingContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def mappingKey(self): - return self.getTypedRuleContext(SolidityParser.MappingKeyContext,0) - + return self.getTypedRuleContext(SolidityParser.MappingKeyContext, 0) def typeName(self): - return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def mappingKeyName(self): - return self.getTypedRuleContext(SolidityParser.MappingKeyNameContext,0) - + return self.getTypedRuleContext(SolidityParser.MappingKeyNameContext, 0) def mappingValueName(self): - return self.getTypedRuleContext(SolidityParser.MappingValueNameContext,0) - + return self.getTypedRuleContext(SolidityParser.MappingValueNameContext, 0) def getRuleIndex(self): return SolidityParser.RULE_mapping - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMapping" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMapping"): listener.enterMapping(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMapping" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMapping"): listener.exitMapping(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMapping" ): + 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, 82, self.RULE_mapping) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 608 @@ -4338,11 +5183,38 @@ def mapping(self): self.state = 612 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 611 self.mappingKeyName() - self.state = 614 self.match(SolidityParser.T__46) self.state = 615 @@ -4350,11 +5222,38 @@ def mapping(self): self.state = 617 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 616 self.mappingValueName() - self.state = 619 self.match(SolidityParser.T__23) except RecognitionException as re: @@ -4365,39 +5264,34 @@ def mapping(self): self.exitRule() return localctx - class MappingKeyNameContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def getRuleIndex(self): return SolidityParser.RULE_mappingKeyName - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMappingKeyName" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMappingKeyName"): listener.enterMappingKeyName(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMappingKeyName" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMappingKeyName"): listener.exitMappingKeyName(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMappingKeyName" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMappingKeyName"): return visitor.visitMappingKeyName(self) else: return visitor.visitChildren(self) - - - def mappingKeyName(self): - localctx = SolidityParser.MappingKeyNameContext(self, self._ctx, self.state) self.enterRule(localctx, 84, self.RULE_mappingKeyName) try: @@ -4412,39 +5306,34 @@ def mappingKeyName(self): self.exitRule() return localctx - class MappingValueNameContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def getRuleIndex(self): return SolidityParser.RULE_mappingValueName - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMappingValueName" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMappingValueName"): listener.enterMappingValueName(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMappingValueName" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMappingValueName"): listener.exitMappingValueName(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMappingValueName" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMappingValueName"): return visitor.visitMappingValueName(self) else: return visitor.visitChildren(self) - - - def mappingValueName(self): - localctx = SolidityParser.MappingValueNameContext(self, self._ctx, self.state) self.enterRule(localctx, 86, self.RULE_mappingValueName) try: @@ -4459,61 +5348,61 @@ def mappingValueName(self): self.exitRule() return localctx - class FunctionTypeNameContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def functionTypeParameterList(self, i:int=None): + def functionTypeParameterList(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterListContext) + return self.getTypedRuleContexts( + SolidityParser.FunctionTypeParameterListContext + ) else: - return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterListContext,i) - + return self.getTypedRuleContext( + SolidityParser.FunctionTypeParameterListContext, i + ) - def InternalKeyword(self, i:int=None): + 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): + 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): + def stateMutability(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext) else: - return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i) - + return self.getTypedRuleContext( + SolidityParser.StateMutabilityContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_functionTypeName - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunctionTypeName" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunctionTypeName"): listener.enterFunctionTypeName(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunctionTypeName" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunctionTypeName"): listener.exitFunctionTypeName(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunctionTypeName" ): + 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, 88, self.RULE_functionTypeName) try: @@ -4524,9 +5413,9 @@ def functionTypeName(self): self.functionTypeParameterList() self.state = 632 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,66,self._ctx) - while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: - if _alt==1: + _alt = self._interp.adaptivePredict(self._input, 66, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: self.state = 630 self._errHandler.sync(self) token = self._input.LA(1) @@ -4538,27 +5427,31 @@ def functionTypeName(self): self.state = 628 self.match(SolidityParser.ExternalKeyword) pass - elif token in [SolidityParser.ConstantKeyword, SolidityParser.PayableKeyword, SolidityParser.PureKeyword, SolidityParser.ViewKeyword]: + elif token in [ + SolidityParser.ConstantKeyword, + SolidityParser.PayableKeyword, + SolidityParser.PureKeyword, + SolidityParser.ViewKeyword, + ]: self.state = 629 self.stateMutability() pass else: raise NoViableAltException(self) - + self.state = 634 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,66,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 66, self._ctx) self.state = 637 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,67,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 67, self._ctx) if la_ == 1: self.state = 635 self.match(SolidityParser.T__38) self.state = 636 self.functionTypeParameterList() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4567,44 +5460,52 @@ def functionTypeName(self): self.exitRule() return localctx - class StorageLocationContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStorageLocation"): listener.enterStorageLocation(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStorageLocation" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStorageLocation"): listener.exitStorageLocation(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStorageLocation" ): + 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, 90, self.RULE_storageLocation) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 639 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__47) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49))) != 0)): + if not ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__47) + | (1 << SolidityParser.T__48) + | (1 << SolidityParser.T__49) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4617,10 +5518,10 @@ def storageLocation(self): self.exitRule() return localctx - class StateMutabilityContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -4639,33 +5540,43 @@ def PayableKeyword(self): def getRuleIndex(self): return SolidityParser.RULE_stateMutability - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStateMutability" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStateMutability"): listener.enterStateMutability(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStateMutability" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStateMutability"): listener.exitStateMutability(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStateMutability" ): + 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, 92, self.RULE_stateMutability) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 641 _la = self._input.LA(1) - if not(((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & ((1 << (SolidityParser.ConstantKeyword - 110)) | (1 << (SolidityParser.PayableKeyword - 110)) | (1 << (SolidityParser.PureKeyword - 110)) | (1 << (SolidityParser.ViewKeyword - 110)))) != 0)): + if not ( + ( + (((_la - 110)) & ~0x3F) == 0 + and ( + (1 << (_la - 110)) + & ( + (1 << (SolidityParser.ConstantKeyword - 110)) + | (1 << (SolidityParser.PayableKeyword - 110)) + | (1 << (SolidityParser.PureKeyword - 110)) + | (1 << (SolidityParser.ViewKeyword - 110)) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4678,45 +5589,40 @@ def stateMutability(self): self.exitRule() return localctx - class BlockContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def statement(self, i:int=None): + def statement(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.StatementContext) else: - return self.getTypedRuleContext(SolidityParser.StatementContext,i) - + return self.getTypedRuleContext(SolidityParser.StatementContext, i) def getRuleIndex(self): return SolidityParser.RULE_block - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBlock" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBlock"): listener.enterBlock(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBlock" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBlock"): listener.exitBlock(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBlock" ): + 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, 94, self.RULE_block) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 643 @@ -4724,7 +5630,75 @@ def block(self): self.state = 647 self._errHandler.sync(self) _la = self._input.LA(1) - while ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__14 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__26 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__50 - 6)) | (1 << (SolidityParser.T__52 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.BreakKeyword - 71)) | (1 << (SolidityParser.ContinueKeyword - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + while ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__14 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__26 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__50 - 6)) + | (1 << (SolidityParser.T__52 - 6)) + | (1 << (SolidityParser.T__54 - 6)) + | (1 << (SolidityParser.T__55 - 6)) + | (1 << (SolidityParser.T__56 - 6)) + | (1 << (SolidityParser.T__57 - 6)) + | (1 << (SolidityParser.T__58 - 6)) + | (1 << (SolidityParser.T__59 - 6)) + | (1 << (SolidityParser.T__60 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.BreakKeyword - 71)) + | (1 << (SolidityParser.ContinueKeyword - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 644 self.statement() self.state = 649 @@ -4741,101 +5715,84 @@ def block(self): self.exitRule() return localctx - class StatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IfStatementContext, 0) def tryStatement(self): - return self.getTypedRuleContext(SolidityParser.TryStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.TryStatementContext, 0) def whileStatement(self): - return self.getTypedRuleContext(SolidityParser.WhileStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.WhileStatementContext, 0) def forStatement(self): - return self.getTypedRuleContext(SolidityParser.ForStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.ForStatementContext, 0) def block(self): - return self.getTypedRuleContext(SolidityParser.BlockContext,0) - + return self.getTypedRuleContext(SolidityParser.BlockContext, 0) def inlineAssemblyStatement(self): - return self.getTypedRuleContext(SolidityParser.InlineAssemblyStatementContext,0) - + return self.getTypedRuleContext( + SolidityParser.InlineAssemblyStatementContext, 0 + ) def doWhileStatement(self): - return self.getTypedRuleContext(SolidityParser.DoWhileStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.DoWhileStatementContext, 0) def continueStatement(self): - return self.getTypedRuleContext(SolidityParser.ContinueStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.ContinueStatementContext, 0) def breakStatement(self): - return self.getTypedRuleContext(SolidityParser.BreakStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.BreakStatementContext, 0) def returnStatement(self): - return self.getTypedRuleContext(SolidityParser.ReturnStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.ReturnStatementContext, 0) def throwStatement(self): - return self.getTypedRuleContext(SolidityParser.ThrowStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.ThrowStatementContext, 0) def emitStatement(self): - return self.getTypedRuleContext(SolidityParser.EmitStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.EmitStatementContext, 0) def simpleStatement(self): - return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.SimpleStatementContext, 0) def uncheckedStatement(self): - return self.getTypedRuleContext(SolidityParser.UncheckedStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.UncheckedStatementContext, 0) def revertStatement(self): - return self.getTypedRuleContext(SolidityParser.RevertStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.RevertStatementContext, 0) def getRuleIndex(self): return SolidityParser.RULE_statement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStatement"): listener.enterStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStatement"): listener.exitStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStatement" ): + 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, 96, self.RULE_statement) try: self.state = 667 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,69,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 69, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 652 @@ -4926,7 +5883,6 @@ def statement(self): self.revertStatement() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4935,40 +5891,37 @@ def statement(self): self.exitRule() return localctx - class ExpressionStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_expressionStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterExpressionStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterExpressionStatement"): listener.enterExpressionStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitExpressionStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitExpressionStatement"): listener.exitExpressionStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitExpressionStatement" ): + 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) + localctx = SolidityParser.ExpressionStatementContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 98, self.RULE_expressionStatement) try: self.enterOuterAlt(localctx, 1) @@ -4984,46 +5937,40 @@ def expressionStatement(self): self.exitRule() return localctx - class IfStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) - def statement(self, i:int=None): + def statement(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.StatementContext) else: - return self.getTypedRuleContext(SolidityParser.StatementContext,i) - + return self.getTypedRuleContext(SolidityParser.StatementContext, i) def getRuleIndex(self): return SolidityParser.RULE_ifStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIfStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIfStatement"): listener.enterIfStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIfStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIfStatement"): listener.exitIfStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIfStatement" ): + 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, 100, self.RULE_ifStatement) try: @@ -5040,14 +5987,13 @@ def ifStatement(self): self.statement() self.state = 679 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,70,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 70, self._ctx) if la_ == 1: self.state = 677 self.match(SolidityParser.T__51) self.state = 678 self.statement() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -5056,57 +6002,49 @@ def ifStatement(self): self.exitRule() return localctx - class TryStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def block(self): - return self.getTypedRuleContext(SolidityParser.BlockContext,0) - + return self.getTypedRuleContext(SolidityParser.BlockContext, 0) def returnParameters(self): - return self.getTypedRuleContext(SolidityParser.ReturnParametersContext,0) - + return self.getTypedRuleContext(SolidityParser.ReturnParametersContext, 0) - def catchClause(self, i:int=None): + def catchClause(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.CatchClauseContext) else: - return self.getTypedRuleContext(SolidityParser.CatchClauseContext,i) - + return self.getTypedRuleContext(SolidityParser.CatchClauseContext, i) def getRuleIndex(self): return SolidityParser.RULE_tryStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTryStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTryStatement"): listener.enterTryStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTryStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTryStatement"): listener.exitTryStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTryStatement" ): + 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, 102, self.RULE_tryStatement) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 681 @@ -5116,23 +6054,22 @@ def tryStatement(self): self.state = 684 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__38: + if _la == SolidityParser.T__38: self.state = 683 self.returnParameters() - self.state = 686 self.block() - self.state = 688 + self.state = 688 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 687 self.catchClause() - self.state = 690 + self.state = 690 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la==SolidityParser.T__53): + if not (_la == SolidityParser.T__53): break except RecognitionException as re: @@ -5143,50 +6080,43 @@ def tryStatement(self): self.exitRule() return localctx - class CatchClauseContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.BlockContext, 0) def parameterList(self): - return self.getTypedRuleContext(SolidityParser.ParameterListContext,0) - + return self.getTypedRuleContext(SolidityParser.ParameterListContext, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def getRuleIndex(self): return SolidityParser.RULE_catchClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCatchClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCatchClause"): listener.enterCatchClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCatchClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCatchClause"): listener.exitCatchClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCatchClause" ): + 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, 104, self.RULE_catchClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 692 @@ -5194,19 +6124,74 @@ def catchClause(self): self.state = 697 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__22) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__22) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 694 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 693 self.identifier() - self.state = 696 self.parameterList() - self.state = 699 self.block() except RecognitionException as re: @@ -5217,43 +6202,37 @@ def catchClause(self): self.exitRule() return localctx - class WhileStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def statement(self): - return self.getTypedRuleContext(SolidityParser.StatementContext,0) - + return self.getTypedRuleContext(SolidityParser.StatementContext, 0) def getRuleIndex(self): return SolidityParser.RULE_whileStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterWhileStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWhileStatement"): listener.enterWhileStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitWhileStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWhileStatement"): listener.exitWhileStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitWhileStatement" ): + 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: @@ -5276,50 +6255,48 @@ def whileStatement(self): self.exitRule() return localctx - class SimpleStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext( + SolidityParser.VariableDeclarationStatementContext, 0 + ) def expressionStatement(self): - return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0) - + return self.getTypedRuleContext( + SolidityParser.ExpressionStatementContext, 0 + ) def getRuleIndex(self): return SolidityParser.RULE_simpleStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSimpleStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSimpleStatement"): listener.enterSimpleStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSimpleStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSimpleStatement"): listener.exitSimpleStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSimpleStatement" ): + 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 = 709 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,75,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 75, self._ctx) if la_ == 1: self.state = 707 self.variableDeclarationStatement() @@ -5330,7 +6307,6 @@ def simpleStatement(self): self.expressionStatement() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -5339,39 +6315,34 @@ def simpleStatement(self): self.exitRule() return localctx - class UncheckedStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.BlockContext, 0) def getRuleIndex(self): return SolidityParser.RULE_uncheckedStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUncheckedStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUncheckedStatement"): listener.enterUncheckedStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUncheckedStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUncheckedStatement"): listener.exitUncheckedStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUncheckedStatement" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUncheckedStatement"): return visitor.visitUncheckedStatement(self) else: return visitor.visitChildren(self) - - - def uncheckedStatement(self): - localctx = SolidityParser.UncheckedStatementContext(self, self._ctx, self.state) self.enterRule(localctx, 110, self.RULE_uncheckedStatement) try: @@ -5388,54 +6359,48 @@ def uncheckedStatement(self): self.exitRule() return localctx - class ForStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.StatementContext, 0) def simpleStatement(self): - return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0) - + return self.getTypedRuleContext(SolidityParser.SimpleStatementContext, 0) def expressionStatement(self): - return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0) - + return self.getTypedRuleContext( + SolidityParser.ExpressionStatementContext, 0 + ) def expression(self): - return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_forStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterForStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterForStatement"): listener.enterForStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitForStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitForStatement"): listener.exitForStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitForStatement" ): + 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, 112, self.RULE_forStatement) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 714 @@ -5445,7 +6410,47 @@ def forStatement(self): self.state = 718 self._errHandler.sync(self) token = self._input.LA(1) - if token in [SolidityParser.T__5, SolidityParser.T__13, SolidityParser.T__22, SolidityParser.T__24, SolidityParser.T__29, SolidityParser.T__30, SolidityParser.T__37, SolidityParser.T__41, SolidityParser.T__43, SolidityParser.T__45, SolidityParser.T__49, 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.T__70, SolidityParser.T__71, SolidityParser.T__94, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.GlobalKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]: + if token in [ + SolidityParser.T__5, + SolidityParser.T__13, + SolidityParser.T__22, + SolidityParser.T__24, + SolidityParser.T__29, + SolidityParser.T__30, + SolidityParser.T__37, + SolidityParser.T__41, + SolidityParser.T__43, + SolidityParser.T__45, + SolidityParser.T__49, + 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.T__70, + SolidityParser.T__71, + SolidityParser.T__94, + SolidityParser.Int, + SolidityParser.Uint, + SolidityParser.Byte, + SolidityParser.Fixed, + SolidityParser.Ufixed, + SolidityParser.BooleanLiteral, + SolidityParser.DecimalNumber, + SolidityParser.HexNumber, + SolidityParser.HexLiteralFragment, + SolidityParser.LeaveKeyword, + SolidityParser.PayableKeyword, + SolidityParser.TypeKeyword, + SolidityParser.GlobalKeyword, + SolidityParser.ConstructorKeyword, + SolidityParser.ReceiveKeyword, + SolidityParser.Identifier, + SolidityParser.StringLiteralFragment, + ]: self.state = 716 self.simpleStatement() pass @@ -5459,7 +6464,47 @@ def forStatement(self): self.state = 722 self._errHandler.sync(self) token = self._input.LA(1) - if token in [SolidityParser.T__5, SolidityParser.T__13, SolidityParser.T__22, SolidityParser.T__24, SolidityParser.T__29, SolidityParser.T__30, SolidityParser.T__37, SolidityParser.T__41, SolidityParser.T__43, SolidityParser.T__45, SolidityParser.T__49, 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.T__70, SolidityParser.T__71, SolidityParser.T__94, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.GlobalKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]: + if token in [ + SolidityParser.T__5, + SolidityParser.T__13, + SolidityParser.T__22, + SolidityParser.T__24, + SolidityParser.T__29, + SolidityParser.T__30, + SolidityParser.T__37, + SolidityParser.T__41, + SolidityParser.T__43, + SolidityParser.T__45, + SolidityParser.T__49, + 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.T__70, + SolidityParser.T__71, + SolidityParser.T__94, + SolidityParser.Int, + SolidityParser.Uint, + SolidityParser.Byte, + SolidityParser.Fixed, + SolidityParser.Ufixed, + SolidityParser.BooleanLiteral, + SolidityParser.DecimalNumber, + SolidityParser.HexNumber, + SolidityParser.HexLiteralFragment, + SolidityParser.LeaveKeyword, + SolidityParser.PayableKeyword, + SolidityParser.TypeKeyword, + SolidityParser.GlobalKeyword, + SolidityParser.ConstructorKeyword, + SolidityParser.ReceiveKeyword, + SolidityParser.Identifier, + SolidityParser.StringLiteralFragment, + ]: self.state = 720 self.expressionStatement() pass @@ -5473,11 +6518,65 @@ def forStatement(self): self.state = 725 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 724 self.expression(0) - self.state = 727 self.match(SolidityParser.T__23) self.state = 728 @@ -5490,49 +6589,47 @@ def forStatement(self): self.exitRule() return localctx - class InlineAssemblyStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext, 0) def StringLiteralFragment(self): return self.getToken(SolidityParser.StringLiteralFragment, 0) def inlineAssemblyStatementFlag(self): - return self.getTypedRuleContext(SolidityParser.InlineAssemblyStatementFlagContext,0) - + return self.getTypedRuleContext( + SolidityParser.InlineAssemblyStatementFlagContext, 0 + ) def getRuleIndex(self): return SolidityParser.RULE_inlineAssemblyStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInlineAssemblyStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInlineAssemblyStatement"): listener.enterInlineAssemblyStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInlineAssemblyStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInlineAssemblyStatement"): listener.exitInlineAssemblyStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInlineAssemblyStatement" ): + 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) + localctx = SolidityParser.InlineAssemblyStatementContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 114, self.RULE_inlineAssemblyStatement) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 730 @@ -5540,15 +6637,14 @@ def inlineAssemblyStatement(self): self.state = 732 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.StringLiteralFragment: + if _la == SolidityParser.StringLiteralFragment: self.state = 731 self.match(SolidityParser.StringLiteralFragment) - self.state = 738 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__22: + if _la == SolidityParser.T__22: self.state = 734 self.match(SolidityParser.T__22) self.state = 735 @@ -5556,7 +6652,6 @@ def inlineAssemblyStatement(self): self.state = 736 self.match(SolidityParser.T__23) - self.state = 740 self.assemblyBlock() except RecognitionException as re: @@ -5567,40 +6662,37 @@ def inlineAssemblyStatement(self): self.exitRule() return localctx - class InlineAssemblyStatementFlagContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def stringLiteral(self): - return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.StringLiteralContext, 0) def getRuleIndex(self): return SolidityParser.RULE_inlineAssemblyStatementFlag - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInlineAssemblyStatementFlag" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInlineAssemblyStatementFlag"): listener.enterInlineAssemblyStatementFlag(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInlineAssemblyStatementFlag" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInlineAssemblyStatementFlag"): listener.exitInlineAssemblyStatementFlag(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInlineAssemblyStatementFlag" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInlineAssemblyStatementFlag"): return visitor.visitInlineAssemblyStatementFlag(self) else: return visitor.visitChildren(self) - - - def inlineAssemblyStatementFlag(self): - - localctx = SolidityParser.InlineAssemblyStatementFlagContext(self, self._ctx, self.state) + localctx = SolidityParser.InlineAssemblyStatementFlagContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 116, self.RULE_inlineAssemblyStatementFlag) try: self.enterOuterAlt(localctx, 1) @@ -5614,43 +6706,37 @@ def inlineAssemblyStatementFlag(self): self.exitRule() return localctx - class DoWhileStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.StatementContext, 0) def expression(self): - return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_doWhileStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDoWhileStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDoWhileStatement"): listener.enterDoWhileStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDoWhileStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDoWhileStatement"): listener.exitDoWhileStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDoWhileStatement" ): + 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, 118, self.RULE_doWhileStatement) try: @@ -5677,10 +6763,10 @@ def doWhileStatement(self): self.exitRule() return localctx - class ContinueStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -5690,25 +6776,21 @@ def ContinueKeyword(self): def getRuleIndex(self): return SolidityParser.RULE_continueStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterContinueStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterContinueStatement"): listener.enterContinueStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitContinueStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitContinueStatement"): listener.exitContinueStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitContinueStatement" ): + 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, 120, self.RULE_continueStatement) try: @@ -5725,10 +6807,10 @@ def continueStatement(self): self.exitRule() return localctx - class BreakStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -5738,25 +6820,21 @@ def BreakKeyword(self): def getRuleIndex(self): return SolidityParser.RULE_breakStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBreakStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBreakStatement"): listener.enterBreakStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBreakStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBreakStatement"): listener.exitBreakStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBreakStatement" ): + 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, 122, self.RULE_breakStatement) try: @@ -5773,42 +6851,37 @@ def breakStatement(self): self.exitRule() return localctx - class ReturnStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_returnStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterReturnStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterReturnStatement"): listener.enterReturnStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitReturnStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitReturnStatement"): listener.exitReturnStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitReturnStatement" ): + 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, 124, self.RULE_returnStatement) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 758 @@ -5816,11 +6889,65 @@ def returnStatement(self): self.state = 760 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 759 self.expression(0) - self.state = 762 self.match(SolidityParser.T__1) except RecognitionException as re: @@ -5831,36 +6958,31 @@ def returnStatement(self): self.exitRule() return localctx - class ThrowStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterThrowStatement"): listener.enterThrowStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitThrowStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitThrowStatement"): listener.exitThrowStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitThrowStatement" ): + 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, 126, self.RULE_throwStatement) try: @@ -5877,39 +6999,34 @@ def throwStatement(self): self.exitRule() return localctx - class EmitStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.FunctionCallContext, 0) def getRuleIndex(self): return SolidityParser.RULE_emitStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEmitStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEmitStatement"): listener.enterEmitStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEmitStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEmitStatement"): listener.exitEmitStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitEmitStatement" ): + 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, 128, self.RULE_emitStatement) try: @@ -5928,39 +7045,34 @@ def emitStatement(self): self.exitRule() return localctx - class RevertStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.FunctionCallContext, 0) def getRuleIndex(self): return SolidityParser.RULE_revertStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRevertStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRevertStatement"): listener.enterRevertStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRevertStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRevertStatement"): listener.exitRevertStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRevertStatement" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRevertStatement"): return visitor.visitRevertStatement(self) else: return visitor.visitChildren(self) - - - def revertStatement(self): - localctx = SolidityParser.RevertStatementContext(self, self._ctx, self.state) self.enterRule(localctx, 130, self.RULE_revertStatement) try: @@ -5979,59 +7091,57 @@ def revertStatement(self): self.exitRule() return localctx - class VariableDeclarationStatementContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierListContext, 0) def variableDeclaration(self): - return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,0) - + return self.getTypedRuleContext( + SolidityParser.VariableDeclarationContext, 0 + ) def variableDeclarationList(self): - return self.getTypedRuleContext(SolidityParser.VariableDeclarationListContext,0) - + return self.getTypedRuleContext( + SolidityParser.VariableDeclarationListContext, 0 + ) def expression(self): - return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_variableDeclarationStatement - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVariableDeclarationStatement" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVariableDeclarationStatement"): listener.enterVariableDeclarationStatement(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVariableDeclarationStatement" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVariableDeclarationStatement"): listener.exitVariableDeclarationStatement(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVariableDeclarationStatement" ): + 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) + localctx = SolidityParser.VariableDeclarationStatementContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 132, self.RULE_variableDeclarationStatement) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 782 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,82,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 82, self._ctx) if la_ == 1: self.state = 775 self.match(SolidityParser.T__62) @@ -6053,17 +7163,15 @@ def variableDeclarationStatement(self): self.match(SolidityParser.T__23) pass - self.state = 786 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__10: + if _la == SolidityParser.T__10: self.state = 784 self.match(SolidityParser.T__10) self.state = 785 self.expression(0) - self.state = 788 self.match(SolidityParser.T__1) except RecognitionException as re: @@ -6074,69 +7182,146 @@ def variableDeclarationStatement(self): self.exitRule() return localctx - class VariableDeclarationListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def variableDeclaration(self, i:int=None): + def variableDeclaration(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext) + return self.getTypedRuleContexts( + SolidityParser.VariableDeclarationContext + ) else: - return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i) - + return self.getTypedRuleContext( + SolidityParser.VariableDeclarationContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_variableDeclarationList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVariableDeclarationList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVariableDeclarationList"): listener.enterVariableDeclarationList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVariableDeclarationList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVariableDeclarationList"): listener.exitVariableDeclarationList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVariableDeclarationList" ): + 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) + localctx = SolidityParser.VariableDeclarationListContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 134, self.RULE_variableDeclarationList) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 791 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & ((1 << (SolidityParser.T__13 - 14)) | (1 << (SolidityParser.T__24 - 14)) | (1 << (SolidityParser.T__37 - 14)) | (1 << (SolidityParser.T__43 - 14)) | (1 << (SolidityParser.T__45 - 14)) | (1 << (SolidityParser.T__49 - 14)) | (1 << (SolidityParser.T__61 - 14)) | (1 << (SolidityParser.T__62 - 14)) | (1 << (SolidityParser.T__63 - 14)) | (1 << (SolidityParser.T__64 - 14)) | (1 << (SolidityParser.T__65 - 14)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.Int - 95)) | (1 << (SolidityParser.Uint - 95)) | (1 << (SolidityParser.Byte - 95)) | (1 << (SolidityParser.Fixed - 95)) | (1 << (SolidityParser.Ufixed - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + (((_la - 14)) & ~0x3F) == 0 + and ( + (1 << (_la - 14)) + & ( + (1 << (SolidityParser.T__13 - 14)) + | (1 << (SolidityParser.T__24 - 14)) + | (1 << (SolidityParser.T__37 - 14)) + | (1 << (SolidityParser.T__43 - 14)) + | (1 << (SolidityParser.T__45 - 14)) + | (1 << (SolidityParser.T__49 - 14)) + | (1 << (SolidityParser.T__61 - 14)) + | (1 << (SolidityParser.T__62 - 14)) + | (1 << (SolidityParser.T__63 - 14)) + | (1 << (SolidityParser.T__64 - 14)) + | (1 << (SolidityParser.T__65 - 14)) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.Int - 95)) + | (1 << (SolidityParser.Uint - 95)) + | (1 << (SolidityParser.Byte - 95)) + | (1 << (SolidityParser.Fixed - 95)) + | (1 << (SolidityParser.Ufixed - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 790 self.variableDeclaration() - self.state = 799 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 793 self.match(SolidityParser.T__15) self.state = 795 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & ((1 << (SolidityParser.T__13 - 14)) | (1 << (SolidityParser.T__24 - 14)) | (1 << (SolidityParser.T__37 - 14)) | (1 << (SolidityParser.T__43 - 14)) | (1 << (SolidityParser.T__45 - 14)) | (1 << (SolidityParser.T__49 - 14)) | (1 << (SolidityParser.T__61 - 14)) | (1 << (SolidityParser.T__62 - 14)) | (1 << (SolidityParser.T__63 - 14)) | (1 << (SolidityParser.T__64 - 14)) | (1 << (SolidityParser.T__65 - 14)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.Int - 95)) | (1 << (SolidityParser.Uint - 95)) | (1 << (SolidityParser.Byte - 95)) | (1 << (SolidityParser.Fixed - 95)) | (1 << (SolidityParser.Ufixed - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + (((_la - 14)) & ~0x3F) == 0 + and ( + (1 << (_la - 14)) + & ( + (1 << (SolidityParser.T__13 - 14)) + | (1 << (SolidityParser.T__24 - 14)) + | (1 << (SolidityParser.T__37 - 14)) + | (1 << (SolidityParser.T__43 - 14)) + | (1 << (SolidityParser.T__45 - 14)) + | (1 << (SolidityParser.T__49 - 14)) + | (1 << (SolidityParser.T__61 - 14)) + | (1 << (SolidityParser.T__62 - 14)) + | (1 << (SolidityParser.T__63 - 14)) + | (1 << (SolidityParser.T__64 - 14)) + | (1 << (SolidityParser.T__65 - 14)) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.Int - 95)) + | (1 << (SolidityParser.Uint - 95)) + | (1 << (SolidityParser.Byte - 95)) + | (1 << (SolidityParser.Fixed - 95)) + | (1 << (SolidityParser.Ufixed - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 794 self.variableDeclaration() - self.state = 801 self._errHandler.sync(self) _la = self._input.LA(1) @@ -6149,76 +7334,125 @@ def variableDeclarationList(self): self.exitRule() return localctx - class IdentifierListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def identifier(self, i:int=None): + def identifier(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.IdentifierContext) else: - return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, i) def getRuleIndex(self): return SolidityParser.RULE_identifierList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIdentifierList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIdentifierList"): listener.enterIdentifierList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIdentifierList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIdentifierList"): listener.exitIdentifierList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIdentifierList" ): + 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, 136, self.RULE_identifierList) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 802 self.match(SolidityParser.T__22) self.state = 809 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,88,self._ctx) - while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: - if _alt==1: + _alt = self._interp.adaptivePredict(self._input, 88, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: self.state = 804 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 803 self.identifier() - self.state = 806 - self.match(SolidityParser.T__15) + self.match(SolidityParser.T__15) self.state = 811 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,88,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 88, self._ctx) self.state = 813 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 812 self.identifier() - self.state = 815 self.match(SolidityParser.T__23) except RecognitionException as re: @@ -6229,10 +7463,10 @@ def identifierList(self): self.exitRule() return localctx - class ElementaryTypeNameContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -6254,33 +7488,49 @@ def Ufixed(self): def getRuleIndex(self): return SolidityParser.RULE_elementaryTypeName - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterElementaryTypeName" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterElementaryTypeName"): listener.enterElementaryTypeName(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitElementaryTypeName" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitElementaryTypeName"): listener.exitElementaryTypeName(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitElementaryTypeName" ): + 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, 138, self.RULE_elementaryTypeName) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 817 _la = self._input.LA(1) - if not(((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & ((1 << (SolidityParser.T__43 - 44)) | (1 << (SolidityParser.T__62 - 44)) | (1 << (SolidityParser.T__63 - 44)) | (1 << (SolidityParser.T__64 - 44)) | (1 << (SolidityParser.T__65 - 44)) | (1 << (SolidityParser.Int - 44)) | (1 << (SolidityParser.Uint - 44)) | (1 << (SolidityParser.Byte - 44)) | (1 << (SolidityParser.Fixed - 44)) | (1 << (SolidityParser.Ufixed - 44)))) != 0)): + if not ( + ( + (((_la - 44)) & ~0x3F) == 0 + and ( + (1 << (_la - 44)) + & ( + (1 << (SolidityParser.T__43 - 44)) + | (1 << (SolidityParser.T__62 - 44)) + | (1 << (SolidityParser.T__63 - 44)) + | (1 << (SolidityParser.T__64 - 44)) + | (1 << (SolidityParser.T__65 - 44)) + | (1 << (SolidityParser.Int - 44)) + | (1 << (SolidityParser.Uint - 44)) + | (1 << (SolidityParser.Byte - 44)) + | (1 << (SolidityParser.Fixed - 44)) + | (1 << (SolidityParser.Ufixed - 44)) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6293,72 +7543,66 @@ def elementaryTypeName(self): self.exitRule() return localctx - class ExpressionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) - - def expression(self, i:int=None): + def expression(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.ExpressionContext) else: - return self.getTypedRuleContext(SolidityParser.ExpressionContext,i) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, i) def primaryExpression(self): - return self.getTypedRuleContext(SolidityParser.PrimaryExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.PrimaryExpressionContext, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def nameValueList(self): - return self.getTypedRuleContext(SolidityParser.NameValueListContext,0) - + return self.getTypedRuleContext(SolidityParser.NameValueListContext, 0) def functionCallArguments(self): - return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0) - + return self.getTypedRuleContext( + SolidityParser.FunctionCallArgumentsContext, 0 + ) def getRuleIndex(self): return SolidityParser.RULE_expression - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterExpression" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterExpression"): listener.enterExpression(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitExpression" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitExpression"): listener.exitExpression(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitExpression" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitExpression"): return visitor.visitExpression(self) else: return visitor.visitChildren(self) - - - def expression(self, _p:int=0): + def expression(self, _p: int = 0): _parentctx = self._ctx _parentState = self.state localctx = SolidityParser.ExpressionContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 140 self.enterRecursionRule(localctx, 140, self.RULE_expression, _p) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 837 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,90,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 90, self._ctx) if la_ == 1: self.state = 820 self.match(SolidityParser.T__68) @@ -6378,7 +7622,7 @@ def expression(self, _p:int=0): elif la_ == 3: self.state = 826 _la = self._input.LA(1) - if not(_la==SolidityParser.T__66 or _la==SolidityParser.T__67): + if not (_la == SolidityParser.T__66 or _la == SolidityParser.T__67): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6390,7 +7634,7 @@ def expression(self, _p:int=0): elif la_ == 4: self.state = 828 _la = self._input.LA(1) - if not(_la==SolidityParser.T__29 or _la==SolidityParser.T__30): + if not (_la == SolidityParser.T__29 or _la == SolidityParser.T__30): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6425,26 +7669,32 @@ def expression(self, _p:int=0): self.primaryExpression() pass - self._ctx.stop = self._input.LT(-1) self.state = 913 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,94,self._ctx) - while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: - if _alt==1: + _alt = self._interp.adaptivePredict(self._input, 94, 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 = 911 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,93,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 93, self._ctx) if la_ == 1: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 839 if not self.precpred(self._ctx, 14): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 14)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 14)" + ) self.state = 840 self.match(SolidityParser.T__72) self.state = 841 @@ -6452,15 +7702,35 @@ def expression(self, _p:int=0): pass elif la_ == 2: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 842 if not self.precpred(self._ctx, 13): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 13)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 13)" + ) self.state = 843 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__32))) != 0)): + if not ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__2) + | (1 << SolidityParser.T__31) + | (1 << SolidityParser.T__32) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6470,15 +7740,24 @@ def expression(self, _p:int=0): pass elif la_ == 3: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 845 if not self.precpred(self._ctx, 12): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 12)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 12)" + ) self.state = 846 _la = self._input.LA(1) - if not(_la==SolidityParser.T__29 or _la==SolidityParser.T__30): + if not ( + _la == SolidityParser.T__29 or _la == SolidityParser.T__30 + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6488,15 +7767,24 @@ def expression(self, _p:int=0): pass elif la_ == 4: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 848 if not self.precpred(self._ctx, 11): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 11)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 11)" + ) self.state = 849 _la = self._input.LA(1) - if not(_la==SolidityParser.T__73 or _la==SolidityParser.T__74): + if not ( + _la == SolidityParser.T__73 or _la == SolidityParser.T__74 + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6506,12 +7794,19 @@ def expression(self, _p:int=0): pass elif la_ == 5: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 851 if not self.precpred(self._ctx, 10): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 10)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 10)" + ) self.state = 852 self.match(SolidityParser.T__28) self.state = 853 @@ -6519,12 +7814,19 @@ def expression(self, _p:int=0): pass elif la_ == 6: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 854 if not self.precpred(self._ctx, 9): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 9)" + ) self.state = 855 self.match(SolidityParser.T__4) self.state = 856 @@ -6532,12 +7834,19 @@ def expression(self, _p:int=0): pass elif la_ == 7: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 857 if not self.precpred(self._ctx, 8): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 8)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 8)" + ) self.state = 858 self.match(SolidityParser.T__27) self.state = 859 @@ -6545,15 +7854,36 @@ def expression(self, _p:int=0): pass elif la_ == 8: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 860 if not self.precpred(self._ctx, 7): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 7)" + ) self.state = 861 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9))) != 0)): + if not ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__6) + | (1 << SolidityParser.T__7) + | (1 << SolidityParser.T__8) + | (1 << SolidityParser.T__9) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6563,15 +7893,24 @@ def expression(self, _p:int=0): pass elif la_ == 9: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 863 if not self.precpred(self._ctx, 6): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 6)" + ) self.state = 864 _la = self._input.LA(1) - if not(_la==SolidityParser.T__33 or _la==SolidityParser.T__34): + if not ( + _la == SolidityParser.T__33 or _la == SolidityParser.T__34 + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6581,12 +7920,19 @@ def expression(self, _p:int=0): pass elif la_ == 10: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 866 if not self.precpred(self._ctx, 5): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 5)" + ) self.state = 867 self.match(SolidityParser.T__75) self.state = 868 @@ -6594,12 +7940,19 @@ def expression(self, _p:int=0): pass elif la_ == 11: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 869 if not self.precpred(self._ctx, 4): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 4)" + ) self.state = 870 self.match(SolidityParser.T__3) self.state = 871 @@ -6607,12 +7960,19 @@ def expression(self, _p:int=0): pass elif la_ == 12: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 872 if not self.precpred(self._ctx, 3): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 3)" + ) self.state = 873 self.match(SolidityParser.T__76) self.state = 874 @@ -6624,15 +7984,43 @@ def expression(self, _p:int=0): pass elif la_ == 13: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 878 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 2)" + ) self.state = 879 _la = self._input.LA(1) - if not(_la==SolidityParser.T__10 or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & ((1 << (SolidityParser.T__77 - 78)) | (1 << (SolidityParser.T__78 - 78)) | (1 << (SolidityParser.T__79 - 78)) | (1 << (SolidityParser.T__80 - 78)) | (1 << (SolidityParser.T__81 - 78)) | (1 << (SolidityParser.T__82 - 78)) | (1 << (SolidityParser.T__83 - 78)) | (1 << (SolidityParser.T__84 - 78)) | (1 << (SolidityParser.T__85 - 78)) | (1 << (SolidityParser.T__86 - 78)))) != 0)): + if not ( + _la == SolidityParser.T__10 + or ( + (((_la - 78)) & ~0x3F) == 0 + and ( + (1 << (_la - 78)) + & ( + (1 << (SolidityParser.T__77 - 78)) + | (1 << (SolidityParser.T__78 - 78)) + | (1 << (SolidityParser.T__79 - 78)) + | (1 << (SolidityParser.T__80 - 78)) + | (1 << (SolidityParser.T__81 - 78)) + | (1 << (SolidityParser.T__82 - 78)) + | (1 << (SolidityParser.T__83 - 78)) + | (1 << (SolidityParser.T__84 - 78)) + | (1 << (SolidityParser.T__85 - 78)) + | (1 << (SolidityParser.T__86 - 78)) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6642,15 +8030,24 @@ def expression(self, _p:int=0): pass elif la_ == 14: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 881 if not self.precpred(self._ctx, 27): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 27)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 27)" + ) self.state = 882 _la = self._input.LA(1) - if not(_la==SolidityParser.T__66 or _la==SolidityParser.T__67): + if not ( + _la == SolidityParser.T__66 or _la == SolidityParser.T__67 + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6658,12 +8055,19 @@ def expression(self, _p:int=0): pass elif la_ == 15: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 883 if not self.precpred(self._ctx, 25): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 25)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 25)" + ) self.state = 884 self.match(SolidityParser.T__41) self.state = 885 @@ -6673,43 +8077,165 @@ def expression(self, _p:int=0): pass elif la_ == 16: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 888 if not self.precpred(self._ctx, 24): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 24)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 24)" + ) self.state = 889 self.match(SolidityParser.T__41) self.state = 891 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 890 self.expression(0) - self.state = 893 self.match(SolidityParser.T__69) self.state = 895 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 894 self.expression(0) - self.state = 897 self.match(SolidityParser.T__42) pass elif la_ == 17: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 898 if not self.precpred(self._ctx, 23): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 23)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 23)" + ) self.state = 899 self.match(SolidityParser.T__44) self.state = 900 @@ -6717,12 +8243,19 @@ def expression(self, _p:int=0): pass elif la_ == 18: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 901 if not self.precpred(self._ctx, 22): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 22)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 22)" + ) self.state = 902 self.match(SolidityParser.T__14) self.state = 903 @@ -6732,12 +8265,19 @@ def expression(self, _p:int=0): pass elif la_ == 19: - localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState) - self.pushNewRecursionContext(localctx, _startState, self.RULE_expression) + localctx = SolidityParser.ExpressionContext( + self, _parentctx, _parentState + ) + self.pushNewRecursionContext( + localctx, _startState, self.RULE_expression + ) self.state = 906 if not self.precpred(self._ctx, 21): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 21)") + + raise FailedPredicateException( + self, "self.precpred(self._ctx, 21)" + ) self.state = 907 self.match(SolidityParser.T__22) self.state = 908 @@ -6746,10 +8286,9 @@ def expression(self, _p:int=0): self.match(SolidityParser.T__23) pass - self.state = 915 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,94,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 94, self._ctx) except RecognitionException as re: localctx.exception = re @@ -6759,10 +8298,10 @@ def expression(self, _p:int=0): self.unrollRecursionContexts(_parentctx) return localctx - class PrimaryExpressionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -6770,20 +8309,16 @@ def BooleanLiteral(self): return self.getToken(SolidityParser.BooleanLiteral, 0) def numberLiteral(self): - return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.NumberLiteralContext, 0) def hexLiteral(self): - return self.getTypedRuleContext(SolidityParser.HexLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.HexLiteralContext, 0) def stringLiteral(self): - return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.StringLiteralContext, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def TypeKeyword(self): return self.getToken(SolidityParser.TypeKeyword, 0) @@ -6792,41 +8327,35 @@ def PayableKeyword(self): return self.getToken(SolidityParser.PayableKeyword, 0) def tupleExpression(self): - return self.getTypedRuleContext(SolidityParser.TupleExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.TupleExpressionContext, 0) def typeName(self): - return self.getTypedRuleContext(SolidityParser.TypeNameContext,0) - + return self.getTypedRuleContext(SolidityParser.TypeNameContext, 0) def getRuleIndex(self): return SolidityParser.RULE_primaryExpression - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPrimaryExpression" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPrimaryExpression"): listener.enterPrimaryExpression(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPrimaryExpression" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPrimaryExpression"): listener.exitPrimaryExpression(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPrimaryExpression" ): + 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, 142, self.RULE_primaryExpression) try: self.state = 925 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,95,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 95, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 916 @@ -6881,7 +8410,6 @@ def primaryExpression(self): self.typeName(0) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -6890,45 +8418,40 @@ def primaryExpression(self): self.exitRule() return localctx - class ExpressionListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def expression(self, i:int=None): + def expression(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.ExpressionContext) else: - return self.getTypedRuleContext(SolidityParser.ExpressionContext,i) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, i) def getRuleIndex(self): return SolidityParser.RULE_expressionList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterExpressionList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterExpressionList"): listener.enterExpressionList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitExpressionList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitExpressionList"): listener.exitExpressionList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitExpressionList" ): + 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, 144, self.RULE_expressionList) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 927 @@ -6936,7 +8459,7 @@ def expressionList(self): self.state = 932 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 928 self.match(SolidityParser.T__15) self.state = 929 @@ -6953,70 +8476,64 @@ def expressionList(self): self.exitRule() return localctx - class NameValueListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def nameValue(self, i:int=None): + def nameValue(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.NameValueContext) else: - return self.getTypedRuleContext(SolidityParser.NameValueContext,i) - + return self.getTypedRuleContext(SolidityParser.NameValueContext, i) def getRuleIndex(self): return SolidityParser.RULE_nameValueList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNameValueList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNameValueList"): listener.enterNameValueList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNameValueList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNameValueList"): listener.exitNameValueList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNameValueList" ): + 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, 146, self.RULE_nameValueList) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 935 self.nameValue() self.state = 940 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,97,self._ctx) - while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: - if _alt==1: + _alt = self._interp.adaptivePredict(self._input, 97, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: self.state = 936 self.match(SolidityParser.T__15) self.state = 937 - self.nameValue() + self.nameValue() self.state = 942 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,97,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 97, self._ctx) self.state = 944 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__15: + if _la == SolidityParser.T__15: self.state = 943 self.match(SolidityParser.T__15) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -7025,43 +8542,37 @@ def nameValueList(self): self.exitRule() return localctx - class NameValueContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def expression(self): - return self.getTypedRuleContext(SolidityParser.ExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_nameValue - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNameValue" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNameValue"): listener.enterNameValue(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNameValue" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNameValue"): listener.exitNameValue(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNameValue" ): + 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, 148, self.RULE_nameValue) try: @@ -7080,46 +8591,42 @@ def nameValue(self): self.exitRule() return localctx - class FunctionCallArgumentsContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.NameValueListContext, 0) def expressionList(self): - return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0) - + return self.getTypedRuleContext(SolidityParser.ExpressionListContext, 0) def getRuleIndex(self): return SolidityParser.RULE_functionCallArguments - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunctionCallArguments" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunctionCallArguments"): listener.enterFunctionCallArguments(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunctionCallArguments" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunctionCallArguments"): listener.exitFunctionCallArguments(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunctionCallArguments" ): + 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) + localctx = SolidityParser.FunctionCallArgumentsContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 150, self.RULE_functionCallArguments) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 958 self._errHandler.sync(self) @@ -7131,24 +8638,146 @@ def functionCallArguments(self): self.state = 952 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 951 self.nameValueList() - self.state = 954 self.match(SolidityParser.T__16) pass - elif token in [SolidityParser.T__5, SolidityParser.T__13, SolidityParser.T__22, SolidityParser.T__23, SolidityParser.T__24, SolidityParser.T__29, SolidityParser.T__30, SolidityParser.T__37, SolidityParser.T__41, SolidityParser.T__43, SolidityParser.T__45, SolidityParser.T__49, 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.T__70, SolidityParser.T__71, SolidityParser.T__94, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.GlobalKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]: + elif token in [ + SolidityParser.T__5, + SolidityParser.T__13, + SolidityParser.T__22, + SolidityParser.T__23, + SolidityParser.T__24, + SolidityParser.T__29, + SolidityParser.T__30, + SolidityParser.T__37, + SolidityParser.T__41, + SolidityParser.T__43, + SolidityParser.T__45, + SolidityParser.T__49, + 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.T__70, + SolidityParser.T__71, + SolidityParser.T__94, + SolidityParser.Int, + SolidityParser.Uint, + SolidityParser.Byte, + SolidityParser.Fixed, + SolidityParser.Ufixed, + SolidityParser.BooleanLiteral, + SolidityParser.DecimalNumber, + SolidityParser.HexNumber, + SolidityParser.HexLiteralFragment, + SolidityParser.LeaveKeyword, + SolidityParser.PayableKeyword, + SolidityParser.TypeKeyword, + SolidityParser.GlobalKeyword, + SolidityParser.ConstructorKeyword, + SolidityParser.ReceiveKeyword, + SolidityParser.Identifier, + SolidityParser.StringLiteralFragment, + ]: self.enterOuterAlt(localctx, 2) self.state = 956 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 955 self.expressionList() - pass else: raise NoViableAltException(self) @@ -7161,43 +8790,39 @@ def functionCallArguments(self): self.exitRule() return localctx - class FunctionCallContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, 0) def functionCallArguments(self): - return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0) - + return self.getTypedRuleContext( + SolidityParser.FunctionCallArgumentsContext, 0 + ) def getRuleIndex(self): return SolidityParser.RULE_functionCall - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunctionCall" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunctionCall"): listener.enterFunctionCall(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunctionCall" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunctionCall"): listener.exitFunctionCall(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunctionCall" ): + 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, 152, self.RULE_functionCall) try: @@ -7218,45 +8843,40 @@ def functionCall(self): self.exitRule() return localctx - class AssemblyBlockContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def assemblyItem(self, i:int=None): + def assemblyItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.AssemblyItemContext) else: - return self.getTypedRuleContext(SolidityParser.AssemblyItemContext,i) - + return self.getTypedRuleContext(SolidityParser.AssemblyItemContext, i) def getRuleIndex(self): return SolidityParser.RULE_assemblyBlock - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyBlock" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyBlock"): listener.enterAssemblyBlock(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyBlock" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyBlock"): listener.exitAssemblyBlock(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyBlock" ): + 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, 154, self.RULE_assemblyBlock) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 965 @@ -7264,7 +8884,51 @@ def assemblyBlock(self): self.state = 969 self._errHandler.sync(self) _la = self._input.LA(1) - while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__14) | (1 << SolidityParser.T__22) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__26) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (SolidityParser.T__65 - 66)) | (1 << (SolidityParser.T__87 - 66)) | (1 << (SolidityParser.T__90 - 66)) | (1 << (SolidityParser.T__94 - 66)) | (1 << (SolidityParser.BooleanLiteral - 66)) | (1 << (SolidityParser.DecimalNumber - 66)) | (1 << (SolidityParser.HexNumber - 66)) | (1 << (SolidityParser.HexLiteralFragment - 66)) | (1 << (SolidityParser.BreakKeyword - 66)) | (1 << (SolidityParser.ContinueKeyword - 66)) | (1 << (SolidityParser.LeaveKeyword - 66)) | (1 << (SolidityParser.PayableKeyword - 66)) | (1 << (SolidityParser.GlobalKeyword - 66)) | (1 << (SolidityParser.ConstructorKeyword - 66)) | (1 << (SolidityParser.ReceiveKeyword - 66)) | (1 << (SolidityParser.Identifier - 66)) | (1 << (SolidityParser.StringLiteralFragment - 66)))) != 0): + while ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__14) + | (1 << SolidityParser.T__22) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__26) + | (1 << SolidityParser.T__37) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__50) + | (1 << SolidityParser.T__58) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 66)) & ~0x3F) == 0 + and ( + (1 << (_la - 66)) + & ( + (1 << (SolidityParser.T__65 - 66)) + | (1 << (SolidityParser.T__87 - 66)) + | (1 << (SolidityParser.T__90 - 66)) + | (1 << (SolidityParser.T__94 - 66)) + | (1 << (SolidityParser.BooleanLiteral - 66)) + | (1 << (SolidityParser.DecimalNumber - 66)) + | (1 << (SolidityParser.HexNumber - 66)) + | (1 << (SolidityParser.HexLiteralFragment - 66)) + | (1 << (SolidityParser.BreakKeyword - 66)) + | (1 << (SolidityParser.ContinueKeyword - 66)) + | (1 << (SolidityParser.LeaveKeyword - 66)) + | (1 << (SolidityParser.PayableKeyword - 66)) + | (1 << (SolidityParser.GlobalKeyword - 66)) + | (1 << (SolidityParser.ConstructorKeyword - 66)) + | (1 << (SolidityParser.ReceiveKeyword - 66)) + | (1 << (SolidityParser.Identifier - 66)) + | (1 << (SolidityParser.StringLiteralFragment - 66)) + ) + ) + != 0 + ): self.state = 966 self.assemblyItem() self.state = 971 @@ -7281,56 +8945,51 @@ def assemblyBlock(self): self.exitRule() return localctx - class AssemblyItemContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def assemblyBlock(self): - return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext, 0) def assemblyExpression(self): - return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext, 0) def assemblyLocalDefinition(self): - return self.getTypedRuleContext(SolidityParser.AssemblyLocalDefinitionContext,0) - + return self.getTypedRuleContext( + SolidityParser.AssemblyLocalDefinitionContext, 0 + ) def assemblyAssignment(self): - return self.getTypedRuleContext(SolidityParser.AssemblyAssignmentContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyAssignmentContext, 0) def assemblyStackAssignment(self): - return self.getTypedRuleContext(SolidityParser.AssemblyStackAssignmentContext,0) - + return self.getTypedRuleContext( + SolidityParser.AssemblyStackAssignmentContext, 0 + ) def labelDefinition(self): - return self.getTypedRuleContext(SolidityParser.LabelDefinitionContext,0) - + return self.getTypedRuleContext(SolidityParser.LabelDefinitionContext, 0) def assemblySwitch(self): - return self.getTypedRuleContext(SolidityParser.AssemblySwitchContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblySwitchContext, 0) def assemblyFunctionDefinition(self): - return self.getTypedRuleContext(SolidityParser.AssemblyFunctionDefinitionContext,0) - + return self.getTypedRuleContext( + SolidityParser.AssemblyFunctionDefinitionContext, 0 + ) def assemblyFor(self): - return self.getTypedRuleContext(SolidityParser.AssemblyForContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyForContext, 0) def assemblyIf(self): - return self.getTypedRuleContext(SolidityParser.AssemblyIfContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyIfContext, 0) def BreakKeyword(self): return self.getToken(SolidityParser.BreakKeyword, 0) @@ -7342,45 +9001,38 @@ def LeaveKeyword(self): return self.getToken(SolidityParser.LeaveKeyword, 0) def numberLiteral(self): - return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.NumberLiteralContext, 0) def stringLiteral(self): - return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.StringLiteralContext, 0) def hexLiteral(self): - return self.getTypedRuleContext(SolidityParser.HexLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.HexLiteralContext, 0) def getRuleIndex(self): return SolidityParser.RULE_assemblyItem - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyItem" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyItem"): listener.enterAssemblyItem(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyItem" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyItem"): listener.exitAssemblyItem(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyItem" ): + 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, 156, self.RULE_assemblyItem) try: self.state = 991 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,103,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 103, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 974 @@ -7483,7 +9135,6 @@ def assemblyItem(self): self.hexLiteral() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -7492,53 +9143,46 @@ def assemblyItem(self): self.exitRule() return localctx - class AssemblyExpressionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.AssemblyCallContext, 0) def assemblyLiteral(self): - return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext, 0) def assemblyMember(self): - return self.getTypedRuleContext(SolidityParser.AssemblyMemberContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyMemberContext, 0) def getRuleIndex(self): return SolidityParser.RULE_assemblyExpression - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyExpression" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyExpression"): listener.enterAssemblyExpression(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyExpression" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyExpression"): listener.exitAssemblyExpression(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyExpression" ): + 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, 158, self.RULE_assemblyExpression) try: self.state = 996 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,104,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 104, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 993 @@ -7557,7 +9201,6 @@ def assemblyExpression(self): self.assemblyMember() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -7566,42 +9209,37 @@ def assemblyExpression(self): self.exitRule() return localctx - class AssemblyMemberContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def identifier(self, i:int=None): + def identifier(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.IdentifierContext) else: - return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, i) def getRuleIndex(self): return SolidityParser.RULE_assemblyMember - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyMember" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyMember"): listener.enterAssemblyMember(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyMember" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyMember"): listener.exitAssemblyMember(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyMember" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAssemblyMember"): return visitor.visitAssemblyMember(self) else: return visitor.visitChildren(self) - - - def assemblyMember(self): - localctx = SolidityParser.AssemblyMemberContext(self, self._ctx, self.state) self.enterRule(localctx, 160, self.RULE_assemblyMember) try: @@ -7620,54 +9258,52 @@ def assemblyMember(self): self.exitRule() return localctx - class AssemblyCallContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) - def assemblyExpression(self, i:int=None): + def assemblyExpression(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext) + return self.getTypedRuleContexts( + SolidityParser.AssemblyExpressionContext + ) else: - return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i) - + return self.getTypedRuleContext( + SolidityParser.AssemblyExpressionContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_assemblyCall - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyCall" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyCall"): listener.enterAssemblyCall(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyCall" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyCall"): listener.exitAssemblyCall(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyCall" ): + 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, 162, self.RULE_assemblyCall) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1006 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,105,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 105, self._ctx) if la_ == 1: self.state = 1002 self.match(SolidityParser.T__58) @@ -7688,25 +9324,58 @@ def assemblyCall(self): self.identifier() pass - self.state = 1020 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,108,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 108, self._ctx) if la_ == 1: self.state = 1008 self.match(SolidityParser.T__22) self.state = 1010 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (SolidityParser.T__65 - 66)) | (1 << (SolidityParser.T__94 - 66)) | (1 << (SolidityParser.BooleanLiteral - 66)) | (1 << (SolidityParser.DecimalNumber - 66)) | (1 << (SolidityParser.HexNumber - 66)) | (1 << (SolidityParser.HexLiteralFragment - 66)) | (1 << (SolidityParser.LeaveKeyword - 66)) | (1 << (SolidityParser.PayableKeyword - 66)) | (1 << (SolidityParser.GlobalKeyword - 66)) | (1 << (SolidityParser.ConstructorKeyword - 66)) | (1 << (SolidityParser.ReceiveKeyword - 66)) | (1 << (SolidityParser.Identifier - 66)) | (1 << (SolidityParser.StringLiteralFragment - 66)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__58) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 66)) & ~0x3F) == 0 + and ( + (1 << (_la - 66)) + & ( + (1 << (SolidityParser.T__65 - 66)) + | (1 << (SolidityParser.T__94 - 66)) + | (1 << (SolidityParser.BooleanLiteral - 66)) + | (1 << (SolidityParser.DecimalNumber - 66)) + | (1 << (SolidityParser.HexNumber - 66)) + | (1 << (SolidityParser.HexLiteralFragment - 66)) + | (1 << (SolidityParser.LeaveKeyword - 66)) + | (1 << (SolidityParser.PayableKeyword - 66)) + | (1 << (SolidityParser.GlobalKeyword - 66)) + | (1 << (SolidityParser.ConstructorKeyword - 66)) + | (1 << (SolidityParser.ReceiveKeyword - 66)) + | (1 << (SolidityParser.Identifier - 66)) + | (1 << (SolidityParser.StringLiteralFragment - 66)) + ) + ) + != 0 + ): self.state = 1009 self.assemblyExpression() - self.state = 1016 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 1012 self.match(SolidityParser.T__15) self.state = 1013 @@ -7718,7 +9387,6 @@ def assemblyCall(self): self.state = 1019 self.match(SolidityParser.T__23) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -7727,46 +9395,44 @@ def assemblyCall(self): self.exitRule() return localctx - class AssemblyLocalDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext( + SolidityParser.AssemblyIdentifierOrListContext, 0 + ) def assemblyExpression(self): - return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_assemblyLocalDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyLocalDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyLocalDefinition"): listener.enterAssemblyLocalDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyLocalDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyLocalDefinition"): listener.exitAssemblyLocalDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyLocalDefinition" ): + 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) + localctx = SolidityParser.AssemblyLocalDefinitionContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 164, self.RULE_assemblyLocalDefinition) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1022 @@ -7776,13 +9442,12 @@ def assemblyLocalDefinition(self): self.state = 1026 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__88: + if _la == SolidityParser.T__88: self.state = 1024 self.match(SolidityParser.T__88) self.state = 1025 self.assemblyExpression() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -7791,43 +9456,39 @@ def assemblyLocalDefinition(self): self.exitRule() return localctx - class AssemblyAssignmentContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext( + SolidityParser.AssemblyIdentifierOrListContext, 0 + ) def assemblyExpression(self): - return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext, 0) def getRuleIndex(self): return SolidityParser.RULE_assemblyAssignment - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyAssignment" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyAssignment"): listener.enterAssemblyAssignment(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyAssignment" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyAssignment"): listener.exitAssemblyAssignment(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyAssignment" ): + 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, 166, self.RULE_assemblyAssignment) try: @@ -7846,53 +9507,50 @@ def assemblyAssignment(self): self.exitRule() return localctx - class AssemblyIdentifierOrListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def assemblyMember(self): - return self.getTypedRuleContext(SolidityParser.AssemblyMemberContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyMemberContext, 0) def assemblyIdentifierList(self): - return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0) - + return self.getTypedRuleContext( + SolidityParser.AssemblyIdentifierListContext, 0 + ) def getRuleIndex(self): return SolidityParser.RULE_assemblyIdentifierOrList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyIdentifierOrList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyIdentifierOrList"): listener.enterAssemblyIdentifierOrList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyIdentifierOrList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyIdentifierOrList"): listener.exitAssemblyIdentifierOrList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyIdentifierOrList" ): + 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) + localctx = SolidityParser.AssemblyIdentifierOrListContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 168, self.RULE_assemblyIdentifierOrList) try: self.state = 1039 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,110,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 110, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 1032 @@ -7921,7 +9579,6 @@ def assemblyIdentifierOrList(self): self.match(SolidityParser.T__23) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -7930,45 +9587,42 @@ def assemblyIdentifierOrList(self): self.exitRule() return localctx - class AssemblyIdentifierListContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def identifier(self, i:int=None): + def identifier(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.IdentifierContext) else: - return self.getTypedRuleContext(SolidityParser.IdentifierContext,i) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, i) def getRuleIndex(self): return SolidityParser.RULE_assemblyIdentifierList - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyIdentifierList" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyIdentifierList"): listener.enterAssemblyIdentifierList(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyIdentifierList" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyIdentifierList"): listener.exitAssemblyIdentifierList(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyIdentifierList" ): + 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) + localctx = SolidityParser.AssemblyIdentifierListContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 170, self.RULE_assemblyIdentifierList) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1041 @@ -7976,7 +9630,7 @@ def assemblyIdentifierList(self): self.state = 1046 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 1042 self.match(SolidityParser.T__15) self.state = 1043 @@ -7993,44 +9647,40 @@ def assemblyIdentifierList(self): self.exitRule() return localctx - class AssemblyStackAssignmentContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext, 0) def identifier(self): - return self.getTypedRuleContext(SolidityParser.IdentifierContext,0) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def getRuleIndex(self): return SolidityParser.RULE_assemblyStackAssignment - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyStackAssignment" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyStackAssignment"): listener.enterAssemblyStackAssignment(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyStackAssignment" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyStackAssignment"): listener.exitAssemblyStackAssignment(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyStackAssignment" ): + 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) + localctx = SolidityParser.AssemblyStackAssignmentContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 172, self.RULE_assemblyStackAssignment) try: self.enterOuterAlt(localctx, 1) @@ -8048,39 +9698,34 @@ def assemblyStackAssignment(self): self.exitRule() return localctx - class LabelDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def getRuleIndex(self): return SolidityParser.RULE_labelDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterLabelDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterLabelDefinition"): listener.enterLabelDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitLabelDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitLabelDefinition"): listener.exitLabelDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitLabelDefinition" ): + 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, 174, self.RULE_labelDefinition) try: @@ -8097,49 +9742,43 @@ def labelDefinition(self): self.exitRule() return localctx - class AssemblySwitchContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext, 0) - def assemblyCase(self, i:int=None): + def assemblyCase(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.AssemblyCaseContext) else: - return self.getTypedRuleContext(SolidityParser.AssemblyCaseContext,i) - + return self.getTypedRuleContext(SolidityParser.AssemblyCaseContext, i) def getRuleIndex(self): return SolidityParser.RULE_assemblySwitch - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblySwitch" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblySwitch"): listener.enterAssemblySwitch(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblySwitch" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblySwitch"): listener.exitAssemblySwitch(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblySwitch" ): + 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, 176, self.RULE_assemblySwitch) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1056 @@ -8149,7 +9788,7 @@ def assemblySwitch(self): self.state = 1061 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__91 or _la==SolidityParser.T__92: + while _la == SolidityParser.T__91 or _la == SolidityParser.T__92: self.state = 1058 self.assemblyCase() self.state = 1063 @@ -8164,43 +9803,37 @@ def assemblySwitch(self): self.exitRule() return localctx - class AssemblyCaseContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext, 0) def assemblyBlock(self): - return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext, 0) def getRuleIndex(self): return SolidityParser.RULE_assemblyCase - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyCase" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyCase"): listener.enterAssemblyCase(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyCase" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyCase"): listener.exitAssemblyCase(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyCase" ): + 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, 178, self.RULE_assemblyCase) try: @@ -8234,54 +9867,52 @@ def assemblyCase(self): self.exitRule() return localctx - class AssemblyFunctionDefinitionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.IdentifierContext, 0) def assemblyBlock(self): - return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext, 0) def assemblyIdentifierList(self): - return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0) - + return self.getTypedRuleContext( + SolidityParser.AssemblyIdentifierListContext, 0 + ) def assemblyFunctionReturns(self): - return self.getTypedRuleContext(SolidityParser.AssemblyFunctionReturnsContext,0) - + return self.getTypedRuleContext( + SolidityParser.AssemblyFunctionReturnsContext, 0 + ) def getRuleIndex(self): return SolidityParser.RULE_assemblyFunctionDefinition - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyFunctionDefinition" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyFunctionDefinition"): listener.enterAssemblyFunctionDefinition(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyFunctionDefinition" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyFunctionDefinition"): listener.exitAssemblyFunctionDefinition(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyFunctionDefinition" ): + 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) + localctx = SolidityParser.AssemblyFunctionDefinitionContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 180, self.RULE_assemblyFunctionDefinition) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1072 @@ -8293,21 +9924,47 @@ def assemblyFunctionDefinition(self): self.state = 1076 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0): + if ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ): self.state = 1075 self.assemblyIdentifierList() - self.state = 1078 self.match(SolidityParser.T__23) self.state = 1080 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__93: + if _la == SolidityParser.T__93: self.state = 1079 self.assemblyFunctionReturns() - self.state = 1082 self.assemblyBlock() except RecognitionException as re: @@ -8318,40 +9975,39 @@ def assemblyFunctionDefinition(self): self.exitRule() return localctx - class AssemblyFunctionReturnsContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext( + SolidityParser.AssemblyIdentifierListContext, 0 + ) def getRuleIndex(self): return SolidityParser.RULE_assemblyFunctionReturns - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyFunctionReturns" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyFunctionReturns"): listener.enterAssemblyFunctionReturns(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyFunctionReturns" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyFunctionReturns"): listener.exitAssemblyFunctionReturns(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyFunctionReturns" ): + 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) + localctx = SolidityParser.AssemblyFunctionReturnsContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 182, self.RULE_assemblyFunctionReturns) try: self.enterOuterAlt(localctx, 1) @@ -8367,49 +10023,47 @@ def assemblyFunctionReturns(self): self.exitRule() return localctx - class AssemblyForContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def assemblyExpression(self, i:int=None): + def assemblyExpression(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext) + return self.getTypedRuleContexts( + SolidityParser.AssemblyExpressionContext + ) else: - return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i) + return self.getTypedRuleContext( + SolidityParser.AssemblyExpressionContext, i + ) - - def assemblyBlock(self, i:int=None): + def assemblyBlock(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.AssemblyBlockContext) else: - return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,i) - + return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext, i) def getRuleIndex(self): return SolidityParser.RULE_assemblyFor - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyFor" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyFor"): listener.enterAssemblyFor(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyFor" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyFor"): listener.exitAssemblyFor(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyFor" ): + 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, 184, self.RULE_assemblyFor) try: @@ -8423,7 +10077,27 @@ def assemblyFor(self): self.state = 1088 self.assemblyBlock() pass - elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__43, SolidityParser.T__49, SolidityParser.T__58, SolidityParser.T__61, SolidityParser.T__65, SolidityParser.T__94, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.GlobalKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]: + elif token in [ + SolidityParser.T__13, + SolidityParser.T__24, + SolidityParser.T__43, + SolidityParser.T__49, + SolidityParser.T__58, + SolidityParser.T__61, + SolidityParser.T__65, + SolidityParser.T__94, + SolidityParser.BooleanLiteral, + SolidityParser.DecimalNumber, + SolidityParser.HexNumber, + SolidityParser.HexLiteralFragment, + SolidityParser.LeaveKeyword, + SolidityParser.PayableKeyword, + SolidityParser.GlobalKeyword, + SolidityParser.ConstructorKeyword, + SolidityParser.ReceiveKeyword, + SolidityParser.Identifier, + SolidityParser.StringLiteralFragment, + ]: self.state = 1089 self.assemblyExpression() pass @@ -8439,7 +10113,27 @@ def assemblyFor(self): self.state = 1093 self.assemblyBlock() pass - elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__43, SolidityParser.T__49, SolidityParser.T__58, SolidityParser.T__61, SolidityParser.T__65, SolidityParser.T__94, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.GlobalKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]: + elif token in [ + SolidityParser.T__13, + SolidityParser.T__24, + SolidityParser.T__43, + SolidityParser.T__49, + SolidityParser.T__58, + SolidityParser.T__61, + SolidityParser.T__65, + SolidityParser.T__94, + SolidityParser.BooleanLiteral, + SolidityParser.DecimalNumber, + SolidityParser.HexNumber, + SolidityParser.HexLiteralFragment, + SolidityParser.LeaveKeyword, + SolidityParser.PayableKeyword, + SolidityParser.GlobalKeyword, + SolidityParser.ConstructorKeyword, + SolidityParser.ReceiveKeyword, + SolidityParser.Identifier, + SolidityParser.StringLiteralFragment, + ]: self.state = 1094 self.assemblyExpression() pass @@ -8456,43 +10150,37 @@ def assemblyFor(self): self.exitRule() return localctx - class AssemblyIfContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + 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) - + return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext, 0) def assemblyBlock(self): - return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0) - + return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext, 0) def getRuleIndex(self): return SolidityParser.RULE_assemblyIf - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyIf" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyIf"): listener.enterAssemblyIf(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyIf" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyIf"): listener.exitAssemblyIf(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyIf" ): + 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, 186, self.RULE_assemblyIf) try: @@ -8511,16 +10199,15 @@ def assemblyIf(self): self.exitRule() return localctx - class AssemblyLiteralContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def stringLiteral(self): - return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.StringLiteralContext, 0) def DecimalNumber(self): return self.getToken(SolidityParser.DecimalNumber, 0) @@ -8529,8 +10216,7 @@ def HexNumber(self): return self.getToken(SolidityParser.HexNumber, 0) def hexLiteral(self): - return self.getTypedRuleContext(SolidityParser.HexLiteralContext,0) - + return self.getTypedRuleContext(SolidityParser.HexLiteralContext, 0) def BooleanLiteral(self): return self.getToken(SolidityParser.BooleanLiteral, 0) @@ -8538,25 +10224,21 @@ def BooleanLiteral(self): def getRuleIndex(self): return SolidityParser.RULE_assemblyLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAssemblyLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAssemblyLiteral"): listener.enterAssemblyLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAssemblyLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAssemblyLiteral"): listener.exitAssemblyLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAssemblyLiteral" ): + 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, 188, self.RULE_assemblyLiteral) try: @@ -8599,45 +10281,40 @@ def assemblyLiteral(self): self.exitRule() return localctx - class TupleExpressionContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def expression(self, i:int=None): + def expression(self, i: int = None): if i is None: return self.getTypedRuleContexts(SolidityParser.ExpressionContext) else: - return self.getTypedRuleContext(SolidityParser.ExpressionContext,i) - + return self.getTypedRuleContext(SolidityParser.ExpressionContext, i) def getRuleIndex(self): return SolidityParser.RULE_tupleExpression - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTupleExpression" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTupleExpression"): listener.enterTupleExpression(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTupleExpression" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTupleExpression"): listener.exitTupleExpression(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTupleExpression" ): + 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, 190, self.RULE_tupleExpression) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1136 self._errHandler.sync(self) @@ -8650,25 +10327,133 @@ def tupleExpression(self): self.state = 1112 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 1111 self.expression(0) - self.state = 1120 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 1114 self.match(SolidityParser.T__15) self.state = 1116 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 1115 self.expression(0) - self.state = 1122 self._errHandler.sync(self) _la = self._input.LA(1) @@ -8683,13 +10468,68 @@ def tupleExpression(self): self.state = 1133 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__30 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__43 - 6)) | (1 << (SolidityParser.T__45 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__61 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)) | (1 << (SolidityParser.T__67 - 6)) | (1 << (SolidityParser.T__68 - 6)))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (SolidityParser.T__70 - 71)) | (1 << (SolidityParser.T__71 - 71)) | (1 << (SolidityParser.T__94 - 71)) | (1 << (SolidityParser.Int - 71)) | (1 << (SolidityParser.Uint - 71)) | (1 << (SolidityParser.Byte - 71)) | (1 << (SolidityParser.Fixed - 71)) | (1 << (SolidityParser.Ufixed - 71)) | (1 << (SolidityParser.BooleanLiteral - 71)) | (1 << (SolidityParser.DecimalNumber - 71)) | (1 << (SolidityParser.HexNumber - 71)) | (1 << (SolidityParser.HexLiteralFragment - 71)) | (1 << (SolidityParser.LeaveKeyword - 71)) | (1 << (SolidityParser.PayableKeyword - 71)) | (1 << (SolidityParser.TypeKeyword - 71)) | (1 << (SolidityParser.GlobalKeyword - 71)) | (1 << (SolidityParser.ConstructorKeyword - 71)) | (1 << (SolidityParser.ReceiveKeyword - 71)) | (1 << (SolidityParser.Identifier - 71)) | (1 << (SolidityParser.StringLiteralFragment - 71)))) != 0): + if ( + (((_la - 6)) & ~0x3F) == 0 + and ( + (1 << (_la - 6)) + & ( + (1 << (SolidityParser.T__5 - 6)) + | (1 << (SolidityParser.T__13 - 6)) + | (1 << (SolidityParser.T__22 - 6)) + | (1 << (SolidityParser.T__24 - 6)) + | (1 << (SolidityParser.T__29 - 6)) + | (1 << (SolidityParser.T__30 - 6)) + | (1 << (SolidityParser.T__37 - 6)) + | (1 << (SolidityParser.T__41 - 6)) + | (1 << (SolidityParser.T__43 - 6)) + | (1 << (SolidityParser.T__45 - 6)) + | (1 << (SolidityParser.T__49 - 6)) + | (1 << (SolidityParser.T__61 - 6)) + | (1 << (SolidityParser.T__62 - 6)) + | (1 << (SolidityParser.T__63 - 6)) + | (1 << (SolidityParser.T__64 - 6)) + | (1 << (SolidityParser.T__65 - 6)) + | (1 << (SolidityParser.T__66 - 6)) + | (1 << (SolidityParser.T__67 - 6)) + | (1 << (SolidityParser.T__68 - 6)) + ) + ) + != 0 + ) or ( + (((_la - 71)) & ~0x3F) == 0 + and ( + (1 << (_la - 71)) + & ( + (1 << (SolidityParser.T__70 - 71)) + | (1 << (SolidityParser.T__71 - 71)) + | (1 << (SolidityParser.T__94 - 71)) + | (1 << (SolidityParser.Int - 71)) + | (1 << (SolidityParser.Uint - 71)) + | (1 << (SolidityParser.Byte - 71)) + | (1 << (SolidityParser.Fixed - 71)) + | (1 << (SolidityParser.Ufixed - 71)) + | (1 << (SolidityParser.BooleanLiteral - 71)) + | (1 << (SolidityParser.DecimalNumber - 71)) + | (1 << (SolidityParser.HexNumber - 71)) + | (1 << (SolidityParser.HexLiteralFragment - 71)) + | (1 << (SolidityParser.LeaveKeyword - 71)) + | (1 << (SolidityParser.PayableKeyword - 71)) + | (1 << (SolidityParser.TypeKeyword - 71)) + | (1 << (SolidityParser.GlobalKeyword - 71)) + | (1 << (SolidityParser.ConstructorKeyword - 71)) + | (1 << (SolidityParser.ReceiveKeyword - 71)) + | (1 << (SolidityParser.Identifier - 71)) + | (1 << (SolidityParser.StringLiteralFragment - 71)) + ) + ) + != 0 + ): self.state = 1125 self.expression(0) self.state = 1130 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 1126 self.match(SolidityParser.T__15) self.state = 1127 @@ -8698,8 +10538,6 @@ def tupleExpression(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 1135 self.match(SolidityParser.T__42) pass @@ -8714,10 +10552,10 @@ def tupleExpression(self): self.exitRule() return localctx - class NumberLiteralContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -8733,45 +10571,42 @@ def NumberUnit(self): def getRuleIndex(self): return SolidityParser.RULE_numberLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNumberLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNumberLiteral"): listener.enterNumberLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNumberLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNumberLiteral"): listener.exitNumberLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNumberLiteral" ): + 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, 192, self.RULE_numberLiteral) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1138 _la = self._input.LA(1) - if not(_la==SolidityParser.DecimalNumber or _la==SolidityParser.HexNumber): + if not ( + _la == SolidityParser.DecimalNumber or _la == SolidityParser.HexNumber + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 1140 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,125,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 125, self._ctx) if la_ == 1: self.state = 1139 self.match(SolidityParser.NumberUnit) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -8780,10 +10615,10 @@ def numberLiteral(self): self.exitRule() return localctx - class IdentifierContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -8808,33 +10643,60 @@ def Identifier(self): def getRuleIndex(self): return SolidityParser.RULE_identifier - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIdentifier" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIdentifier"): listener.enterIdentifier(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIdentifier" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIdentifier"): listener.exitIdentifier(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIdentifier" ): + 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, 194, self.RULE_identifier) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1142 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__43) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__61))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (SolidityParser.T__94 - 95)) | (1 << (SolidityParser.LeaveKeyword - 95)) | (1 << (SolidityParser.PayableKeyword - 95)) | (1 << (SolidityParser.GlobalKeyword - 95)) | (1 << (SolidityParser.ConstructorKeyword - 95)) | (1 << (SolidityParser.ReceiveKeyword - 95)) | (1 << (SolidityParser.Identifier - 95)))) != 0)): + if not ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << SolidityParser.T__13) + | (1 << SolidityParser.T__24) + | (1 << SolidityParser.T__43) + | (1 << SolidityParser.T__49) + | (1 << SolidityParser.T__61) + ) + ) + != 0 + ) + or ( + (((_la - 95)) & ~0x3F) == 0 + and ( + (1 << (_la - 95)) + & ( + (1 << (SolidityParser.T__94 - 95)) + | (1 << (SolidityParser.LeaveKeyword - 95)) + | (1 << (SolidityParser.PayableKeyword - 95)) + | (1 << (SolidityParser.GlobalKeyword - 95)) + | (1 << (SolidityParser.ConstructorKeyword - 95)) + | (1 << (SolidityParser.ReceiveKeyword - 95)) + | (1 << (SolidityParser.Identifier - 95)) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -8847,14 +10709,14 @@ def identifier(self): self.exitRule() return localctx - class HexLiteralContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def HexLiteralFragment(self, i:int=None): + def HexLiteralFragment(self, i: int = None): if i is None: return self.getTokens(SolidityParser.HexLiteralFragment) else: @@ -8863,42 +10725,38 @@ def HexLiteralFragment(self, i:int=None): def getRuleIndex(self): return SolidityParser.RULE_hexLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHexLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHexLiteral"): listener.enterHexLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHexLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHexLiteral"): listener.exitHexLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHexLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHexLiteral"): return visitor.visitHexLiteral(self) else: return visitor.visitChildren(self) - - - def hexLiteral(self): - localctx = SolidityParser.HexLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 196, self.RULE_hexLiteral) try: self.enterOuterAlt(localctx, 1) - self.state = 1145 + self.state = 1145 self._errHandler.sync(self) _alt = 1 - while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 1144 self.match(SolidityParser.HexLiteralFragment) else: raise NoViableAltException(self) - self.state = 1147 + self.state = 1147 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,126,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 126, self._ctx) except RecognitionException as re: localctx.exception = re @@ -8908,45 +10766,44 @@ def hexLiteral(self): self.exitRule() return localctx - class OverrideSpecifierContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def userDefinedTypeName(self, i:int=None): + def userDefinedTypeName(self, i: int = None): if i is None: - return self.getTypedRuleContexts(SolidityParser.UserDefinedTypeNameContext) + return self.getTypedRuleContexts( + SolidityParser.UserDefinedTypeNameContext + ) else: - return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,i) - + return self.getTypedRuleContext( + SolidityParser.UserDefinedTypeNameContext, i + ) def getRuleIndex(self): return SolidityParser.RULE_overrideSpecifier - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOverrideSpecifier" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOverrideSpecifier"): listener.enterOverrideSpecifier(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOverrideSpecifier" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOverrideSpecifier"): listener.exitOverrideSpecifier(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOverrideSpecifier" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOverrideSpecifier"): return visitor.visitOverrideSpecifier(self) else: return visitor.visitChildren(self) - - - def overrideSpecifier(self): - localctx = SolidityParser.OverrideSpecifierContext(self, self._ctx, self.state) self.enterRule(localctx, 198, self.RULE_overrideSpecifier) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1149 @@ -8954,7 +10811,7 @@ def overrideSpecifier(self): self.state = 1161 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==SolidityParser.T__22: + if _la == SolidityParser.T__22: self.state = 1150 self.match(SolidityParser.T__22) self.state = 1151 @@ -8962,7 +10819,7 @@ def overrideSpecifier(self): self.state = 1156 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==SolidityParser.T__15: + while _la == SolidityParser.T__15: self.state = 1152 self.match(SolidityParser.T__15) self.state = 1153 @@ -8974,7 +10831,6 @@ def overrideSpecifier(self): self.state = 1159 self.match(SolidityParser.T__23) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -8983,14 +10839,14 @@ def overrideSpecifier(self): self.exitRule() return localctx - class StringLiteralContext(ParserRuleContext): - - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def StringLiteralFragment(self, i:int=None): + def StringLiteralFragment(self, i: int = None): if i is None: return self.getTokens(SolidityParser.StringLiteralFragment) else: @@ -8999,42 +10855,38 @@ def StringLiteralFragment(self, i:int=None): def getRuleIndex(self): return SolidityParser.RULE_stringLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStringLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringLiteral"): listener.enterStringLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStringLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringLiteral"): listener.exitStringLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStringLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringLiteral"): return visitor.visitStringLiteral(self) else: return visitor.visitChildren(self) - - - def stringLiteral(self): - localctx = SolidityParser.StringLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 200, self.RULE_stringLiteral) try: self.enterOuterAlt(localctx, 1) - self.state = 1164 + self.state = 1164 self._errHandler.sync(self) _alt = 1 - while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 1163 self.match(SolidityParser.StringLiteralFragment) else: raise NoViableAltException(self) - self.state = 1166 + self.state = 1166 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,129,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 129, self._ctx) except RecognitionException as re: localctx.exception = re @@ -9044,9 +10896,7 @@ def stringLiteral(self): self.exitRule() return localctx - - - def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): + def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int): if self._predicates == None: self._predicates = dict() self._predicates[38] = self.typeName_sempred @@ -9057,88 +10907,64 @@ def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): 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) - + def typeName_sempred(self, localctx: TypeNameContext, predIndex: int): + if predIndex == 0: + return self.precpred(self._ctx, 3) - if predIndex == 5: - return self.precpred(self._ctx, 10) - + def expression_sempred(self, localctx: ExpressionContext, predIndex: int): + if predIndex == 1: + return self.precpred(self._ctx, 14) - if predIndex == 6: - return self.precpred(self._ctx, 9) - + if predIndex == 2: + return self.precpred(self._ctx, 13) - if predIndex == 7: - return self.precpred(self._ctx, 8) - + if predIndex == 3: + return self.precpred(self._ctx, 12) - if predIndex == 8: - return self.precpred(self._ctx, 7) - + if predIndex == 4: + return self.precpred(self._ctx, 11) - if predIndex == 9: - return self.precpred(self._ctx, 6) - + if predIndex == 5: + return self.precpred(self._ctx, 10) - if predIndex == 10: - return self.precpred(self._ctx, 5) - + if predIndex == 6: + return self.precpred(self._ctx, 9) - if predIndex == 11: - return self.precpred(self._ctx, 4) - + if predIndex == 7: + return self.precpred(self._ctx, 8) - if predIndex == 12: - return self.precpred(self._ctx, 3) - + if predIndex == 8: + return self.precpred(self._ctx, 7) - if predIndex == 13: - return self.precpred(self._ctx, 2) - + if predIndex == 9: + return self.precpred(self._ctx, 6) - if predIndex == 14: - return self.precpred(self._ctx, 27) - + if predIndex == 10: + return self.precpred(self._ctx, 5) - if predIndex == 15: - return self.precpred(self._ctx, 25) - + if predIndex == 11: + return self.precpred(self._ctx, 4) - if predIndex == 16: - return self.precpred(self._ctx, 24) - + if predIndex == 12: + return self.precpred(self._ctx, 3) - if predIndex == 17: - return self.precpred(self._ctx, 23) - + if predIndex == 13: + return self.precpred(self._ctx, 2) - if predIndex == 18: - return self.precpred(self._ctx, 22) - + if predIndex == 14: + return self.precpred(self._ctx, 27) - if predIndex == 19: - return self.precpred(self._ctx, 21) - + if predIndex == 15: + return self.precpred(self._ctx, 25) + if predIndex == 16: + return self.precpred(self._ctx, 24) + if predIndex == 17: + return self.precpred(self._ctx, 23) + if predIndex == 18: + return self.precpred(self._ctx, 22) + if predIndex == 19: + return self.precpred(self._ctx, 21) diff --git a/solidity_parser/solidity_antlr4/SolidityVisitor.py b/solidity_parser/solidity_antlr4/SolidityVisitor.py index 953502b..84b35d8 100644 --- a/solidity_parser/solidity_antlr4/SolidityVisitor.py +++ b/solidity_parser/solidity_antlr4/SolidityVisitor.py @@ -1,5 +1,6 @@ # Generated from solidity-antlr4/Solidity.g4 by ANTLR 4.7.2 from antlr4 import * + if __name__ is not None and "." in __name__: from .SolidityParser import SolidityParser else: @@ -7,512 +8,447 @@ # This class defines a complete generic visitor for a parse tree produced by SolidityParser. -class SolidityVisitor(ParseTreeVisitor): +class SolidityVisitor(ParseTreeVisitor): # Visit a parse tree produced by SolidityParser#sourceUnit. - def visitSourceUnit(self, ctx:SolidityParser.SourceUnitContext): + def visitSourceUnit(self, ctx: SolidityParser.SourceUnitContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#pragmaDirective. - def visitPragmaDirective(self, ctx:SolidityParser.PragmaDirectiveContext): + def visitPragmaDirective(self, ctx: SolidityParser.PragmaDirectiveContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#pragmaName. - def visitPragmaName(self, ctx:SolidityParser.PragmaNameContext): + def visitPragmaName(self, ctx: SolidityParser.PragmaNameContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#pragmaValue. - def visitPragmaValue(self, ctx:SolidityParser.PragmaValueContext): + def visitPragmaValue(self, ctx: SolidityParser.PragmaValueContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#version. - def visitVersion(self, ctx:SolidityParser.VersionContext): + def visitVersion(self, ctx: SolidityParser.VersionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#versionOperator. - def visitVersionOperator(self, ctx:SolidityParser.VersionOperatorContext): + def visitVersionOperator(self, ctx: SolidityParser.VersionOperatorContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#versionConstraint. - def visitVersionConstraint(self, ctx:SolidityParser.VersionConstraintContext): + def visitVersionConstraint(self, ctx: SolidityParser.VersionConstraintContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#importDeclaration. - def visitImportDeclaration(self, ctx:SolidityParser.ImportDeclarationContext): + def visitImportDeclaration(self, ctx: SolidityParser.ImportDeclarationContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#importDirective. - def visitImportDirective(self, ctx:SolidityParser.ImportDirectiveContext): + def visitImportDirective(self, ctx: SolidityParser.ImportDirectiveContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#importPath. - def visitImportPath(self, ctx:SolidityParser.ImportPathContext): + def visitImportPath(self, ctx: SolidityParser.ImportPathContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#contractDefinition. - def visitContractDefinition(self, ctx:SolidityParser.ContractDefinitionContext): + def visitContractDefinition(self, ctx: SolidityParser.ContractDefinitionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#inheritanceSpecifier. - def visitInheritanceSpecifier(self, ctx:SolidityParser.InheritanceSpecifierContext): + def visitInheritanceSpecifier( + self, ctx: SolidityParser.InheritanceSpecifierContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#contractPart. - def visitContractPart(self, ctx:SolidityParser.ContractPartContext): + def visitContractPart(self, ctx: SolidityParser.ContractPartContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#stateVariableDeclaration. - def visitStateVariableDeclaration(self, ctx:SolidityParser.StateVariableDeclarationContext): + def visitStateVariableDeclaration( + self, ctx: SolidityParser.StateVariableDeclarationContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#fileLevelConstant. - def visitFileLevelConstant(self, ctx:SolidityParser.FileLevelConstantContext): + def visitFileLevelConstant(self, ctx: SolidityParser.FileLevelConstantContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#customErrorDefinition. - def visitCustomErrorDefinition(self, ctx:SolidityParser.CustomErrorDefinitionContext): + def visitCustomErrorDefinition( + self, ctx: SolidityParser.CustomErrorDefinitionContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#typeDefinition. - def visitTypeDefinition(self, ctx:SolidityParser.TypeDefinitionContext): + def visitTypeDefinition(self, ctx: SolidityParser.TypeDefinitionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#usingForDeclaration. - def visitUsingForDeclaration(self, ctx:SolidityParser.UsingForDeclarationContext): + def visitUsingForDeclaration(self, ctx: SolidityParser.UsingForDeclarationContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#usingForObject. - def visitUsingForObject(self, ctx:SolidityParser.UsingForObjectContext): + def visitUsingForObject(self, ctx: SolidityParser.UsingForObjectContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#usingForObjectDirective. - def visitUsingForObjectDirective(self, ctx:SolidityParser.UsingForObjectDirectiveContext): + def visitUsingForObjectDirective( + self, ctx: SolidityParser.UsingForObjectDirectiveContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#userDefinableOperators. - def visitUserDefinableOperators(self, ctx:SolidityParser.UserDefinableOperatorsContext): + def visitUserDefinableOperators( + self, ctx: SolidityParser.UserDefinableOperatorsContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#structDefinition. - def visitStructDefinition(self, ctx:SolidityParser.StructDefinitionContext): + def visitStructDefinition(self, ctx: SolidityParser.StructDefinitionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#modifierDefinition. - def visitModifierDefinition(self, ctx:SolidityParser.ModifierDefinitionContext): + def visitModifierDefinition(self, ctx: SolidityParser.ModifierDefinitionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#modifierInvocation. - def visitModifierInvocation(self, ctx:SolidityParser.ModifierInvocationContext): + def visitModifierInvocation(self, ctx: SolidityParser.ModifierInvocationContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#functionDefinition. - def visitFunctionDefinition(self, ctx:SolidityParser.FunctionDefinitionContext): + def visitFunctionDefinition(self, ctx: SolidityParser.FunctionDefinitionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#functionDescriptor. - def visitFunctionDescriptor(self, ctx:SolidityParser.FunctionDescriptorContext): + def visitFunctionDescriptor(self, ctx: SolidityParser.FunctionDescriptorContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#returnParameters. - def visitReturnParameters(self, ctx:SolidityParser.ReturnParametersContext): + def visitReturnParameters(self, ctx: SolidityParser.ReturnParametersContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#modifierList. - def visitModifierList(self, ctx:SolidityParser.ModifierListContext): + def visitModifierList(self, ctx: SolidityParser.ModifierListContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#eventDefinition. - def visitEventDefinition(self, ctx:SolidityParser.EventDefinitionContext): + def visitEventDefinition(self, ctx: SolidityParser.EventDefinitionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#enumValue. - def visitEnumValue(self, ctx:SolidityParser.EnumValueContext): + def visitEnumValue(self, ctx: SolidityParser.EnumValueContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#enumDefinition. - def visitEnumDefinition(self, ctx:SolidityParser.EnumDefinitionContext): + def visitEnumDefinition(self, ctx: SolidityParser.EnumDefinitionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#parameterList. - def visitParameterList(self, ctx:SolidityParser.ParameterListContext): + def visitParameterList(self, ctx: SolidityParser.ParameterListContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#parameter. - def visitParameter(self, ctx:SolidityParser.ParameterContext): + def visitParameter(self, ctx: SolidityParser.ParameterContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#eventParameterList. - def visitEventParameterList(self, ctx:SolidityParser.EventParameterListContext): + def visitEventParameterList(self, ctx: SolidityParser.EventParameterListContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#eventParameter. - def visitEventParameter(self, ctx:SolidityParser.EventParameterContext): + def visitEventParameter(self, ctx: SolidityParser.EventParameterContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#functionTypeParameterList. - def visitFunctionTypeParameterList(self, ctx:SolidityParser.FunctionTypeParameterListContext): + def visitFunctionTypeParameterList( + self, ctx: SolidityParser.FunctionTypeParameterListContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#functionTypeParameter. - def visitFunctionTypeParameter(self, ctx:SolidityParser.FunctionTypeParameterContext): + def visitFunctionTypeParameter( + self, ctx: SolidityParser.FunctionTypeParameterContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#variableDeclaration. - def visitVariableDeclaration(self, ctx:SolidityParser.VariableDeclarationContext): + def visitVariableDeclaration(self, ctx: SolidityParser.VariableDeclarationContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#typeName. - def visitTypeName(self, ctx:SolidityParser.TypeNameContext): + def visitTypeName(self, ctx: SolidityParser.TypeNameContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#userDefinedTypeName. - def visitUserDefinedTypeName(self, ctx:SolidityParser.UserDefinedTypeNameContext): + def visitUserDefinedTypeName(self, ctx: SolidityParser.UserDefinedTypeNameContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#mappingKey. - def visitMappingKey(self, ctx:SolidityParser.MappingKeyContext): + def visitMappingKey(self, ctx: SolidityParser.MappingKeyContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#mapping. - def visitMapping(self, ctx:SolidityParser.MappingContext): + def visitMapping(self, ctx: SolidityParser.MappingContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#mappingKeyName. - def visitMappingKeyName(self, ctx:SolidityParser.MappingKeyNameContext): + def visitMappingKeyName(self, ctx: SolidityParser.MappingKeyNameContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#mappingValueName. - def visitMappingValueName(self, ctx:SolidityParser.MappingValueNameContext): + def visitMappingValueName(self, ctx: SolidityParser.MappingValueNameContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#functionTypeName. - def visitFunctionTypeName(self, ctx:SolidityParser.FunctionTypeNameContext): + def visitFunctionTypeName(self, ctx: SolidityParser.FunctionTypeNameContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#storageLocation. - def visitStorageLocation(self, ctx:SolidityParser.StorageLocationContext): + def visitStorageLocation(self, ctx: SolidityParser.StorageLocationContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#stateMutability. - def visitStateMutability(self, ctx:SolidityParser.StateMutabilityContext): + def visitStateMutability(self, ctx: SolidityParser.StateMutabilityContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#block. - def visitBlock(self, ctx:SolidityParser.BlockContext): + def visitBlock(self, ctx: SolidityParser.BlockContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#statement. - def visitStatement(self, ctx:SolidityParser.StatementContext): + def visitStatement(self, ctx: SolidityParser.StatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#expressionStatement. - def visitExpressionStatement(self, ctx:SolidityParser.ExpressionStatementContext): + def visitExpressionStatement(self, ctx: SolidityParser.ExpressionStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#ifStatement. - def visitIfStatement(self, ctx:SolidityParser.IfStatementContext): + def visitIfStatement(self, ctx: SolidityParser.IfStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#tryStatement. - def visitTryStatement(self, ctx:SolidityParser.TryStatementContext): + def visitTryStatement(self, ctx: SolidityParser.TryStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#catchClause. - def visitCatchClause(self, ctx:SolidityParser.CatchClauseContext): + def visitCatchClause(self, ctx: SolidityParser.CatchClauseContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#whileStatement. - def visitWhileStatement(self, ctx:SolidityParser.WhileStatementContext): + def visitWhileStatement(self, ctx: SolidityParser.WhileStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#simpleStatement. - def visitSimpleStatement(self, ctx:SolidityParser.SimpleStatementContext): + def visitSimpleStatement(self, ctx: SolidityParser.SimpleStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#uncheckedStatement. - def visitUncheckedStatement(self, ctx:SolidityParser.UncheckedStatementContext): + def visitUncheckedStatement(self, ctx: SolidityParser.UncheckedStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#forStatement. - def visitForStatement(self, ctx:SolidityParser.ForStatementContext): + def visitForStatement(self, ctx: SolidityParser.ForStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#inlineAssemblyStatement. - def visitInlineAssemblyStatement(self, ctx:SolidityParser.InlineAssemblyStatementContext): + def visitInlineAssemblyStatement( + self, ctx: SolidityParser.InlineAssemblyStatementContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#inlineAssemblyStatementFlag. - def visitInlineAssemblyStatementFlag(self, ctx:SolidityParser.InlineAssemblyStatementFlagContext): + def visitInlineAssemblyStatementFlag( + self, ctx: SolidityParser.InlineAssemblyStatementFlagContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#doWhileStatement. - def visitDoWhileStatement(self, ctx:SolidityParser.DoWhileStatementContext): + def visitDoWhileStatement(self, ctx: SolidityParser.DoWhileStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#continueStatement. - def visitContinueStatement(self, ctx:SolidityParser.ContinueStatementContext): + def visitContinueStatement(self, ctx: SolidityParser.ContinueStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#breakStatement. - def visitBreakStatement(self, ctx:SolidityParser.BreakStatementContext): + def visitBreakStatement(self, ctx: SolidityParser.BreakStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#returnStatement. - def visitReturnStatement(self, ctx:SolidityParser.ReturnStatementContext): + def visitReturnStatement(self, ctx: SolidityParser.ReturnStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#throwStatement. - def visitThrowStatement(self, ctx:SolidityParser.ThrowStatementContext): + def visitThrowStatement(self, ctx: SolidityParser.ThrowStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#emitStatement. - def visitEmitStatement(self, ctx:SolidityParser.EmitStatementContext): + def visitEmitStatement(self, ctx: SolidityParser.EmitStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#revertStatement. - def visitRevertStatement(self, ctx:SolidityParser.RevertStatementContext): + def visitRevertStatement(self, ctx: SolidityParser.RevertStatementContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#variableDeclarationStatement. - def visitVariableDeclarationStatement(self, ctx:SolidityParser.VariableDeclarationStatementContext): + def visitVariableDeclarationStatement( + self, ctx: SolidityParser.VariableDeclarationStatementContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#variableDeclarationList. - def visitVariableDeclarationList(self, ctx:SolidityParser.VariableDeclarationListContext): + def visitVariableDeclarationList( + self, ctx: SolidityParser.VariableDeclarationListContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#identifierList. - def visitIdentifierList(self, ctx:SolidityParser.IdentifierListContext): + def visitIdentifierList(self, ctx: SolidityParser.IdentifierListContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#elementaryTypeName. - def visitElementaryTypeName(self, ctx:SolidityParser.ElementaryTypeNameContext): + def visitElementaryTypeName(self, ctx: SolidityParser.ElementaryTypeNameContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#expression. - def visitExpression(self, ctx:SolidityParser.ExpressionContext): + def visitExpression(self, ctx: SolidityParser.ExpressionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#primaryExpression. - def visitPrimaryExpression(self, ctx:SolidityParser.PrimaryExpressionContext): + def visitPrimaryExpression(self, ctx: SolidityParser.PrimaryExpressionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#expressionList. - def visitExpressionList(self, ctx:SolidityParser.ExpressionListContext): + def visitExpressionList(self, ctx: SolidityParser.ExpressionListContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#nameValueList. - def visitNameValueList(self, ctx:SolidityParser.NameValueListContext): + def visitNameValueList(self, ctx: SolidityParser.NameValueListContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#nameValue. - def visitNameValue(self, ctx:SolidityParser.NameValueContext): + def visitNameValue(self, ctx: SolidityParser.NameValueContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#functionCallArguments. - def visitFunctionCallArguments(self, ctx:SolidityParser.FunctionCallArgumentsContext): + def visitFunctionCallArguments( + self, ctx: SolidityParser.FunctionCallArgumentsContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#functionCall. - def visitFunctionCall(self, ctx:SolidityParser.FunctionCallContext): + def visitFunctionCall(self, ctx: SolidityParser.FunctionCallContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyBlock. - def visitAssemblyBlock(self, ctx:SolidityParser.AssemblyBlockContext): + def visitAssemblyBlock(self, ctx: SolidityParser.AssemblyBlockContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyItem. - def visitAssemblyItem(self, ctx:SolidityParser.AssemblyItemContext): + def visitAssemblyItem(self, ctx: SolidityParser.AssemblyItemContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyExpression. - def visitAssemblyExpression(self, ctx:SolidityParser.AssemblyExpressionContext): + def visitAssemblyExpression(self, ctx: SolidityParser.AssemblyExpressionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyMember. - def visitAssemblyMember(self, ctx:SolidityParser.AssemblyMemberContext): + def visitAssemblyMember(self, ctx: SolidityParser.AssemblyMemberContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyCall. - def visitAssemblyCall(self, ctx:SolidityParser.AssemblyCallContext): + def visitAssemblyCall(self, ctx: SolidityParser.AssemblyCallContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyLocalDefinition. - def visitAssemblyLocalDefinition(self, ctx:SolidityParser.AssemblyLocalDefinitionContext): + def visitAssemblyLocalDefinition( + self, ctx: SolidityParser.AssemblyLocalDefinitionContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyAssignment. - def visitAssemblyAssignment(self, ctx:SolidityParser.AssemblyAssignmentContext): + def visitAssemblyAssignment(self, ctx: SolidityParser.AssemblyAssignmentContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyIdentifierOrList. - def visitAssemblyIdentifierOrList(self, ctx:SolidityParser.AssemblyIdentifierOrListContext): + def visitAssemblyIdentifierOrList( + self, ctx: SolidityParser.AssemblyIdentifierOrListContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyIdentifierList. - def visitAssemblyIdentifierList(self, ctx:SolidityParser.AssemblyIdentifierListContext): + def visitAssemblyIdentifierList( + self, ctx: SolidityParser.AssemblyIdentifierListContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyStackAssignment. - def visitAssemblyStackAssignment(self, ctx:SolidityParser.AssemblyStackAssignmentContext): + def visitAssemblyStackAssignment( + self, ctx: SolidityParser.AssemblyStackAssignmentContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#labelDefinition. - def visitLabelDefinition(self, ctx:SolidityParser.LabelDefinitionContext): + def visitLabelDefinition(self, ctx: SolidityParser.LabelDefinitionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblySwitch. - def visitAssemblySwitch(self, ctx:SolidityParser.AssemblySwitchContext): + def visitAssemblySwitch(self, ctx: SolidityParser.AssemblySwitchContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyCase. - def visitAssemblyCase(self, ctx:SolidityParser.AssemblyCaseContext): + def visitAssemblyCase(self, ctx: SolidityParser.AssemblyCaseContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyFunctionDefinition. - def visitAssemblyFunctionDefinition(self, ctx:SolidityParser.AssemblyFunctionDefinitionContext): + def visitAssemblyFunctionDefinition( + self, ctx: SolidityParser.AssemblyFunctionDefinitionContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyFunctionReturns. - def visitAssemblyFunctionReturns(self, ctx:SolidityParser.AssemblyFunctionReturnsContext): + def visitAssemblyFunctionReturns( + self, ctx: SolidityParser.AssemblyFunctionReturnsContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyFor. - def visitAssemblyFor(self, ctx:SolidityParser.AssemblyForContext): + def visitAssemblyFor(self, ctx: SolidityParser.AssemblyForContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyIf. - def visitAssemblyIf(self, ctx:SolidityParser.AssemblyIfContext): + def visitAssemblyIf(self, ctx: SolidityParser.AssemblyIfContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#assemblyLiteral. - def visitAssemblyLiteral(self, ctx:SolidityParser.AssemblyLiteralContext): + def visitAssemblyLiteral(self, ctx: SolidityParser.AssemblyLiteralContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#tupleExpression. - def visitTupleExpression(self, ctx:SolidityParser.TupleExpressionContext): + def visitTupleExpression(self, ctx: SolidityParser.TupleExpressionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#numberLiteral. - def visitNumberLiteral(self, ctx:SolidityParser.NumberLiteralContext): + def visitNumberLiteral(self, ctx: SolidityParser.NumberLiteralContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#identifier. - def visitIdentifier(self, ctx:SolidityParser.IdentifierContext): + def visitIdentifier(self, ctx: SolidityParser.IdentifierContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#hexLiteral. - def visitHexLiteral(self, ctx:SolidityParser.HexLiteralContext): + def visitHexLiteral(self, ctx: SolidityParser.HexLiteralContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#overrideSpecifier. - def visitOverrideSpecifier(self, ctx:SolidityParser.OverrideSpecifierContext): + def visitOverrideSpecifier(self, ctx: SolidityParser.OverrideSpecifierContext): return self.visitChildren(ctx) - # Visit a parse tree produced by SolidityParser#stringLiteral. - def visitStringLiteral(self, ctx:SolidityParser.StringLiteralContext): + def visitStringLiteral(self, ctx: SolidityParser.StringLiteralContext): return self.visitChildren(ctx) - -del SolidityParser \ No newline at end of file +del SolidityParser From 748d014f736d9a82bd6b5ac04e19954d8d657d4e Mon Sep 17 00:00:00 2001 From: sam bacha Date: Tue, 15 Aug 2023 09:51:08 -0700 Subject: [PATCH 2/6] build(scripts): setup build scripts --- .github/workflows/build.yml | 27 ++++++++++++++++++++++++++ scripts/antlr4.sh | 7 ------- scripts/prebuild.sh | 38 +++++++++++++++++++++++++++++++++++++ scripts/start.sh | 18 ++++++++++++++++++ 4 files changed, 83 insertions(+), 7 deletions(-) create mode 100644 .github/workflows/build.yml create mode 100755 scripts/prebuild.sh create mode 100755 scripts/start.sh diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..42913b1 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,27 @@ +# .github/workflows/pytest-ci.yml + +name: build + +on: [push, pull_request] + +jobs: + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + with: + # Repository name with owner. For example, actions/checkout + # Default: ${{ github.repository }} + repository: "" + submodules: recursive + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + python setup.py install + bash scripts/build.sh diff --git a/scripts/antlr4.sh b/scripts/antlr4.sh index 5187cf3..79ad4ae 100755 --- a/scripts/antlr4.sh +++ b/scripts/antlr4.sh @@ -3,13 +3,6 @@ set -o errexit # antlr -Dlanguage=Python3 solidity-antlr4/Solidity.g4 -o src -visitor - -git submodule sync --recursive && git submodule update --init --recursive -git submodule foreach --recursive git clean -ffdx -git submodule update --remote --rebase solidity-antlr4 - - -bash solidity-antlr4/build.sh sleep 1 [ ! -f ./solidity-antlr4/antlr4.jar ] && { echo "ANTLR4 Jar does not exist."; exit 1; } diff --git a/scripts/prebuild.sh b/scripts/prebuild.sh new file mode 100755 index 0000000..07f3a16 --- /dev/null +++ b/scripts/prebuild.sh @@ -0,0 +1,38 @@ +#!/usr/bin/env bash +# shellcheck disable=SC2034 + +echo "$JAVA_HOME" + + +ANTLR_JAR="antlr4.jar" +ANTLR_JAR_URI="https://www.antlr.org/download/antlr-4.9-complete.jar" + + +GRAMMAR="Solidity" +START_RULE="sourceUnit" +TEST_FILE="test.sol" +ERROR_PATTERN="mismatched|extraneous" + +function download_antlr4 +{ + if [[ ! -e "$ANTLR_JAR" ]] + then + curl -sL "${ANTLR_JAR_URI}" -o "${ANTLR_JAR}" + fi +} + +echo "Downloading Antlr 4.9..." + +download_antlr4 + +mkdir -p target/ + +echo "Creating parser" +( +java -jar $ANTLR_JAR $GRAMMAR.g4 -o src/ +sleep 1 +javac -classpath $ANTLR_JAR src/*.java -d target/ +) + +echo "Artifacts Generated" +exit 0 \ No newline at end of file diff --git a/scripts/start.sh b/scripts/start.sh new file mode 100755 index 0000000..04a5d26 --- /dev/null +++ b/scripts/start.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash +set -o errexit + +git submodule sync --recursive && git submodule update --init --recursive +git submodule foreach --recursive git clean -ffdx +git submodule update --remote --rebase solidity-antlr4 +sleep 1 + +[ ! -f ./scripts/build.sh ] && { echo "Solidity Antlr4 does not exist."; exit 1; } + +cp scripts/build.sh solidity-antlr4/setup.sh +bash solidity-antlr4/setup.sh +sleep 1 +bash scripts/anltr4.sh + +echo "Solidity Antlr4.9 build complete!" + +exit 0 \ No newline at end of file From 4f1cfbeb87dc29d1a62e6e6fbf07332bb87dfd7d Mon Sep 17 00:00:00 2001 From: sam bacha Date: Tue, 15 Aug 2023 09:51:45 -0700 Subject: [PATCH 3/6] ci(build): use start script --- .github/workflows/build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 42913b1..8e37d90 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -24,4 +24,4 @@ jobs: python -m pip install --upgrade pip if [ -f requirements.txt ]; then pip install -r requirements.txt; fi python setup.py install - bash scripts/build.sh + bash scripts/start.sh From 0120617fe563d2830ac7629cbd2ee539251f7902 Mon Sep 17 00:00:00 2001 From: sam bacha Date: Tue, 15 Aug 2023 09:59:13 -0700 Subject: [PATCH 4/6] ci(build): workflow fixes --- .github/workflows/build.yml | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 8e37d90..aec9938 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -2,7 +2,15 @@ name: build -on: [push, pull_request] +on: + push: + tags: + - "[0-9]+.[0-9]+" + - "[0-9]+.[0-9]+.[0-9]+" + pull_request: + paths: + - ".github/workflows/build.yml" + workflow_dispatch: {} jobs: test: @@ -10,18 +18,14 @@ jobs: steps: - uses: actions/checkout@v3 with: - # Repository name with owner. For example, actions/checkout - # Default: ${{ github.repository }} - repository: "" submodules: recursive - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v4 + - uses: actions/setup-python@v4 with: - python-version: ${{ matrix.python-version }} + python-version: "3.9" + cache: "pip" # caching pip dependencies - name: Install dependencies run: | - python -m pip install --upgrade pip - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + pip install -r requirements.txt python setup.py install bash scripts/start.sh From 0197f2f3fb2e9c57aab240860c31aa3c6257b7a5 Mon Sep 17 00:00:00 2001 From: sam bacha Date: Tue, 15 Aug 2023 10:02:31 -0700 Subject: [PATCH 5/6] fix(build): ensure submodule check --- scripts/start.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/scripts/start.sh b/scripts/start.sh index 04a5d26..552269b 100755 --- a/scripts/start.sh +++ b/scripts/start.sh @@ -6,7 +6,8 @@ git submodule foreach --recursive git clean -ffdx git submodule update --remote --rebase solidity-antlr4 sleep 1 -[ ! -f ./scripts/build.sh ] && { echo "Solidity Antlr4 does not exist."; exit 1; } +# Sanity Check that Submodules was successful +[ ! -f ./solidity-antlr4/scripts/build.sh ] && { echo "Solidity Antlr4 does not exist."; exit 1; } cp scripts/build.sh solidity-antlr4/setup.sh bash solidity-antlr4/setup.sh From 980ccd59d90ef975203deb2a427e5843d412e44c Mon Sep 17 00:00:00 2001 From: sam bacha Date: Tue, 15 Aug 2023 10:06:39 -0700 Subject: [PATCH 6/6] fix(submodules): anltr4 --- solidity-antlr4 | 1 - 1 file changed, 1 deletion(-) delete mode 160000 solidity-antlr4 diff --git a/solidity-antlr4 b/solidity-antlr4 deleted file mode 160000 index 1048147..0000000 --- a/solidity-antlr4 +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 104814708338d8d20e4e3f2deda64c557b7b2756