diff options
| author | Michael Kubacki <michael.kubacki@microsoft.com> | 2026-02-26 23:59:32 +0300 |
|---|---|---|
| committer | mergify[bot] <37929162+mergify[bot]@users.noreply.github.com> | 2026-02-28 02:18:15 +0300 |
| commit | 0cdbc92544909d1843605ba0561eb4e4519ded34 (patch) | |
| tree | e033833fcddb16d42e6f47f05e2bba3b034f77ae /BaseTools/Source/Python | |
| parent | ba8010bc6c04af4932f69acd1cbf6afa2a423a91 (diff) | |
| download | edk2-0cdbc92544909d1843605ba0561eb4e4519ded34.tar.xz | |
BaseTools/Eot: Regenerate CParser4 files with ANTLR 4.9
The CParser4 Python parser files (CLexer.py, CParser.py, CListener.py)
were generated 7 years ago with ANTLR 4.7.1.
Meanwhile, pip-requirements.txt pins antlr4-python3-runtime to version
4.9 in commit 4a7dd50, but the files were patched, not fully
regenerated. This version mismatch could result in failures when
running against non-trivial C code.
This change regenerates the CParser4 files with ANTLR 4.9 to resolve
the version mismatch. It also updates import statements to correctly
reference Eot instead of Ecc.
Steps used to regenerate the files:
1. Download the ANTLR 4.9 complete tool JAR:
- `https://www.antlr.org/download/antlr-4.9-complete.jar`
2. Generate Python3 parser files
Signed-off-by: Michael Kubacki <michael.kubacki@microsoft.com>
Diffstat (limited to 'BaseTools/Source/Python')
| -rw-r--r-- | BaseTools/Source/Python/Eot/CParser4/CLexer.py | 12 | ||||
| -rw-r--r-- | BaseTools/Source/Python/Eot/CParser4/CListener.py | 433 | ||||
| -rw-r--r-- | BaseTools/Source/Python/Eot/CParser4/CParser.py | 1384 |
3 files changed, 929 insertions, 900 deletions
diff --git a/BaseTools/Source/Python/Eot/CParser4/CLexer.py b/BaseTools/Source/Python/Eot/CParser4/CLexer.py index 6666664d6b..56f86602cc 100644 --- a/BaseTools/Source/Python/Eot/CParser4/CLexer.py +++ b/BaseTools/Source/Python/Eot/CParser4/CLexer.py @@ -1,6 +1,7 @@ -# Generated from C.g4 by ANTLR 4.7.1
+# Generated from C.g4 by ANTLR 4.9
from antlr4 import *
from io import StringIO
+from typing.io import TextIO
import sys
@@ -17,8 +18,8 @@ import sys #
##
-import Ecc.CodeFragment as CodeFragment
-import Ecc.FileProfile as FileProfile
+import Eot.CodeFragment as CodeFragment
+import Eot.FileProfile as FileProfile
def serializedATN():
@@ -581,10 +582,9 @@ class CLexer(Lexer): grammarFileName = "C.g4"
- # @param output= sys.stdout Type: TextIO
- def __init__(self,input=None,output= sys.stdout):
+ def __init__(self, input=None, output:TextIO = sys.stdout):
super().__init__(input, output)
- self.checkVersion("4.7.1")
+ self.checkVersion("4.9")
self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
self._actions = None
self._predicates = None
diff --git a/BaseTools/Source/Python/Eot/CParser4/CListener.py b/BaseTools/Source/Python/Eot/CParser4/CListener.py index 46f7f1b3d1..e6b81de39c 100644 --- a/BaseTools/Source/Python/Eot/CParser4/CListener.py +++ b/BaseTools/Source/Python/Eot/CParser4/CListener.py @@ -1,4 +1,4 @@ -# Generated from C.g4 by ANTLR 4.7.1
+# Generated from C.g4 by ANTLR 4.9
from antlr4 import *
if __name__ is not None and "." in __name__:
from .CParser import CParser
@@ -18,791 +18,650 @@ else: #
##
-import Ecc.CodeFragment as CodeFragment
-import Ecc.FileProfile as FileProfile
+import Eot.CodeFragment as CodeFragment
+import Eot.FileProfile as FileProfile
# This class defines a complete listener for a parse tree produced by CParser.
class CListener(ParseTreeListener):
# Enter a parse tree produced by CParser#translation_unit.
- # @param ctx Type: CParser.Translation_unitContext
- def enterTranslation_unit(self,ctx):
+ def enterTranslation_unit(self, ctx:CParser.Translation_unitContext):
pass
# Exit a parse tree produced by CParser#translation_unit.
- # @param ctx Type: CParser.Translation_unitContext
- def exitTranslation_unit(self,ctx):
+ def exitTranslation_unit(self, ctx:CParser.Translation_unitContext):
pass
# Enter a parse tree produced by CParser#external_declaration.
- # @param ctx Type: CParser.External_declarationContext
- def enterExternal_declaration(self,ctx):
+ def enterExternal_declaration(self, ctx:CParser.External_declarationContext):
pass
# Exit a parse tree produced by CParser#external_declaration.
- # @param ctx Type: CParser.External_declarationContext
- def exitExternal_declaration(self,ctx):
+ def exitExternal_declaration(self, ctx:CParser.External_declarationContext):
pass
# Enter a parse tree produced by CParser#function_definition.
- # @param ctx Type: CParser.Function_definitionContext
- def enterFunction_definition(self,ctx):
+ def enterFunction_definition(self, ctx:CParser.Function_definitionContext):
pass
# Exit a parse tree produced by CParser#function_definition.
- # @param ctx Type: CParser.Function_definitionContext
- def exitFunction_definition(self,ctx):
+ def exitFunction_definition(self, ctx:CParser.Function_definitionContext):
pass
# Enter a parse tree produced by CParser#declaration_specifiers.
- # @param ctx Type: CParser.Declaration_specifiersContext
- def enterDeclaration_specifiers(self,ctx):
+ def enterDeclaration_specifiers(self, ctx:CParser.Declaration_specifiersContext):
pass
# Exit a parse tree produced by CParser#declaration_specifiers.
- # @param ctx Type: CParser.Declaration_specifiersContext
- def exitDeclaration_specifiers(self,ctx):
+ def exitDeclaration_specifiers(self, ctx:CParser.Declaration_specifiersContext):
pass
# Enter a parse tree produced by CParser#declaration.
- # @param ctx Type: CParser.DeclarationContext
- def enterDeclaration(self,ctx):
+ def enterDeclaration(self, ctx:CParser.DeclarationContext):
pass
# Exit a parse tree produced by CParser#declaration.
- # @param ctx Type: CParser.DeclarationContext
- def exitDeclaration(self,ctx):
+ def exitDeclaration(self, ctx:CParser.DeclarationContext):
pass
# Enter a parse tree produced by CParser#init_declarator_list.
- # @param ctx Type: CParser.Init_declarator_listContext
- def enterInit_declarator_list(self,ctx):
+ def enterInit_declarator_list(self, ctx:CParser.Init_declarator_listContext):
pass
# Exit a parse tree produced by CParser#init_declarator_list.
- # @param ctx Type: CParser.Init_declarator_listContext
- def exitInit_declarator_list(self,ctx):
+ def exitInit_declarator_list(self, ctx:CParser.Init_declarator_listContext):
pass
# Enter a parse tree produced by CParser#init_declarator.
- # @param ctx Type: CParser.Init_declaratorContext
- def enterInit_declarator(self,ctx):
+ def enterInit_declarator(self, ctx:CParser.Init_declaratorContext):
pass
# Exit a parse tree produced by CParser#init_declarator.
- # @param ctx Type: CParser.Init_declaratorContext
- def exitInit_declarator(self,ctx):
+ def exitInit_declarator(self, ctx:CParser.Init_declaratorContext):
pass
# Enter a parse tree produced by CParser#storage_class_specifier.
- # @param ctx Type: CParser.Storage_class_specifierContext
- def enterStorage_class_specifier(self,ctx):
+ def enterStorage_class_specifier(self, ctx:CParser.Storage_class_specifierContext):
pass
# Exit a parse tree produced by CParser#storage_class_specifier.
- # @param ctx Type: CParser.Storage_class_specifierContext
- def exitStorage_class_specifier(self,ctx):
+ def exitStorage_class_specifier(self, ctx:CParser.Storage_class_specifierContext):
pass
# Enter a parse tree produced by CParser#type_specifier.
- # @param ctx Type: CParser.Type_specifierContext
- def enterType_specifier(self,ctx):
+ def enterType_specifier(self, ctx:CParser.Type_specifierContext):
pass
# Exit a parse tree produced by CParser#type_specifier.
- # @param ctx Type: CParser.Type_specifierContext
- def exitType_specifier(self,ctx):
+ def exitType_specifier(self, ctx:CParser.Type_specifierContext):
pass
# Enter a parse tree produced by CParser#type_id.
- # @param ctx Type: CParser.Type_idContext
- def enterType_id(self,ctx):
+ def enterType_id(self, ctx:CParser.Type_idContext):
pass
# Exit a parse tree produced by CParser#type_id.
- # @param ctx Type: CParser.Type_idContext
- def exitType_id(self,ctx):
+ def exitType_id(self, ctx:CParser.Type_idContext):
pass
# Enter a parse tree produced by CParser#struct_or_union_specifier.
- # @param ctx Type: CParser.Struct_or_union_specifierContext
- def enterStruct_or_union_specifier(self,ctx):
+ def enterStruct_or_union_specifier(self, ctx:CParser.Struct_or_union_specifierContext):
pass
# Exit a parse tree produced by CParser#struct_or_union_specifier.
- # @param ctx Type: CParser.Struct_or_union_specifierContext
- def exitStruct_or_union_specifier(self,ctx):
+ def exitStruct_or_union_specifier(self, ctx:CParser.Struct_or_union_specifierContext):
pass
# Enter a parse tree produced by CParser#struct_or_union.
- # @param ctx Type: CParser.Struct_or_unionContext
- def enterStruct_or_union(self,ctx):
+ def enterStruct_or_union(self, ctx:CParser.Struct_or_unionContext):
pass
# Exit a parse tree produced by CParser#struct_or_union.
- # @param ctx Type: CParser.Struct_or_unionContext
- def exitStruct_or_union(self,ctx):
+ def exitStruct_or_union(self, ctx:CParser.Struct_or_unionContext):
pass
# Enter a parse tree produced by CParser#struct_declaration_list.
- # @param ctx Type: CParser.Struct_declaration_listContext
- def enterStruct_declaration_list(self,ctx):
+ def enterStruct_declaration_list(self, ctx:CParser.Struct_declaration_listContext):
pass
# Exit a parse tree produced by CParser#struct_declaration_list.
- # @param ctx Type: CParser.Struct_declaration_listContext
- def exitStruct_declaration_list(self,ctx):
+ def exitStruct_declaration_list(self, ctx:CParser.Struct_declaration_listContext):
pass
# Enter a parse tree produced by CParser#struct_declaration.
- # @param ctx Type: CParser.Struct_declarationContext
- def enterStruct_declaration(self,ctx):
+ def enterStruct_declaration(self, ctx:CParser.Struct_declarationContext):
pass
# Exit a parse tree produced by CParser#struct_declaration.
- # @param ctx Type: CParser.Struct_declarationContext
- def exitStruct_declaration(self,ctx):
+ def exitStruct_declaration(self, ctx:CParser.Struct_declarationContext):
pass
# Enter a parse tree produced by CParser#specifier_qualifier_list.
- # @param ctx Type: CParser.Specifier_qualifier_listContext
- def enterSpecifier_qualifier_list(self,ctx):
+ def enterSpecifier_qualifier_list(self, ctx:CParser.Specifier_qualifier_listContext):
pass
# Exit a parse tree produced by CParser#specifier_qualifier_list.
- # @param ctx Type: CParser.Specifier_qualifier_listContext
- def exitSpecifier_qualifier_list(self,ctx):
+ def exitSpecifier_qualifier_list(self, ctx:CParser.Specifier_qualifier_listContext):
pass
# Enter a parse tree produced by CParser#struct_declarator_list.
- # @param ctx Type: CParser.Struct_declarator_listContext
- def enterStruct_declarator_list(self,ctx):
+ def enterStruct_declarator_list(self, ctx:CParser.Struct_declarator_listContext):
pass
# Exit a parse tree produced by CParser#struct_declarator_list.
- # @param ctx Type: CParser.Struct_declarator_listContext
- def exitStruct_declarator_list(self,ctx):
+ def exitStruct_declarator_list(self, ctx:CParser.Struct_declarator_listContext):
pass
# Enter a parse tree produced by CParser#struct_declarator.
- # @param ctx Type: CParser.Struct_declaratorContext
- def enterStruct_declarator(self,ctx):
+ def enterStruct_declarator(self, ctx:CParser.Struct_declaratorContext):
pass
# Exit a parse tree produced by CParser#struct_declarator.
- # @param ctx Type: CParser.Struct_declaratorContext
- def exitStruct_declarator(self,ctx):
+ def exitStruct_declarator(self, ctx:CParser.Struct_declaratorContext):
pass
# Enter a parse tree produced by CParser#enum_specifier.
- # @param ctx Type: CParser.Enum_specifierContext
- def enterEnum_specifier(self,ctx):
+ def enterEnum_specifier(self, ctx:CParser.Enum_specifierContext):
pass
# Exit a parse tree produced by CParser#enum_specifier.
- # @param ctx Type: CParser.Enum_specifierContext
- def exitEnum_specifier(self,ctx):
+ def exitEnum_specifier(self, ctx:CParser.Enum_specifierContext):
pass
# Enter a parse tree produced by CParser#enumerator_list.
- # @param ctx Type: CParser.Enumerator_listContext
- def enterEnumerator_list(self,ctx):
+ def enterEnumerator_list(self, ctx:CParser.Enumerator_listContext):
pass
# Exit a parse tree produced by CParser#enumerator_list.
- # @param ctx Type: CParser.Enumerator_listContext
- def exitEnumerator_list(self,ctx):
+ def exitEnumerator_list(self, ctx:CParser.Enumerator_listContext):
pass
# Enter a parse tree produced by CParser#enumerator.
- # @param ctx Type: CParser.EnumeratorContext
- def enterEnumerator(self,ctx):
+ def enterEnumerator(self, ctx:CParser.EnumeratorContext):
pass
# Exit a parse tree produced by CParser#enumerator.
- # @param ctx Type: CParser.EnumeratorContext
- def exitEnumerator(self,ctx):
+ def exitEnumerator(self, ctx:CParser.EnumeratorContext):
pass
# Enter a parse tree produced by CParser#type_qualifier.
- # @param ctx Type: CParser.Type_qualifierContext
- def enterType_qualifier(self,ctx):
+ def enterType_qualifier(self, ctx:CParser.Type_qualifierContext):
pass
# Exit a parse tree produced by CParser#type_qualifier.
- # @param ctx Type: CParser.Type_qualifierContext
- def exitType_qualifier(self,ctx):
+ def exitType_qualifier(self, ctx:CParser.Type_qualifierContext):
pass
# Enter a parse tree produced by CParser#declarator.
- # @param ctx Type: CParser.DeclaratorContext
- def enterDeclarator(self,ctx):
+ def enterDeclarator(self, ctx:CParser.DeclaratorContext):
pass
# Exit a parse tree produced by CParser#declarator.
- # @param ctx Type: CParser.DeclaratorContext
- def exitDeclarator(self,ctx):
+ def exitDeclarator(self, ctx:CParser.DeclaratorContext):
pass
# Enter a parse tree produced by CParser#direct_declarator.
- # @param ctx Type: CParser.Direct_declaratorContext
- def enterDirect_declarator(self,ctx):
+ def enterDirect_declarator(self, ctx:CParser.Direct_declaratorContext):
pass
# Exit a parse tree produced by CParser#direct_declarator.
- # @param ctx Type: CParser.Direct_declaratorContext
- def exitDirect_declarator(self,ctx):
+ def exitDirect_declarator(self, ctx:CParser.Direct_declaratorContext):
pass
# Enter a parse tree produced by CParser#declarator_suffix.
- # @param ctx Type: CParser.Declarator_suffixContext
- def enterDeclarator_suffix(self,ctx):
+ def enterDeclarator_suffix(self, ctx:CParser.Declarator_suffixContext):
pass
# Exit a parse tree produced by CParser#declarator_suffix.
- # @param ctx Type: CParser.Declarator_suffixContext
- def exitDeclarator_suffix(self,ctx):
+ def exitDeclarator_suffix(self, ctx:CParser.Declarator_suffixContext):
pass
# Enter a parse tree produced by CParser#pointer.
- # @param ctx Type: CParser.PointerContext
- def enterPointer(self,ctx):
+ def enterPointer(self, ctx:CParser.PointerContext):
pass
# Exit a parse tree produced by CParser#pointer.
- # @param ctx Type: CParser.PointerContext
- def exitPointer(self,ctx):
+ def exitPointer(self, ctx:CParser.PointerContext):
pass
# Enter a parse tree produced by CParser#parameter_type_list.
- # @param ctx Type: CParser.Parameter_type_listContext
- def enterParameter_type_list(self,ctx):
+ def enterParameter_type_list(self, ctx:CParser.Parameter_type_listContext):
pass
# Exit a parse tree produced by CParser#parameter_type_list.
- # @param ctx Type: CParser.Parameter_type_listContext
- def exitParameter_type_list(self,ctx):
+ def exitParameter_type_list(self, ctx:CParser.Parameter_type_listContext):
pass
# Enter a parse tree produced by CParser#parameter_list.
- # @param ctx Type: CParser.Parameter_listContext
- def enterParameter_list(self,ctx):
+ def enterParameter_list(self, ctx:CParser.Parameter_listContext):
pass
# Exit a parse tree produced by CParser#parameter_list.
- # @param ctx Type: CParser.Parameter_listContext
- def exitParameter_list(self,ctx):
+ def exitParameter_list(self, ctx:CParser.Parameter_listContext):
pass
# Enter a parse tree produced by CParser#parameter_declaration.
- # @param ctx Type: CParser.Parameter_declarationContext
- def enterParameter_declaration(self,ctx):
+ def enterParameter_declaration(self, ctx:CParser.Parameter_declarationContext):
pass
# Exit a parse tree produced by CParser#parameter_declaration.
- # @param ctx Type: CParser.Parameter_declarationContext
- def exitParameter_declaration(self,ctx):
+ def exitParameter_declaration(self, ctx:CParser.Parameter_declarationContext):
pass
# Enter a parse tree produced by CParser#identifier_list.
- # @param ctx Type: CParser.Identifier_listContext
- def enterIdentifier_list(self,ctx):
+ def enterIdentifier_list(self, ctx:CParser.Identifier_listContext):
pass
# Exit a parse tree produced by CParser#identifier_list.
- # @param ctx Type: CParser.Identifier_listContext
- def exitIdentifier_list(self,ctx):
+ def exitIdentifier_list(self, ctx:CParser.Identifier_listContext):
pass
# Enter a parse tree produced by CParser#type_name.
- # @param ctx Type: CParser.Type_nameContext
- def enterType_name(self,ctx):
+ def enterType_name(self, ctx:CParser.Type_nameContext):
pass
# Exit a parse tree produced by CParser#type_name.
- # @param ctx Type: CParser.Type_nameContext
- def exitType_name(self,ctx):
+ def exitType_name(self, ctx:CParser.Type_nameContext):
pass
# Enter a parse tree produced by CParser#abstract_declarator.
- # @param ctx Type: CParser.Abstract_declaratorContext
- def enterAbstract_declarator(self,ctx):
+ def enterAbstract_declarator(self, ctx:CParser.Abstract_declaratorContext):
pass
# Exit a parse tree produced by CParser#abstract_declarator.
- # @param ctx Type: CParser.Abstract_declaratorContext
- def exitAbstract_declarator(self,ctx):
+ def exitAbstract_declarator(self, ctx:CParser.Abstract_declaratorContext):
pass
# Enter a parse tree produced by CParser#direct_abstract_declarator.
- # @param ctx Type: CParser.Direct_abstract_declaratorContext
- def enterDirect_abstract_declarator(self,ctx):
+ def enterDirect_abstract_declarator(self, ctx:CParser.Direct_abstract_declaratorContext):
pass
# Exit a parse tree produced by CParser#direct_abstract_declarator.
- # @param ctx Type: CParser.Direct_abstract_declaratorContext
- def exitDirect_abstract_declarator(self,ctx):
+ def exitDirect_abstract_declarator(self, ctx:CParser.Direct_abstract_declaratorContext):
pass
# Enter a parse tree produced by CParser#abstract_declarator_suffix.
- # @param ctx Type: CParser.Abstract_declarator_suffixContext
- def enterAbstract_declarator_suffix(self,ctx):
+ def enterAbstract_declarator_suffix(self, ctx:CParser.Abstract_declarator_suffixContext):
pass
# Exit a parse tree produced by CParser#abstract_declarator_suffix.
- # @param ctx Type: CParser.Abstract_declarator_suffixContext
- def exitAbstract_declarator_suffix(self,ctx):
+ def exitAbstract_declarator_suffix(self, ctx:CParser.Abstract_declarator_suffixContext):
pass
# Enter a parse tree produced by CParser#initializer.
- # @param ctx Type: CParser.InitializerContext
- def enterInitializer(self,ctx):
+ def enterInitializer(self, ctx:CParser.InitializerContext):
pass
# Exit a parse tree produced by CParser#initializer.
- # @param ctx Type: CParser.InitializerContext
- def exitInitializer(self,ctx):
+ def exitInitializer(self, ctx:CParser.InitializerContext):
pass
# Enter a parse tree produced by CParser#initializer_list.
- # @param ctx Type: CParser.Initializer_listContext
- def enterInitializer_list(self,ctx):
+ def enterInitializer_list(self, ctx:CParser.Initializer_listContext):
pass
# Exit a parse tree produced by CParser#initializer_list.
- # @param ctx Type: CParser.Initializer_listContext
- def exitInitializer_list(self,ctx):
+ def exitInitializer_list(self, ctx:CParser.Initializer_listContext):
pass
# Enter a parse tree produced by CParser#argument_expression_list.
- # @param ctx Type: CParser.Argument_expression_listContext
- def enterArgument_expression_list(self,ctx):
+ def enterArgument_expression_list(self, ctx:CParser.Argument_expression_listContext):
pass
# Exit a parse tree produced by CParser#argument_expression_list.
- # @param ctx Type: CParser.Argument_expression_listContext
- def exitArgument_expression_list(self,ctx):
+ def exitArgument_expression_list(self, ctx:CParser.Argument_expression_listContext):
pass
# Enter a parse tree produced by CParser#additive_expression.
- # @param ctx Type: CParser.Additive_expressionContext
- def enterAdditive_expression(self,ctx):
+ def enterAdditive_expression(self, ctx:CParser.Additive_expressionContext):
pass
# Exit a parse tree produced by CParser#additive_expression.
- # @param ctx Type: CParser.Additive_expressionContext
- def exitAdditive_expression(self,ctx):
+ def exitAdditive_expression(self, ctx:CParser.Additive_expressionContext):
pass
# Enter a parse tree produced by CParser#multiplicative_expression.
- # @param ctx Type: CParser.Multiplicative_expressionContext
- def enterMultiplicative_expression(self,ctx):
+ def enterMultiplicative_expression(self, ctx:CParser.Multiplicative_expressionContext):
pass
# Exit a parse tree produced by CParser#multiplicative_expression.
- # @param ctx Type: CParser.Multiplicative_expressionContext
- def exitMultiplicative_expression(self,ctx):
+ def exitMultiplicative_expression(self, ctx:CParser.Multiplicative_expressionContext):
pass
# Enter a parse tree produced by CParser#cast_expression.
- # @param ctx Type: CParser.Cast_expressionContext
- def enterCast_expression(self,ctx):
+ def enterCast_expression(self, ctx:CParser.Cast_expressionContext):
pass
# Exit a parse tree produced by CParser#cast_expression.
- # @param ctx Type: CParser.Cast_expressionContext
- def exitCast_expression(self,ctx):
+ def exitCast_expression(self, ctx:CParser.Cast_expressionContext):
pass
# Enter a parse tree produced by CParser#unary_expression.
- # @param ctx Type: CParser.Unary_expressionContext
- def enterUnary_expression(self,ctx):
+ def enterUnary_expression(self, ctx:CParser.Unary_expressionContext):
pass
# Exit a parse tree produced by CParser#unary_expression.
- # @param ctx Type: CParser.Unary_expressionContext
- def exitUnary_expression(self,ctx):
+ def exitUnary_expression(self, ctx:CParser.Unary_expressionContext):
pass
# Enter a parse tree produced by CParser#postfix_expression.
- # @param ctx Type: CParser.Postfix_expressionContext
- def enterPostfix_expression(self,ctx):
+ def enterPostfix_expression(self, ctx:CParser.Postfix_expressionContext):
pass
# Exit a parse tree produced by CParser#postfix_expression.
- # @param ctx Type: CParser.Postfix_expressionContext
- def exitPostfix_expression(self,ctx):
+ def exitPostfix_expression(self, ctx:CParser.Postfix_expressionContext):
pass
# Enter a parse tree produced by CParser#macro_parameter_list.
- # @param ctx Type: CParser.Macro_parameter_listContext
- def enterMacro_parameter_list(self,ctx):
+ def enterMacro_parameter_list(self, ctx:CParser.Macro_parameter_listContext):
pass
# Exit a parse tree produced by CParser#macro_parameter_list.
- # @param ctx Type: CParser.Macro_parameter_listContext
- def exitMacro_parameter_list(self,ctx):
+ def exitMacro_parameter_list(self, ctx:CParser.Macro_parameter_listContext):
pass
# Enter a parse tree produced by CParser#unary_operator.
- # @param ctx Type: CParser.Unary_operatorContext
- def enterUnary_operator(self,ctx):
+ def enterUnary_operator(self, ctx:CParser.Unary_operatorContext):
pass
# Exit a parse tree produced by CParser#unary_operator.
- # @param ctx Type: CParser.Unary_operatorContext
- def exitUnary_operator(self,ctx):
+ def exitUnary_operator(self, ctx:CParser.Unary_operatorContext):
pass
# Enter a parse tree produced by CParser#primary_expression.
- # @param ctx Type: CParser.Primary_expressionContext
- def enterPrimary_expression(self,ctx):
+ def enterPrimary_expression(self, ctx:CParser.Primary_expressionContext):
pass
# Exit a parse tree produced by CParser#primary_expression.
- # @param ctx Type: CParser.Primary_expressionContext
- def exitPrimary_expression(self,ctx):
+ def exitPrimary_expression(self, ctx:CParser.Primary_expressionContext):
pass
# Enter a parse tree produced by CParser#constant.
- # @param ctx Type: CParser.ConstantContext
- def enterConstant(self,ctx):
+ def enterConstant(self, ctx:CParser.ConstantContext):
pass
# Exit a parse tree produced by CParser#constant.
- # @param ctx Type: CParser.ConstantContext
- def exitConstant(self,ctx):
+ def exitConstant(self, ctx:CParser.ConstantContext):
pass
# Enter a parse tree produced by CParser#expression.
- # @param ctx Type: CParser.ExpressionContext
- def enterExpression(self,ctx):
+ def enterExpression(self, ctx:CParser.ExpressionContext):
pass
# Exit a parse tree produced by CParser#expression.
- # @param ctx Type: CParser.ExpressionContext
- def exitExpression(self,ctx):
+ def exitExpression(self, ctx:CParser.ExpressionContext):
pass
# Enter a parse tree produced by CParser#constant_expression.
- # @param ctx Type: CParser.Constant_expressionContext
- def enterConstant_expression(self,ctx):
+ def enterConstant_expression(self, ctx:CParser.Constant_expressionContext):
pass
# Exit a parse tree produced by CParser#constant_expression.
- # @param ctx Type: CParser.Constant_expressionContext
- def exitConstant_expression(self,ctx):
+ def exitConstant_expression(self, ctx:CParser.Constant_expressionContext):
pass
# Enter a parse tree produced by CParser#assignment_expression.
- # @param ctx Type: CParser.Assignment_expressionContext
- def enterAssignment_expression(self,ctx):
+ def enterAssignment_expression(self, ctx:CParser.Assignment_expressionContext):
pass
# Exit a parse tree produced by CParser#assignment_expression.
- # @param ctx Type: CParser.Assignment_expressionContext
- def exitAssignment_expression(self,ctx):
+ def exitAssignment_expression(self, ctx:CParser.Assignment_expressionContext):
pass
# Enter a parse tree produced by CParser#lvalue.
- # @param ctx Type: CParser.LvalueContext
- def enterLvalue(self,ctx):
+ def enterLvalue(self, ctx:CParser.LvalueContext):
pass
# Exit a parse tree produced by CParser#lvalue.
- # @param ctx Type: CParser.LvalueContext
- def exitLvalue(self,ctx):
+ def exitLvalue(self, ctx:CParser.LvalueContext):
pass
# Enter a parse tree produced by CParser#assignment_operator.
- # @param ctx Type: CParser.Assignment_operatorContext
- def enterAssignment_operator(self,ctx):
+ def enterAssignment_operator(self, ctx:CParser.Assignment_operatorContext):
pass
# Exit a parse tree produced by CParser#assignment_operator.
- # @param ctx Type: CParser.Assignment_operatorContext
- def exitAssignment_operator(self,ctx):
+ def exitAssignment_operator(self, ctx:CParser.Assignment_operatorContext):
pass
# Enter a parse tree produced by CParser#conditional_expression.
- # @param ctx Type: CParser.Conditional_expressionContext
- def enterConditional_expression(self,ctx):
+ def enterConditional_expression(self, ctx:CParser.Conditional_expressionContext):
pass
# Exit a parse tree produced by CParser#conditional_expression.
- # @param ctx Type: CParser.Conditional_expressionContext
- def exitConditional_expression(self,ctx):
+ def exitConditional_expression(self, ctx:CParser.Conditional_expressionContext):
pass
# Enter a parse tree produced by CParser#logical_or_expression.
- # @param ctx Type: CParser.Logical_or_expressionContext
- def enterLogical_or_expression(self,ctx):
+ def enterLogical_or_expression(self, ctx:CParser.Logical_or_expressionContext):
pass
# Exit a parse tree produced by CParser#logical_or_expression.
- # @param ctx Type: CParser.Logical_or_expressionContext
- def exitLogical_or_expression(self,ctx):
+ def exitLogical_or_expression(self, ctx:CParser.Logical_or_expressionContext):
pass
# Enter a parse tree produced by CParser#logical_and_expression.
- # @param ctx Type: CParser.Logical_and_expressionContext
- def enterLogical_and_expression(self,ctx):
+ def enterLogical_and_expression(self, ctx:CParser.Logical_and_expressionContext):
pass
# Exit a parse tree produced by CParser#logical_and_expression.
- # @param ctx Type: CParser.Logical_and_expressionContext
- def exitLogical_and_expression(self,ctx):
+ def exitLogical_and_expression(self, ctx:CParser.Logical_and_expressionContext):
pass
# Enter a parse tree produced by CParser#inclusive_or_expression.
- # @param ctx Type: CParser.Inclusive_or_expressionContext
- def enterInclusive_or_expression(self,ctx):
+ def enterInclusive_or_expression(self, ctx:CParser.Inclusive_or_expressionContext):
pass
# Exit a parse tree produced by CParser#inclusive_or_expression.
- # @param ctx Type: CParser.Inclusive_or_expressionContext
- def exitInclusive_or_expression(self,ctx):
+ def exitInclusive_or_expression(self, ctx:CParser.Inclusive_or_expressionContext):
pass
# Enter a parse tree produced by CParser#exclusive_or_expression.
- # @param ctx Type: CParser.Exclusive_or_expressionContext
- def enterExclusive_or_expression(self,ctx):
+ def enterExclusive_or_expression(self, ctx:CParser.Exclusive_or_expressionContext):
pass
# Exit a parse tree produced by CParser#exclusive_or_expression.
- # @param ctx Type: CParser.Exclusive_or_expressionContext
- def exitExclusive_or_expression(self,ctx):
+ def exitExclusive_or_expression(self, ctx:CParser.Exclusive_or_expressionContext):
pass
# Enter a parse tree produced by CParser#and_expression.
- # @param ctx Type: CParser.And_expressionContext
- def enterAnd_expression(self,ctx):
+ def enterAnd_expression(self, ctx:CParser.And_expressionContext):
pass
# Exit a parse tree produced by CParser#and_expression.
- # @param ctx Type: CParser.And_expressionContext
- def exitAnd_expression(self,ctx):
+ def exitAnd_expression(self, ctx:CParser.And_expressionContext):
pass
# Enter a parse tree produced by CParser#equality_expression.
- # @param ctx Type: CParser.Equality_expressionContext
- def enterEquality_expression(self,ctx):
+ def enterEquality_expression(self, ctx:CParser.Equality_expressionContext):
pass
# Exit a parse tree produced by CParser#equality_expression.
- # @param ctx Type: CParser.Equality_expressionContext
- def exitEquality_expression(self,ctx):
+ def exitEquality_expression(self, ctx:CParser.Equality_expressionContext):
pass
# Enter a parse tree produced by CParser#relational_expression.
- # @param ctx Type: CParser.Relational_expressionContext
- def enterRelational_expression(self,ctx):
+ def enterRelational_expression(self, ctx:CParser.Relational_expressionContext):
pass
# Exit a parse tree produced by CParser#relational_expression.
- # @param ctx Type: CParser.Relational_expressionContext
- def exitRelational_expression(self,ctx):
+ def exitRelational_expression(self, ctx:CParser.Relational_expressionContext):
pass
# Enter a parse tree produced by CParser#shift_expression.
- # @param ctx Type: CParser.Shift_expressionContext
- def enterShift_expression(self,ctx):
+ def enterShift_expression(self, ctx:CParser.Shift_expressionContext):
pass
# Exit a parse tree produced by CParser#shift_expression.
- # @param ctx Type: CParser.Shift_expressionContext
- def exitShift_expression(self,ctx):
+ def exitShift_expression(self, ctx:CParser.Shift_expressionContext):
pass
# Enter a parse tree produced by CParser#statement.
- # @param ctx Type: CParser.StatementContext
- def enterStatement(self,ctx):
+ def enterStatement(self, ctx:CParser.StatementContext):
pass
# Exit a parse tree produced by CParser#statement.
- # @param ctx Type: CParser.StatementContext
- def exitStatement(self,ctx):
+ def exitStatement(self, ctx:CParser.StatementContext):
pass
# Enter a parse tree produced by CParser#asm2_statement.
- # @param ctx Type: CParser.Asm2_statementContext
- def enterAsm2_statement(self,ctx):
+ def enterAsm2_statement(self, ctx:CParser.Asm2_statementContext):
pass
# Exit a parse tree produced by CParser#asm2_statement.
- # @param ctx Type: CParser.Asm2_statementContext
- def exitAsm2_statement(self,ctx):
+ def exitAsm2_statement(self, ctx:CParser.Asm2_statementContext):
pass
# Enter a parse tree produced by CParser#asm1_statement.
- # @param ctx Type: CParser.Asm1_statementContext
- def enterAsm1_statement(self,ctx):
+ def enterAsm1_statement(self, ctx:CParser.Asm1_statementContext):
pass
# Exit a parse tree produced by CParser#asm1_statement.
- # @param ctx Type: CParser.Asm1_statementContext
- def exitAsm1_statement(self,ctx):
+ def exitAsm1_statement(self, ctx:CParser.Asm1_statementContext):
pass
# Enter a parse tree produced by CParser#asm_statement.
- # @param ctx Type: CParser.Asm_statementContext
- def enterAsm_statement(self,ctx):
+ def enterAsm_statement(self, ctx:CParser.Asm_statementContext):
pass
# Exit a parse tree produced by CParser#asm_statement.
- # @param ctx Type: CParser.Asm_statementContext
- def exitAsm_statement(self,ctx):
+ def exitAsm_statement(self, ctx:CParser.Asm_statementContext):
pass
# Enter a parse tree produced by CParser#macro_statement.
- # @param ctx Type: CParser.Macro_statementContext
- def enterMacro_statement(self,ctx):
+ def enterMacro_statement(self, ctx:CParser.Macro_statementContext):
pass
# Exit a parse tree produced by CParser#macro_statement.
- # @param ctx Type: CParser.Macro_statementContext
- def exitMacro_statement(self,ctx):
+ def exitMacro_statement(self, ctx:CParser.Macro_statementContext):
pass
# Enter a parse tree produced by CParser#labeled_statement.
- # @param ctx Type: CParser.Labeled_statementContext
- def enterLabeled_statement(self,ctx):
+ def enterLabeled_statement(self, ctx:CParser.Labeled_statementContext):
pass
# Exit a parse tree produced by CParser#labeled_statement.
- # @param ctx Type: CParser.Labeled_statementContext
- def exitLabeled_statement(self,ctx):
+ def exitLabeled_statement(self, ctx:CParser.Labeled_statementContext):
pass
# Enter a parse tree produced by CParser#compound_statement.
- # @param ctx Type: CParser.Compound_statementContext
- def enterCompound_statement(self,ctx):
+ def enterCompound_statement(self, ctx:CParser.Compound_statementContext):
pass
# Exit a parse tree produced by CParser#compound_statement.
- # @param ctx Type: CParser.Compound_statementContext
- def exitCompound_statement(self,ctx):
+ def exitCompound_statement(self, ctx:CParser.Compound_statementContext):
pass
# Enter a parse tree produced by CParser#statement_list.
- # @param ctx Type: CParser.Statement_listContext
- def enterStatement_list(self,ctx):
+ def enterStatement_list(self, ctx:CParser.Statement_listContext):
pass
# Exit a parse tree produced by CParser#statement_list.
- # @param ctx Type: CParser.Statement_listContext
- def exitStatement_list(self,ctx):
+ def exitStatement_list(self, ctx:CParser.Statement_listContext):
pass
# Enter a parse tree produced by CParser#expression_statement.
- # @param ctx Type: CParser.Expression_statementContext
- def enterExpression_statement(self,ctx):
+ def enterExpression_statement(self, ctx:CParser.Expression_statementContext):
pass
# Exit a parse tree produced by CParser#expression_statement.
- # @param ctx Type: CParser.Expression_statementContext
- def exitExpression_statement(self,ctx):
+ def exitExpression_statement(self, ctx:CParser.Expression_statementContext):
pass
# Enter a parse tree produced by CParser#selection_statement.
- # @param ctx Type: CParser.Selection_statementContext
- def enterSelection_statement(self,ctx):
+ def enterSelection_statement(self, ctx:CParser.Selection_statementContext):
pass
# Exit a parse tree produced by CParser#selection_statement.
- # @param ctx Type: CParser.Selection_statementContext
- def exitSelection_statement(self,ctx):
+ def exitSelection_statement(self, ctx:CParser.Selection_statementContext):
pass
# Enter a parse tree produced by CParser#iteration_statement.
- # @param ctx Type: CParser.Iteration_statementContext
- def enterIteration_statement(self,ctx):
+ def enterIteration_statement(self, ctx:CParser.Iteration_statementContext):
pass
# Exit a parse tree produced by CParser#iteration_statement.
- # @param ctx Type: CParser.Iteration_statementContext
- def exitIteration_statement(self,ctx):
+ def exitIteration_statement(self, ctx:CParser.Iteration_statementContext):
pass
# Enter a parse tree produced by CParser#jump_statement.
- # @param ctx Type: CParser.Jump_statementContext
- def enterJump_statement(self,ctx):
+ def enterJump_statement(self, ctx:CParser.Jump_statementContext):
pass
# Exit a parse tree produced by CParser#jump_statement.
- # @param ctx Type: CParser.Jump_statementContext
- def exitJump_statement(self,ctx):
+ def exitJump_statement(self, ctx:CParser.Jump_statementContext):
pass
+del CParser
diff --git a/BaseTools/Source/Python/Eot/CParser4/CParser.py b/BaseTools/Source/Python/Eot/CParser4/CParser.py index 3946497f81..d8f76a2877 100644 --- a/BaseTools/Source/Python/Eot/CParser4/CParser.py +++ b/BaseTools/Source/Python/Eot/CParser4/CParser.py @@ -1,8 +1,12 @@ -# Generated from C.g4 by ANTLR 4.7.1
+# Generated from C.g4 by ANTLR 4.9
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
+if sys.version_info[1] > 5:
+ from typing import TextIO
+else:
+ from typing.io import TextIO
## @file
@@ -18,8 +22,8 @@ import sys #
##
-import Ecc.CodeFragment as CodeFragment
-import Ecc.FileProfile as FileProfile
+import Eot.CodeFragment as CodeFragment
+import Eot.FileProfile as FileProfile
def serializedATN():
with StringIO() as buf:
@@ -734,11 +738,9 @@ class CParser ( Parser ): LINE_COMMENT=104
LINE_COMMAND=105
- # @param input Type: TokenStream
- # @param output= sys.stdout Type: TextIO
- def __init__(self,input,output= sys.stdout):
+ def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
super().__init__(input, output)
- self.checkVersion("4.7.1")
+ self.checkVersion("4.9")
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
self._predicates = None
@@ -778,16 +780,14 @@ class CParser ( Parser ): +
class Translation_unitContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def external_declaration(self,i=None):
+ def external_declaration(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.External_declarationContext)
else:
@@ -797,16 +797,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_translation_unit
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTranslation_unit" ):
listener.enterTranslation_unit(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTranslation_unit" ):
listener.exitTranslation_unit(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitTranslation_unit" ):
+ return visitor.visitTranslation_unit(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -835,11 +839,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class External_declarationContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -851,8 +854,7 @@ class CParser ( Parser ): return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
- # @param i=None Type: int
- def declaration(self,i=None):
+ def declaration(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.DeclarationContext)
else:
@@ -870,16 +872,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_external_declaration
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExternal_declaration" ):
listener.enterExternal_declaration(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExternal_declaration" ):
listener.exitExternal_declaration(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitExternal_declaration" ):
+ return visitor.visitExternal_declaration(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -953,11 +959,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Function_definitionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.ModifierText = ''
@@ -984,8 +989,7 @@ class CParser ( Parser ): return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
- # @param i=None Type: int
- def declaration(self,i=None):
+ def declaration(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.DeclarationContext)
else:
@@ -995,16 +999,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_function_definition
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFunction_definition" ):
listener.enterFunction_definition(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFunction_definition" ):
listener.exitFunction_definition(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitFunction_definition" ):
+ return visitor.visitFunction_definition(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1061,10 +1069,10 @@ class CParser ( Parser ): if localctx.d != None:
- ModifierText = (None if localctx._declaration_specifiers is None else self._input.getText((localctx._declaration_specifiers.start,localctx._declaration_specifiers.stop)))
+ ModifierText = (None if localctx._declaration_specifiers is None else self._input.getText(localctx._declaration_specifiers.start,localctx._declaration_specifiers.stop))
else:
ModifierText = ''
- DeclText = (None if localctx._declarator is None else self._input.getText((localctx._declarator.start,localctx._declarator.stop)))
+ DeclText = (None if localctx._declarator is None else self._input.getText(localctx._declarator.start,localctx._declarator.stop))
DeclLine = (None if localctx._declarator is None else localctx._declarator.start).line
DeclOffset = (None if localctx._declarator is None else localctx._declarator.start).column
if localctx.a != None:
@@ -1086,32 +1094,28 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Declaration_specifiersContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def storage_class_specifier(self,i=None):
+ def storage_class_specifier(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Storage_class_specifierContext)
else:
return self.getTypedRuleContext(CParser.Storage_class_specifierContext,i)
- # @param i=None Type: int
- def type_specifier(self,i=None):
+ def type_specifier(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Type_specifierContext)
else:
return self.getTypedRuleContext(CParser.Type_specifierContext,i)
- # @param i=None Type: int
- def type_qualifier(self,i=None):
+ def type_qualifier(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Type_qualifierContext)
else:
@@ -1121,16 +1125,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_declaration_specifiers
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclaration_specifiers" ):
listener.enterDeclaration_specifiers(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclaration_specifiers" ):
listener.exitDeclaration_specifiers(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDeclaration_specifiers" ):
+ return visitor.visitDeclaration_specifiers(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1178,11 +1186,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class DeclarationContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.a = None # Token
@@ -1204,16 +1211,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_declaration
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclaration" ):
listener.enterDeclaration(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclaration" ):
listener.exitDeclaration(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDeclaration" ):
+ return visitor.visitDeclaration(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1244,9 +1255,9 @@ class CParser ( Parser ): localctx.d = self.match(CParser.T__1)
if localctx.b is not None:
- self.StoreTypedefDefinition(localctx.a.line, localctx.a.column, (0 if localctx.d is None else localctx.d.line), localctx.d.column, (None if localctx.b is None else self._input.getText((localctx.b.start,localctx.b.stop))), (None if localctx.c is None else self._input.getText((localctx.c.start,localctx.c.stop))))
+ self.StoreTypedefDefinition(localctx.a.line, localctx.a.column, (0 if localctx.d is None else localctx.d.line), localctx.d.column, (None if localctx.b is None else self._input.getText(localctx.b.start,localctx.b.stop)), (None if localctx.c is None else self._input.getText(localctx.c.start,localctx.c.stop)))
else:
- self.StoreTypedefDefinition(localctx.a.line, localctx.a.column, (0 if localctx.d is None else localctx.d.line), localctx.d.column, '', (None if localctx.c is None else self._input.getText((localctx.c.start,localctx.c.stop))))
+ self.StoreTypedefDefinition(localctx.a.line, localctx.a.column, (0 if localctx.d is None else localctx.d.line), localctx.d.column, '', (None if localctx.c is None else self._input.getText(localctx.c.start,localctx.c.stop)))
pass
elif token in [CParser.T__5, CParser.T__6, CParser.T__7, CParser.T__8, CParser.T__9, CParser.T__10, CParser.T__11, CParser.T__12, CParser.T__13, CParser.T__14, CParser.T__15, CParser.T__16, CParser.T__17, CParser.T__18, CParser.T__20, CParser.T__21, CParser.T__23, CParser.T__24, CParser.T__25, CParser.T__26, CParser.T__27, CParser.T__28, CParser.T__29, CParser.T__30, CParser.T__31, CParser.T__32, CParser.T__33, CParser.T__34, CParser.T__35, CParser.T__36, CParser.IDENTIFIER]:
@@ -1265,7 +1276,7 @@ class CParser ( Parser ): localctx.e = self.match(CParser.T__1)
if localctx.t is not None:
- self.StoreVariableDeclaration((None if localctx.s is None else localctx.s.start).line, (None if localctx.s is None else localctx.s.start).column, (None if localctx.t is None else localctx.t.start).line, (None if localctx.t is None else localctx.t.start).column, (None if localctx.s is None else self._input.getText((localctx.s.start,localctx.s.stop))), (None if localctx.t is None else self._input.getText((localctx.t.start,localctx.t.stop))))
+ self.StoreVariableDeclaration((None if localctx.s is None else localctx.s.start).line, (None if localctx.s is None else localctx.s.start).column, (None if localctx.t is None else localctx.t.start).line, (None if localctx.t is None else localctx.t.start).column, (None if localctx.s is None else self._input.getText(localctx.s.start,localctx.s.stop)), (None if localctx.t is None else self._input.getText(localctx.t.start,localctx.t.stop)))
pass
else:
@@ -1279,16 +1290,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Init_declarator_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def init_declarator(self,i=None):
+ def init_declarator(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Init_declaratorContext)
else:
@@ -1298,16 +1307,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_init_declarator_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInit_declarator_list" ):
listener.enterInit_declarator_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInit_declarator_list" ):
listener.exitInit_declarator_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitInit_declarator_list" ):
+ return visitor.visitInit_declarator_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1340,11 +1353,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Init_declaratorContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -1359,16 +1371,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_init_declarator
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInit_declarator" ):
listener.enterInit_declarator(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInit_declarator" ):
listener.exitInit_declarator(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitInit_declarator" ):
+ return visitor.visitInit_declarator(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1399,11 +1415,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Storage_class_specifierContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -1411,16 +1426,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_storage_class_specifier
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStorage_class_specifier" ):
listener.enterStorage_class_specifier(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStorage_class_specifier" ):
listener.exitStorage_class_specifier(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStorage_class_specifier" ):
+ return visitor.visitStorage_class_specifier(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1446,11 +1465,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Type_specifierContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.s = None # Struct_or_union_specifierContext
@@ -1471,8 +1489,7 @@ class CParser ( Parser ): return self.getTypedRuleContext(CParser.DeclaratorContext,0)
- # @param i=None Type: int
- def type_qualifier(self,i=None):
+ def type_qualifier(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Type_qualifierContext)
else:
@@ -1486,16 +1503,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_type_specifier
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterType_specifier" ):
listener.enterType_specifier(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitType_specifier" ):
listener.exitType_specifier(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitType_specifier" ):
+ return visitor.visitType_specifier(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1567,7 +1588,7 @@ class CParser ( Parser ): localctx.s = self.struct_or_union_specifier()
if localctx.s.stop is not None:
- self.StoreStructUnionDefinition((None if localctx.s is None else localctx.s.start).line, (None if localctx.s is None else localctx.s.start).column, (None if localctx.s is None else localctx.s.stop).line, (None if localctx.s is None else localctx.s.stop).column, (None if localctx.s is None else self._input.getText((localctx.s.start,localctx.s.stop))))
+ self.StoreStructUnionDefinition((None if localctx.s is None else localctx.s.start).line, (None if localctx.s is None else localctx.s.start).column, (None if localctx.s is None else localctx.s.stop).line, (None if localctx.s is None else localctx.s.stop).column, (None if localctx.s is None else self._input.getText(localctx.s.start,localctx.s.stop)))
pass
@@ -1577,7 +1598,7 @@ class CParser ( Parser ): localctx.e = self.enum_specifier()
if localctx.e.stop is not None:
- self.StoreEnumerationDefinition((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
+ self.StoreEnumerationDefinition((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText(localctx.e.start,localctx.e.stop)))
pass
@@ -1615,11 +1636,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Type_idContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -1629,16 +1649,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_type_id
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterType_id" ):
listener.enterType_id(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitType_id" ):
listener.exitType_id(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitType_id" ):
+ return visitor.visitType_id(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1658,11 +1682,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Struct_or_union_specifierContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -1680,16 +1703,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_struct_or_union_specifier
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStruct_or_union_specifier" ):
listener.enterStruct_or_union_specifier(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStruct_or_union_specifier" ):
listener.exitStruct_or_union_specifier(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStruct_or_union_specifier" ):
+ return visitor.visitStruct_or_union_specifier(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1739,11 +1766,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Struct_or_unionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -1751,16 +1777,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_struct_or_union
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStruct_or_union" ):
listener.enterStruct_or_union(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStruct_or_union" ):
listener.exitStruct_or_union(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStruct_or_union" ):
+ return visitor.visitStruct_or_union(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1786,16 +1816,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Struct_declaration_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def struct_declaration(self,i=None):
+ def struct_declaration(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Struct_declarationContext)
else:
@@ -1805,16 +1833,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_struct_declaration_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStruct_declaration_list" ):
listener.enterStruct_declaration_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStruct_declaration_list" ):
listener.exitStruct_declaration_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStruct_declaration_list" ):
+ return visitor.visitStruct_declaration_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1845,11 +1877,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Struct_declarationContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -1864,16 +1895,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_struct_declaration
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStruct_declaration" ):
listener.enterStruct_declaration(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStruct_declaration" ):
listener.exitStruct_declaration(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStruct_declaration" ):
+ return visitor.visitStruct_declaration(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1897,24 +1932,21 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Specifier_qualifier_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def type_qualifier(self,i=None):
+ def type_qualifier(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Type_qualifierContext)
else:
return self.getTypedRuleContext(CParser.Type_qualifierContext,i)
- # @param i=None Type: int
- def type_specifier(self,i=None):
+ def type_specifier(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Type_specifierContext)
else:
@@ -1924,16 +1956,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_specifier_qualifier_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSpecifier_qualifier_list" ):
listener.enterSpecifier_qualifier_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSpecifier_qualifier_list" ):
listener.exitSpecifier_qualifier_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSpecifier_qualifier_list" ):
+ return visitor.visitSpecifier_qualifier_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -1977,16 +2013,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Struct_declarator_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def struct_declarator(self,i=None):
+ def struct_declarator(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Struct_declaratorContext)
else:
@@ -1996,16 +2030,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_struct_declarator_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStruct_declarator_list" ):
listener.enterStruct_declarator_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStruct_declarator_list" ):
listener.exitStruct_declarator_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStruct_declarator_list" ):
+ return visitor.visitStruct_declarator_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2038,11 +2076,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Struct_declaratorContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -2057,16 +2094,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_struct_declarator
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStruct_declarator" ):
listener.enterStruct_declarator(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStruct_declarator" ):
listener.exitStruct_declarator(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStruct_declarator" ):
+ return visitor.visitStruct_declarator(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2112,11 +2153,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Enum_specifierContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -2130,16 +2170,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_enum_specifier
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnum_specifier" ):
listener.enterEnum_specifier(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnum_specifier" ):
listener.exitEnum_specifier(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEnum_specifier" ):
+ return visitor.visitEnum_specifier(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2211,16 +2255,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Enumerator_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def enumerator(self,i=None):
+ def enumerator(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.EnumeratorContext)
else:
@@ -2230,16 +2272,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_enumerator_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumerator_list" ):
listener.enterEnumerator_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumerator_list" ):
listener.exitEnumerator_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEnumerator_list" ):
+ return visitor.visitEnumerator_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2272,11 +2318,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class EnumeratorContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -2290,16 +2335,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_enumerator
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnumerator" ):
listener.enterEnumerator(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnumerator" ):
listener.exitEnumerator(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEnumerator" ):
+ return visitor.visitEnumerator(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2330,11 +2379,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Type_qualifierContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -2342,16 +2390,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_type_qualifier
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterType_qualifier" ):
listener.enterType_qualifier(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitType_qualifier" ):
listener.exitType_qualifier(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitType_qualifier" ):
+ return visitor.visitType_qualifier(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2377,11 +2429,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class DeclaratorContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -2396,16 +2447,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_declarator
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclarator" ):
listener.enterDeclarator(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclarator" ):
listener.exitDeclarator(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDeclarator" ):
+ return visitor.visitDeclarator(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2471,19 +2526,17 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Direct_declaratorContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def IDENTIFIER(self):
return self.getToken(CParser.IDENTIFIER, 0)
- # @param i=None Type: int
- def declarator_suffix(self,i=None):
+ def declarator_suffix(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Declarator_suffixContext)
else:
@@ -2497,16 +2550,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_direct_declarator
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDirect_declarator" ):
listener.enterDirect_declarator(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDirect_declarator" ):
listener.exitDirect_declarator(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDirect_declarator" ):
+ return visitor.visitDirect_declarator(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2576,11 +2633,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Declarator_suffixContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -2599,16 +2655,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_declarator_suffix
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDeclarator_suffix" ):
listener.enterDeclarator_suffix(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDeclarator_suffix" ):
listener.exitDeclarator_suffix(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDeclarator_suffix" ):
+ return visitor.visitDeclarator_suffix(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2675,16 +2735,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class PointerContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def type_qualifier(self,i=None):
+ def type_qualifier(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Type_qualifierContext)
else:
@@ -2698,16 +2756,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_pointer
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPointer" ):
listener.enterPointer(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPointer" ):
listener.exitPointer(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPointer" ):
+ return visitor.visitPointer(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2770,11 +2832,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Parameter_type_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -2785,16 +2846,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_parameter_type_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParameter_type_list" ):
listener.enterParameter_type_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParameter_type_list" ):
listener.exitParameter_type_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitParameter_type_list" ):
+ return visitor.visitParameter_type_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2833,16 +2898,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Parameter_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def parameter_declaration(self,i=None):
+ def parameter_declaration(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Parameter_declarationContext)
else:
@@ -2852,16 +2915,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_parameter_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParameter_list" ):
listener.enterParameter_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParameter_list" ):
listener.exitParameter_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitParameter_list" ):
+ return visitor.visitParameter_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -2902,11 +2969,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Parameter_declarationContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -2914,16 +2980,14 @@ class CParser ( Parser ): return self.getTypedRuleContext(CParser.Declaration_specifiersContext,0)
- # @param i=None Type: int
- def declarator(self,i=None):
+ def declarator(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.DeclaratorContext)
else:
return self.getTypedRuleContext(CParser.DeclaratorContext,i)
- # @param i=None Type: int
- def abstract_declarator(self,i=None):
+ def abstract_declarator(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Abstract_declaratorContext)
else:
@@ -2933,8 +2997,7 @@ class CParser ( Parser ): def IDENTIFIER(self):
return self.getToken(CParser.IDENTIFIER, 0)
- # @param i=None Type: int
- def pointer(self,i=None):
+ def pointer(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.PointerContext)
else:
@@ -2944,16 +3007,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_parameter_declaration
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParameter_declaration" ):
listener.enterParameter_declaration(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParameter_declaration" ):
listener.exitParameter_declaration(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitParameter_declaration" ):
+ return visitor.visitParameter_declaration(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3027,16 +3094,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Identifier_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def IDENTIFIER(self,i=None):
+ def IDENTIFIER(self, i:int=None):
if i is None:
return self.getTokens(CParser.IDENTIFIER)
else:
@@ -3045,16 +3110,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_identifier_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIdentifier_list" ):
listener.enterIdentifier_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIdentifier_list" ):
listener.exitIdentifier_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitIdentifier_list" ):
+ return visitor.visitIdentifier_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3087,11 +3156,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Type_nameContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -3110,16 +3178,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_type_name
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterType_name" ):
listener.enterType_name(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitType_name" ):
listener.exitType_name(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitType_name" ):
+ return visitor.visitType_name(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3161,11 +3233,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Abstract_declaratorContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -3180,16 +3251,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_abstract_declarator
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAbstract_declarator" ):
listener.enterAbstract_declarator(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAbstract_declarator" ):
listener.exitAbstract_declarator(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAbstract_declarator" ):
+ return visitor.visitAbstract_declarator(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3230,11 +3305,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Direct_abstract_declaratorContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -3242,8 +3316,7 @@ class CParser ( Parser ): return self.getTypedRuleContext(CParser.Abstract_declaratorContext,0)
- # @param i=None Type: int
- def abstract_declarator_suffix(self,i=None):
+ def abstract_declarator_suffix(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Abstract_declarator_suffixContext)
else:
@@ -3253,16 +3326,21 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_direct_abstract_declarator
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDirect_abstract_declarator" ):
listener.enterDirect_abstract_declarator(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDirect_abstract_declarator" ):
listener.exitDirect_abstract_declarator(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDirect_abstract_declarator" ):
+ return visitor.visitDirect_abstract_declarator(self)
+ else:
+ return visitor.visitChildren(self)
+
+
def direct_abstract_declarator(self):
@@ -3308,11 +3386,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Abstract_declarator_suffixContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -3327,16 +3404,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_abstract_declarator_suffix
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAbstract_declarator_suffix" ):
listener.enterAbstract_declarator_suffix(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAbstract_declarator_suffix" ):
listener.exitAbstract_declarator_suffix(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAbstract_declarator_suffix" ):
+ return visitor.visitAbstract_declarator_suffix(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3393,11 +3474,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class InitializerContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -3412,16 +3492,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_initializer
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInitializer" ):
listener.enterInitializer(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInitializer" ):
listener.exitInitializer(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitInitializer" ):
+ return visitor.visitInitializer(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3467,16 +3551,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Initializer_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def initializer(self,i=None):
+ def initializer(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.InitializerContext)
else:
@@ -3486,16 +3568,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_initializer_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInitializer_list" ):
listener.enterInitializer_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInitializer_list" ):
listener.exitInitializer_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitInitializer_list" ):
+ return visitor.visitInitializer_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3528,16 +3614,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Argument_expression_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def assignment_expression(self,i=None):
+ def assignment_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Assignment_expressionContext)
else:
@@ -3547,16 +3631,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_argument_expression_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArgument_expression_list" ):
listener.enterArgument_expression_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArgument_expression_list" ):
listener.exitArgument_expression_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitArgument_expression_list" ):
+ return visitor.visitArgument_expression_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3605,16 +3693,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Additive_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def multiplicative_expression(self,i=None):
+ def multiplicative_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Multiplicative_expressionContext)
else:
@@ -3624,16 +3710,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_additive_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAdditive_expression" ):
listener.enterAdditive_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAdditive_expression" ):
listener.exitAdditive_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAdditive_expression" ):
+ return visitor.visitAdditive_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3680,16 +3770,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Multiplicative_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def cast_expression(self,i=None):
+ def cast_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Cast_expressionContext)
else:
@@ -3699,16 +3787,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_multiplicative_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMultiplicative_expression" ):
listener.enterMultiplicative_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMultiplicative_expression" ):
listener.exitMultiplicative_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMultiplicative_expression" ):
+ return visitor.visitMultiplicative_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3761,11 +3853,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Cast_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -3784,16 +3875,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_cast_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCast_expression" ):
listener.enterCast_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCast_expression" ):
listener.exitCast_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCast_expression" ):
+ return visitor.visitCast_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3832,11 +3927,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Unary_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -3863,16 +3957,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_unary_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnary_expression" ):
listener.enterUnary_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnary_expression" ):
listener.exitUnary_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitUnary_expression" ):
+ return visitor.visitUnary_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -3943,11 +4041,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Postfix_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.FuncCallText = ''
@@ -3963,32 +4060,28 @@ class CParser ( Parser ): return self.getTypedRuleContext(CParser.Primary_expressionContext,0)
- # @param i=None Type: int
- def expression(self,i=None):
+ def expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.ExpressionContext)
else:
return self.getTypedRuleContext(CParser.ExpressionContext,i)
- # @param i=None Type: int
- def macro_parameter_list(self,i=None):
+ def macro_parameter_list(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Macro_parameter_listContext)
else:
return self.getTypedRuleContext(CParser.Macro_parameter_listContext,i)
- # @param i=None Type: int
- def argument_expression_list(self,i=None):
+ def argument_expression_list(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Argument_expression_listContext)
else:
return self.getTypedRuleContext(CParser.Argument_expression_listContext,i)
- # @param i=None Type: int
- def IDENTIFIER(self,i=None):
+ def IDENTIFIER(self, i:int=None):
if i is None:
return self.getTokens(CParser.IDENTIFIER)
else:
@@ -3997,16 +4090,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_postfix_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPostfix_expression" ):
listener.enterPostfix_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPostfix_expression" ):
listener.exitPostfix_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPostfix_expression" ):
+ return visitor.visitPostfix_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4021,7 +4118,7 @@ class CParser ( Parser ): self.enterOuterAlt(localctx, 1)
self.state = 569
localctx.p = self.primary_expression()
- self.FuncCallText += (None if localctx.p is None else self._input.getText((localctx.p.start,localctx.p.stop)))
+ self.FuncCallText += (None if localctx.p is None else self._input.getText(localctx.p.start,localctx.p.stop))
self.state = 600
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,73,self._ctx)
@@ -4054,7 +4151,7 @@ class CParser ( Parser ): localctx.c = self.argument_expression_list()
self.state = 580
localctx.b = self.match(CParser.T__38)
- self.StoreFunctionCalling((None if localctx.p is None else localctx.p.start).line, (None if localctx.p is None else localctx.p.start).column, (0 if localctx.b is None else localctx.b.line), localctx.b.column, self.FuncCallText, (None if localctx.c is None else self._input.getText((localctx.c.start,localctx.c.stop))))
+ self.StoreFunctionCalling((None if localctx.p is None else localctx.p.start).line, (None if localctx.p is None else localctx.p.start).column, (0 if localctx.b is None else localctx.b.line), localctx.b.column, self.FuncCallText, (None if localctx.c is None else self._input.getText(localctx.c.start,localctx.c.stop)))
pass
elif la_ == 4:
@@ -4113,16 +4210,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Macro_parameter_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def parameter_declaration(self,i=None):
+ def parameter_declaration(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Parameter_declarationContext)
else:
@@ -4132,16 +4227,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_macro_parameter_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMacro_parameter_list" ):
listener.enterMacro_parameter_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMacro_parameter_list" ):
listener.exitMacro_parameter_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMacro_parameter_list" ):
+ return visitor.visitMacro_parameter_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4174,11 +4273,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Unary_operatorContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -4186,16 +4284,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_unary_operator
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterUnary_operator" ):
listener.enterUnary_operator(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitUnary_operator" ):
listener.exitUnary_operator(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitUnary_operator" ):
+ return visitor.visitUnary_operator(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4221,11 +4323,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Primary_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -4243,16 +4344,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_primary_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPrimary_expression" ):
listener.enterPrimary_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPrimary_expression" ):
listener.exitPrimary_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPrimary_expression" ):
+ return visitor.visitPrimary_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4295,11 +4400,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class ConstantContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -4315,15 +4419,13 @@ class CParser ( Parser ): def CHARACTER_LITERAL(self):
return self.getToken(CParser.CHARACTER_LITERAL, 0)
- # @param i=None Type: int
- def IDENTIFIER(self,i=None):
+ def IDENTIFIER(self, i:int=None):
if i is None:
return self.getTokens(CParser.IDENTIFIER)
else:
return self.getToken(CParser.IDENTIFIER, i)
- # @param i=None Type: int
- def STRING_LITERAL(self,i=None):
+ def STRING_LITERAL(self, i:int=None):
if i is None:
return self.getTokens(CParser.STRING_LITERAL)
else:
@@ -4335,16 +4437,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_constant
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConstant" ):
listener.enterConstant(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConstant" ):
listener.exitConstant(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitConstant" ):
+ return visitor.visitConstant(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4442,16 +4548,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class ExpressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def assignment_expression(self,i=None):
+ def assignment_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Assignment_expressionContext)
else:
@@ -4461,16 +4565,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExpression" ):
listener.enterExpression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExpression" ):
listener.exitExpression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitExpression" ):
+ return visitor.visitExpression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4503,11 +4611,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Constant_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -4518,16 +4625,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_constant_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConstant_expression" ):
listener.enterConstant_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConstant_expression" ):
listener.exitConstant_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitConstant_expression" ):
+ return visitor.visitConstant_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4547,11 +4658,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Assignment_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -4574,16 +4684,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_assignment_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssignment_expression" ):
listener.enterAssignment_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssignment_expression" ):
listener.exitAssignment_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAssignment_expression" ):
+ return visitor.visitAssignment_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4620,11 +4734,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class LvalueContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -4635,16 +4748,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_lvalue
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLvalue" ):
listener.enterLvalue(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLvalue" ):
listener.exitLvalue(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitLvalue" ):
+ return visitor.visitLvalue(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4664,11 +4781,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Assignment_operatorContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -4676,16 +4792,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_assignment_operator
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssignment_operator" ):
listener.enterAssignment_operator(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssignment_operator" ):
listener.exitAssignment_operator(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAssignment_operator" ):
+ return visitor.visitAssignment_operator(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4711,11 +4831,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Conditional_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.e = None # Logical_or_expressionContext
@@ -4735,16 +4854,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_conditional_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterConditional_expression" ):
listener.enterConditional_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitConditional_expression" ):
listener.exitConditional_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitConditional_expression" ):
+ return visitor.visitConditional_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4769,7 +4892,7 @@ class CParser ( Parser ): self.match(CParser.T__22)
self.state = 674
self.conditional_expression()
- self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
+ self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText(localctx.e.start,localctx.e.stop)))
except RecognitionException as re:
@@ -4780,16 +4903,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Logical_or_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def logical_and_expression(self,i=None):
+ def logical_and_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Logical_and_expressionContext)
else:
@@ -4799,16 +4920,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_logical_or_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLogical_or_expression" ):
listener.enterLogical_or_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLogical_or_expression" ):
listener.exitLogical_or_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitLogical_or_expression" ):
+ return visitor.visitLogical_or_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4841,16 +4966,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Logical_and_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def inclusive_or_expression(self,i=None):
+ def inclusive_or_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Inclusive_or_expressionContext)
else:
@@ -4860,16 +4983,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_logical_and_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLogical_and_expression" ):
listener.enterLogical_and_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLogical_and_expression" ):
listener.exitLogical_and_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitLogical_and_expression" ):
+ return visitor.visitLogical_and_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4902,16 +5029,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Inclusive_or_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def exclusive_or_expression(self,i=None):
+ def exclusive_or_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Exclusive_or_expressionContext)
else:
@@ -4921,16 +5046,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_inclusive_or_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInclusive_or_expression" ):
listener.enterInclusive_or_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInclusive_or_expression" ):
listener.exitInclusive_or_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitInclusive_or_expression" ):
+ return visitor.visitInclusive_or_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -4963,16 +5092,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Exclusive_or_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def and_expression(self,i=None):
+ def and_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.And_expressionContext)
else:
@@ -4982,16 +5109,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_exclusive_or_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExclusive_or_expression" ):
listener.enterExclusive_or_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExclusive_or_expression" ):
listener.exitExclusive_or_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitExclusive_or_expression" ):
+ return visitor.visitExclusive_or_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5024,16 +5155,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class And_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def equality_expression(self,i=None):
+ def equality_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Equality_expressionContext)
else:
@@ -5043,16 +5172,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_and_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAnd_expression" ):
listener.enterAnd_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAnd_expression" ):
listener.exitAnd_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAnd_expression" ):
+ return visitor.visitAnd_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5085,16 +5218,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Equality_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def relational_expression(self,i=None):
+ def relational_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Relational_expressionContext)
else:
@@ -5104,16 +5235,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_equality_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEquality_expression" ):
listener.enterEquality_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEquality_expression" ):
listener.exitEquality_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEquality_expression" ):
+ return visitor.visitEquality_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5151,16 +5286,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Relational_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def shift_expression(self,i=None):
+ def shift_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Shift_expressionContext)
else:
@@ -5170,16 +5303,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_relational_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRelational_expression" ):
listener.enterRelational_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRelational_expression" ):
listener.exitRelational_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitRelational_expression" ):
+ return visitor.visitRelational_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5217,16 +5354,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Shift_expressionContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def additive_expression(self,i=None):
+ def additive_expression(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.Additive_expressionContext)
else:
@@ -5236,16 +5371,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_shift_expression
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterShift_expression" ):
listener.enterShift_expression(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitShift_expression" ):
listener.exitShift_expression(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitShift_expression" ):
+ return visitor.visitShift_expression(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5283,11 +5422,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class StatementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -5338,16 +5476,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStatement" ):
listener.enterStatement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStatement" ):
listener.exitStatement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStatement" ):
+ return visitor.visitStatement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5434,11 +5576,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Asm2_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -5448,16 +5589,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_asm2_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAsm2_statement" ):
listener.enterAsm2_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAsm2_statement" ):
listener.exitAsm2_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAsm2_statement" ):
+ return visitor.visitAsm2_statement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5508,11 +5653,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Asm1_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -5520,16 +5664,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_asm1_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAsm1_statement" ):
listener.enterAsm1_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAsm1_statement" ):
listener.exitAsm1_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAsm1_statement" ):
+ return visitor.visitAsm1_statement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5569,11 +5717,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Asm_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -5581,16 +5728,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_asm_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAsm_statement" ):
listener.enterAsm_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAsm_statement" ):
listener.exitAsm_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAsm_statement" ):
+ return visitor.visitAsm_statement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5630,19 +5781,17 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Macro_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def IDENTIFIER(self):
return self.getToken(CParser.IDENTIFIER, 0)
- # @param i=None Type: int
- def declaration(self,i=None):
+ def declaration(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.DeclarationContext)
else:
@@ -5660,16 +5809,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_macro_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMacro_statement" ):
listener.enterMacro_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMacro_statement" ):
listener.exitMacro_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMacro_statement" ):
+ return visitor.visitMacro_statement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5721,11 +5874,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Labeled_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -5743,16 +5895,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_labeled_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLabeled_statement" ):
listener.enterLabeled_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLabeled_statement" ):
listener.exitLabeled_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitLabeled_statement" ):
+ return visitor.visitLabeled_statement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5804,16 +5960,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Compound_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def declaration(self,i=None):
+ def declaration(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.DeclarationContext)
else:
@@ -5827,16 +5981,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_compound_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCompound_statement" ):
listener.enterCompound_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCompound_statement" ):
listener.exitCompound_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompound_statement" ):
+ return visitor.visitCompound_statement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5878,16 +6036,14 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Statement_listContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
- # @param i=None Type: int
- def statement(self,i=None):
+ def statement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.StatementContext)
else:
@@ -5897,16 +6053,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_statement_list
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStatement_list" ):
listener.enterStatement_list(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStatement_list" ):
listener.exitStatement_list(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStatement_list" ):
+ return visitor.visitStatement_list(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5938,11 +6098,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Expression_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -5953,16 +6112,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_expression_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExpression_statement" ):
listener.enterExpression_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExpression_statement" ):
listener.exitExpression_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitExpression_statement" ):
+ return visitor.visitExpression_statement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -5997,17 +6160,15 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Selection_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.e = None # ExpressionContext
- # @param i=None Type: int
- def statement(self,i=None):
+ def statement(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(CParser.StatementContext)
else:
@@ -6021,16 +6182,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_selection_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSelection_statement" ):
listener.enterSelection_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSelection_statement" ):
listener.exitSelection_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSelection_statement" ):
+ return visitor.visitSelection_statement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -6052,7 +6217,7 @@ class CParser ( Parser ): localctx.e = self.expression()
self.state = 845
self.match(CParser.T__38)
- self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
+ self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText(localctx.e.start,localctx.e.stop)))
self.state = 847
self.statement()
self.state = 850
@@ -6090,11 +6255,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Iteration_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.e = None # ExpressionContext
@@ -6110,16 +6274,20 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_iteration_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIteration_statement" ):
listener.enterIteration_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIteration_statement" ):
listener.exitIteration_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitIteration_statement" ):
+ return visitor.visitIteration_statement(self)
+ else:
+ return visitor.visitChildren(self)
+
@@ -6143,7 +6311,7 @@ class CParser ( Parser ): self.match(CParser.T__38)
self.state = 864
self.statement()
- self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
+ self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText(localctx.e.start,localctx.e.stop)))
pass
elif token in [CParser.T__87]:
self.enterOuterAlt(localctx, 2)
@@ -6161,7 +6329,7 @@ class CParser ( Parser ): self.match(CParser.T__38)
self.state = 873
self.match(CParser.T__1)
- self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText((localctx.e.start,localctx.e.stop))))
+ self.StorePredicateExpression((None if localctx.e is None else localctx.e.start).line, (None if localctx.e is None else localctx.e.start).column, (None if localctx.e is None else localctx.e.stop).line, (None if localctx.e is None else localctx.e.stop).column, (None if localctx.e is None else self._input.getText(localctx.e.start,localctx.e.stop)))
pass
else:
raise NoViableAltException(self)
@@ -6174,11 +6342,10 @@ class CParser ( Parser ): self.exitRule()
return localctx
+
class Jump_statementContext(ParserRuleContext):
- # @param parent=None Type: ParserRuleContext
- # @param invokingState=-1 Type: int
- def __init__(self,parser,parent=None,invokingState=-1):
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
@@ -6192,16 +6359,19 @@ class CParser ( Parser ): def getRuleIndex(self):
return CParser.RULE_jump_statement
- # @param listener Type: ParseTreeListener
- def enterRule(self,listener):
+ def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterJump_statement" ):
listener.enterJump_statement(self)
- # @param listener Type: ParseTreeListener
- def exitRule(self,listener):
+ def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitJump_statement" ):
listener.exitJump_statement(self)
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitJump_statement" ):
+ return visitor.visitJump_statement(self)
+ else:
+ return visitor.visitChildren(self)
|