From 30fdf1140b8d1ce93f3821d986fa165552023440 Mon Sep 17 00:00:00 2001 From: lgao4 Date: Fri, 17 Jul 2009 09:10:31 +0000 Subject: Check In tool source code based on Build tool project revision r1655. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8964 6f19259b-4bc3-4df7-8a09-765794883524 --- BaseTools/Source/Python/Ecc/C.g | 626 + BaseTools/Source/Python/Ecc/CLexer.py | 4887 +++++ BaseTools/Source/Python/Ecc/CParser.py | 18825 +++++++++++++++++++ BaseTools/Source/Python/Ecc/Check.py | 865 + BaseTools/Source/Python/Ecc/CodeFragment.py | 165 + .../Source/Python/Ecc/CodeFragmentCollector.py | 624 + BaseTools/Source/Python/Ecc/Configuration.py | 264 + BaseTools/Source/Python/Ecc/Database.py | 344 + BaseTools/Source/Python/Ecc/Ecc.py | 329 + BaseTools/Source/Python/Ecc/EccGlobalData.py | 24 + BaseTools/Source/Python/Ecc/EccToolError.py | 179 + BaseTools/Source/Python/Ecc/Exception.py | 87 + BaseTools/Source/Python/Ecc/FileProfile.py | 57 + BaseTools/Source/Python/Ecc/MetaDataParser.py | 65 + BaseTools/Source/Python/Ecc/ParserWarning.py | 17 + BaseTools/Source/Python/Ecc/__init__.py | 0 BaseTools/Source/Python/Ecc/c.py | 2503 +++ BaseTools/Source/Python/Ecc/config.ini | 242 + BaseTools/Source/Python/Ecc/exception.xml | 310 + 19 files changed, 30413 insertions(+) create mode 100644 BaseTools/Source/Python/Ecc/C.g create mode 100644 BaseTools/Source/Python/Ecc/CLexer.py create mode 100644 BaseTools/Source/Python/Ecc/CParser.py create mode 100644 BaseTools/Source/Python/Ecc/Check.py create mode 100644 BaseTools/Source/Python/Ecc/CodeFragment.py create mode 100644 BaseTools/Source/Python/Ecc/CodeFragmentCollector.py create mode 100644 BaseTools/Source/Python/Ecc/Configuration.py create mode 100644 BaseTools/Source/Python/Ecc/Database.py create mode 100644 BaseTools/Source/Python/Ecc/Ecc.py create mode 100644 BaseTools/Source/Python/Ecc/EccGlobalData.py create mode 100644 BaseTools/Source/Python/Ecc/EccToolError.py create mode 100644 BaseTools/Source/Python/Ecc/Exception.py create mode 100644 BaseTools/Source/Python/Ecc/FileProfile.py create mode 100644 BaseTools/Source/Python/Ecc/MetaDataParser.py create mode 100644 BaseTools/Source/Python/Ecc/ParserWarning.py create mode 100644 BaseTools/Source/Python/Ecc/__init__.py create mode 100644 BaseTools/Source/Python/Ecc/c.py create mode 100644 BaseTools/Source/Python/Ecc/config.ini create mode 100644 BaseTools/Source/Python/Ecc/exception.xml (limited to 'BaseTools/Source/Python/Ecc') diff --git a/BaseTools/Source/Python/Ecc/C.g b/BaseTools/Source/Python/Ecc/C.g new file mode 100644 index 0000000000..6aa50460de --- /dev/null +++ b/BaseTools/Source/Python/Ecc/C.g @@ -0,0 +1,626 @@ + +grammar C; +options { + language=Python; + backtrack=true; + memoize=true; + k=2; +} + +@header { + import CodeFragment + import FileProfile +} + +@members { + + def printTokenInfo(self, line, offset, tokenText): + print str(line)+ ',' + str(offset) + ':' + str(tokenText) + + def StorePredicateExpression(self, StartLine, StartOffset, EndLine, EndOffset, Text): + PredExp = CodeFragment.PredicateExpression(Text, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.PredicateExpressionList.append(PredExp) + + def StoreEnumerationDefinition(self, StartLine, StartOffset, EndLine, EndOffset, Text): + EnumDef = CodeFragment.EnumerationDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.EnumerationDefinitionList.append(EnumDef) + + def StoreStructUnionDefinition(self, StartLine, StartOffset, EndLine, EndOffset, Text): + SUDef = CodeFragment.StructUnionDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.StructUnionDefinitionList.append(SUDef) + + def StoreTypedefDefinition(self, StartLine, StartOffset, EndLine, EndOffset, FromText, ToText): + Tdef = CodeFragment.TypedefDefinition(FromText, ToText, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.TypedefDefinitionList.append(Tdef) + + def StoreFunctionDefinition(self, StartLine, StartOffset, EndLine, EndOffset, ModifierText, DeclText, LeftBraceLine, LeftBraceOffset, DeclLine, DeclOffset): + FuncDef = CodeFragment.FunctionDefinition(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset), (LeftBraceLine, LeftBraceOffset), (DeclLine, DeclOffset)) + FileProfile.FunctionDefinitionList.append(FuncDef) + + def StoreVariableDeclaration(self, StartLine, StartOffset, EndLine, EndOffset, ModifierText, DeclText): + VarDecl = CodeFragment.VariableDeclaration(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.VariableDeclarationList.append(VarDecl) + + def StoreFunctionCalling(self, StartLine, StartOffset, EndLine, EndOffset, FuncName, ParamList): + FuncCall = CodeFragment.FunctionCalling(FuncName, ParamList, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.FunctionCallingList.append(FuncCall) + +} + +translation_unit + : external_declaration* + ; + + +/*function_declaration +@after{ + print $function_declaration.text +} + : declaration_specifiers IDENTIFIER '(' parameter_list ')' ';' + ; +*/ +external_declaration +options {k=1;} +/*@after{ + print $external_declaration.text +}*/ + : ( declaration_specifiers? declarator declaration* '{' )=> function_definition + | declaration + | macro_statement (';')? + ; + + + +function_definition +scope { + ModifierText; + DeclText; + LBLine; + LBOffset; + DeclLine; + DeclOffset; +} +@init { + $function_definition::ModifierText = ''; + $function_definition::DeclText = ''; + $function_definition::LBLine = 0; + $function_definition::LBOffset = 0; + $function_definition::DeclLine = 0; + $function_definition::DeclOffset = 0; +} +@after{ + self.StoreFunctionDefinition($function_definition.start.line, $function_definition.start.charPositionInLine, $function_definition.stop.line, $function_definition.stop.charPositionInLine, $function_definition::ModifierText, $function_definition::DeclText, $function_definition::LBLine, $function_definition::LBOffset, $function_definition::DeclLine, $function_definition::DeclOffset) +} + : d=declaration_specifiers? declarator + ( declaration+ a=compound_statement // K&R style + | b=compound_statement // ANSI style + ) { + if d != None: + $function_definition::ModifierText = $declaration_specifiers.text + else: + $function_definition::ModifierText = '' + $function_definition::DeclText = $declarator.text + $function_definition::DeclLine = $declarator.start.line + $function_definition::DeclOffset = $declarator.start.charPositionInLine + if a != None: + $function_definition::LBLine = $a.start.line + $function_definition::LBOffset = $a.start.charPositionInLine + else: + $function_definition::LBLine = $b.start.line + $function_definition::LBOffset = $b.start.charPositionInLine + } + ; + +declaration + : a='typedef' b=declaration_specifiers? + c=init_declarator_list d=';' + { + if b != None: + self.StoreTypedefDefinition($a.line, $a.charPositionInLine, $d.line, $d.charPositionInLine, $b.text, $c.text) + else: + self.StoreTypedefDefinition($a.line, $a.charPositionInLine, $d.line, $d.charPositionInLine, '', $c.text) + } + | s=declaration_specifiers t=init_declarator_list? e=';' + { + if t != None: + self.StoreVariableDeclaration($s.start.line, $s.start.charPositionInLine, $t.start.line, $t.start.charPositionInLine, $s.text, $t.text) + } + ; + +declaration_specifiers + : ( storage_class_specifier + | type_specifier + | type_qualifier + )+ + ; + +init_declarator_list + : init_declarator (',' init_declarator)* + ; + +init_declarator + : declarator ('=' initializer)? + ; + +storage_class_specifier + : 'extern' + | 'static' + | 'auto' + | 'register' + | 'STATIC' + ; + +type_specifier + : 'void' + | 'char' + | 'short' + | 'int' + | 'long' + | 'float' + | 'double' + | 'signed' + | 'unsigned' + | s=struct_or_union_specifier + { + if s.stop != None: + self.StoreStructUnionDefinition($s.start.line, $s.start.charPositionInLine, $s.stop.line, $s.stop.charPositionInLine, $s.text) + } + | e=enum_specifier + { + if e.stop != None: + self.StoreEnumerationDefinition($e.start.line, $e.start.charPositionInLine, $e.stop.line, $e.stop.charPositionInLine, $e.text) + } + | (IDENTIFIER type_qualifier* declarator)=> type_id + ; + +type_id + : IDENTIFIER + //{self.printTokenInfo($a.line, $a.pos, $a.text)} + ; + +struct_or_union_specifier +options {k=3;} + : struct_or_union IDENTIFIER? '{' struct_declaration_list '}' + | struct_or_union IDENTIFIER + ; + +struct_or_union + : 'struct' + | 'union' + ; + +struct_declaration_list + : struct_declaration+ + ; + +struct_declaration + : specifier_qualifier_list struct_declarator_list ';' + ; + +specifier_qualifier_list + : ( type_qualifier | type_specifier )+ + ; + +struct_declarator_list + : struct_declarator (',' struct_declarator)* + ; + +struct_declarator + : declarator (':' constant_expression)? + | ':' constant_expression + ; + +enum_specifier +options {k=3;} + : 'enum' '{' enumerator_list ','? '}' + | 'enum' IDENTIFIER '{' enumerator_list ','? '}' + | 'enum' IDENTIFIER + ; + +enumerator_list + : enumerator (',' enumerator)* + ; + +enumerator + : IDENTIFIER ('=' constant_expression)? + ; + +type_qualifier + : 'const' + | 'volatile' + | 'IN' + | 'OUT' + | 'OPTIONAL' + | 'CONST' + | 'UNALIGNED' + | 'VOLATILE' + | 'GLOBAL_REMOVE_IF_UNREFERENCED' + | 'EFIAPI' + | 'EFI_BOOTSERVICE' + | 'EFI_RUNTIMESERVICE' + ; + +declarator + : pointer? ('EFIAPI')? ('EFI_BOOTSERVICE')? ('EFI_RUNTIMESERVICE')? direct_declarator +// | ('EFIAPI')? ('EFI_BOOTSERVICE')? ('EFI_RUNTIMESERVICE')? pointer? direct_declarator + | pointer + ; + +direct_declarator + : IDENTIFIER declarator_suffix* + | '(' ('EFIAPI')? declarator ')' declarator_suffix+ + ; + +declarator_suffix + : '[' constant_expression ']' + | '[' ']' + | '(' parameter_type_list ')' + | '(' identifier_list ')' + | '(' ')' + ; + +pointer + : '*' type_qualifier+ pointer? + | '*' pointer + | '*' + ; + +parameter_type_list + : parameter_list (',' ('OPTIONAL')? '...')? + ; + +parameter_list + : parameter_declaration (',' ('OPTIONAL')? parameter_declaration)* + ; + +parameter_declaration + : declaration_specifiers (declarator|abstract_declarator)* ('OPTIONAL')? + //accomerdate user-defined type only, no declarator follow. + | pointer* IDENTIFIER + ; + +identifier_list + : IDENTIFIER + (',' IDENTIFIER)* + ; + +type_name + : specifier_qualifier_list abstract_declarator? + | type_id + ; + +abstract_declarator + : pointer direct_abstract_declarator? + | direct_abstract_declarator + ; + +direct_abstract_declarator + : ( '(' abstract_declarator ')' | abstract_declarator_suffix ) abstract_declarator_suffix* + ; + +abstract_declarator_suffix + : '[' ']' + | '[' constant_expression ']' + | '(' ')' + | '(' parameter_type_list ')' + ; + +initializer + + : assignment_expression + | '{' initializer_list ','? '}' + ; + +initializer_list + : initializer (',' initializer )* + ; + +// E x p r e s s i o n s + +argument_expression_list + : assignment_expression ('OPTIONAL')? (',' assignment_expression ('OPTIONAL')?)* + ; + +additive_expression + : (multiplicative_expression) ('+' multiplicative_expression | '-' multiplicative_expression)* + ; + +multiplicative_expression + : (cast_expression) ('*' cast_expression | '/' cast_expression | '%' cast_expression)* + ; + +cast_expression + : '(' type_name ')' cast_expression + | unary_expression + ; + +unary_expression + : postfix_expression + | '++' unary_expression + | '--' unary_expression + | unary_operator cast_expression + | 'sizeof' unary_expression + | 'sizeof' '(' type_name ')' + ; + +postfix_expression +scope { + FuncCallText; +} +@init { + $postfix_expression::FuncCallText = ''; +} + : p=primary_expression {$postfix_expression::FuncCallText += $p.text} + ( '[' expression ']' + | '(' a=')'{self.StoreFunctionCalling($p.start.line, $p.start.charPositionInLine, $a.line, $a.charPositionInLine, $postfix_expression::FuncCallText, '')} + | '(' c=argument_expression_list b=')' {self.StoreFunctionCalling($p.start.line, $p.start.charPositionInLine, $b.line, $b.charPositionInLine, $postfix_expression::FuncCallText, $c.text)} + | '(' macro_parameter_list ')' + | '.' x=IDENTIFIER {$postfix_expression::FuncCallText += '.' + $x.text} + | '*' y=IDENTIFIER {$postfix_expression::FuncCallText = $y.text} + | '->' z=IDENTIFIER {$postfix_expression::FuncCallText += '->' + $z.text} + | '++' + | '--' + )* + ; + +macro_parameter_list + : parameter_declaration (',' parameter_declaration)* + ; + +unary_operator + : '&' + | '*' + | '+' + | '-' + | '~' + | '!' + ; + +primary_expression + : IDENTIFIER + | constant + | '(' expression ')' + ; + +constant + : HEX_LITERAL + | OCTAL_LITERAL + | DECIMAL_LITERAL + | CHARACTER_LITERAL + | (IDENTIFIER* STRING_LITERAL+)+ IDENTIFIER* + | FLOATING_POINT_LITERAL + ; + +///// + +expression + : assignment_expression (',' assignment_expression)* + ; + +constant_expression + : conditional_expression + ; + +assignment_expression + : lvalue assignment_operator assignment_expression + | conditional_expression + ; + +lvalue + : unary_expression + ; + +assignment_operator + : '=' + | '*=' + | '/=' + | '%=' + | '+=' + | '-=' + | '<<=' + | '>>=' + | '&=' + | '^=' + | '|=' + ; + +conditional_expression + : e=logical_or_expression ('?' expression ':' conditional_expression {self.StorePredicateExpression($e.start.line, $e.start.charPositionInLine, $e.stop.line, $e.stop.charPositionInLine, $e.text)})? + ; + +logical_or_expression + : logical_and_expression ('||' logical_and_expression)* + ; + +logical_and_expression + : inclusive_or_expression ('&&' inclusive_or_expression)* + ; + +inclusive_or_expression + : exclusive_or_expression ('|' exclusive_or_expression)* + ; + +exclusive_or_expression + : and_expression ('^' and_expression)* + ; + +and_expression + : equality_expression ('&' equality_expression)* + ; +equality_expression + : relational_expression (('=='|'!=') relational_expression )* + ; + +relational_expression + : shift_expression (('<'|'>'|'<='|'>=') shift_expression)* + ; + +shift_expression + : additive_expression (('<<'|'>>') additive_expression)* + ; + +// S t a t e m e n t s + +statement + : labeled_statement + | compound_statement + | expression_statement + | selection_statement + | iteration_statement + | jump_statement + | macro_statement + | asm2_statement + | asm1_statement + | asm_statement + | declaration + ; + +asm2_statement + : '__asm__'? IDENTIFIER '(' (~(';'))* ')' ';' + ; + +asm1_statement + : '_asm' '{' (~('}'))* '}' + ; + +asm_statement + : '__asm' '{' (~('}'))* '}' + ; + +macro_statement + : IDENTIFIER '(' declaration* statement_list? expression? ')' + ; + +labeled_statement + : IDENTIFIER ':' statement + | 'case' constant_expression ':' statement + | 'default' ':' statement + ; + +compound_statement + : '{' declaration* statement_list? '}' + ; + +statement_list + : statement+ + ; + +expression_statement + : ';' + | expression ';' + ; + +selection_statement + : 'if' '(' e=expression ')' {self.StorePredicateExpression($e.start.line, $e.start.charPositionInLine, $e.stop.line, $e.stop.charPositionInLine, $e.text)} statement (options {k=1; backtrack=false;}:'else' statement)? + | 'switch' '(' expression ')' statement + ; + +iteration_statement + : 'while' '(' e=expression ')' statement {self.StorePredicateExpression($e.start.line, $e.start.charPositionInLine, $e.stop.line, $e.stop.charPositionInLine, $e.text)} + | 'do' statement 'while' '(' e=expression ')' ';' {self.StorePredicateExpression($e.start.line, $e.start.charPositionInLine, $e.stop.line, $e.stop.charPositionInLine, $e.text)} + | 'for' '(' expression_statement e=expression_statement expression? ')' statement {self.StorePredicateExpression($e.start.line, $e.start.charPositionInLine, $e.stop.line, $e.stop.charPositionInLine, $e.text)} + ; + +jump_statement + : 'goto' IDENTIFIER ';' + | 'continue' ';' + | 'break' ';' + | 'return' ';' + | 'return' expression ';' + ; + +IDENTIFIER + : LETTER (LETTER|'0'..'9')* + ; + +fragment +LETTER + : '$' + | 'A'..'Z' + | 'a'..'z' + | '_' + ; + +CHARACTER_LITERAL + : ('L')? '\'' ( EscapeSequence | ~('\''|'\\') ) '\'' + ; + +STRING_LITERAL + : ('L')? '"' ( EscapeSequence | ~('\\'|'"') )* '"' + ; + +HEX_LITERAL : '0' ('x'|'X') HexDigit+ IntegerTypeSuffix? ; + +DECIMAL_LITERAL : ('0' | '1'..'9' '0'..'9'*) IntegerTypeSuffix? ; + +OCTAL_LITERAL : '0' ('0'..'7')+ IntegerTypeSuffix? ; + +fragment +HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ; + +fragment +IntegerTypeSuffix + : ('u'|'U') + | ('l'|'L') + | ('u'|'U') ('l'|'L') + | ('u'|'U') ('l'|'L') ('l'|'L') + ; + +FLOATING_POINT_LITERAL + : ('0'..'9')+ '.' ('0'..'9')* Exponent? FloatTypeSuffix? + | '.' ('0'..'9')+ Exponent? FloatTypeSuffix? + | ('0'..'9')+ Exponent FloatTypeSuffix? + | ('0'..'9')+ Exponent? FloatTypeSuffix + ; + +fragment +Exponent : ('e'|'E') ('+'|'-')? ('0'..'9')+ ; + +fragment +FloatTypeSuffix : ('f'|'F'|'d'|'D') ; + +fragment +EscapeSequence + : '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\') + | OctalEscape + ; + +fragment +OctalEscape + : '\\' ('0'..'3') ('0'..'7') ('0'..'7') + | '\\' ('0'..'7') ('0'..'7') + | '\\' ('0'..'7') + ; + +fragment +UnicodeEscape + : '\\' 'u' HexDigit HexDigit HexDigit HexDigit + ; + +WS : (' '|'\r'|'\t'|'\u000C'|'\n') {$channel=HIDDEN;} + ; + +// ingore '\' of line concatenation +BS : ('\\') {$channel=HIDDEN;} + ; + +// ingore function modifiers +//FUNC_MODIFIERS : 'EFIAPI' {$channel=HIDDEN;} +// ; + +UnicodeVocabulary + : '\u0003'..'\uFFFE' + ; +COMMENT + : '/*' ( options {greedy=false;} : . )* '*/' {$channel=HIDDEN;} + ; + + +LINE_COMMENT + : '//' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;} + ; + +// ignore #line info for now +LINE_COMMAND + : '#' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;} + ; diff --git a/BaseTools/Source/Python/Ecc/CLexer.py b/BaseTools/Source/Python/Ecc/CLexer.py new file mode 100644 index 0000000000..cc437e0821 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/CLexer.py @@ -0,0 +1,4887 @@ +# $ANTLR 3.0.1 C.g 2009-02-16 16:02:51 + +from antlr3 import * +from antlr3.compat import set, frozenset + + +# for convenience in actions +HIDDEN = BaseRecognizer.HIDDEN + +# token types +T29=29 +HexDigit=13 +T70=70 +T74=74 +T85=85 +T102=102 +T114=114 +T103=103 +STRING_LITERAL=9 +T32=32 +T81=81 +T41=41 +FloatTypeSuffix=16 +T113=113 +T62=62 +T109=109 +DECIMAL_LITERAL=7 +IntegerTypeSuffix=14 +T68=68 +T73=73 +T84=84 +T33=33 +UnicodeVocabulary=21 +T78=78 +T115=115 +WS=19 +LINE_COMMAND=24 +T42=42 +T96=96 +T71=71 +LINE_COMMENT=23 +T72=72 +T94=94 +FLOATING_POINT_LITERAL=10 +T76=76 +UnicodeEscape=18 +T75=75 +T89=89 +T67=67 +T31=31 +T60=60 +T82=82 +T100=100 +T49=49 +IDENTIFIER=4 +T30=30 +CHARACTER_LITERAL=8 +T79=79 +T36=36 +T58=58 +T93=93 +T35=35 +T107=107 +OCTAL_LITERAL=6 +T83=83 +T61=61 +HEX_LITERAL=5 +T45=45 +T34=34 +T101=101 +T64=64 +T25=25 +T91=91 +T105=105 +T37=37 +T86=86 +T116=116 +EscapeSequence=12 +T26=26 +T51=51 +T111=111 +T46=46 +T77=77 +T38=38 +T106=106 +T112=112 +T69=69 +T39=39 +T44=44 +T55=55 +LETTER=11 +Exponent=15 +T95=95 +T50=50 +T110=110 +T108=108 +BS=20 +T92=92 +T43=43 +T28=28 +T40=40 +T66=66 +COMMENT=22 +T88=88 +T63=63 +T57=57 +T65=65 +T98=98 +T56=56 +T87=87 +T80=80 +T59=59 +T97=97 +T48=48 +T54=54 +EOF=-1 +T104=104 +T47=47 +Tokens=117 +T53=53 +OctalEscape=17 +T99=99 +T27=27 +T52=52 +T90=90 + +class CLexer(Lexer): + + grammarFileName = "C.g" + + def __init__(self, input=None): + Lexer.__init__(self, input) + self.dfa25 = self.DFA25( + self, 25, + eot = self.DFA25_eot, + eof = self.DFA25_eof, + min = self.DFA25_min, + max = self.DFA25_max, + accept = self.DFA25_accept, + special = self.DFA25_special, + transition = self.DFA25_transition + ) + self.dfa35 = self.DFA35( + self, 35, + eot = self.DFA35_eot, + eof = self.DFA35_eof, + min = self.DFA35_min, + max = self.DFA35_max, + accept = self.DFA35_accept, + special = self.DFA35_special, + transition = self.DFA35_transition + ) + + + + + + + # $ANTLR start T25 + def mT25(self, ): + + try: + self.type = T25 + + # C.g:7:5: ( ';' ) + # C.g:7:7: ';' + self.match(u';') + + + + + + finally: + + pass + + # $ANTLR end T25 + + + + # $ANTLR start T26 + def mT26(self, ): + + try: + self.type = T26 + + # C.g:8:5: ( 'typedef' ) + # C.g:8:7: 'typedef' + self.match("typedef") + + + + + + + finally: + + pass + + # $ANTLR end T26 + + + + # $ANTLR start T27 + def mT27(self, ): + + try: + self.type = T27 + + # C.g:9:5: ( ',' ) + # C.g:9:7: ',' + self.match(u',') + + + + + + finally: + + pass + + # $ANTLR end T27 + + + + # $ANTLR start T28 + def mT28(self, ): + + try: + self.type = T28 + + # C.g:10:5: ( '=' ) + # C.g:10:7: '=' + self.match(u'=') + + + + + + finally: + + pass + + # $ANTLR end T28 + + + + # $ANTLR start T29 + def mT29(self, ): + + try: + self.type = T29 + + # C.g:11:5: ( 'extern' ) + # C.g:11:7: 'extern' + self.match("extern") + + + + + + + finally: + + pass + + # $ANTLR end T29 + + + + # $ANTLR start T30 + def mT30(self, ): + + try: + self.type = T30 + + # C.g:12:5: ( 'static' ) + # C.g:12:7: 'static' + self.match("static") + + + + + + + finally: + + pass + + # $ANTLR end T30 + + + + # $ANTLR start T31 + def mT31(self, ): + + try: + self.type = T31 + + # C.g:13:5: ( 'auto' ) + # C.g:13:7: 'auto' + self.match("auto") + + + + + + + finally: + + pass + + # $ANTLR end T31 + + + + # $ANTLR start T32 + def mT32(self, ): + + try: + self.type = T32 + + # C.g:14:5: ( 'register' ) + # C.g:14:7: 'register' + self.match("register") + + + + + + + finally: + + pass + + # $ANTLR end T32 + + + + # $ANTLR start T33 + def mT33(self, ): + + try: + self.type = T33 + + # C.g:15:5: ( 'STATIC' ) + # C.g:15:7: 'STATIC' + self.match("STATIC") + + + + + + + finally: + + pass + + # $ANTLR end T33 + + + + # $ANTLR start T34 + def mT34(self, ): + + try: + self.type = T34 + + # C.g:16:5: ( 'void' ) + # C.g:16:7: 'void' + self.match("void") + + + + + + + finally: + + pass + + # $ANTLR end T34 + + + + # $ANTLR start T35 + def mT35(self, ): + + try: + self.type = T35 + + # C.g:17:5: ( 'char' ) + # C.g:17:7: 'char' + self.match("char") + + + + + + + finally: + + pass + + # $ANTLR end T35 + + + + # $ANTLR start T36 + def mT36(self, ): + + try: + self.type = T36 + + # C.g:18:5: ( 'short' ) + # C.g:18:7: 'short' + self.match("short") + + + + + + + finally: + + pass + + # $ANTLR end T36 + + + + # $ANTLR start T37 + def mT37(self, ): + + try: + self.type = T37 + + # C.g:19:5: ( 'int' ) + # C.g:19:7: 'int' + self.match("int") + + + + + + + finally: + + pass + + # $ANTLR end T37 + + + + # $ANTLR start T38 + def mT38(self, ): + + try: + self.type = T38 + + # C.g:20:5: ( 'long' ) + # C.g:20:7: 'long' + self.match("long") + + + + + + + finally: + + pass + + # $ANTLR end T38 + + + + # $ANTLR start T39 + def mT39(self, ): + + try: + self.type = T39 + + # C.g:21:5: ( 'float' ) + # C.g:21:7: 'float' + self.match("float") + + + + + + + finally: + + pass + + # $ANTLR end T39 + + + + # $ANTLR start T40 + def mT40(self, ): + + try: + self.type = T40 + + # C.g:22:5: ( 'double' ) + # C.g:22:7: 'double' + self.match("double") + + + + + + + finally: + + pass + + # $ANTLR end T40 + + + + # $ANTLR start T41 + def mT41(self, ): + + try: + self.type = T41 + + # C.g:23:5: ( 'signed' ) + # C.g:23:7: 'signed' + self.match("signed") + + + + + + + finally: + + pass + + # $ANTLR end T41 + + + + # $ANTLR start T42 + def mT42(self, ): + + try: + self.type = T42 + + # C.g:24:5: ( 'unsigned' ) + # C.g:24:7: 'unsigned' + self.match("unsigned") + + + + + + + finally: + + pass + + # $ANTLR end T42 + + + + # $ANTLR start T43 + def mT43(self, ): + + try: + self.type = T43 + + # C.g:25:5: ( '{' ) + # C.g:25:7: '{' + self.match(u'{') + + + + + + finally: + + pass + + # $ANTLR end T43 + + + + # $ANTLR start T44 + def mT44(self, ): + + try: + self.type = T44 + + # C.g:26:5: ( '}' ) + # C.g:26:7: '}' + self.match(u'}') + + + + + + finally: + + pass + + # $ANTLR end T44 + + + + # $ANTLR start T45 + def mT45(self, ): + + try: + self.type = T45 + + # C.g:27:5: ( 'struct' ) + # C.g:27:7: 'struct' + self.match("struct") + + + + + + + finally: + + pass + + # $ANTLR end T45 + + + + # $ANTLR start T46 + def mT46(self, ): + + try: + self.type = T46 + + # C.g:28:5: ( 'union' ) + # C.g:28:7: 'union' + self.match("union") + + + + + + + finally: + + pass + + # $ANTLR end T46 + + + + # $ANTLR start T47 + def mT47(self, ): + + try: + self.type = T47 + + # C.g:29:5: ( ':' ) + # C.g:29:7: ':' + self.match(u':') + + + + + + finally: + + pass + + # $ANTLR end T47 + + + + # $ANTLR start T48 + def mT48(self, ): + + try: + self.type = T48 + + # C.g:30:5: ( 'enum' ) + # C.g:30:7: 'enum' + self.match("enum") + + + + + + + finally: + + pass + + # $ANTLR end T48 + + + + # $ANTLR start T49 + def mT49(self, ): + + try: + self.type = T49 + + # C.g:31:5: ( 'const' ) + # C.g:31:7: 'const' + self.match("const") + + + + + + + finally: + + pass + + # $ANTLR end T49 + + + + # $ANTLR start T50 + def mT50(self, ): + + try: + self.type = T50 + + # C.g:32:5: ( 'volatile' ) + # C.g:32:7: 'volatile' + self.match("volatile") + + + + + + + finally: + + pass + + # $ANTLR end T50 + + + + # $ANTLR start T51 + def mT51(self, ): + + try: + self.type = T51 + + # C.g:33:5: ( 'IN' ) + # C.g:33:7: 'IN' + self.match("IN") + + + + + + + finally: + + pass + + # $ANTLR end T51 + + + + # $ANTLR start T52 + def mT52(self, ): + + try: + self.type = T52 + + # C.g:34:5: ( 'OUT' ) + # C.g:34:7: 'OUT' + self.match("OUT") + + + + + + + finally: + + pass + + # $ANTLR end T52 + + + + # $ANTLR start T53 + def mT53(self, ): + + try: + self.type = T53 + + # C.g:35:5: ( 'OPTIONAL' ) + # C.g:35:7: 'OPTIONAL' + self.match("OPTIONAL") + + + + + + + finally: + + pass + + # $ANTLR end T53 + + + + # $ANTLR start T54 + def mT54(self, ): + + try: + self.type = T54 + + # C.g:36:5: ( 'CONST' ) + # C.g:36:7: 'CONST' + self.match("CONST") + + + + + + + finally: + + pass + + # $ANTLR end T54 + + + + # $ANTLR start T55 + def mT55(self, ): + + try: + self.type = T55 + + # C.g:37:5: ( 'UNALIGNED' ) + # C.g:37:7: 'UNALIGNED' + self.match("UNALIGNED") + + + + + + + finally: + + pass + + # $ANTLR end T55 + + + + # $ANTLR start T56 + def mT56(self, ): + + try: + self.type = T56 + + # C.g:38:5: ( 'VOLATILE' ) + # C.g:38:7: 'VOLATILE' + self.match("VOLATILE") + + + + + + + finally: + + pass + + # $ANTLR end T56 + + + + # $ANTLR start T57 + def mT57(self, ): + + try: + self.type = T57 + + # C.g:39:5: ( 'GLOBAL_REMOVE_IF_UNREFERENCED' ) + # C.g:39:7: 'GLOBAL_REMOVE_IF_UNREFERENCED' + self.match("GLOBAL_REMOVE_IF_UNREFERENCED") + + + + + + + finally: + + pass + + # $ANTLR end T57 + + + + # $ANTLR start T58 + def mT58(self, ): + + try: + self.type = T58 + + # C.g:40:5: ( 'EFIAPI' ) + # C.g:40:7: 'EFIAPI' + self.match("EFIAPI") + + + + + + + finally: + + pass + + # $ANTLR end T58 + + + + # $ANTLR start T59 + def mT59(self, ): + + try: + self.type = T59 + + # C.g:41:5: ( 'EFI_BOOTSERVICE' ) + # C.g:41:7: 'EFI_BOOTSERVICE' + self.match("EFI_BOOTSERVICE") + + + + + + + finally: + + pass + + # $ANTLR end T59 + + + + # $ANTLR start T60 + def mT60(self, ): + + try: + self.type = T60 + + # C.g:42:5: ( 'EFI_RUNTIMESERVICE' ) + # C.g:42:7: 'EFI_RUNTIMESERVICE' + self.match("EFI_RUNTIMESERVICE") + + + + + + + finally: + + pass + + # $ANTLR end T60 + + + + # $ANTLR start T61 + def mT61(self, ): + + try: + self.type = T61 + + # C.g:43:5: ( '(' ) + # C.g:43:7: '(' + self.match(u'(') + + + + + + finally: + + pass + + # $ANTLR end T61 + + + + # $ANTLR start T62 + def mT62(self, ): + + try: + self.type = T62 + + # C.g:44:5: ( ')' ) + # C.g:44:7: ')' + self.match(u')') + + + + + + finally: + + pass + + # $ANTLR end T62 + + + + # $ANTLR start T63 + def mT63(self, ): + + try: + self.type = T63 + + # C.g:45:5: ( '[' ) + # C.g:45:7: '[' + self.match(u'[') + + + + + + finally: + + pass + + # $ANTLR end T63 + + + + # $ANTLR start T64 + def mT64(self, ): + + try: + self.type = T64 + + # C.g:46:5: ( ']' ) + # C.g:46:7: ']' + self.match(u']') + + + + + + finally: + + pass + + # $ANTLR end T64 + + + + # $ANTLR start T65 + def mT65(self, ): + + try: + self.type = T65 + + # C.g:47:5: ( '*' ) + # C.g:47:7: '*' + self.match(u'*') + + + + + + finally: + + pass + + # $ANTLR end T65 + + + + # $ANTLR start T66 + def mT66(self, ): + + try: + self.type = T66 + + # C.g:48:5: ( '...' ) + # C.g:48:7: '...' + self.match("...") + + + + + + + finally: + + pass + + # $ANTLR end T66 + + + + # $ANTLR start T67 + def mT67(self, ): + + try: + self.type = T67 + + # C.g:49:5: ( '+' ) + # C.g:49:7: '+' + self.match(u'+') + + + + + + finally: + + pass + + # $ANTLR end T67 + + + + # $ANTLR start T68 + def mT68(self, ): + + try: + self.type = T68 + + # C.g:50:5: ( '-' ) + # C.g:50:7: '-' + self.match(u'-') + + + + + + finally: + + pass + + # $ANTLR end T68 + + + + # $ANTLR start T69 + def mT69(self, ): + + try: + self.type = T69 + + # C.g:51:5: ( '/' ) + # C.g:51:7: '/' + self.match(u'/') + + + + + + finally: + + pass + + # $ANTLR end T69 + + + + # $ANTLR start T70 + def mT70(self, ): + + try: + self.type = T70 + + # C.g:52:5: ( '%' ) + # C.g:52:7: '%' + self.match(u'%') + + + + + + finally: + + pass + + # $ANTLR end T70 + + + + # $ANTLR start T71 + def mT71(self, ): + + try: + self.type = T71 + + # C.g:53:5: ( '++' ) + # C.g:53:7: '++' + self.match("++") + + + + + + + finally: + + pass + + # $ANTLR end T71 + + + + # $ANTLR start T72 + def mT72(self, ): + + try: + self.type = T72 + + # C.g:54:5: ( '--' ) + # C.g:54:7: '--' + self.match("--") + + + + + + + finally: + + pass + + # $ANTLR end T72 + + + + # $ANTLR start T73 + def mT73(self, ): + + try: + self.type = T73 + + # C.g:55:5: ( 'sizeof' ) + # C.g:55:7: 'sizeof' + self.match("sizeof") + + + + + + + finally: + + pass + + # $ANTLR end T73 + + + + # $ANTLR start T74 + def mT74(self, ): + + try: + self.type = T74 + + # C.g:56:5: ( '.' ) + # C.g:56:7: '.' + self.match(u'.') + + + + + + finally: + + pass + + # $ANTLR end T74 + + + + # $ANTLR start T75 + def mT75(self, ): + + try: + self.type = T75 + + # C.g:57:5: ( '->' ) + # C.g:57:7: '->' + self.match("->") + + + + + + + finally: + + pass + + # $ANTLR end T75 + + + + # $ANTLR start T76 + def mT76(self, ): + + try: + self.type = T76 + + # C.g:58:5: ( '&' ) + # C.g:58:7: '&' + self.match(u'&') + + + + + + finally: + + pass + + # $ANTLR end T76 + + + + # $ANTLR start T77 + def mT77(self, ): + + try: + self.type = T77 + + # C.g:59:5: ( '~' ) + # C.g:59:7: '~' + self.match(u'~') + + + + + + finally: + + pass + + # $ANTLR end T77 + + + + # $ANTLR start T78 + def mT78(self, ): + + try: + self.type = T78 + + # C.g:60:5: ( '!' ) + # C.g:60:7: '!' + self.match(u'!') + + + + + + finally: + + pass + + # $ANTLR end T78 + + + + # $ANTLR start T79 + def mT79(self, ): + + try: + self.type = T79 + + # C.g:61:5: ( '*=' ) + # C.g:61:7: '*=' + self.match("*=") + + + + + + + finally: + + pass + + # $ANTLR end T79 + + + + # $ANTLR start T80 + def mT80(self, ): + + try: + self.type = T80 + + # C.g:62:5: ( '/=' ) + # C.g:62:7: '/=' + self.match("/=") + + + + + + + finally: + + pass + + # $ANTLR end T80 + + + + # $ANTLR start T81 + def mT81(self, ): + + try: + self.type = T81 + + # C.g:63:5: ( '%=' ) + # C.g:63:7: '%=' + self.match("%=") + + + + + + + finally: + + pass + + # $ANTLR end T81 + + + + # $ANTLR start T82 + def mT82(self, ): + + try: + self.type = T82 + + # C.g:64:5: ( '+=' ) + # C.g:64:7: '+=' + self.match("+=") + + + + + + + finally: + + pass + + # $ANTLR end T82 + + + + # $ANTLR start T83 + def mT83(self, ): + + try: + self.type = T83 + + # C.g:65:5: ( '-=' ) + # C.g:65:7: '-=' + self.match("-=") + + + + + + + finally: + + pass + + # $ANTLR end T83 + + + + # $ANTLR start T84 + def mT84(self, ): + + try: + self.type = T84 + + # C.g:66:5: ( '<<=' ) + # C.g:66:7: '<<=' + self.match("<<=") + + + + + + + finally: + + pass + + # $ANTLR end T84 + + + + # $ANTLR start T85 + def mT85(self, ): + + try: + self.type = T85 + + # C.g:67:5: ( '>>=' ) + # C.g:67:7: '>>=' + self.match(">>=") + + + + + + + finally: + + pass + + # $ANTLR end T85 + + + + # $ANTLR start T86 + def mT86(self, ): + + try: + self.type = T86 + + # C.g:68:5: ( '&=' ) + # C.g:68:7: '&=' + self.match("&=") + + + + + + + finally: + + pass + + # $ANTLR end T86 + + + + # $ANTLR start T87 + def mT87(self, ): + + try: + self.type = T87 + + # C.g:69:5: ( '^=' ) + # C.g:69:7: '^=' + self.match("^=") + + + + + + + finally: + + pass + + # $ANTLR end T87 + + + + # $ANTLR start T88 + def mT88(self, ): + + try: + self.type = T88 + + # C.g:70:5: ( '|=' ) + # C.g:70:7: '|=' + self.match("|=") + + + + + + + finally: + + pass + + # $ANTLR end T88 + + + + # $ANTLR start T89 + def mT89(self, ): + + try: + self.type = T89 + + # C.g:71:5: ( '?' ) + # C.g:71:7: '?' + self.match(u'?') + + + + + + finally: + + pass + + # $ANTLR end T89 + + + + # $ANTLR start T90 + def mT90(self, ): + + try: + self.type = T90 + + # C.g:72:5: ( '||' ) + # C.g:72:7: '||' + self.match("||") + + + + + + + finally: + + pass + + # $ANTLR end T90 + + + + # $ANTLR start T91 + def mT91(self, ): + + try: + self.type = T91 + + # C.g:73:5: ( '&&' ) + # C.g:73:7: '&&' + self.match("&&") + + + + + + + finally: + + pass + + # $ANTLR end T91 + + + + # $ANTLR start T92 + def mT92(self, ): + + try: + self.type = T92 + + # C.g:74:5: ( '|' ) + # C.g:74:7: '|' + self.match(u'|') + + + + + + finally: + + pass + + # $ANTLR end T92 + + + + # $ANTLR start T93 + def mT93(self, ): + + try: + self.type = T93 + + # C.g:75:5: ( '^' ) + # C.g:75:7: '^' + self.match(u'^') + + + + + + finally: + + pass + + # $ANTLR end T93 + + + + # $ANTLR start T94 + def mT94(self, ): + + try: + self.type = T94 + + # C.g:76:5: ( '==' ) + # C.g:76:7: '==' + self.match("==") + + + + + + + finally: + + pass + + # $ANTLR end T94 + + + + # $ANTLR start T95 + def mT95(self, ): + + try: + self.type = T95 + + # C.g:77:5: ( '!=' ) + # C.g:77:7: '!=' + self.match("!=") + + + + + + + finally: + + pass + + # $ANTLR end T95 + + + + # $ANTLR start T96 + def mT96(self, ): + + try: + self.type = T96 + + # C.g:78:5: ( '<' ) + # C.g:78:7: '<' + self.match(u'<') + + + + + + finally: + + pass + + # $ANTLR end T96 + + + + # $ANTLR start T97 + def mT97(self, ): + + try: + self.type = T97 + + # C.g:79:5: ( '>' ) + # C.g:79:7: '>' + self.match(u'>') + + + + + + finally: + + pass + + # $ANTLR end T97 + + + + # $ANTLR start T98 + def mT98(self, ): + + try: + self.type = T98 + + # C.g:80:5: ( '<=' ) + # C.g:80:7: '<=' + self.match("<=") + + + + + + + finally: + + pass + + # $ANTLR end T98 + + + + # $ANTLR start T99 + def mT99(self, ): + + try: + self.type = T99 + + # C.g:81:5: ( '>=' ) + # C.g:81:7: '>=' + self.match(">=") + + + + + + + finally: + + pass + + # $ANTLR end T99 + + + + # $ANTLR start T100 + def mT100(self, ): + + try: + self.type = T100 + + # C.g:82:6: ( '<<' ) + # C.g:82:8: '<<' + self.match("<<") + + + + + + + finally: + + pass + + # $ANTLR end T100 + + + + # $ANTLR start T101 + def mT101(self, ): + + try: + self.type = T101 + + # C.g:83:6: ( '>>' ) + # C.g:83:8: '>>' + self.match(">>") + + + + + + + finally: + + pass + + # $ANTLR end T101 + + + + # $ANTLR start T102 + def mT102(self, ): + + try: + self.type = T102 + + # C.g:84:6: ( '__asm__' ) + # C.g:84:8: '__asm__' + self.match("__asm__") + + + + + + + finally: + + pass + + # $ANTLR end T102 + + + + # $ANTLR start T103 + def mT103(self, ): + + try: + self.type = T103 + + # C.g:85:6: ( '_asm' ) + # C.g:85:8: '_asm' + self.match("_asm") + + + + + + + finally: + + pass + + # $ANTLR end T103 + + + + # $ANTLR start T104 + def mT104(self, ): + + try: + self.type = T104 + + # C.g:86:6: ( '__asm' ) + # C.g:86:8: '__asm' + self.match("__asm") + + + + + + + finally: + + pass + + # $ANTLR end T104 + + + + # $ANTLR start T105 + def mT105(self, ): + + try: + self.type = T105 + + # C.g:87:6: ( 'case' ) + # C.g:87:8: 'case' + self.match("case") + + + + + + + finally: + + pass + + # $ANTLR end T105 + + + + # $ANTLR start T106 + def mT106(self, ): + + try: + self.type = T106 + + # C.g:88:6: ( 'default' ) + # C.g:88:8: 'default' + self.match("default") + + + + + + + finally: + + pass + + # $ANTLR end T106 + + + + # $ANTLR start T107 + def mT107(self, ): + + try: + self.type = T107 + + # C.g:89:6: ( 'if' ) + # C.g:89:8: 'if' + self.match("if") + + + + + + + finally: + + pass + + # $ANTLR end T107 + + + + # $ANTLR start T108 + def mT108(self, ): + + try: + self.type = T108 + + # C.g:90:6: ( 'else' ) + # C.g:90:8: 'else' + self.match("else") + + + + + + + finally: + + pass + + # $ANTLR end T108 + + + + # $ANTLR start T109 + def mT109(self, ): + + try: + self.type = T109 + + # C.g:91:6: ( 'switch' ) + # C.g:91:8: 'switch' + self.match("switch") + + + + + + + finally: + + pass + + # $ANTLR end T109 + + + + # $ANTLR start T110 + def mT110(self, ): + + try: + self.type = T110 + + # C.g:92:6: ( 'while' ) + # C.g:92:8: 'while' + self.match("while") + + + + + + + finally: + + pass + + # $ANTLR end T110 + + + + # $ANTLR start T111 + def mT111(self, ): + + try: + self.type = T111 + + # C.g:93:6: ( 'do' ) + # C.g:93:8: 'do' + self.match("do") + + + + + + + finally: + + pass + + # $ANTLR end T111 + + + + # $ANTLR start T112 + def mT112(self, ): + + try: + self.type = T112 + + # C.g:94:6: ( 'for' ) + # C.g:94:8: 'for' + self.match("for") + + + + + + + finally: + + pass + + # $ANTLR end T112 + + + + # $ANTLR start T113 + def mT113(self, ): + + try: + self.type = T113 + + # C.g:95:6: ( 'goto' ) + # C.g:95:8: 'goto' + self.match("goto") + + + + + + + finally: + + pass + + # $ANTLR end T113 + + + + # $ANTLR start T114 + def mT114(self, ): + + try: + self.type = T114 + + # C.g:96:6: ( 'continue' ) + # C.g:96:8: 'continue' + self.match("continue") + + + + + + + finally: + + pass + + # $ANTLR end T114 + + + + # $ANTLR start T115 + def mT115(self, ): + + try: + self.type = T115 + + # C.g:97:6: ( 'break' ) + # C.g:97:8: 'break' + self.match("break") + + + + + + + finally: + + pass + + # $ANTLR end T115 + + + + # $ANTLR start T116 + def mT116(self, ): + + try: + self.type = T116 + + # C.g:98:6: ( 'return' ) + # C.g:98:8: 'return' + self.match("return") + + + + + + + finally: + + pass + + # $ANTLR end T116 + + + + # $ANTLR start IDENTIFIER + def mIDENTIFIER(self, ): + + try: + self.type = IDENTIFIER + + # C.g:533:2: ( LETTER ( LETTER | '0' .. '9' )* ) + # C.g:533:4: LETTER ( LETTER | '0' .. '9' )* + self.mLETTER() + + # C.g:533:11: ( LETTER | '0' .. '9' )* + while True: #loop1 + alt1 = 2 + LA1_0 = self.input.LA(1) + + if (LA1_0 == u'$' or (u'0' <= LA1_0 <= u'9') or (u'A' <= LA1_0 <= u'Z') or LA1_0 == u'_' or (u'a' <= LA1_0 <= u'z')) : + alt1 = 1 + + + if alt1 == 1: + # C.g: + if self.input.LA(1) == u'$' or (u'0' <= self.input.LA(1) <= u'9') or (u'A' <= self.input.LA(1) <= u'Z') or self.input.LA(1) == u'_' or (u'a' <= self.input.LA(1) <= u'z'): + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + else: + break #loop1 + + + + + + + finally: + + pass + + # $ANTLR end IDENTIFIER + + + + # $ANTLR start LETTER + def mLETTER(self, ): + + try: + # C.g:538:2: ( '$' | 'A' .. 'Z' | 'a' .. 'z' | '_' ) + # C.g: + if self.input.LA(1) == u'$' or (u'A' <= self.input.LA(1) <= u'Z') or self.input.LA(1) == u'_' or (u'a' <= self.input.LA(1) <= u'z'): + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + + + finally: + + pass + + # $ANTLR end LETTER + + + + # $ANTLR start CHARACTER_LITERAL + def mCHARACTER_LITERAL(self, ): + + try: + self.type = CHARACTER_LITERAL + + # C.g:545:5: ( ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\'' ) + # C.g:545:9: ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\'' + # C.g:545:9: ( 'L' )? + alt2 = 2 + LA2_0 = self.input.LA(1) + + if (LA2_0 == u'L') : + alt2 = 1 + if alt2 == 1: + # C.g:545:10: 'L' + self.match(u'L') + + + + + self.match(u'\'') + + # C.g:545:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) + alt3 = 2 + LA3_0 = self.input.LA(1) + + if (LA3_0 == u'\\') : + alt3 = 1 + elif ((u'\u0000' <= LA3_0 <= u'&') or (u'(' <= LA3_0 <= u'[') or (u']' <= LA3_0 <= u'\uFFFE')) : + alt3 = 2 + else: + nvae = NoViableAltException("545:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )", 3, 0, self.input) + + raise nvae + + if alt3 == 1: + # C.g:545:23: EscapeSequence + self.mEscapeSequence() + + + + elif alt3 == 2: + # C.g:545:40: ~ ( '\\'' | '\\\\' ) + if (u'\u0000' <= self.input.LA(1) <= u'&') or (u'(' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'): + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + + self.match(u'\'') + + + + + + finally: + + pass + + # $ANTLR end CHARACTER_LITERAL + + + + # $ANTLR start STRING_LITERAL + def mSTRING_LITERAL(self, ): + + try: + self.type = STRING_LITERAL + + # C.g:549:5: ( ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' ) + # C.g:549:8: ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' + # C.g:549:8: ( 'L' )? + alt4 = 2 + LA4_0 = self.input.LA(1) + + if (LA4_0 == u'L') : + alt4 = 1 + if alt4 == 1: + # C.g:549:9: 'L' + self.match(u'L') + + + + + self.match(u'"') + + # C.g:549:19: ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* + while True: #loop5 + alt5 = 3 + LA5_0 = self.input.LA(1) + + if (LA5_0 == u'\\') : + alt5 = 1 + elif ((u'\u0000' <= LA5_0 <= u'!') or (u'#' <= LA5_0 <= u'[') or (u']' <= LA5_0 <= u'\uFFFE')) : + alt5 = 2 + + + if alt5 == 1: + # C.g:549:21: EscapeSequence + self.mEscapeSequence() + + + + elif alt5 == 2: + # C.g:549:38: ~ ( '\\\\' | '\"' ) + if (u'\u0000' <= self.input.LA(1) <= u'!') or (u'#' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'): + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + else: + break #loop5 + + + self.match(u'"') + + + + + + finally: + + pass + + # $ANTLR end STRING_LITERAL + + + + # $ANTLR start HEX_LITERAL + def mHEX_LITERAL(self, ): + + try: + self.type = HEX_LITERAL + + # C.g:552:13: ( '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )? ) + # C.g:552:15: '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )? + self.match(u'0') + + if self.input.LA(1) == u'X' or self.input.LA(1) == u'x': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + # C.g:552:29: ( HexDigit )+ + cnt6 = 0 + while True: #loop6 + alt6 = 2 + LA6_0 = self.input.LA(1) + + if ((u'0' <= LA6_0 <= u'9') or (u'A' <= LA6_0 <= u'F') or (u'a' <= LA6_0 <= u'f')) : + alt6 = 1 + + + if alt6 == 1: + # C.g:552:29: HexDigit + self.mHexDigit() + + + + else: + if cnt6 >= 1: + break #loop6 + + eee = EarlyExitException(6, self.input) + raise eee + + cnt6 += 1 + + + # C.g:552:39: ( IntegerTypeSuffix )? + alt7 = 2 + LA7_0 = self.input.LA(1) + + if (LA7_0 == u'L' or LA7_0 == u'U' or LA7_0 == u'l' or LA7_0 == u'u') : + alt7 = 1 + if alt7 == 1: + # C.g:552:39: IntegerTypeSuffix + self.mIntegerTypeSuffix() + + + + + + + + + finally: + + pass + + # $ANTLR end HEX_LITERAL + + + + # $ANTLR start DECIMAL_LITERAL + def mDECIMAL_LITERAL(self, ): + + try: + self.type = DECIMAL_LITERAL + + # C.g:554:17: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )? ) + # C.g:554:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )? + # C.g:554:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) + alt9 = 2 + LA9_0 = self.input.LA(1) + + if (LA9_0 == u'0') : + alt9 = 1 + elif ((u'1' <= LA9_0 <= u'9')) : + alt9 = 2 + else: + nvae = NoViableAltException("554:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )", 9, 0, self.input) + + raise nvae + + if alt9 == 1: + # C.g:554:20: '0' + self.match(u'0') + + + + elif alt9 == 2: + # C.g:554:26: '1' .. '9' ( '0' .. '9' )* + self.matchRange(u'1', u'9') + + # C.g:554:35: ( '0' .. '9' )* + while True: #loop8 + alt8 = 2 + LA8_0 = self.input.LA(1) + + if ((u'0' <= LA8_0 <= u'9')) : + alt8 = 1 + + + if alt8 == 1: + # C.g:554:35: '0' .. '9' + self.matchRange(u'0', u'9') + + + + else: + break #loop8 + + + + + + # C.g:554:46: ( IntegerTypeSuffix )? + alt10 = 2 + LA10_0 = self.input.LA(1) + + if (LA10_0 == u'L' or LA10_0 == u'U' or LA10_0 == u'l' or LA10_0 == u'u') : + alt10 = 1 + if alt10 == 1: + # C.g:554:46: IntegerTypeSuffix + self.mIntegerTypeSuffix() + + + + + + + + + finally: + + pass + + # $ANTLR end DECIMAL_LITERAL + + + + # $ANTLR start OCTAL_LITERAL + def mOCTAL_LITERAL(self, ): + + try: + self.type = OCTAL_LITERAL + + # C.g:556:15: ( '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )? ) + # C.g:556:17: '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )? + self.match(u'0') + + # C.g:556:21: ( '0' .. '7' )+ + cnt11 = 0 + while True: #loop11 + alt11 = 2 + LA11_0 = self.input.LA(1) + + if ((u'0' <= LA11_0 <= u'7')) : + alt11 = 1 + + + if alt11 == 1: + # C.g:556:22: '0' .. '7' + self.matchRange(u'0', u'7') + + + + else: + if cnt11 >= 1: + break #loop11 + + eee = EarlyExitException(11, self.input) + raise eee + + cnt11 += 1 + + + # C.g:556:33: ( IntegerTypeSuffix )? + alt12 = 2 + LA12_0 = self.input.LA(1) + + if (LA12_0 == u'L' or LA12_0 == u'U' or LA12_0 == u'l' or LA12_0 == u'u') : + alt12 = 1 + if alt12 == 1: + # C.g:556:33: IntegerTypeSuffix + self.mIntegerTypeSuffix() + + + + + + + + + finally: + + pass + + # $ANTLR end OCTAL_LITERAL + + + + # $ANTLR start HexDigit + def mHexDigit(self, ): + + try: + # C.g:559:10: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) ) + # C.g:559:12: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) + if (u'0' <= self.input.LA(1) <= u'9') or (u'A' <= self.input.LA(1) <= u'F') or (u'a' <= self.input.LA(1) <= u'f'): + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + + + finally: + + pass + + # $ANTLR end HexDigit + + + + # $ANTLR start IntegerTypeSuffix + def mIntegerTypeSuffix(self, ): + + try: + # C.g:563:2: ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) ) + alt13 = 4 + LA13_0 = self.input.LA(1) + + if (LA13_0 == u'U' or LA13_0 == u'u') : + LA13_1 = self.input.LA(2) + + if (LA13_1 == u'L' or LA13_1 == u'l') : + LA13_3 = self.input.LA(3) + + if (LA13_3 == u'L' or LA13_3 == u'l') : + alt13 = 4 + else: + alt13 = 3 + else: + alt13 = 1 + elif (LA13_0 == u'L' or LA13_0 == u'l') : + alt13 = 2 + else: + nvae = NoViableAltException("561:1: fragment IntegerTypeSuffix : ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) );", 13, 0, self.input) + + raise nvae + + if alt13 == 1: + # C.g:563:4: ( 'u' | 'U' ) + if self.input.LA(1) == u'U' or self.input.LA(1) == u'u': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + elif alt13 == 2: + # C.g:564:4: ( 'l' | 'L' ) + if self.input.LA(1) == u'L' or self.input.LA(1) == u'l': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + elif alt13 == 3: + # C.g:565:4: ( 'u' | 'U' ) ( 'l' | 'L' ) + if self.input.LA(1) == u'U' or self.input.LA(1) == u'u': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + if self.input.LA(1) == u'L' or self.input.LA(1) == u'l': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + elif alt13 == 4: + # C.g:566:4: ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) + if self.input.LA(1) == u'U' or self.input.LA(1) == u'u': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + if self.input.LA(1) == u'L' or self.input.LA(1) == u'l': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + if self.input.LA(1) == u'L' or self.input.LA(1) == u'l': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + + finally: + + pass + + # $ANTLR end IntegerTypeSuffix + + + + # $ANTLR start FLOATING_POINT_LITERAL + def mFLOATING_POINT_LITERAL(self, ): + + try: + self.type = FLOATING_POINT_LITERAL + + # C.g:570:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? | '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? | ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? | ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix ) + alt25 = 4 + alt25 = self.dfa25.predict(self.input) + if alt25 == 1: + # C.g:570:9: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? + # C.g:570:9: ( '0' .. '9' )+ + cnt14 = 0 + while True: #loop14 + alt14 = 2 + LA14_0 = self.input.LA(1) + + if ((u'0' <= LA14_0 <= u'9')) : + alt14 = 1 + + + if alt14 == 1: + # C.g:570:10: '0' .. '9' + self.matchRange(u'0', u'9') + + + + else: + if cnt14 >= 1: + break #loop14 + + eee = EarlyExitException(14, self.input) + raise eee + + cnt14 += 1 + + + self.match(u'.') + + # C.g:570:25: ( '0' .. '9' )* + while True: #loop15 + alt15 = 2 + LA15_0 = self.input.LA(1) + + if ((u'0' <= LA15_0 <= u'9')) : + alt15 = 1 + + + if alt15 == 1: + # C.g:570:26: '0' .. '9' + self.matchRange(u'0', u'9') + + + + else: + break #loop15 + + + # C.g:570:37: ( Exponent )? + alt16 = 2 + LA16_0 = self.input.LA(1) + + if (LA16_0 == u'E' or LA16_0 == u'e') : + alt16 = 1 + if alt16 == 1: + # C.g:570:37: Exponent + self.mExponent() + + + + + # C.g:570:47: ( FloatTypeSuffix )? + alt17 = 2 + LA17_0 = self.input.LA(1) + + if (LA17_0 == u'D' or LA17_0 == u'F' or LA17_0 == u'd' or LA17_0 == u'f') : + alt17 = 1 + if alt17 == 1: + # C.g:570:47: FloatTypeSuffix + self.mFloatTypeSuffix() + + + + + + + elif alt25 == 2: + # C.g:571:9: '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? + self.match(u'.') + + # C.g:571:13: ( '0' .. '9' )+ + cnt18 = 0 + while True: #loop18 + alt18 = 2 + LA18_0 = self.input.LA(1) + + if ((u'0' <= LA18_0 <= u'9')) : + alt18 = 1 + + + if alt18 == 1: + # C.g:571:14: '0' .. '9' + self.matchRange(u'0', u'9') + + + + else: + if cnt18 >= 1: + break #loop18 + + eee = EarlyExitException(18, self.input) + raise eee + + cnt18 += 1 + + + # C.g:571:25: ( Exponent )? + alt19 = 2 + LA19_0 = self.input.LA(1) + + if (LA19_0 == u'E' or LA19_0 == u'e') : + alt19 = 1 + if alt19 == 1: + # C.g:571:25: Exponent + self.mExponent() + + + + + # C.g:571:35: ( FloatTypeSuffix )? + alt20 = 2 + LA20_0 = self.input.LA(1) + + if (LA20_0 == u'D' or LA20_0 == u'F' or LA20_0 == u'd' or LA20_0 == u'f') : + alt20 = 1 + if alt20 == 1: + # C.g:571:35: FloatTypeSuffix + self.mFloatTypeSuffix() + + + + + + + elif alt25 == 3: + # C.g:572:9: ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? + # C.g:572:9: ( '0' .. '9' )+ + cnt21 = 0 + while True: #loop21 + alt21 = 2 + LA21_0 = self.input.LA(1) + + if ((u'0' <= LA21_0 <= u'9')) : + alt21 = 1 + + + if alt21 == 1: + # C.g:572:10: '0' .. '9' + self.matchRange(u'0', u'9') + + + + else: + if cnt21 >= 1: + break #loop21 + + eee = EarlyExitException(21, self.input) + raise eee + + cnt21 += 1 + + + self.mExponent() + + # C.g:572:30: ( FloatTypeSuffix )? + alt22 = 2 + LA22_0 = self.input.LA(1) + + if (LA22_0 == u'D' or LA22_0 == u'F' or LA22_0 == u'd' or LA22_0 == u'f') : + alt22 = 1 + if alt22 == 1: + # C.g:572:30: FloatTypeSuffix + self.mFloatTypeSuffix() + + + + + + + elif alt25 == 4: + # C.g:573:9: ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix + # C.g:573:9: ( '0' .. '9' )+ + cnt23 = 0 + while True: #loop23 + alt23 = 2 + LA23_0 = self.input.LA(1) + + if ((u'0' <= LA23_0 <= u'9')) : + alt23 = 1 + + + if alt23 == 1: + # C.g:573:10: '0' .. '9' + self.matchRange(u'0', u'9') + + + + else: + if cnt23 >= 1: + break #loop23 + + eee = EarlyExitException(23, self.input) + raise eee + + cnt23 += 1 + + + # C.g:573:21: ( Exponent )? + alt24 = 2 + LA24_0 = self.input.LA(1) + + if (LA24_0 == u'E' or LA24_0 == u'e') : + alt24 = 1 + if alt24 == 1: + # C.g:573:21: Exponent + self.mExponent() + + + + + self.mFloatTypeSuffix() + + + + + finally: + + pass + + # $ANTLR end FLOATING_POINT_LITERAL + + + + # $ANTLR start Exponent + def mExponent(self, ): + + try: + # C.g:577:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ ) + # C.g:577:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ + if self.input.LA(1) == u'E' or self.input.LA(1) == u'e': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + # C.g:577:22: ( '+' | '-' )? + alt26 = 2 + LA26_0 = self.input.LA(1) + + if (LA26_0 == u'+' or LA26_0 == u'-') : + alt26 = 1 + if alt26 == 1: + # C.g: + if self.input.LA(1) == u'+' or self.input.LA(1) == u'-': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + + # C.g:577:33: ( '0' .. '9' )+ + cnt27 = 0 + while True: #loop27 + alt27 = 2 + LA27_0 = self.input.LA(1) + + if ((u'0' <= LA27_0 <= u'9')) : + alt27 = 1 + + + if alt27 == 1: + # C.g:577:34: '0' .. '9' + self.matchRange(u'0', u'9') + + + + else: + if cnt27 >= 1: + break #loop27 + + eee = EarlyExitException(27, self.input) + raise eee + + cnt27 += 1 + + + + + + + finally: + + pass + + # $ANTLR end Exponent + + + + # $ANTLR start FloatTypeSuffix + def mFloatTypeSuffix(self, ): + + try: + # C.g:580:17: ( ( 'f' | 'F' | 'd' | 'D' ) ) + # C.g:580:19: ( 'f' | 'F' | 'd' | 'D' ) + if self.input.LA(1) == u'D' or self.input.LA(1) == u'F' or self.input.LA(1) == u'd' or self.input.LA(1) == u'f': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + + + finally: + + pass + + # $ANTLR end FloatTypeSuffix + + + + # $ANTLR start EscapeSequence + def mEscapeSequence(self, ): + + try: + # C.g:584:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape ) + alt28 = 2 + LA28_0 = self.input.LA(1) + + if (LA28_0 == u'\\') : + LA28_1 = self.input.LA(2) + + if (LA28_1 == u'"' or LA28_1 == u'\'' or LA28_1 == u'\\' or LA28_1 == u'b' or LA28_1 == u'f' or LA28_1 == u'n' or LA28_1 == u'r' or LA28_1 == u't') : + alt28 = 1 + elif ((u'0' <= LA28_1 <= u'7')) : + alt28 = 2 + else: + nvae = NoViableAltException("582:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 1, self.input) + + raise nvae + + else: + nvae = NoViableAltException("582:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 0, self.input) + + raise nvae + + if alt28 == 1: + # C.g:584:8: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) + self.match(u'\\') + + if self.input.LA(1) == u'"' or self.input.LA(1) == u'\'' or self.input.LA(1) == u'\\' or self.input.LA(1) == u'b' or self.input.LA(1) == u'f' or self.input.LA(1) == u'n' or self.input.LA(1) == u'r' or self.input.LA(1) == u't': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + elif alt28 == 2: + # C.g:585:9: OctalEscape + self.mOctalEscape() + + + + + finally: + + pass + + # $ANTLR end EscapeSequence + + + + # $ANTLR start OctalEscape + def mOctalEscape(self, ): + + try: + # C.g:590:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ) + alt29 = 3 + LA29_0 = self.input.LA(1) + + if (LA29_0 == u'\\') : + LA29_1 = self.input.LA(2) + + if ((u'0' <= LA29_1 <= u'3')) : + LA29_2 = self.input.LA(3) + + if ((u'0' <= LA29_2 <= u'7')) : + LA29_4 = self.input.LA(4) + + if ((u'0' <= LA29_4 <= u'7')) : + alt29 = 1 + else: + alt29 = 2 + else: + alt29 = 3 + elif ((u'4' <= LA29_1 <= u'7')) : + LA29_3 = self.input.LA(3) + + if ((u'0' <= LA29_3 <= u'7')) : + alt29 = 2 + else: + alt29 = 3 + else: + nvae = NoViableAltException("588:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 1, self.input) + + raise nvae + + else: + nvae = NoViableAltException("588:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 0, self.input) + + raise nvae + + if alt29 == 1: + # C.g:590:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) + self.match(u'\\') + + # C.g:590:14: ( '0' .. '3' ) + # C.g:590:15: '0' .. '3' + self.matchRange(u'0', u'3') + + + + + # C.g:590:25: ( '0' .. '7' ) + # C.g:590:26: '0' .. '7' + self.matchRange(u'0', u'7') + + + + + # C.g:590:36: ( '0' .. '7' ) + # C.g:590:37: '0' .. '7' + self.matchRange(u'0', u'7') + + + + + + + elif alt29 == 2: + # C.g:591:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) + self.match(u'\\') + + # C.g:591:14: ( '0' .. '7' ) + # C.g:591:15: '0' .. '7' + self.matchRange(u'0', u'7') + + + + + # C.g:591:25: ( '0' .. '7' ) + # C.g:591:26: '0' .. '7' + self.matchRange(u'0', u'7') + + + + + + + elif alt29 == 3: + # C.g:592:9: '\\\\' ( '0' .. '7' ) + self.match(u'\\') + + # C.g:592:14: ( '0' .. '7' ) + # C.g:592:15: '0' .. '7' + self.matchRange(u'0', u'7') + + + + + + + + finally: + + pass + + # $ANTLR end OctalEscape + + + + # $ANTLR start UnicodeEscape + def mUnicodeEscape(self, ): + + try: + # C.g:597:5: ( '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit ) + # C.g:597:9: '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit + self.match(u'\\') + + self.match(u'u') + + self.mHexDigit() + + self.mHexDigit() + + self.mHexDigit() + + self.mHexDigit() + + + + + + finally: + + pass + + # $ANTLR end UnicodeEscape + + + + # $ANTLR start WS + def mWS(self, ): + + try: + self.type = WS + + # C.g:600:5: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) ) + # C.g:600:8: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) + if (u'\t' <= self.input.LA(1) <= u'\n') or (u'\f' <= self.input.LA(1) <= u'\r') or self.input.LA(1) == u' ': + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + #action start + self.channel=HIDDEN; + #action end + + + + + finally: + + pass + + # $ANTLR end WS + + + + # $ANTLR start BS + def mBS(self, ): + + try: + self.type = BS + + # C.g:604:5: ( ( '\\\\' ) ) + # C.g:604:7: ( '\\\\' ) + # C.g:604:7: ( '\\\\' ) + # C.g:604:8: '\\\\' + self.match(u'\\') + + + + + #action start + self.channel=HIDDEN; + #action end + + + + + finally: + + pass + + # $ANTLR end BS + + + + # $ANTLR start UnicodeVocabulary + def mUnicodeVocabulary(self, ): + + try: + self.type = UnicodeVocabulary + + # C.g:612:5: ( '\\u0003' .. '\\uFFFE' ) + # C.g:612:7: '\\u0003' .. '\\uFFFE' + self.matchRange(u'\u0003', u'\uFFFE') + + + + + + finally: + + pass + + # $ANTLR end UnicodeVocabulary + + + + # $ANTLR start COMMENT + def mCOMMENT(self, ): + + try: + self.type = COMMENT + + # C.g:615:5: ( '/*' ( options {greedy=false; } : . )* '*/' ) + # C.g:615:9: '/*' ( options {greedy=false; } : . )* '*/' + self.match("/*") + + + # C.g:615:14: ( options {greedy=false; } : . )* + while True: #loop30 + alt30 = 2 + LA30_0 = self.input.LA(1) + + if (LA30_0 == u'*') : + LA30_1 = self.input.LA(2) + + if (LA30_1 == u'/') : + alt30 = 2 + elif ((u'\u0000' <= LA30_1 <= u'.') or (u'0' <= LA30_1 <= u'\uFFFE')) : + alt30 = 1 + + + elif ((u'\u0000' <= LA30_0 <= u')') or (u'+' <= LA30_0 <= u'\uFFFE')) : + alt30 = 1 + + + if alt30 == 1: + # C.g:615:42: . + self.matchAny() + + + + else: + break #loop30 + + + self.match("*/") + + + #action start + self.channel=HIDDEN; + #action end + + + + + finally: + + pass + + # $ANTLR end COMMENT + + + + # $ANTLR start LINE_COMMENT + def mLINE_COMMENT(self, ): + + try: + self.type = LINE_COMMENT + + # C.g:620:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' ) + # C.g:620:7: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' + self.match("//") + + + # C.g:620:12: (~ ( '\\n' | '\\r' ) )* + while True: #loop31 + alt31 = 2 + LA31_0 = self.input.LA(1) + + if ((u'\u0000' <= LA31_0 <= u'\t') or (u'\u000B' <= LA31_0 <= u'\f') or (u'\u000E' <= LA31_0 <= u'\uFFFE')) : + alt31 = 1 + + + if alt31 == 1: + # C.g:620:12: ~ ( '\\n' | '\\r' ) + if (u'\u0000' <= self.input.LA(1) <= u'\t') or (u'\u000B' <= self.input.LA(1) <= u'\f') or (u'\u000E' <= self.input.LA(1) <= u'\uFFFE'): + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + else: + break #loop31 + + + # C.g:620:26: ( '\\r' )? + alt32 = 2 + LA32_0 = self.input.LA(1) + + if (LA32_0 == u'\r') : + alt32 = 1 + if alt32 == 1: + # C.g:620:26: '\\r' + self.match(u'\r') + + + + + self.match(u'\n') + + #action start + self.channel=HIDDEN; + #action end + + + + + finally: + + pass + + # $ANTLR end LINE_COMMENT + + + + # $ANTLR start LINE_COMMAND + def mLINE_COMMAND(self, ): + + try: + self.type = LINE_COMMAND + + # C.g:625:5: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' ) + # C.g:625:7: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' + self.match(u'#') + + # C.g:625:11: (~ ( '\\n' | '\\r' ) )* + while True: #loop33 + alt33 = 2 + LA33_0 = self.input.LA(1) + + if ((u'\u0000' <= LA33_0 <= u'\t') or (u'\u000B' <= LA33_0 <= u'\f') or (u'\u000E' <= LA33_0 <= u'\uFFFE')) : + alt33 = 1 + + + if alt33 == 1: + # C.g:625:11: ~ ( '\\n' | '\\r' ) + if (u'\u0000' <= self.input.LA(1) <= u'\t') or (u'\u000B' <= self.input.LA(1) <= u'\f') or (u'\u000E' <= self.input.LA(1) <= u'\uFFFE'): + self.input.consume(); + + else: + mse = MismatchedSetException(None, self.input) + self.recover(mse) + raise mse + + + + + else: + break #loop33 + + + # C.g:625:25: ( '\\r' )? + alt34 = 2 + LA34_0 = self.input.LA(1) + + if (LA34_0 == u'\r') : + alt34 = 1 + if alt34 == 1: + # C.g:625:25: '\\r' + self.match(u'\r') + + + + + self.match(u'\n') + + #action start + self.channel=HIDDEN; + #action end + + + + + finally: + + pass + + # $ANTLR end LINE_COMMAND + + + + def mTokens(self): + # C.g:1:8: ( T25 | T26 | T27 | T28 | T29 | T30 | T31 | T32 | T33 | T34 | T35 | T36 | T37 | T38 | T39 | T40 | T41 | T42 | T43 | T44 | T45 | T46 | T47 | T48 | T49 | T50 | T51 | T52 | T53 | T54 | T55 | T56 | T57 | T58 | T59 | T60 | T61 | T62 | T63 | T64 | T65 | T66 | T67 | T68 | T69 | T70 | T71 | T72 | T73 | T74 | T75 | T76 | T77 | T78 | T79 | T80 | T81 | T82 | T83 | T84 | T85 | T86 | T87 | T88 | T89 | T90 | T91 | T92 | T93 | T94 | T95 | T96 | T97 | T98 | T99 | T100 | T101 | T102 | T103 | T104 | T105 | T106 | T107 | T108 | T109 | T110 | T111 | T112 | T113 | T114 | T115 | T116 | IDENTIFIER | CHARACTER_LITERAL | STRING_LITERAL | HEX_LITERAL | DECIMAL_LITERAL | OCTAL_LITERAL | FLOATING_POINT_LITERAL | WS | BS | UnicodeVocabulary | COMMENT | LINE_COMMENT | LINE_COMMAND ) + alt35 = 105 + alt35 = self.dfa35.predict(self.input) + if alt35 == 1: + # C.g:1:10: T25 + self.mT25() + + + + elif alt35 == 2: + # C.g:1:14: T26 + self.mT26() + + + + elif alt35 == 3: + # C.g:1:18: T27 + self.mT27() + + + + elif alt35 == 4: + # C.g:1:22: T28 + self.mT28() + + + + elif alt35 == 5: + # C.g:1:26: T29 + self.mT29() + + + + elif alt35 == 6: + # C.g:1:30: T30 + self.mT30() + + + + elif alt35 == 7: + # C.g:1:34: T31 + self.mT31() + + + + elif alt35 == 8: + # C.g:1:38: T32 + self.mT32() + + + + elif alt35 == 9: + # C.g:1:42: T33 + self.mT33() + + + + elif alt35 == 10: + # C.g:1:46: T34 + self.mT34() + + + + elif alt35 == 11: + # C.g:1:50: T35 + self.mT35() + + + + elif alt35 == 12: + # C.g:1:54: T36 + self.mT36() + + + + elif alt35 == 13: + # C.g:1:58: T37 + self.mT37() + + + + elif alt35 == 14: + # C.g:1:62: T38 + self.mT38() + + + + elif alt35 == 15: + # C.g:1:66: T39 + self.mT39() + + + + elif alt35 == 16: + # C.g:1:70: T40 + self.mT40() + + + + elif alt35 == 17: + # C.g:1:74: T41 + self.mT41() + + + + elif alt35 == 18: + # C.g:1:78: T42 + self.mT42() + + + + elif alt35 == 19: + # C.g:1:82: T43 + self.mT43() + + + + elif alt35 == 20: + # C.g:1:86: T44 + self.mT44() + + + + elif alt35 == 21: + # C.g:1:90: T45 + self.mT45() + + + + elif alt35 == 22: + # C.g:1:94: T46 + self.mT46() + + + + elif alt35 == 23: + # C.g:1:98: T47 + self.mT47() + + + + elif alt35 == 24: + # C.g:1:102: T48 + self.mT48() + + + + elif alt35 == 25: + # C.g:1:106: T49 + self.mT49() + + + + elif alt35 == 26: + # C.g:1:110: T50 + self.mT50() + + + + elif alt35 == 27: + # C.g:1:114: T51 + self.mT51() + + + + elif alt35 == 28: + # C.g:1:118: T52 + self.mT52() + + + + elif alt35 == 29: + # C.g:1:122: T53 + self.mT53() + + + + elif alt35 == 30: + # C.g:1:126: T54 + self.mT54() + + + + elif alt35 == 31: + # C.g:1:130: T55 + self.mT55() + + + + elif alt35 == 32: + # C.g:1:134: T56 + self.mT56() + + + + elif alt35 == 33: + # C.g:1:138: T57 + self.mT57() + + + + elif alt35 == 34: + # C.g:1:142: T58 + self.mT58() + + + + elif alt35 == 35: + # C.g:1:146: T59 + self.mT59() + + + + elif alt35 == 36: + # C.g:1:150: T60 + self.mT60() + + + + elif alt35 == 37: + # C.g:1:154: T61 + self.mT61() + + + + elif alt35 == 38: + # C.g:1:158: T62 + self.mT62() + + + + elif alt35 == 39: + # C.g:1:162: T63 + self.mT63() + + + + elif alt35 == 40: + # C.g:1:166: T64 + self.mT64() + + + + elif alt35 == 41: + # C.g:1:170: T65 + self.mT65() + + + + elif alt35 == 42: + # C.g:1:174: T66 + self.mT66() + + + + elif alt35 == 43: + # C.g:1:178: T67 + self.mT67() + + + + elif alt35 == 44: + # C.g:1:182: T68 + self.mT68() + + + + elif alt35 == 45: + # C.g:1:186: T69 + self.mT69() + + + + elif alt35 == 46: + # C.g:1:190: T70 + self.mT70() + + + + elif alt35 == 47: + # C.g:1:194: T71 + self.mT71() + + + + elif alt35 == 48: + # C.g:1:198: T72 + self.mT72() + + + + elif alt35 == 49: + # C.g:1:202: T73 + self.mT73() + + + + elif alt35 == 50: + # C.g:1:206: T74 + self.mT74() + + + + elif alt35 == 51: + # C.g:1:210: T75 + self.mT75() + + + + elif alt35 == 52: + # C.g:1:214: T76 + self.mT76() + + + + elif alt35 == 53: + # C.g:1:218: T77 + self.mT77() + + + + elif alt35 == 54: + # C.g:1:222: T78 + self.mT78() + + + + elif alt35 == 55: + # C.g:1:226: T79 + self.mT79() + + + + elif alt35 == 56: + # C.g:1:230: T80 + self.mT80() + + + + elif alt35 == 57: + # C.g:1:234: T81 + self.mT81() + + + + elif alt35 == 58: + # C.g:1:238: T82 + self.mT82() + + + + elif alt35 == 59: + # C.g:1:242: T83 + self.mT83() + + + + elif alt35 == 60: + # C.g:1:246: T84 + self.mT84() + + + + elif alt35 == 61: + # C.g:1:250: T85 + self.mT85() + + + + elif alt35 == 62: + # C.g:1:254: T86 + self.mT86() + + + + elif alt35 == 63: + # C.g:1:258: T87 + self.mT87() + + + + elif alt35 == 64: + # C.g:1:262: T88 + self.mT88() + + + + elif alt35 == 65: + # C.g:1:266: T89 + self.mT89() + + + + elif alt35 == 66: + # C.g:1:270: T90 + self.mT90() + + + + elif alt35 == 67: + # C.g:1:274: T91 + self.mT91() + + + + elif alt35 == 68: + # C.g:1:278: T92 + self.mT92() + + + + elif alt35 == 69: + # C.g:1:282: T93 + self.mT93() + + + + elif alt35 == 70: + # C.g:1:286: T94 + self.mT94() + + + + elif alt35 == 71: + # C.g:1:290: T95 + self.mT95() + + + + elif alt35 == 72: + # C.g:1:294: T96 + self.mT96() + + + + elif alt35 == 73: + # C.g:1:298: T97 + self.mT97() + + + + elif alt35 == 74: + # C.g:1:302: T98 + self.mT98() + + + + elif alt35 == 75: + # C.g:1:306: T99 + self.mT99() + + + + elif alt35 == 76: + # C.g:1:310: T100 + self.mT100() + + + + elif alt35 == 77: + # C.g:1:315: T101 + self.mT101() + + + + elif alt35 == 78: + # C.g:1:320: T102 + self.mT102() + + + + elif alt35 == 79: + # C.g:1:325: T103 + self.mT103() + + + + elif alt35 == 80: + # C.g:1:330: T104 + self.mT104() + + + + elif alt35 == 81: + # C.g:1:335: T105 + self.mT105() + + + + elif alt35 == 82: + # C.g:1:340: T106 + self.mT106() + + + + elif alt35 == 83: + # C.g:1:345: T107 + self.mT107() + + + + elif alt35 == 84: + # C.g:1:350: T108 + self.mT108() + + + + elif alt35 == 85: + # C.g:1:355: T109 + self.mT109() + + + + elif alt35 == 86: + # C.g:1:360: T110 + self.mT110() + + + + elif alt35 == 87: + # C.g:1:365: T111 + self.mT111() + + + + elif alt35 == 88: + # C.g:1:370: T112 + self.mT112() + + + + elif alt35 == 89: + # C.g:1:375: T113 + self.mT113() + + + + elif alt35 == 90: + # C.g:1:380: T114 + self.mT114() + + + + elif alt35 == 91: + # C.g:1:385: T115 + self.mT115() + + + + elif alt35 == 92: + # C.g:1:390: T116 + self.mT116() + + + + elif alt35 == 93: + # C.g:1:395: IDENTIFIER + self.mIDENTIFIER() + + + + elif alt35 == 94: + # C.g:1:406: CHARACTER_LITERAL + self.mCHARACTER_LITERAL() + + + + elif alt35 == 95: + # C.g:1:424: STRING_LITERAL + self.mSTRING_LITERAL() + + + + elif alt35 == 96: + # C.g:1:439: HEX_LITERAL + self.mHEX_LITERAL() + + + + elif alt35 == 97: + # C.g:1:451: DECIMAL_LITERAL + self.mDECIMAL_LITERAL() + + + + elif alt35 == 98: + # C.g:1:467: OCTAL_LITERAL + self.mOCTAL_LITERAL() + + + + elif alt35 == 99: + # C.g:1:481: FLOATING_POINT_LITERAL + self.mFLOATING_POINT_LITERAL() + + + + elif alt35 == 100: + # C.g:1:504: WS + self.mWS() + + + + elif alt35 == 101: + # C.g:1:507: BS + self.mBS() + + + + elif alt35 == 102: + # C.g:1:510: UnicodeVocabulary + self.mUnicodeVocabulary() + + + + elif alt35 == 103: + # C.g:1:528: COMMENT + self.mCOMMENT() + + + + elif alt35 == 104: + # C.g:1:536: LINE_COMMENT + self.mLINE_COMMENT() + + + + elif alt35 == 105: + # C.g:1:549: LINE_COMMAND + self.mLINE_COMMAND() + + + + + + + + + # lookup tables for DFA #25 + + DFA25_eot = DFA.unpack( + u"\7\uffff\1\10\2\uffff" + ) + + DFA25_eof = DFA.unpack( + u"\12\uffff" + ) + + DFA25_min = DFA.unpack( + u"\2\56\1\uffff\1\53\2\uffff\2\60\2\uffff" + ) + + DFA25_max = DFA.unpack( + u"\1\71\1\146\1\uffff\1\71\2\uffff\1\71\1\146\2\uffff" + ) + + DFA25_accept = DFA.unpack( + u"\2\uffff\1\2\1\uffff\1\4\1\1\2\uffff\2\3" + ) + + DFA25_special = DFA.unpack( + u"\12\uffff" + ) + + + DFA25_transition = [ + DFA.unpack(u"\1\2\1\uffff\12\1"), + DFA.unpack(u"\1\5\1\uffff\12\1\12\uffff\1\4\1\3\1\4\35\uffff\1\4" + u"\1\3\1\4"), + DFA.unpack(u""), + DFA.unpack(u"\1\6\1\uffff\1\6\2\uffff\12\7"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\12\7"), + DFA.unpack(u"\12\7\12\uffff\1\11\1\uffff\1\11\35\uffff\1\11\1\uffff" + u"\1\11"), + DFA.unpack(u""), + DFA.unpack(u"") + ] + + # class definition for DFA #25 + + DFA25 = DFA + # lookup tables for DFA #35 + + DFA35_eot = DFA.unpack( + u"\2\uffff\1\75\1\uffff\1\100\14\75\3\uffff\7\75\4\uffff\1\147\1" + u"\151\1\155\1\161\1\165\1\167\1\172\1\uffff\1\175\1\u0080\1\u0083" + u"\1\u0085\1\u0088\1\uffff\5\75\1\uffff\2\72\2\u0092\2\uffff\1\72" + u"\2\uffff\1\75\4\uffff\16\75\1\u00ab\4\75\1\u00b1\2\75\3\uffff\1" + u"\u00b5\7\75\35\uffff\1\u00be\1\uffff\1\u00c0\10\uffff\5\75\4\uffff" + u"\1\u00c6\1\u0092\3\uffff\23\75\1\uffff\1\u00db\1\75\1\u00dd\2\75" + u"\1\uffff\3\75\1\uffff\1\u00e3\6\75\4\uffff\5\75\1\uffff\1\75\1" + u"\u00f1\1\u00f2\7\75\1\u00fa\3\75\1\u00fe\3\75\1\u0102\1\u0103\1" + u"\uffff\1\u0104\1\uffff\5\75\1\uffff\10\75\1\u0113\1\75\1\u0115" + u"\2\75\2\uffff\6\75\1\u011e\1\uffff\3\75\1\uffff\2\75\1\u0124\3" + u"\uffff\1\u0125\3\75\1\u0129\1\75\1\u012b\6\75\1\u0133\1\uffff\1" + u"\u0134\1\uffff\1\u0135\1\75\1\u0137\1\u0138\1\u0139\1\u013a\1\u013b" + u"\1\u013c\1\uffff\1\75\1\u013e\1\u013f\2\75\2\uffff\1\u0142\2\75" + u"\1\uffff\1\75\1\uffff\5\75\1\u014b\1\75\3\uffff\1\u014d\6\uffff" + u"\1\75\2\uffff\2\75\1\uffff\1\u0151\7\75\1\uffff\1\u0159\1\uffff" + u"\1\u015a\1\u015b\1\u015c\1\uffff\1\u015d\1\u015e\1\75\1\u0160\3" + u"\75\6\uffff\1\u0164\1\uffff\3\75\1\uffff\20\75\1\u0178\2\75\1\uffff" + u"\4\75\1\u017f\1\75\1\uffff\11\75\1\u018a\1\uffff" + ) + + DFA35_eof = DFA.unpack( + u"\u018b\uffff" + ) + + DFA35_min = DFA.unpack( + u"\1\3\1\uffff\1\171\1\uffff\1\75\1\154\1\150\1\165\1\145\1\124\1" + u"\157\1\141\1\146\1\157\1\154\1\145\1\156\3\uffff\1\116\1\120\1" + u"\117\1\116\1\117\1\114\1\106\4\uffff\1\75\1\56\1\53\1\55\1\52\1" + u"\75\1\46\1\uffff\1\75\1\74\3\75\1\uffff\1\137\1\150\1\157\1\162" + u"\1\42\1\uffff\2\0\2\56\2\uffff\1\0\2\uffff\1\160\4\uffff\1\165" + u"\1\163\1\164\1\141\1\151\1\147\1\157\1\164\1\147\1\101\1\151\1" + u"\156\1\163\1\141\1\44\1\164\1\156\1\162\1\157\1\44\1\146\1\151" + u"\3\uffff\1\44\2\124\1\116\1\101\1\114\1\117\1\111\35\uffff\1\75" + u"\1\uffff\1\75\10\uffff\1\141\1\163\1\151\1\164\1\145\4\uffff\2" + u"\56\3\uffff\1\145\1\155\2\145\1\165\2\164\1\156\1\145\1\162\1\157" + u"\1\151\1\165\1\124\1\144\1\141\1\163\1\145\1\162\1\uffff\1\44\1" + u"\147\1\44\1\141\1\142\1\uffff\1\141\1\151\1\157\1\uffff\1\44\1" + u"\111\1\123\1\114\1\101\1\102\1\101\4\uffff\1\163\1\155\1\154\1" + u"\157\1\141\1\uffff\1\144\2\44\1\162\1\143\1\151\1\143\1\145\1\157" + u"\1\164\1\44\1\163\1\162\1\111\1\44\1\164\1\151\1\164\2\44\1\uffff" + u"\1\44\1\uffff\1\164\1\154\1\165\1\147\1\156\1\uffff\1\117\1\124" + u"\1\111\1\124\1\101\1\102\1\120\1\155\1\44\1\145\1\44\1\153\1\145" + u"\2\uffff\1\156\1\164\1\143\1\150\1\144\1\146\1\44\1\uffff\1\164" + u"\1\156\1\103\1\uffff\1\151\1\156\1\44\3\uffff\1\44\1\145\1\154" + u"\1\156\1\44\1\116\1\44\1\107\1\111\1\114\1\117\1\125\1\111\1\44" + u"\1\uffff\1\44\1\uffff\1\44\1\146\6\44\1\uffff\1\145\2\44\1\154" + u"\1\165\2\uffff\1\44\1\164\1\145\1\uffff\1\101\1\uffff\1\116\1\114" + u"\1\137\1\117\1\116\1\44\1\137\3\uffff\1\44\6\uffff\1\162\2\uffff" + u"\2\145\1\uffff\1\44\1\144\1\114\2\105\1\122\2\124\1\uffff\1\44" + u"\1\uffff\3\44\1\uffff\2\44\1\104\1\44\1\105\1\123\1\111\6\uffff" + u"\1\44\1\uffff\1\115\1\105\1\115\1\uffff\1\117\1\122\1\105\2\126" + u"\1\123\1\105\1\111\1\105\1\137\1\103\1\122\1\111\1\105\1\126\1" + u"\106\1\44\1\111\1\137\1\uffff\1\103\1\125\1\105\1\116\1\44\1\122" + u"\1\uffff\1\105\1\106\1\105\1\122\1\105\1\116\1\103\1\105\1\104" + u"\1\44\1\uffff" + ) + + DFA35_max = DFA.unpack( + u"\1\ufffe\1\uffff\1\171\1\uffff\1\75\1\170\1\167\1\165\1\145\1\124" + u"\2\157\1\156\3\157\1\156\3\uffff\1\116\1\125\1\117\1\116\1\117" + u"\1\114\1\106\4\uffff\1\75\1\71\1\75\1\76\3\75\1\uffff\2\75\1\76" + u"\1\75\1\174\1\uffff\1\141\1\150\1\157\1\162\1\47\1\uffff\2\ufffe" + u"\1\170\1\146\2\uffff\1\ufffe\2\uffff\1\160\4\uffff\1\165\1\163" + u"\1\164\1\162\1\151\1\172\1\157\2\164\1\101\1\154\1\156\1\163\1" + u"\141\1\172\1\164\1\156\1\162\1\157\1\172\1\146\1\163\3\uffff\1" + u"\172\2\124\1\116\1\101\1\114\1\117\1\111\35\uffff\1\75\1\uffff" + u"\1\75\10\uffff\1\141\1\163\1\151\1\164\1\145\4\uffff\2\146\3\uffff" + u"\1\145\1\155\2\145\1\165\2\164\1\156\1\145\1\162\1\157\1\151\1" + u"\165\1\124\1\144\1\141\1\164\1\145\1\162\1\uffff\1\172\1\147\1" + u"\172\1\141\1\142\1\uffff\1\141\1\151\1\157\1\uffff\1\172\1\111" + u"\1\123\1\114\1\101\1\102\1\137\4\uffff\1\163\1\155\1\154\1\157" + u"\1\141\1\uffff\1\144\2\172\1\162\1\143\1\151\1\143\1\145\1\157" + u"\1\164\1\172\1\163\1\162\1\111\1\172\1\164\1\151\1\164\2\172\1" + u"\uffff\1\172\1\uffff\1\164\1\154\1\165\1\147\1\156\1\uffff\1\117" + u"\1\124\1\111\1\124\1\101\1\122\1\120\1\155\1\172\1\145\1\172\1" + u"\153\1\145\2\uffff\1\156\1\164\1\143\1\150\1\144\1\146\1\172\1" + u"\uffff\1\164\1\156\1\103\1\uffff\1\151\1\156\1\172\3\uffff\1\172" + u"\1\145\1\154\1\156\1\172\1\116\1\172\1\107\1\111\1\114\1\117\1" + u"\125\1\111\1\172\1\uffff\1\172\1\uffff\1\172\1\146\6\172\1\uffff" + u"\1\145\2\172\1\154\1\165\2\uffff\1\172\1\164\1\145\1\uffff\1\101" + u"\1\uffff\1\116\1\114\1\137\1\117\1\116\1\172\1\137\3\uffff\1\172" + u"\6\uffff\1\162\2\uffff\2\145\1\uffff\1\172\1\144\1\114\2\105\1" + u"\122\2\124\1\uffff\1\172\1\uffff\3\172\1\uffff\2\172\1\104\1\172" + u"\1\105\1\123\1\111\6\uffff\1\172\1\uffff\1\115\1\105\1\115\1\uffff" + u"\1\117\1\122\1\105\2\126\1\123\1\105\1\111\1\105\1\137\1\103\1" + u"\122\1\111\1\105\1\126\1\106\1\172\1\111\1\137\1\uffff\1\103\1" + u"\125\1\105\1\116\1\172\1\122\1\uffff\1\105\1\106\1\105\1\122\1" + u"\105\1\116\1\103\1\105\1\104\1\172\1\uffff" + ) + + DFA35_accept = DFA.unpack( + u"\1\uffff\1\1\1\uffff\1\3\15\uffff\1\23\1\24\1\27\7\uffff\1\45\1" + u"\46\1\47\1\50\7\uffff\1\65\5\uffff\1\101\5\uffff\1\135\4\uffff" + u"\1\144\1\145\1\uffff\1\146\1\1\1\uffff\1\135\1\3\1\106\1\4\26\uffff" + u"\1\23\1\24\1\27\10\uffff\1\45\1\46\1\47\1\50\1\67\1\51\1\52\1\62" + u"\1\143\1\57\1\72\1\53\1\63\1\73\1\60\1\54\1\70\1\150\1\147\1\55" + u"\1\71\1\56\1\76\1\103\1\64\1\65\1\107\1\66\1\112\1\uffff\1\110" + u"\1\uffff\1\113\1\111\1\77\1\105\1\100\1\102\1\104\1\101\5\uffff" + u"\1\136\1\137\1\140\1\141\2\uffff\1\144\1\145\1\151\23\uffff\1\123" + u"\5\uffff\1\127\3\uffff\1\33\7\uffff\1\74\1\114\1\75\1\115\5\uffff" + u"\1\142\24\uffff\1\15\1\uffff\1\130\5\uffff\1\34\15\uffff\1\30\1" + u"\124\7\uffff\1\7\3\uffff\1\12\3\uffff\1\121\1\13\1\16\16\uffff" + u"\1\117\1\uffff\1\131\10\uffff\1\14\5\uffff\1\31\1\17\3\uffff\1" + u"\26\1\uffff\1\36\7\uffff\1\120\1\126\1\133\1\uffff\1\5\1\25\1\6" + u"\1\125\1\21\1\61\1\uffff\1\134\1\11\2\uffff\1\20\10\uffff\1\42" + u"\1\uffff\1\2\3\uffff\1\122\7\uffff\1\116\1\10\1\32\1\132\1\22\1" + u"\35\1\uffff\1\40\3\uffff\1\37\23\uffff\1\43\6\uffff\1\44\12\uffff" + u"\1\41" + ) + + DFA35_special = DFA.unpack( + u"\u018b\uffff" + ) + + + DFA35_transition = [ + DFA.unpack(u"\6\72\2\67\1\72\2\67\22\72\1\67\1\47\1\64\1\71\1\62" + u"\1\44\1\45\1\63\1\33\1\34\1\37\1\41\1\3\1\42\1\40\1\43\1\65\11" + u"\66\1\23\1\1\1\50\1\4\1\51\1\54\1\72\2\62\1\26\1\62\1\32\1\62\1" + u"\31\1\62\1\24\2\62\1\61\2\62\1\25\3\62\1\11\1\62\1\27\1\30\4\62" + u"\1\35\1\70\1\36\1\52\1\55\1\72\1\7\1\60\1\13\1\17\1\5\1\16\1\57" + u"\1\62\1\14\2\62\1\15\5\62\1\10\1\6\1\2\1\20\1\12\1\56\3\62\1\21" + u"\1\53\1\22\1\46\uff80\72"), + DFA.unpack(u""), + DFA.unpack(u"\1\74"), + DFA.unpack(u""), + DFA.unpack(u"\1\77"), + DFA.unpack(u"\1\102\1\uffff\1\101\11\uffff\1\103"), + DFA.unpack(u"\1\107\1\106\12\uffff\1\104\2\uffff\1\105"), + DFA.unpack(u"\1\110"), + DFA.unpack(u"\1\111"), + DFA.unpack(u"\1\112"), + DFA.unpack(u"\1\113"), + DFA.unpack(u"\1\115\6\uffff\1\116\6\uffff\1\114"), + DFA.unpack(u"\1\117\7\uffff\1\120"), + DFA.unpack(u"\1\121"), + DFA.unpack(u"\1\123\2\uffff\1\122"), + DFA.unpack(u"\1\125\11\uffff\1\124"), + DFA.unpack(u"\1\126"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\132"), + DFA.unpack(u"\1\134\4\uffff\1\133"), + DFA.unpack(u"\1\135"), + DFA.unpack(u"\1\136"), + DFA.unpack(u"\1\137"), + DFA.unpack(u"\1\140"), + DFA.unpack(u"\1\141"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\146"), + DFA.unpack(u"\1\150\1\uffff\12\152"), + DFA.unpack(u"\1\153\21\uffff\1\154"), + DFA.unpack(u"\1\160\17\uffff\1\157\1\156"), + DFA.unpack(u"\1\164\4\uffff\1\163\15\uffff\1\162"), + DFA.unpack(u"\1\166"), + DFA.unpack(u"\1\171\26\uffff\1\170"), + DFA.unpack(u""), + DFA.unpack(u"\1\174"), + DFA.unpack(u"\1\177\1\176"), + DFA.unpack(u"\1\u0082\1\u0081"), + DFA.unpack(u"\1\u0084"), + DFA.unpack(u"\1\u0086\76\uffff\1\u0087"), + DFA.unpack(u""), + DFA.unpack(u"\1\u008a\1\uffff\1\u008b"), + DFA.unpack(u"\1\u008c"), + DFA.unpack(u"\1\u008d"), + DFA.unpack(u"\1\u008e"), + DFA.unpack(u"\1\u0090\4\uffff\1\u008f"), + DFA.unpack(u""), + DFA.unpack(u"\47\u008f\1\uffff\uffd7\u008f"), + DFA.unpack(u"\uffff\u0090"), + DFA.unpack(u"\1\152\1\uffff\10\u0093\2\152\12\uffff\3\152\21\uffff" + u"\1\u0091\13\uffff\3\152\21\uffff\1\u0091"), + DFA.unpack(u"\1\152\1\uffff\12\u0094\12\uffff\3\152\35\uffff\3\152"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\uffff\u0097"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\u0098"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\u0099"), + DFA.unpack(u"\1\u009a"), + DFA.unpack(u"\1\u009b"), + DFA.unpack(u"\1\u009d\20\uffff\1\u009c"), + DFA.unpack(u"\1\u009e"), + DFA.unpack(u"\1\u009f\22\uffff\1\u00a0"), + DFA.unpack(u"\1\u00a1"), + DFA.unpack(u"\1\u00a2"), + DFA.unpack(u"\1\u00a3\14\uffff\1\u00a4"), + DFA.unpack(u"\1\u00a5"), + DFA.unpack(u"\1\u00a6\2\uffff\1\u00a7"), + DFA.unpack(u"\1\u00a8"), + DFA.unpack(u"\1\u00a9"), + DFA.unpack(u"\1\u00aa"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u00ac"), + DFA.unpack(u"\1\u00ad"), + DFA.unpack(u"\1\u00ae"), + DFA.unpack(u"\1\u00af"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\24\75\1\u00b0\5\75"), + DFA.unpack(u"\1\u00b2"), + DFA.unpack(u"\1\u00b4\11\uffff\1\u00b3"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u00b6"), + DFA.unpack(u"\1\u00b7"), + DFA.unpack(u"\1\u00b8"), + DFA.unpack(u"\1\u00b9"), + DFA.unpack(u"\1\u00ba"), + DFA.unpack(u"\1\u00bb"), + DFA.unpack(u"\1\u00bc"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\u00bd"), + DFA.unpack(u""), + DFA.unpack(u"\1\u00bf"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\u00c1"), + DFA.unpack(u"\1\u00c2"), + DFA.unpack(u"\1\u00c3"), + DFA.unpack(u"\1\u00c4"), + DFA.unpack(u"\1\u00c5"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\152\1\uffff\10\u0093\2\152\12\uffff\3\152\35\uffff" + u"\3\152"), + DFA.unpack(u"\1\152\1\uffff\12\u0094\12\uffff\3\152\35\uffff\3\152"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\u00c7"), + DFA.unpack(u"\1\u00c8"), + DFA.unpack(u"\1\u00c9"), + DFA.unpack(u"\1\u00ca"), + DFA.unpack(u"\1\u00cb"), + DFA.unpack(u"\1\u00cc"), + DFA.unpack(u"\1\u00cd"), + DFA.unpack(u"\1\u00ce"), + DFA.unpack(u"\1\u00cf"), + DFA.unpack(u"\1\u00d0"), + DFA.unpack(u"\1\u00d1"), + DFA.unpack(u"\1\u00d2"), + DFA.unpack(u"\1\u00d3"), + DFA.unpack(u"\1\u00d4"), + DFA.unpack(u"\1\u00d5"), + DFA.unpack(u"\1\u00d6"), + DFA.unpack(u"\1\u00d8\1\u00d7"), + DFA.unpack(u"\1\u00d9"), + DFA.unpack(u"\1\u00da"), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u00dc"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u00de"), + DFA.unpack(u"\1\u00df"), + DFA.unpack(u""), + DFA.unpack(u"\1\u00e0"), + DFA.unpack(u"\1\u00e1"), + DFA.unpack(u"\1\u00e2"), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u00e4"), + DFA.unpack(u"\1\u00e5"), + DFA.unpack(u"\1\u00e6"), + DFA.unpack(u"\1\u00e7"), + DFA.unpack(u"\1\u00e8"), + DFA.unpack(u"\1\u00ea\35\uffff\1\u00e9"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\u00eb"), + DFA.unpack(u"\1\u00ec"), + DFA.unpack(u"\1\u00ed"), + DFA.unpack(u"\1\u00ee"), + DFA.unpack(u"\1\u00ef"), + DFA.unpack(u""), + DFA.unpack(u"\1\u00f0"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u00f3"), + DFA.unpack(u"\1\u00f4"), + DFA.unpack(u"\1\u00f5"), + DFA.unpack(u"\1\u00f6"), + DFA.unpack(u"\1\u00f7"), + DFA.unpack(u"\1\u00f8"), + DFA.unpack(u"\1\u00f9"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u00fb"), + DFA.unpack(u"\1\u00fc"), + DFA.unpack(u"\1\u00fd"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u00ff"), + DFA.unpack(u"\1\u0100"), + DFA.unpack(u"\1\u0101"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u"\1\u0105"), + DFA.unpack(u"\1\u0106"), + DFA.unpack(u"\1\u0107"), + DFA.unpack(u"\1\u0108"), + DFA.unpack(u"\1\u0109"), + DFA.unpack(u""), + DFA.unpack(u"\1\u010a"), + DFA.unpack(u"\1\u010b"), + DFA.unpack(u"\1\u010c"), + DFA.unpack(u"\1\u010d"), + DFA.unpack(u"\1\u010e"), + DFA.unpack(u"\1\u010f\17\uffff\1\u0110"), + DFA.unpack(u"\1\u0111"), + DFA.unpack(u"\1\u0112"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0114"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0116"), + DFA.unpack(u"\1\u0117"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\u0118"), + DFA.unpack(u"\1\u0119"), + DFA.unpack(u"\1\u011a"), + DFA.unpack(u"\1\u011b"), + DFA.unpack(u"\1\u011c"), + DFA.unpack(u"\1\u011d"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u"\1\u011f"), + DFA.unpack(u"\1\u0120"), + DFA.unpack(u"\1\u0121"), + DFA.unpack(u""), + DFA.unpack(u"\1\u0122"), + DFA.unpack(u"\1\u0123"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0126"), + DFA.unpack(u"\1\u0127"), + DFA.unpack(u"\1\u0128"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u012a"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u012c"), + DFA.unpack(u"\1\u012d"), + DFA.unpack(u"\1\u012e"), + DFA.unpack(u"\1\u012f"), + DFA.unpack(u"\1\u0130"), + DFA.unpack(u"\1\u0131"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\u0132\1" + u"\uffff\32\75"), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0136"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u"\1\u013d"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0140"), + DFA.unpack(u"\1\u0141"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0143"), + DFA.unpack(u"\1\u0144"), + DFA.unpack(u""), + DFA.unpack(u"\1\u0145"), + DFA.unpack(u""), + DFA.unpack(u"\1\u0146"), + DFA.unpack(u"\1\u0147"), + DFA.unpack(u"\1\u0148"), + DFA.unpack(u"\1\u0149"), + DFA.unpack(u"\1\u014a"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u014c"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\u014e"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\u014f"), + DFA.unpack(u"\1\u0150"), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0152"), + DFA.unpack(u"\1\u0153"), + DFA.unpack(u"\1\u0154"), + DFA.unpack(u"\1\u0155"), + DFA.unpack(u"\1\u0156"), + DFA.unpack(u"\1\u0157"), + DFA.unpack(u"\1\u0158"), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u015f"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0161"), + DFA.unpack(u"\1\u0162"), + DFA.unpack(u"\1\u0163"), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u""), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u""), + DFA.unpack(u"\1\u0165"), + DFA.unpack(u"\1\u0166"), + DFA.unpack(u"\1\u0167"), + DFA.unpack(u""), + DFA.unpack(u"\1\u0168"), + DFA.unpack(u"\1\u0169"), + DFA.unpack(u"\1\u016a"), + DFA.unpack(u"\1\u016b"), + DFA.unpack(u"\1\u016c"), + DFA.unpack(u"\1\u016d"), + DFA.unpack(u"\1\u016e"), + DFA.unpack(u"\1\u016f"), + DFA.unpack(u"\1\u0170"), + DFA.unpack(u"\1\u0171"), + DFA.unpack(u"\1\u0172"), + DFA.unpack(u"\1\u0173"), + DFA.unpack(u"\1\u0174"), + DFA.unpack(u"\1\u0175"), + DFA.unpack(u"\1\u0176"), + DFA.unpack(u"\1\u0177"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0179"), + DFA.unpack(u"\1\u017a"), + DFA.unpack(u""), + DFA.unpack(u"\1\u017b"), + DFA.unpack(u"\1\u017c"), + DFA.unpack(u"\1\u017d"), + DFA.unpack(u"\1\u017e"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"\1\u0180"), + DFA.unpack(u""), + DFA.unpack(u"\1\u0181"), + DFA.unpack(u"\1\u0182"), + DFA.unpack(u"\1\u0183"), + DFA.unpack(u"\1\u0184"), + DFA.unpack(u"\1\u0185"), + DFA.unpack(u"\1\u0186"), + DFA.unpack(u"\1\u0187"), + DFA.unpack(u"\1\u0188"), + DFA.unpack(u"\1\u0189"), + DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" + u"\32\75"), + DFA.unpack(u"") + ] + + # class definition for DFA #35 + + DFA35 = DFA + + diff --git a/BaseTools/Source/Python/Ecc/CParser.py b/BaseTools/Source/Python/Ecc/CParser.py new file mode 100644 index 0000000000..194a6aa451 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/CParser.py @@ -0,0 +1,18825 @@ +# $ANTLR 3.0.1 C.g 2009-02-16 16:02:50 + +from antlr3 import * +from antlr3.compat import set, frozenset + +import CodeFragment +import FileProfile + + + +# for convenience in actions +HIDDEN = BaseRecognizer.HIDDEN + +# token types +CHARACTER_LITERAL=8 +LETTER=11 +Exponent=15 +DECIMAL_LITERAL=7 +IntegerTypeSuffix=14 +UnicodeVocabulary=21 +HexDigit=13 +BS=20 +WS=19 +LINE_COMMAND=24 +COMMENT=22 +LINE_COMMENT=23 +OCTAL_LITERAL=6 +HEX_LITERAL=5 +FLOATING_POINT_LITERAL=10 +UnicodeEscape=18 +EscapeSequence=12 +EOF=-1 +STRING_LITERAL=9 +OctalEscape=17 +IDENTIFIER=4 +FloatTypeSuffix=16 + +# token names +tokenNames = [ + "", "", "", "", + "IDENTIFIER", "HEX_LITERAL", "OCTAL_LITERAL", "DECIMAL_LITERAL", "CHARACTER_LITERAL", + "STRING_LITERAL", "FLOATING_POINT_LITERAL", "LETTER", "EscapeSequence", + "HexDigit", "IntegerTypeSuffix", "Exponent", "FloatTypeSuffix", "OctalEscape", + "UnicodeEscape", "WS", "BS", "UnicodeVocabulary", "COMMENT", "LINE_COMMENT", + "LINE_COMMAND", "';'", "'typedef'", "','", "'='", "'extern'", "'static'", + "'auto'", "'register'", "'STATIC'", "'void'", "'char'", "'short'", "'int'", + "'long'", "'float'", "'double'", "'signed'", "'unsigned'", "'{'", "'}'", + "'struct'", "'union'", "':'", "'enum'", "'const'", "'volatile'", "'IN'", + "'OUT'", "'OPTIONAL'", "'CONST'", "'UNALIGNED'", "'VOLATILE'", "'GLOBAL_REMOVE_IF_UNREFERENCED'", + "'EFIAPI'", "'EFI_BOOTSERVICE'", "'EFI_RUNTIMESERVICE'", "'('", "')'", + "'['", "']'", "'*'", "'...'", "'+'", "'-'", "'/'", "'%'", "'++'", "'--'", + "'sizeof'", "'.'", "'->'", "'&'", "'~'", "'!'", "'*='", "'/='", "'%='", + "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", "'|='", "'?'", "'||'", + "'&&'", "'|'", "'^'", "'=='", "'!='", "'<'", "'>'", "'<='", "'>='", + "'<<'", "'>>'", "'__asm__'", "'_asm'", "'__asm'", "'case'", "'default'", + "'if'", "'else'", "'switch'", "'while'", "'do'", "'for'", "'goto'", + "'continue'", "'break'", "'return'" +] + + +class function_definition_scope(object): + def __init__(self): + self.ModifierText = None + self.DeclText = None + self.LBLine = None + self.LBOffset = None + self.DeclLine = None + self.DeclOffset = None +class postfix_expression_scope(object): + def __init__(self): + self.FuncCallText = None + + +class CParser(Parser): + grammarFileName = "C.g" + tokenNames = tokenNames + + def __init__(self, input): + Parser.__init__(self, input) + self.ruleMemo = {} + + self.function_definition_stack = [] + self.postfix_expression_stack = [] + + + + + + + + + def printTokenInfo(self, line, offset, tokenText): + print str(line)+ ',' + str(offset) + ':' + str(tokenText) + + def StorePredicateExpression(self, StartLine, StartOffset, EndLine, EndOffset, Text): + PredExp = CodeFragment.PredicateExpression(Text, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.PredicateExpressionList.append(PredExp) + + def StoreEnumerationDefinition(self, StartLine, StartOffset, EndLine, EndOffset, Text): + EnumDef = CodeFragment.EnumerationDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.EnumerationDefinitionList.append(EnumDef) + + def StoreStructUnionDefinition(self, StartLine, StartOffset, EndLine, EndOffset, Text): + SUDef = CodeFragment.StructUnionDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.StructUnionDefinitionList.append(SUDef) + + def StoreTypedefDefinition(self, StartLine, StartOffset, EndLine, EndOffset, FromText, ToText): + Tdef = CodeFragment.TypedefDefinition(FromText, ToText, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.TypedefDefinitionList.append(Tdef) + + def StoreFunctionDefinition(self, StartLine, StartOffset, EndLine, EndOffset, ModifierText, DeclText, LeftBraceLine, LeftBraceOffset, DeclLine, DeclOffset): + FuncDef = CodeFragment.FunctionDefinition(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset), (LeftBraceLine, LeftBraceOffset), (DeclLine, DeclOffset)) + FileProfile.FunctionDefinitionList.append(FuncDef) + + def StoreVariableDeclaration(self, StartLine, StartOffset, EndLine, EndOffset, ModifierText, DeclText): + VarDecl = CodeFragment.VariableDeclaration(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.VariableDeclarationList.append(VarDecl) + + def StoreFunctionCalling(self, StartLine, StartOffset, EndLine, EndOffset, FuncName, ParamList): + FuncCall = CodeFragment.FunctionCalling(FuncName, ParamList, (StartLine, StartOffset), (EndLine, EndOffset)) + FileProfile.FunctionCallingList.append(FuncCall) + + + + + # $ANTLR start translation_unit + # C.g:50:1: translation_unit : ( external_declaration )* ; + def translation_unit(self, ): + + translation_unit_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 1): + return + + # C.g:51:2: ( ( external_declaration )* ) + # C.g:51:4: ( external_declaration )* + # C.g:51:4: ( external_declaration )* + while True: #loop1 + alt1 = 2 + LA1_0 = self.input.LA(1) + + if (LA1_0 == IDENTIFIER or LA1_0 == 26 or (29 <= LA1_0 <= 42) or (45 <= LA1_0 <= 46) or (48 <= LA1_0 <= 61) or LA1_0 == 65) : + alt1 = 1 + + + if alt1 == 1: + # C.g:0:0: external_declaration + self.following.append(self.FOLLOW_external_declaration_in_translation_unit64) + self.external_declaration() + self.following.pop() + if self.failed: + return + + + else: + break #loop1 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 1, translation_unit_StartIndex) + + pass + + return + + # $ANTLR end translation_unit + + + # $ANTLR start external_declaration + # C.g:62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? ); + def external_declaration(self, ): + + external_declaration_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 2): + return + + # C.g:67:2: ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? ) + alt3 = 3 + LA3_0 = self.input.LA(1) + + if ((29 <= LA3_0 <= 33)) : + LA3_1 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 1, self.input) + + raise nvae + + elif (LA3_0 == 34) : + LA3_2 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 2, self.input) + + raise nvae + + elif (LA3_0 == 35) : + LA3_3 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 3, self.input) + + raise nvae + + elif (LA3_0 == 36) : + LA3_4 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 4, self.input) + + raise nvae + + elif (LA3_0 == 37) : + LA3_5 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 5, self.input) + + raise nvae + + elif (LA3_0 == 38) : + LA3_6 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 6, self.input) + + raise nvae + + elif (LA3_0 == 39) : + LA3_7 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 7, self.input) + + raise nvae + + elif (LA3_0 == 40) : + LA3_8 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 8, self.input) + + raise nvae + + elif (LA3_0 == 41) : + LA3_9 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 9, self.input) + + raise nvae + + elif (LA3_0 == 42) : + LA3_10 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 10, self.input) + + raise nvae + + elif ((45 <= LA3_0 <= 46)) : + LA3_11 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 11, self.input) + + raise nvae + + elif (LA3_0 == 48) : + LA3_12 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 12, self.input) + + raise nvae + + elif (LA3_0 == IDENTIFIER) : + LA3_13 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + elif (True) : + alt3 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 13, self.input) + + raise nvae + + elif (LA3_0 == 58) : + LA3_14 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 14, self.input) + + raise nvae + + elif (LA3_0 == 65) and (self.synpred4()): + alt3 = 1 + elif (LA3_0 == 59) : + LA3_16 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 16, self.input) + + raise nvae + + elif (LA3_0 == 60) : + LA3_17 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 17, self.input) + + raise nvae + + elif ((49 <= LA3_0 <= 57)) : + LA3_18 = self.input.LA(2) + + if (self.synpred4()) : + alt3 = 1 + elif (self.synpred5()) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 18, self.input) + + raise nvae + + elif (LA3_0 == 61) and (self.synpred4()): + alt3 = 1 + elif (LA3_0 == 26) : + alt3 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 0, self.input) + + raise nvae + + if alt3 == 1: + # C.g:67:4: ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition + self.following.append(self.FOLLOW_function_definition_in_external_declaration103) + self.function_definition() + self.following.pop() + if self.failed: + return + + + elif alt3 == 2: + # C.g:68:4: declaration + self.following.append(self.FOLLOW_declaration_in_external_declaration108) + self.declaration() + self.following.pop() + if self.failed: + return + + + elif alt3 == 3: + # C.g:69:4: macro_statement ( ';' )? + self.following.append(self.FOLLOW_macro_statement_in_external_declaration113) + self.macro_statement() + self.following.pop() + if self.failed: + return + # C.g:69:20: ( ';' )? + alt2 = 2 + LA2_0 = self.input.LA(1) + + if (LA2_0 == 25) : + alt2 = 1 + if alt2 == 1: + # C.g:69:21: ';' + self.match(self.input, 25, self.FOLLOW_25_in_external_declaration116) + if self.failed: + return + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 2, external_declaration_StartIndex) + + pass + + return + + # $ANTLR end external_declaration + + class function_definition_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start function_definition + # C.g:74:1: function_definition : (d= declaration_specifiers )? declarator ( ( declaration )+ a= compound_statement | b= compound_statement ) ; + def function_definition(self, ): + self.function_definition_stack.append(function_definition_scope()) + retval = self.function_definition_return() + retval.start = self.input.LT(1) + function_definition_StartIndex = self.input.index() + d = None + + a = None + + b = None + + declarator1 = None + + + + self.function_definition_stack[-1].ModifierText = '' + self.function_definition_stack[-1].DeclText = '' + self.function_definition_stack[-1].LBLine = 0 + self.function_definition_stack[-1].LBOffset = 0 + self.function_definition_stack[-1].DeclLine = 0 + self.function_definition_stack[-1].DeclOffset = 0 + + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 3): + return retval + + # C.g:94:2: ( (d= declaration_specifiers )? declarator ( ( declaration )+ a= compound_statement | b= compound_statement ) ) + # C.g:94:4: (d= declaration_specifiers )? declarator ( ( declaration )+ a= compound_statement | b= compound_statement ) + # C.g:94:5: (d= declaration_specifiers )? + alt4 = 2 + LA4 = self.input.LA(1) + if LA4 == 29 or LA4 == 30 or LA4 == 31 or LA4 == 32 or LA4 == 33 or LA4 == 34 or LA4 == 35 or LA4 == 36 or LA4 == 37 or LA4 == 38 or LA4 == 39 or LA4 == 40 or LA4 == 41 or LA4 == 42 or LA4 == 45 or LA4 == 46 or LA4 == 48 or LA4 == 49 or LA4 == 50 or LA4 == 51 or LA4 == 52 or LA4 == 53 or LA4 == 54 or LA4 == 55 or LA4 == 56 or LA4 == 57: + alt4 = 1 + elif LA4 == IDENTIFIER: + LA4 = self.input.LA(2) + if LA4 == 65: + alt4 = 1 + elif LA4 == 58: + LA4_21 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 59: + LA4_22 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 60: + LA4_23 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == IDENTIFIER: + LA4_24 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 61: + LA4_25 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 29 or LA4 == 30 or LA4 == 31 or LA4 == 32 or LA4 == 33: + LA4_26 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 34: + LA4_27 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 35: + LA4_28 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 36: + LA4_29 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 37: + LA4_30 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 38: + LA4_31 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 39: + LA4_32 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 40: + LA4_33 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 41: + LA4_34 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 42: + LA4_35 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 45 or LA4 == 46: + LA4_36 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 48: + LA4_37 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 49 or LA4 == 50 or LA4 == 51 or LA4 == 52 or LA4 == 53 or LA4 == 54 or LA4 == 55 or LA4 == 56 or LA4 == 57: + LA4_38 = self.input.LA(3) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 58: + LA4_14 = self.input.LA(2) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 59: + LA4_16 = self.input.LA(2) + + if (self.synpred7()) : + alt4 = 1 + elif LA4 == 60: + LA4_17 = self.input.LA(2) + + if (self.synpred7()) : + alt4 = 1 + if alt4 == 1: + # C.g:0:0: d= declaration_specifiers + self.following.append(self.FOLLOW_declaration_specifiers_in_function_definition147) + d = self.declaration_specifiers() + self.following.pop() + if self.failed: + return retval + + + + self.following.append(self.FOLLOW_declarator_in_function_definition150) + declarator1 = self.declarator() + self.following.pop() + if self.failed: + return retval + # C.g:95:3: ( ( declaration )+ a= compound_statement | b= compound_statement ) + alt6 = 2 + LA6_0 = self.input.LA(1) + + if (LA6_0 == IDENTIFIER or LA6_0 == 26 or (29 <= LA6_0 <= 42) or (45 <= LA6_0 <= 46) or (48 <= LA6_0 <= 60)) : + alt6 = 1 + elif (LA6_0 == 43) : + alt6 = 2 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("95:3: ( ( declaration )+ a= compound_statement | b= compound_statement )", 6, 0, self.input) + + raise nvae + + if alt6 == 1: + # C.g:95:5: ( declaration )+ a= compound_statement + # C.g:95:5: ( declaration )+ + cnt5 = 0 + while True: #loop5 + alt5 = 2 + LA5_0 = self.input.LA(1) + + if (LA5_0 == IDENTIFIER or LA5_0 == 26 or (29 <= LA5_0 <= 42) or (45 <= LA5_0 <= 46) or (48 <= LA5_0 <= 60)) : + alt5 = 1 + + + if alt5 == 1: + # C.g:0:0: declaration + self.following.append(self.FOLLOW_declaration_in_function_definition156) + self.declaration() + self.following.pop() + if self.failed: + return retval + + + else: + if cnt5 >= 1: + break #loop5 + + if self.backtracking > 0: + self.failed = True + return retval + + eee = EarlyExitException(5, self.input) + raise eee + + cnt5 += 1 + + + self.following.append(self.FOLLOW_compound_statement_in_function_definition161) + a = self.compound_statement() + self.following.pop() + if self.failed: + return retval + + + elif alt6 == 2: + # C.g:96:5: b= compound_statement + self.following.append(self.FOLLOW_compound_statement_in_function_definition170) + b = self.compound_statement() + self.following.pop() + if self.failed: + return retval + + + + if self.backtracking == 0: + + if d != None: + self.function_definition_stack[-1].ModifierText = self.input.toString(d.start,d.stop) + else: + self.function_definition_stack[-1].ModifierText = '' + self.function_definition_stack[-1].DeclText = self.input.toString(declarator1.start,declarator1.stop) + self.function_definition_stack[-1].DeclLine = declarator1.start.line + self.function_definition_stack[-1].DeclOffset = declarator1.start.charPositionInLine + if a != None: + self.function_definition_stack[-1].LBLine = a.start.line + self.function_definition_stack[-1].LBOffset = a.start.charPositionInLine + else: + self.function_definition_stack[-1].LBLine = b.start.line + self.function_definition_stack[-1].LBOffset = b.start.charPositionInLine + + + + + + retval.stop = self.input.LT(-1) + + if self.backtracking == 0: + + self.StoreFunctionDefinition(retval.start.line, retval.start.charPositionInLine, retval.stop.line, retval.stop.charPositionInLine, self.function_definition_stack[-1].ModifierText, self.function_definition_stack[-1].DeclText, self.function_definition_stack[-1].LBLine, self.function_definition_stack[-1].LBOffset, self.function_definition_stack[-1].DeclLine, self.function_definition_stack[-1].DeclOffset) + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 3, function_definition_StartIndex) + + self.function_definition_stack.pop() + pass + + return retval + + # $ANTLR end function_definition + + + # $ANTLR start declaration + # C.g:114:1: declaration : (a= 'typedef' (b= declaration_specifiers )? c= init_declarator_list d= ';' | s= declaration_specifiers (t= init_declarator_list )? e= ';' ); + def declaration(self, ): + + declaration_StartIndex = self.input.index() + a = None + d = None + e = None + b = None + + c = None + + s = None + + t = None + + + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 4): + return + + # C.g:115:2: (a= 'typedef' (b= declaration_specifiers )? c= init_declarator_list d= ';' | s= declaration_specifiers (t= init_declarator_list )? e= ';' ) + alt9 = 2 + LA9_0 = self.input.LA(1) + + if (LA9_0 == 26) : + alt9 = 1 + elif (LA9_0 == IDENTIFIER or (29 <= LA9_0 <= 42) or (45 <= LA9_0 <= 46) or (48 <= LA9_0 <= 60)) : + alt9 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("114:1: declaration : (a= 'typedef' (b= declaration_specifiers )? c= init_declarator_list d= ';' | s= declaration_specifiers (t= init_declarator_list )? e= ';' );", 9, 0, self.input) + + raise nvae + + if alt9 == 1: + # C.g:115:4: a= 'typedef' (b= declaration_specifiers )? c= init_declarator_list d= ';' + a = self.input.LT(1) + self.match(self.input, 26, self.FOLLOW_26_in_declaration193) + if self.failed: + return + # C.g:115:17: (b= declaration_specifiers )? + alt7 = 2 + LA7 = self.input.LA(1) + if LA7 == 29 or LA7 == 30 or LA7 == 31 or LA7 == 32 or LA7 == 33 or LA7 == 34 or LA7 == 35 or LA7 == 36 or LA7 == 37 or LA7 == 38 or LA7 == 39 or LA7 == 40 or LA7 == 41 or LA7 == 42 or LA7 == 45 or LA7 == 46 or LA7 == 48 or LA7 == 49 or LA7 == 50 or LA7 == 51 or LA7 == 52 or LA7 == 53 or LA7 == 54 or LA7 == 55 or LA7 == 56 or LA7 == 57: + alt7 = 1 + elif LA7 == IDENTIFIER: + LA7_13 = self.input.LA(2) + + if (LA7_13 == IDENTIFIER or (29 <= LA7_13 <= 42) or (45 <= LA7_13 <= 46) or (48 <= LA7_13 <= 60) or LA7_13 == 65) : + alt7 = 1 + elif (LA7_13 == 61) : + LA7_25 = self.input.LA(3) + + if (self.synpred10()) : + alt7 = 1 + elif LA7 == 58: + LA7_14 = self.input.LA(2) + + if (self.synpred10()) : + alt7 = 1 + elif LA7 == 59: + LA7_16 = self.input.LA(2) + + if (self.synpred10()) : + alt7 = 1 + elif LA7 == 60: + LA7_17 = self.input.LA(2) + + if (self.synpred10()) : + alt7 = 1 + if alt7 == 1: + # C.g:0:0: b= declaration_specifiers + self.following.append(self.FOLLOW_declaration_specifiers_in_declaration197) + b = self.declaration_specifiers() + self.following.pop() + if self.failed: + return + + + + self.following.append(self.FOLLOW_init_declarator_list_in_declaration206) + c = self.init_declarator_list() + self.following.pop() + if self.failed: + return + d = self.input.LT(1) + self.match(self.input, 25, self.FOLLOW_25_in_declaration210) + if self.failed: + return + if self.backtracking == 0: + + if b != None: + self.StoreTypedefDefinition(a.line, a.charPositionInLine, d.line, d.charPositionInLine, self.input.toString(b.start,b.stop), self.input.toString(c.start,c.stop)) + else: + self.StoreTypedefDefinition(a.line, a.charPositionInLine, d.line, d.charPositionInLine, '', self.input.toString(c.start,c.stop)) + + + + + elif alt9 == 2: + # C.g:123:4: s= declaration_specifiers (t= init_declarator_list )? e= ';' + self.following.append(self.FOLLOW_declaration_specifiers_in_declaration224) + s = self.declaration_specifiers() + self.following.pop() + if self.failed: + return + # C.g:123:30: (t= init_declarator_list )? + alt8 = 2 + LA8_0 = self.input.LA(1) + + if (LA8_0 == IDENTIFIER or (58 <= LA8_0 <= 61) or LA8_0 == 65) : + alt8 = 1 + if alt8 == 1: + # C.g:0:0: t= init_declarator_list + self.following.append(self.FOLLOW_init_declarator_list_in_declaration228) + t = self.init_declarator_list() + self.following.pop() + if self.failed: + return + + + + e = self.input.LT(1) + self.match(self.input, 25, self.FOLLOW_25_in_declaration233) + if self.failed: + return + if self.backtracking == 0: + + if t != None: + self.StoreVariableDeclaration(s.start.line, s.start.charPositionInLine, t.start.line, t.start.charPositionInLine, self.input.toString(s.start,s.stop), self.input.toString(t.start,t.stop)) + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 4, declaration_StartIndex) + + pass + + return + + # $ANTLR end declaration + + class declaration_specifiers_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start declaration_specifiers + # C.g:130:1: declaration_specifiers : ( storage_class_specifier | type_specifier | type_qualifier )+ ; + def declaration_specifiers(self, ): + + retval = self.declaration_specifiers_return() + retval.start = self.input.LT(1) + declaration_specifiers_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 5): + return retval + + # C.g:131:2: ( ( storage_class_specifier | type_specifier | type_qualifier )+ ) + # C.g:131:6: ( storage_class_specifier | type_specifier | type_qualifier )+ + # C.g:131:6: ( storage_class_specifier | type_specifier | type_qualifier )+ + cnt10 = 0 + while True: #loop10 + alt10 = 4 + LA10 = self.input.LA(1) + if LA10 == 58: + LA10_2 = self.input.LA(2) + + if (self.synpred15()) : + alt10 = 3 + + + elif LA10 == 59: + LA10_3 = self.input.LA(2) + + if (self.synpred15()) : + alt10 = 3 + + + elif LA10 == 60: + LA10_4 = self.input.LA(2) + + if (self.synpred15()) : + alt10 = 3 + + + elif LA10 == IDENTIFIER: + LA10_5 = self.input.LA(2) + + if (self.synpred14()) : + alt10 = 2 + + + elif LA10 == 53: + LA10_9 = self.input.LA(2) + + if (self.synpred15()) : + alt10 = 3 + + + elif LA10 == 29 or LA10 == 30 or LA10 == 31 or LA10 == 32 or LA10 == 33: + alt10 = 1 + elif LA10 == 34 or LA10 == 35 or LA10 == 36 or LA10 == 37 or LA10 == 38 or LA10 == 39 or LA10 == 40 or LA10 == 41 or LA10 == 42 or LA10 == 45 or LA10 == 46 or LA10 == 48: + alt10 = 2 + elif LA10 == 49 or LA10 == 50 or LA10 == 51 or LA10 == 52 or LA10 == 54 or LA10 == 55 or LA10 == 56 or LA10 == 57: + alt10 = 3 + + if alt10 == 1: + # C.g:131:10: storage_class_specifier + self.following.append(self.FOLLOW_storage_class_specifier_in_declaration_specifiers254) + self.storage_class_specifier() + self.following.pop() + if self.failed: + return retval + + + elif alt10 == 2: + # C.g:132:7: type_specifier + self.following.append(self.FOLLOW_type_specifier_in_declaration_specifiers262) + self.type_specifier() + self.following.pop() + if self.failed: + return retval + + + elif alt10 == 3: + # C.g:133:13: type_qualifier + self.following.append(self.FOLLOW_type_qualifier_in_declaration_specifiers276) + self.type_qualifier() + self.following.pop() + if self.failed: + return retval + + + else: + if cnt10 >= 1: + break #loop10 + + if self.backtracking > 0: + self.failed = True + return retval + + eee = EarlyExitException(10, self.input) + raise eee + + cnt10 += 1 + + + + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 5, declaration_specifiers_StartIndex) + + pass + + return retval + + # $ANTLR end declaration_specifiers + + class init_declarator_list_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start init_declarator_list + # C.g:137:1: init_declarator_list : init_declarator ( ',' init_declarator )* ; + def init_declarator_list(self, ): + + retval = self.init_declarator_list_return() + retval.start = self.input.LT(1) + init_declarator_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 6): + return retval + + # C.g:138:2: ( init_declarator ( ',' init_declarator )* ) + # C.g:138:4: init_declarator ( ',' init_declarator )* + self.following.append(self.FOLLOW_init_declarator_in_init_declarator_list298) + self.init_declarator() + self.following.pop() + if self.failed: + return retval + # C.g:138:20: ( ',' init_declarator )* + while True: #loop11 + alt11 = 2 + LA11_0 = self.input.LA(1) + + if (LA11_0 == 27) : + alt11 = 1 + + + if alt11 == 1: + # C.g:138:21: ',' init_declarator + self.match(self.input, 27, self.FOLLOW_27_in_init_declarator_list301) + if self.failed: + return retval + self.following.append(self.FOLLOW_init_declarator_in_init_declarator_list303) + self.init_declarator() + self.following.pop() + if self.failed: + return retval + + + else: + break #loop11 + + + + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 6, init_declarator_list_StartIndex) + + pass + + return retval + + # $ANTLR end init_declarator_list + + + # $ANTLR start init_declarator + # C.g:141:1: init_declarator : declarator ( '=' initializer )? ; + def init_declarator(self, ): + + init_declarator_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 7): + return + + # C.g:142:2: ( declarator ( '=' initializer )? ) + # C.g:142:4: declarator ( '=' initializer )? + self.following.append(self.FOLLOW_declarator_in_init_declarator316) + self.declarator() + self.following.pop() + if self.failed: + return + # C.g:142:15: ( '=' initializer )? + alt12 = 2 + LA12_0 = self.input.LA(1) + + if (LA12_0 == 28) : + alt12 = 1 + if alt12 == 1: + # C.g:142:16: '=' initializer + self.match(self.input, 28, self.FOLLOW_28_in_init_declarator319) + if self.failed: + return + self.following.append(self.FOLLOW_initializer_in_init_declarator321) + self.initializer() + self.following.pop() + if self.failed: + return + + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 7, init_declarator_StartIndex) + + pass + + return + + # $ANTLR end init_declarator + + + # $ANTLR start storage_class_specifier + # C.g:145:1: storage_class_specifier : ( 'extern' | 'static' | 'auto' | 'register' | 'STATIC' ); + def storage_class_specifier(self, ): + + storage_class_specifier_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 8): + return + + # C.g:146:2: ( 'extern' | 'static' | 'auto' | 'register' | 'STATIC' ) + # C.g: + if (29 <= self.input.LA(1) <= 33): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_storage_class_specifier0 + ) + raise mse + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 8, storage_class_specifier_StartIndex) + + pass + + return + + # $ANTLR end storage_class_specifier + + + # $ANTLR start type_specifier + # C.g:153:1: type_specifier : ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER ( type_qualifier )* declarator )=> type_id ); + def type_specifier(self, ): + + type_specifier_StartIndex = self.input.index() + s = None + + e = None + + + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 9): + return + + # C.g:154:2: ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER ( type_qualifier )* declarator )=> type_id ) + alt13 = 12 + LA13_0 = self.input.LA(1) + + if (LA13_0 == 34) : + alt13 = 1 + elif (LA13_0 == 35) : + alt13 = 2 + elif (LA13_0 == 36) : + alt13 = 3 + elif (LA13_0 == 37) : + alt13 = 4 + elif (LA13_0 == 38) : + alt13 = 5 + elif (LA13_0 == 39) : + alt13 = 6 + elif (LA13_0 == 40) : + alt13 = 7 + elif (LA13_0 == 41) : + alt13 = 8 + elif (LA13_0 == 42) : + alt13 = 9 + elif ((45 <= LA13_0 <= 46)) : + alt13 = 10 + elif (LA13_0 == 48) : + alt13 = 11 + elif (LA13_0 == IDENTIFIER) and (self.synpred34()): + alt13 = 12 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("153:1: type_specifier : ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER ( type_qualifier )* declarator )=> type_id );", 13, 0, self.input) + + raise nvae + + if alt13 == 1: + # C.g:154:4: 'void' + self.match(self.input, 34, self.FOLLOW_34_in_type_specifier366) + if self.failed: + return + + + elif alt13 == 2: + # C.g:155:4: 'char' + self.match(self.input, 35, self.FOLLOW_35_in_type_specifier371) + if self.failed: + return + + + elif alt13 == 3: + # C.g:156:4: 'short' + self.match(self.input, 36, self.FOLLOW_36_in_type_specifier376) + if self.failed: + return + + + elif alt13 == 4: + # C.g:157:4: 'int' + self.match(self.input, 37, self.FOLLOW_37_in_type_specifier381) + if self.failed: + return + + + elif alt13 == 5: + # C.g:158:4: 'long' + self.match(self.input, 38, self.FOLLOW_38_in_type_specifier386) + if self.failed: + return + + + elif alt13 == 6: + # C.g:159:4: 'float' + self.match(self.input, 39, self.FOLLOW_39_in_type_specifier391) + if self.failed: + return + + + elif alt13 == 7: + # C.g:160:4: 'double' + self.match(self.input, 40, self.FOLLOW_40_in_type_specifier396) + if self.failed: + return + + + elif alt13 == 8: + # C.g:161:4: 'signed' + self.match(self.input, 41, self.FOLLOW_41_in_type_specifier401) + if self.failed: + return + + + elif alt13 == 9: + # C.g:162:4: 'unsigned' + self.match(self.input, 42, self.FOLLOW_42_in_type_specifier406) + if self.failed: + return + + + elif alt13 == 10: + # C.g:163:4: s= struct_or_union_specifier + self.following.append(self.FOLLOW_struct_or_union_specifier_in_type_specifier413) + s = self.struct_or_union_specifier() + self.following.pop() + if self.failed: + return + if self.backtracking == 0: + + if s.stop != None: + self.StoreStructUnionDefinition(s.start.line, s.start.charPositionInLine, s.stop.line, s.stop.charPositionInLine, self.input.toString(s.start,s.stop)) + + + + + elif alt13 == 11: + # C.g:168:4: e= enum_specifier + self.following.append(self.FOLLOW_enum_specifier_in_type_specifier423) + e = self.enum_specifier() + self.following.pop() + if self.failed: + return + if self.backtracking == 0: + + if e.stop != None: + self.StoreEnumerationDefinition(e.start.line, e.start.charPositionInLine, e.stop.line, e.stop.charPositionInLine, self.input.toString(e.start,e.stop)) + + + + + elif alt13 == 12: + # C.g:173:4: ( IDENTIFIER ( type_qualifier )* declarator )=> type_id + self.following.append(self.FOLLOW_type_id_in_type_specifier441) + self.type_id() + self.following.pop() + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 9, type_specifier_StartIndex) + + pass + + return + + # $ANTLR end type_specifier + + + # $ANTLR start type_id + # C.g:176:1: type_id : IDENTIFIER ; + def type_id(self, ): + + type_id_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 10): + return + + # C.g:177:5: ( IDENTIFIER ) + # C.g:177:9: IDENTIFIER + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_type_id457) + if self.failed: + return + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 10, type_id_StartIndex) + + pass + + return + + # $ANTLR end type_id + + class struct_or_union_specifier_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start struct_or_union_specifier + # C.g:181:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER ); + def struct_or_union_specifier(self, ): + + retval = self.struct_or_union_specifier_return() + retval.start = self.input.LT(1) + struct_or_union_specifier_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 11): + return retval + + # C.g:183:2: ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER ) + alt15 = 2 + LA15_0 = self.input.LA(1) + + if ((45 <= LA15_0 <= 46)) : + LA15_1 = self.input.LA(2) + + if (LA15_1 == IDENTIFIER) : + LA15_2 = self.input.LA(3) + + if (LA15_2 == 43) : + alt15 = 1 + elif (LA15_2 == EOF or LA15_2 == IDENTIFIER or LA15_2 == 25 or LA15_2 == 27 or (29 <= LA15_2 <= 42) or (45 <= LA15_2 <= 63) or LA15_2 == 65) : + alt15 = 2 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("181:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 15, 2, self.input) + + raise nvae + + elif (LA15_1 == 43) : + alt15 = 1 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("181:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 15, 1, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("181:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 15, 0, self.input) + + raise nvae + + if alt15 == 1: + # C.g:183:4: struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' + self.following.append(self.FOLLOW_struct_or_union_in_struct_or_union_specifier484) + self.struct_or_union() + self.following.pop() + if self.failed: + return retval + # C.g:183:20: ( IDENTIFIER )? + alt14 = 2 + LA14_0 = self.input.LA(1) + + if (LA14_0 == IDENTIFIER) : + alt14 = 1 + if alt14 == 1: + # C.g:0:0: IDENTIFIER + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_struct_or_union_specifier486) + if self.failed: + return retval + + + + self.match(self.input, 43, self.FOLLOW_43_in_struct_or_union_specifier489) + if self.failed: + return retval + self.following.append(self.FOLLOW_struct_declaration_list_in_struct_or_union_specifier491) + self.struct_declaration_list() + self.following.pop() + if self.failed: + return retval + self.match(self.input, 44, self.FOLLOW_44_in_struct_or_union_specifier493) + if self.failed: + return retval + + + elif alt15 == 2: + # C.g:184:4: struct_or_union IDENTIFIER + self.following.append(self.FOLLOW_struct_or_union_in_struct_or_union_specifier498) + self.struct_or_union() + self.following.pop() + if self.failed: + return retval + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_struct_or_union_specifier500) + if self.failed: + return retval + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 11, struct_or_union_specifier_StartIndex) + + pass + + return retval + + # $ANTLR end struct_or_union_specifier + + + # $ANTLR start struct_or_union + # C.g:187:1: struct_or_union : ( 'struct' | 'union' ); + def struct_or_union(self, ): + + struct_or_union_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 12): + return + + # C.g:188:2: ( 'struct' | 'union' ) + # C.g: + if (45 <= self.input.LA(1) <= 46): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_struct_or_union0 + ) + raise mse + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 12, struct_or_union_StartIndex) + + pass + + return + + # $ANTLR end struct_or_union + + + # $ANTLR start struct_declaration_list + # C.g:192:1: struct_declaration_list : ( struct_declaration )+ ; + def struct_declaration_list(self, ): + + struct_declaration_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 13): + return + + # C.g:193:2: ( ( struct_declaration )+ ) + # C.g:193:4: ( struct_declaration )+ + # C.g:193:4: ( struct_declaration )+ + cnt16 = 0 + while True: #loop16 + alt16 = 2 + LA16_0 = self.input.LA(1) + + if (LA16_0 == IDENTIFIER or (34 <= LA16_0 <= 42) or (45 <= LA16_0 <= 46) or (48 <= LA16_0 <= 60)) : + alt16 = 1 + + + if alt16 == 1: + # C.g:0:0: struct_declaration + self.following.append(self.FOLLOW_struct_declaration_in_struct_declaration_list527) + self.struct_declaration() + self.following.pop() + if self.failed: + return + + + else: + if cnt16 >= 1: + break #loop16 + + if self.backtracking > 0: + self.failed = True + return + + eee = EarlyExitException(16, self.input) + raise eee + + cnt16 += 1 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 13, struct_declaration_list_StartIndex) + + pass + + return + + # $ANTLR end struct_declaration_list + + + # $ANTLR start struct_declaration + # C.g:196:1: struct_declaration : specifier_qualifier_list struct_declarator_list ';' ; + def struct_declaration(self, ): + + struct_declaration_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 14): + return + + # C.g:197:2: ( specifier_qualifier_list struct_declarator_list ';' ) + # C.g:197:4: specifier_qualifier_list struct_declarator_list ';' + self.following.append(self.FOLLOW_specifier_qualifier_list_in_struct_declaration539) + self.specifier_qualifier_list() + self.following.pop() + if self.failed: + return + self.following.append(self.FOLLOW_struct_declarator_list_in_struct_declaration541) + self.struct_declarator_list() + self.following.pop() + if self.failed: + return + self.match(self.input, 25, self.FOLLOW_25_in_struct_declaration543) + if self.failed: + return + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 14, struct_declaration_StartIndex) + + pass + + return + + # $ANTLR end struct_declaration + + + # $ANTLR start specifier_qualifier_list + # C.g:200:1: specifier_qualifier_list : ( type_qualifier | type_specifier )+ ; + def specifier_qualifier_list(self, ): + + specifier_qualifier_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 15): + return + + # C.g:201:2: ( ( type_qualifier | type_specifier )+ ) + # C.g:201:4: ( type_qualifier | type_specifier )+ + # C.g:201:4: ( type_qualifier | type_specifier )+ + cnt17 = 0 + while True: #loop17 + alt17 = 3 + LA17 = self.input.LA(1) + if LA17 == 58: + LA17_2 = self.input.LA(2) + + if (self.synpred39()) : + alt17 = 1 + + + elif LA17 == 59: + LA17_3 = self.input.LA(2) + + if (self.synpred39()) : + alt17 = 1 + + + elif LA17 == 60: + LA17_4 = self.input.LA(2) + + if (self.synpred39()) : + alt17 = 1 + + + elif LA17 == IDENTIFIER: + LA17 = self.input.LA(2) + if LA17 == EOF or LA17 == IDENTIFIER or LA17 == 34 or LA17 == 35 or LA17 == 36 or LA17 == 37 or LA17 == 38 or LA17 == 39 or LA17 == 40 or LA17 == 41 or LA17 == 42 or LA17 == 45 or LA17 == 46 or LA17 == 48 or LA17 == 49 or LA17 == 50 or LA17 == 51 or LA17 == 52 or LA17 == 53 or LA17 == 54 or LA17 == 55 or LA17 == 56 or LA17 == 57 or LA17 == 58 or LA17 == 59 or LA17 == 60 or LA17 == 62 or LA17 == 65: + alt17 = 2 + elif LA17 == 61: + LA17_94 = self.input.LA(3) + + if (self.synpred40()) : + alt17 = 2 + + + elif LA17 == 47: + LA17_95 = self.input.LA(3) + + if (self.synpred40()) : + alt17 = 2 + + + elif LA17 == 63: + LA17_96 = self.input.LA(3) + + if (self.synpred40()) : + alt17 = 2 + + + + elif LA17 == 49 or LA17 == 50 or LA17 == 51 or LA17 == 52 or LA17 == 53 or LA17 == 54 or LA17 == 55 or LA17 == 56 or LA17 == 57: + alt17 = 1 + elif LA17 == 34 or LA17 == 35 or LA17 == 36 or LA17 == 37 or LA17 == 38 or LA17 == 39 or LA17 == 40 or LA17 == 41 or LA17 == 42 or LA17 == 45 or LA17 == 46 or LA17 == 48: + alt17 = 2 + + if alt17 == 1: + # C.g:201:6: type_qualifier + self.following.append(self.FOLLOW_type_qualifier_in_specifier_qualifier_list556) + self.type_qualifier() + self.following.pop() + if self.failed: + return + + + elif alt17 == 2: + # C.g:201:23: type_specifier + self.following.append(self.FOLLOW_type_specifier_in_specifier_qualifier_list560) + self.type_specifier() + self.following.pop() + if self.failed: + return + + + else: + if cnt17 >= 1: + break #loop17 + + if self.backtracking > 0: + self.failed = True + return + + eee = EarlyExitException(17, self.input) + raise eee + + cnt17 += 1 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 15, specifier_qualifier_list_StartIndex) + + pass + + return + + # $ANTLR end specifier_qualifier_list + + + # $ANTLR start struct_declarator_list + # C.g:204:1: struct_declarator_list : struct_declarator ( ',' struct_declarator )* ; + def struct_declarator_list(self, ): + + struct_declarator_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 16): + return + + # C.g:205:2: ( struct_declarator ( ',' struct_declarator )* ) + # C.g:205:4: struct_declarator ( ',' struct_declarator )* + self.following.append(self.FOLLOW_struct_declarator_in_struct_declarator_list574) + self.struct_declarator() + self.following.pop() + if self.failed: + return + # C.g:205:22: ( ',' struct_declarator )* + while True: #loop18 + alt18 = 2 + LA18_0 = self.input.LA(1) + + if (LA18_0 == 27) : + alt18 = 1 + + + if alt18 == 1: + # C.g:205:23: ',' struct_declarator + self.match(self.input, 27, self.FOLLOW_27_in_struct_declarator_list577) + if self.failed: + return + self.following.append(self.FOLLOW_struct_declarator_in_struct_declarator_list579) + self.struct_declarator() + self.following.pop() + if self.failed: + return + + + else: + break #loop18 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 16, struct_declarator_list_StartIndex) + + pass + + return + + # $ANTLR end struct_declarator_list + + + # $ANTLR start struct_declarator + # C.g:208:1: struct_declarator : ( declarator ( ':' constant_expression )? | ':' constant_expression ); + def struct_declarator(self, ): + + struct_declarator_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 17): + return + + # C.g:209:2: ( declarator ( ':' constant_expression )? | ':' constant_expression ) + alt20 = 2 + LA20_0 = self.input.LA(1) + + if (LA20_0 == IDENTIFIER or (58 <= LA20_0 <= 61) or LA20_0 == 65) : + alt20 = 1 + elif (LA20_0 == 47) : + alt20 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("208:1: struct_declarator : ( declarator ( ':' constant_expression )? | ':' constant_expression );", 20, 0, self.input) + + raise nvae + + if alt20 == 1: + # C.g:209:4: declarator ( ':' constant_expression )? + self.following.append(self.FOLLOW_declarator_in_struct_declarator592) + self.declarator() + self.following.pop() + if self.failed: + return + # C.g:209:15: ( ':' constant_expression )? + alt19 = 2 + LA19_0 = self.input.LA(1) + + if (LA19_0 == 47) : + alt19 = 1 + if alt19 == 1: + # C.g:209:16: ':' constant_expression + self.match(self.input, 47, self.FOLLOW_47_in_struct_declarator595) + if self.failed: + return + self.following.append(self.FOLLOW_constant_expression_in_struct_declarator597) + self.constant_expression() + self.following.pop() + if self.failed: + return + + + + + + elif alt20 == 2: + # C.g:210:4: ':' constant_expression + self.match(self.input, 47, self.FOLLOW_47_in_struct_declarator604) + if self.failed: + return + self.following.append(self.FOLLOW_constant_expression_in_struct_declarator606) + self.constant_expression() + self.following.pop() + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 17, struct_declarator_StartIndex) + + pass + + return + + # $ANTLR end struct_declarator + + class enum_specifier_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start enum_specifier + # C.g:213:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER ); + def enum_specifier(self, ): + + retval = self.enum_specifier_return() + retval.start = self.input.LT(1) + enum_specifier_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 18): + return retval + + # C.g:215:2: ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER ) + alt23 = 3 + LA23_0 = self.input.LA(1) + + if (LA23_0 == 48) : + LA23_1 = self.input.LA(2) + + if (LA23_1 == IDENTIFIER) : + LA23_2 = self.input.LA(3) + + if (LA23_2 == 43) : + alt23 = 2 + elif (LA23_2 == EOF or LA23_2 == IDENTIFIER or LA23_2 == 25 or LA23_2 == 27 or (29 <= LA23_2 <= 42) or (45 <= LA23_2 <= 63) or LA23_2 == 65) : + alt23 = 3 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("213:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER );", 23, 2, self.input) + + raise nvae + + elif (LA23_1 == 43) : + alt23 = 1 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("213:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER );", 23, 1, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("213:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER );", 23, 0, self.input) + + raise nvae + + if alt23 == 1: + # C.g:215:4: 'enum' '{' enumerator_list ( ',' )? '}' + self.match(self.input, 48, self.FOLLOW_48_in_enum_specifier624) + if self.failed: + return retval + self.match(self.input, 43, self.FOLLOW_43_in_enum_specifier626) + if self.failed: + return retval + self.following.append(self.FOLLOW_enumerator_list_in_enum_specifier628) + self.enumerator_list() + self.following.pop() + if self.failed: + return retval + # C.g:215:31: ( ',' )? + alt21 = 2 + LA21_0 = self.input.LA(1) + + if (LA21_0 == 27) : + alt21 = 1 + if alt21 == 1: + # C.g:0:0: ',' + self.match(self.input, 27, self.FOLLOW_27_in_enum_specifier630) + if self.failed: + return retval + + + + self.match(self.input, 44, self.FOLLOW_44_in_enum_specifier633) + if self.failed: + return retval + + + elif alt23 == 2: + # C.g:216:4: 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' + self.match(self.input, 48, self.FOLLOW_48_in_enum_specifier638) + if self.failed: + return retval + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enum_specifier640) + if self.failed: + return retval + self.match(self.input, 43, self.FOLLOW_43_in_enum_specifier642) + if self.failed: + return retval + self.following.append(self.FOLLOW_enumerator_list_in_enum_specifier644) + self.enumerator_list() + self.following.pop() + if self.failed: + return retval + # C.g:216:42: ( ',' )? + alt22 = 2 + LA22_0 = self.input.LA(1) + + if (LA22_0 == 27) : + alt22 = 1 + if alt22 == 1: + # C.g:0:0: ',' + self.match(self.input, 27, self.FOLLOW_27_in_enum_specifier646) + if self.failed: + return retval + + + + self.match(self.input, 44, self.FOLLOW_44_in_enum_specifier649) + if self.failed: + return retval + + + elif alt23 == 3: + # C.g:217:4: 'enum' IDENTIFIER + self.match(self.input, 48, self.FOLLOW_48_in_enum_specifier654) + if self.failed: + return retval + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enum_specifier656) + if self.failed: + return retval + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 18, enum_specifier_StartIndex) + + pass + + return retval + + # $ANTLR end enum_specifier + + + # $ANTLR start enumerator_list + # C.g:220:1: enumerator_list : enumerator ( ',' enumerator )* ; + def enumerator_list(self, ): + + enumerator_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 19): + return + + # C.g:221:2: ( enumerator ( ',' enumerator )* ) + # C.g:221:4: enumerator ( ',' enumerator )* + self.following.append(self.FOLLOW_enumerator_in_enumerator_list667) + self.enumerator() + self.following.pop() + if self.failed: + return + # C.g:221:15: ( ',' enumerator )* + while True: #loop24 + alt24 = 2 + LA24_0 = self.input.LA(1) + + if (LA24_0 == 27) : + LA24_1 = self.input.LA(2) + + if (LA24_1 == IDENTIFIER) : + alt24 = 1 + + + + + if alt24 == 1: + # C.g:221:16: ',' enumerator + self.match(self.input, 27, self.FOLLOW_27_in_enumerator_list670) + if self.failed: + return + self.following.append(self.FOLLOW_enumerator_in_enumerator_list672) + self.enumerator() + self.following.pop() + if self.failed: + return + + + else: + break #loop24 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 19, enumerator_list_StartIndex) + + pass + + return + + # $ANTLR end enumerator_list + + + # $ANTLR start enumerator + # C.g:224:1: enumerator : IDENTIFIER ( '=' constant_expression )? ; + def enumerator(self, ): + + enumerator_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 20): + return + + # C.g:225:2: ( IDENTIFIER ( '=' constant_expression )? ) + # C.g:225:4: IDENTIFIER ( '=' constant_expression )? + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enumerator685) + if self.failed: + return + # C.g:225:15: ( '=' constant_expression )? + alt25 = 2 + LA25_0 = self.input.LA(1) + + if (LA25_0 == 28) : + alt25 = 1 + if alt25 == 1: + # C.g:225:16: '=' constant_expression + self.match(self.input, 28, self.FOLLOW_28_in_enumerator688) + if self.failed: + return + self.following.append(self.FOLLOW_constant_expression_in_enumerator690) + self.constant_expression() + self.following.pop() + if self.failed: + return + + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 20, enumerator_StartIndex) + + pass + + return + + # $ANTLR end enumerator + + + # $ANTLR start type_qualifier + # C.g:228:1: type_qualifier : ( 'const' | 'volatile' | 'IN' | 'OUT' | 'OPTIONAL' | 'CONST' | 'UNALIGNED' | 'VOLATILE' | 'GLOBAL_REMOVE_IF_UNREFERENCED' | 'EFIAPI' | 'EFI_BOOTSERVICE' | 'EFI_RUNTIMESERVICE' ); + def type_qualifier(self, ): + + type_qualifier_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 21): + return + + # C.g:229:2: ( 'const' | 'volatile' | 'IN' | 'OUT' | 'OPTIONAL' | 'CONST' | 'UNALIGNED' | 'VOLATILE' | 'GLOBAL_REMOVE_IF_UNREFERENCED' | 'EFIAPI' | 'EFI_BOOTSERVICE' | 'EFI_RUNTIMESERVICE' ) + # C.g: + if (49 <= self.input.LA(1) <= 60): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_type_qualifier0 + ) + raise mse + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 21, type_qualifier_StartIndex) + + pass + + return + + # $ANTLR end type_qualifier + + class declarator_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start declarator + # C.g:243:1: declarator : ( ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator | pointer ); + def declarator(self, ): + + retval = self.declarator_return() + retval.start = self.input.LT(1) + declarator_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 22): + return retval + + # C.g:244:2: ( ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator | pointer ) + alt30 = 2 + LA30_0 = self.input.LA(1) + + if (LA30_0 == 65) : + LA30_1 = self.input.LA(2) + + if (self.synpred65()) : + alt30 = 1 + elif (True) : + alt30 = 2 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("243:1: declarator : ( ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator | pointer );", 30, 1, self.input) + + raise nvae + + elif (LA30_0 == IDENTIFIER or (58 <= LA30_0 <= 61)) : + alt30 = 1 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("243:1: declarator : ( ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator | pointer );", 30, 0, self.input) + + raise nvae + + if alt30 == 1: + # C.g:244:4: ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator + # C.g:244:4: ( pointer )? + alt26 = 2 + LA26_0 = self.input.LA(1) + + if (LA26_0 == 65) : + alt26 = 1 + if alt26 == 1: + # C.g:0:0: pointer + self.following.append(self.FOLLOW_pointer_in_declarator769) + self.pointer() + self.following.pop() + if self.failed: + return retval + + + + # C.g:244:13: ( 'EFIAPI' )? + alt27 = 2 + LA27_0 = self.input.LA(1) + + if (LA27_0 == 58) : + alt27 = 1 + if alt27 == 1: + # C.g:244:14: 'EFIAPI' + self.match(self.input, 58, self.FOLLOW_58_in_declarator773) + if self.failed: + return retval + + + + # C.g:244:25: ( 'EFI_BOOTSERVICE' )? + alt28 = 2 + LA28_0 = self.input.LA(1) + + if (LA28_0 == 59) : + alt28 = 1 + if alt28 == 1: + # C.g:244:26: 'EFI_BOOTSERVICE' + self.match(self.input, 59, self.FOLLOW_59_in_declarator778) + if self.failed: + return retval + + + + # C.g:244:46: ( 'EFI_RUNTIMESERVICE' )? + alt29 = 2 + LA29_0 = self.input.LA(1) + + if (LA29_0 == 60) : + alt29 = 1 + if alt29 == 1: + # C.g:244:47: 'EFI_RUNTIMESERVICE' + self.match(self.input, 60, self.FOLLOW_60_in_declarator783) + if self.failed: + return retval + + + + self.following.append(self.FOLLOW_direct_declarator_in_declarator787) + self.direct_declarator() + self.following.pop() + if self.failed: + return retval + + + elif alt30 == 2: + # C.g:246:4: pointer + self.following.append(self.FOLLOW_pointer_in_declarator793) + self.pointer() + self.following.pop() + if self.failed: + return retval + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 22, declarator_StartIndex) + + pass + + return retval + + # $ANTLR end declarator + + + # $ANTLR start direct_declarator + # C.g:249:1: direct_declarator : ( IDENTIFIER ( declarator_suffix )* | '(' ( 'EFIAPI' )? declarator ')' ( declarator_suffix )+ ); + def direct_declarator(self, ): + + direct_declarator_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 23): + return + + # C.g:250:2: ( IDENTIFIER ( declarator_suffix )* | '(' ( 'EFIAPI' )? declarator ')' ( declarator_suffix )+ ) + alt34 = 2 + LA34_0 = self.input.LA(1) + + if (LA34_0 == IDENTIFIER) : + alt34 = 1 + elif (LA34_0 == 61) : + alt34 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("249:1: direct_declarator : ( IDENTIFIER ( declarator_suffix )* | '(' ( 'EFIAPI' )? declarator ')' ( declarator_suffix )+ );", 34, 0, self.input) + + raise nvae + + if alt34 == 1: + # C.g:250:4: IDENTIFIER ( declarator_suffix )* + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_direct_declarator804) + if self.failed: + return + # C.g:250:15: ( declarator_suffix )* + while True: #loop31 + alt31 = 2 + LA31_0 = self.input.LA(1) + + if (LA31_0 == 61) : + LA31 = self.input.LA(2) + if LA31 == 62: + LA31_30 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 58: + LA31_31 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 65: + LA31_32 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 59: + LA31_33 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 60: + LA31_34 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == IDENTIFIER: + LA31_35 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 29 or LA31 == 30 or LA31 == 31 or LA31 == 32 or LA31 == 33: + LA31_37 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 34: + LA31_38 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 35: + LA31_39 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 36: + LA31_40 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 37: + LA31_41 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 38: + LA31_42 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 39: + LA31_43 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 40: + LA31_44 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 41: + LA31_45 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 42: + LA31_46 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 45 or LA31 == 46: + LA31_47 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 48: + LA31_48 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 49 or LA31 == 50 or LA31 == 51 or LA31 == 52 or LA31 == 53 or LA31 == 54 or LA31 == 55 or LA31 == 56 or LA31 == 57: + LA31_49 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + + elif (LA31_0 == 63) : + LA31 = self.input.LA(2) + if LA31 == 64: + LA31_51 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 61: + LA31_52 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == IDENTIFIER: + LA31_53 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == HEX_LITERAL: + LA31_54 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == OCTAL_LITERAL: + LA31_55 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == DECIMAL_LITERAL: + LA31_56 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == CHARACTER_LITERAL: + LA31_57 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == STRING_LITERAL: + LA31_58 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == FLOATING_POINT_LITERAL: + LA31_59 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 71: + LA31_60 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 72: + LA31_61 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 65 or LA31 == 67 or LA31 == 68 or LA31 == 76 or LA31 == 77 or LA31 == 78: + LA31_62 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + elif LA31 == 73: + LA31_63 = self.input.LA(3) + + if (self.synpred66()) : + alt31 = 1 + + + + + + if alt31 == 1: + # C.g:0:0: declarator_suffix + self.following.append(self.FOLLOW_declarator_suffix_in_direct_declarator806) + self.declarator_suffix() + self.following.pop() + if self.failed: + return + + + else: + break #loop31 + + + + + elif alt34 == 2: + # C.g:251:4: '(' ( 'EFIAPI' )? declarator ')' ( declarator_suffix )+ + self.match(self.input, 61, self.FOLLOW_61_in_direct_declarator812) + if self.failed: + return + # C.g:251:8: ( 'EFIAPI' )? + alt32 = 2 + LA32_0 = self.input.LA(1) + + if (LA32_0 == 58) : + LA32_1 = self.input.LA(2) + + if (self.synpred68()) : + alt32 = 1 + if alt32 == 1: + # C.g:251:9: 'EFIAPI' + self.match(self.input, 58, self.FOLLOW_58_in_direct_declarator815) + if self.failed: + return + + + + self.following.append(self.FOLLOW_declarator_in_direct_declarator819) + self.declarator() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_direct_declarator821) + if self.failed: + return + # C.g:251:35: ( declarator_suffix )+ + cnt33 = 0 + while True: #loop33 + alt33 = 2 + LA33_0 = self.input.LA(1) + + if (LA33_0 == 61) : + LA33 = self.input.LA(2) + if LA33 == 62: + LA33_30 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 58: + LA33_31 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 65: + LA33_32 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 59: + LA33_33 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 60: + LA33_34 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == IDENTIFIER: + LA33_35 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 29 or LA33 == 30 or LA33 == 31 or LA33 == 32 or LA33 == 33: + LA33_37 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 34: + LA33_38 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 35: + LA33_39 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 36: + LA33_40 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 37: + LA33_41 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 38: + LA33_42 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 39: + LA33_43 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 40: + LA33_44 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 41: + LA33_45 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 42: + LA33_46 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 45 or LA33 == 46: + LA33_47 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 48: + LA33_48 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 49 or LA33 == 50 or LA33 == 51 or LA33 == 52 or LA33 == 53 or LA33 == 54 or LA33 == 55 or LA33 == 56 or LA33 == 57: + LA33_49 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + + elif (LA33_0 == 63) : + LA33 = self.input.LA(2) + if LA33 == 64: + LA33_51 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 61: + LA33_52 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == IDENTIFIER: + LA33_53 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == HEX_LITERAL: + LA33_54 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == OCTAL_LITERAL: + LA33_55 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == DECIMAL_LITERAL: + LA33_56 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == CHARACTER_LITERAL: + LA33_57 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == STRING_LITERAL: + LA33_58 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == FLOATING_POINT_LITERAL: + LA33_59 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 71: + LA33_60 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 72: + LA33_61 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 65 or LA33 == 67 or LA33 == 68 or LA33 == 76 or LA33 == 77 or LA33 == 78: + LA33_62 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + elif LA33 == 73: + LA33_63 = self.input.LA(3) + + if (self.synpred69()) : + alt33 = 1 + + + + + + if alt33 == 1: + # C.g:0:0: declarator_suffix + self.following.append(self.FOLLOW_declarator_suffix_in_direct_declarator823) + self.declarator_suffix() + self.following.pop() + if self.failed: + return + + + else: + if cnt33 >= 1: + break #loop33 + + if self.backtracking > 0: + self.failed = True + return + + eee = EarlyExitException(33, self.input) + raise eee + + cnt33 += 1 + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 23, direct_declarator_StartIndex) + + pass + + return + + # $ANTLR end direct_declarator + + + # $ANTLR start declarator_suffix + # C.g:254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' ); + def declarator_suffix(self, ): + + declarator_suffix_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 24): + return + + # C.g:255:2: ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' ) + alt35 = 5 + LA35_0 = self.input.LA(1) + + if (LA35_0 == 63) : + LA35_1 = self.input.LA(2) + + if (LA35_1 == 64) : + alt35 = 2 + elif ((IDENTIFIER <= LA35_1 <= FLOATING_POINT_LITERAL) or LA35_1 == 61 or LA35_1 == 65 or (67 <= LA35_1 <= 68) or (71 <= LA35_1 <= 73) or (76 <= LA35_1 <= 78)) : + alt35 = 1 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 35, 1, self.input) + + raise nvae + + elif (LA35_0 == 61) : + LA35 = self.input.LA(2) + if LA35 == 62: + alt35 = 5 + elif LA35 == IDENTIFIER: + LA35_17 = self.input.LA(3) + + if (self.synpred72()) : + alt35 = 3 + elif (self.synpred73()) : + alt35 = 4 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 35, 17, self.input) + + raise nvae + + elif LA35 == 29 or LA35 == 30 or LA35 == 31 or LA35 == 32 or LA35 == 33 or LA35 == 34 or LA35 == 35 or LA35 == 36 or LA35 == 37 or LA35 == 38 or LA35 == 39 or LA35 == 40 or LA35 == 41 or LA35 == 42 or LA35 == 45 or LA35 == 46 or LA35 == 48 or LA35 == 49 or LA35 == 50 or LA35 == 51 or LA35 == 52 or LA35 == 53 or LA35 == 54 or LA35 == 55 or LA35 == 56 or LA35 == 57 or LA35 == 58 or LA35 == 59 or LA35 == 60 or LA35 == 65: + alt35 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 35, 2, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 35, 0, self.input) + + raise nvae + + if alt35 == 1: + # C.g:255:6: '[' constant_expression ']' + self.match(self.input, 63, self.FOLLOW_63_in_declarator_suffix837) + if self.failed: + return + self.following.append(self.FOLLOW_constant_expression_in_declarator_suffix839) + self.constant_expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 64, self.FOLLOW_64_in_declarator_suffix841) + if self.failed: + return + + + elif alt35 == 2: + # C.g:256:9: '[' ']' + self.match(self.input, 63, self.FOLLOW_63_in_declarator_suffix851) + if self.failed: + return + self.match(self.input, 64, self.FOLLOW_64_in_declarator_suffix853) + if self.failed: + return + + + elif alt35 == 3: + # C.g:257:9: '(' parameter_type_list ')' + self.match(self.input, 61, self.FOLLOW_61_in_declarator_suffix863) + if self.failed: + return + self.following.append(self.FOLLOW_parameter_type_list_in_declarator_suffix865) + self.parameter_type_list() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_declarator_suffix867) + if self.failed: + return + + + elif alt35 == 4: + # C.g:258:9: '(' identifier_list ')' + self.match(self.input, 61, self.FOLLOW_61_in_declarator_suffix877) + if self.failed: + return + self.following.append(self.FOLLOW_identifier_list_in_declarator_suffix879) + self.identifier_list() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_declarator_suffix881) + if self.failed: + return + + + elif alt35 == 5: + # C.g:259:9: '(' ')' + self.match(self.input, 61, self.FOLLOW_61_in_declarator_suffix891) + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_declarator_suffix893) + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 24, declarator_suffix_StartIndex) + + pass + + return + + # $ANTLR end declarator_suffix + + + # $ANTLR start pointer + # C.g:262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' ); + def pointer(self, ): + + pointer_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 25): + return + + # C.g:263:2: ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' ) + alt38 = 3 + LA38_0 = self.input.LA(1) + + if (LA38_0 == 65) : + LA38 = self.input.LA(2) + if LA38 == 58: + LA38_2 = self.input.LA(3) + + if (self.synpred76()) : + alt38 = 1 + elif (True) : + alt38 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 2, self.input) + + raise nvae + + elif LA38 == 59: + LA38_3 = self.input.LA(3) + + if (self.synpred76()) : + alt38 = 1 + elif (True) : + alt38 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 3, self.input) + + raise nvae + + elif LA38 == 60: + LA38_4 = self.input.LA(3) + + if (self.synpred76()) : + alt38 = 1 + elif (True) : + alt38 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 4, self.input) + + raise nvae + + elif LA38 == EOF or LA38 == IDENTIFIER or LA38 == 25 or LA38 == 26 or LA38 == 27 or LA38 == 28 or LA38 == 29 or LA38 == 30 or LA38 == 31 or LA38 == 32 or LA38 == 33 or LA38 == 34 or LA38 == 35 or LA38 == 36 or LA38 == 37 or LA38 == 38 or LA38 == 39 or LA38 == 40 or LA38 == 41 or LA38 == 42 or LA38 == 43 or LA38 == 45 or LA38 == 46 or LA38 == 47 or LA38 == 48 or LA38 == 61 or LA38 == 62 or LA38 == 63: + alt38 = 3 + elif LA38 == 53: + LA38_20 = self.input.LA(3) + + if (self.synpred76()) : + alt38 = 1 + elif (True) : + alt38 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 20, self.input) + + raise nvae + + elif LA38 == 49 or LA38 == 50 or LA38 == 51 or LA38 == 52 or LA38 == 54 or LA38 == 55 or LA38 == 56 or LA38 == 57: + LA38_28 = self.input.LA(3) + + if (self.synpred76()) : + alt38 = 1 + elif (True) : + alt38 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 28, self.input) + + raise nvae + + elif LA38 == 65: + LA38_29 = self.input.LA(3) + + if (self.synpred77()) : + alt38 = 2 + elif (True) : + alt38 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 29, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 1, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 0, self.input) + + raise nvae + + if alt38 == 1: + # C.g:263:4: '*' ( type_qualifier )+ ( pointer )? + self.match(self.input, 65, self.FOLLOW_65_in_pointer904) + if self.failed: + return + # C.g:263:8: ( type_qualifier )+ + cnt36 = 0 + while True: #loop36 + alt36 = 2 + LA36 = self.input.LA(1) + if LA36 == 58: + LA36_2 = self.input.LA(2) + + if (self.synpred74()) : + alt36 = 1 + + + elif LA36 == 59: + LA36_3 = self.input.LA(2) + + if (self.synpred74()) : + alt36 = 1 + + + elif LA36 == 60: + LA36_4 = self.input.LA(2) + + if (self.synpred74()) : + alt36 = 1 + + + elif LA36 == 53: + LA36_20 = self.input.LA(2) + + if (self.synpred74()) : + alt36 = 1 + + + elif LA36 == 49 or LA36 == 50 or LA36 == 51 or LA36 == 52 or LA36 == 54 or LA36 == 55 or LA36 == 56 or LA36 == 57: + LA36_28 = self.input.LA(2) + + if (self.synpred74()) : + alt36 = 1 + + + + if alt36 == 1: + # C.g:0:0: type_qualifier + self.following.append(self.FOLLOW_type_qualifier_in_pointer906) + self.type_qualifier() + self.following.pop() + if self.failed: + return + + + else: + if cnt36 >= 1: + break #loop36 + + if self.backtracking > 0: + self.failed = True + return + + eee = EarlyExitException(36, self.input) + raise eee + + cnt36 += 1 + + + # C.g:263:24: ( pointer )? + alt37 = 2 + LA37_0 = self.input.LA(1) + + if (LA37_0 == 65) : + LA37_1 = self.input.LA(2) + + if (self.synpred75()) : + alt37 = 1 + if alt37 == 1: + # C.g:0:0: pointer + self.following.append(self.FOLLOW_pointer_in_pointer909) + self.pointer() + self.following.pop() + if self.failed: + return + + + + + + elif alt38 == 2: + # C.g:264:4: '*' pointer + self.match(self.input, 65, self.FOLLOW_65_in_pointer915) + if self.failed: + return + self.following.append(self.FOLLOW_pointer_in_pointer917) + self.pointer() + self.following.pop() + if self.failed: + return + + + elif alt38 == 3: + # C.g:265:4: '*' + self.match(self.input, 65, self.FOLLOW_65_in_pointer922) + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 25, pointer_StartIndex) + + pass + + return + + # $ANTLR end pointer + + + # $ANTLR start parameter_type_list + # C.g:268:1: parameter_type_list : parameter_list ( ',' ( 'OPTIONAL' )? '...' )? ; + def parameter_type_list(self, ): + + parameter_type_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 26): + return + + # C.g:269:2: ( parameter_list ( ',' ( 'OPTIONAL' )? '...' )? ) + # C.g:269:4: parameter_list ( ',' ( 'OPTIONAL' )? '...' )? + self.following.append(self.FOLLOW_parameter_list_in_parameter_type_list933) + self.parameter_list() + self.following.pop() + if self.failed: + return + # C.g:269:19: ( ',' ( 'OPTIONAL' )? '...' )? + alt40 = 2 + LA40_0 = self.input.LA(1) + + if (LA40_0 == 27) : + alt40 = 1 + if alt40 == 1: + # C.g:269:20: ',' ( 'OPTIONAL' )? '...' + self.match(self.input, 27, self.FOLLOW_27_in_parameter_type_list936) + if self.failed: + return + # C.g:269:24: ( 'OPTIONAL' )? + alt39 = 2 + LA39_0 = self.input.LA(1) + + if (LA39_0 == 53) : + alt39 = 1 + if alt39 == 1: + # C.g:269:25: 'OPTIONAL' + self.match(self.input, 53, self.FOLLOW_53_in_parameter_type_list939) + if self.failed: + return + + + + self.match(self.input, 66, self.FOLLOW_66_in_parameter_type_list943) + if self.failed: + return + + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 26, parameter_type_list_StartIndex) + + pass + + return + + # $ANTLR end parameter_type_list + + + # $ANTLR start parameter_list + # C.g:272:1: parameter_list : parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )* ; + def parameter_list(self, ): + + parameter_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 27): + return + + # C.g:273:2: ( parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )* ) + # C.g:273:4: parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )* + self.following.append(self.FOLLOW_parameter_declaration_in_parameter_list956) + self.parameter_declaration() + self.following.pop() + if self.failed: + return + # C.g:273:26: ( ',' ( 'OPTIONAL' )? parameter_declaration )* + while True: #loop42 + alt42 = 2 + LA42_0 = self.input.LA(1) + + if (LA42_0 == 27) : + LA42_1 = self.input.LA(2) + + if (LA42_1 == 53) : + LA42_3 = self.input.LA(3) + + if (self.synpred81()) : + alt42 = 1 + + + elif (LA42_1 == IDENTIFIER or (29 <= LA42_1 <= 42) or (45 <= LA42_1 <= 46) or (48 <= LA42_1 <= 52) or (54 <= LA42_1 <= 60) or LA42_1 == 65) : + alt42 = 1 + + + + + if alt42 == 1: + # C.g:273:27: ',' ( 'OPTIONAL' )? parameter_declaration + self.match(self.input, 27, self.FOLLOW_27_in_parameter_list959) + if self.failed: + return + # C.g:273:31: ( 'OPTIONAL' )? + alt41 = 2 + LA41_0 = self.input.LA(1) + + if (LA41_0 == 53) : + LA41_1 = self.input.LA(2) + + if (self.synpred80()) : + alt41 = 1 + if alt41 == 1: + # C.g:273:32: 'OPTIONAL' + self.match(self.input, 53, self.FOLLOW_53_in_parameter_list962) + if self.failed: + return + + + + self.following.append(self.FOLLOW_parameter_declaration_in_parameter_list966) + self.parameter_declaration() + self.following.pop() + if self.failed: + return + + + else: + break #loop42 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 27, parameter_list_StartIndex) + + pass + + return + + # $ANTLR end parameter_list + + + # $ANTLR start parameter_declaration + # C.g:276:1: parameter_declaration : ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | ( pointer )* IDENTIFIER ); + def parameter_declaration(self, ): + + parameter_declaration_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 28): + return + + # C.g:277:2: ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | ( pointer )* IDENTIFIER ) + alt46 = 2 + LA46 = self.input.LA(1) + if LA46 == 29 or LA46 == 30 or LA46 == 31 or LA46 == 32 or LA46 == 33 or LA46 == 34 or LA46 == 35 or LA46 == 36 or LA46 == 37 or LA46 == 38 or LA46 == 39 or LA46 == 40 or LA46 == 41 or LA46 == 42 or LA46 == 45 or LA46 == 46 or LA46 == 48 or LA46 == 49 or LA46 == 50 or LA46 == 51 or LA46 == 52 or LA46 == 53 or LA46 == 54 or LA46 == 55 or LA46 == 56 or LA46 == 57 or LA46 == 58 or LA46 == 59 or LA46 == 60: + alt46 = 1 + elif LA46 == IDENTIFIER: + LA46_13 = self.input.LA(2) + + if (self.synpred85()) : + alt46 = 1 + elif (True) : + alt46 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("276:1: parameter_declaration : ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | ( pointer )* IDENTIFIER );", 46, 13, self.input) + + raise nvae + + elif LA46 == 65: + alt46 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("276:1: parameter_declaration : ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | ( pointer )* IDENTIFIER );", 46, 0, self.input) + + raise nvae + + if alt46 == 1: + # C.g:277:4: declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? + self.following.append(self.FOLLOW_declaration_specifiers_in_parameter_declaration979) + self.declaration_specifiers() + self.following.pop() + if self.failed: + return + # C.g:277:27: ( declarator | abstract_declarator )* + while True: #loop43 + alt43 = 3 + LA43 = self.input.LA(1) + if LA43 == 65: + LA43_5 = self.input.LA(2) + + if (self.synpred82()) : + alt43 = 1 + elif (self.synpred83()) : + alt43 = 2 + + + elif LA43 == IDENTIFIER or LA43 == 58 or LA43 == 59 or LA43 == 60: + alt43 = 1 + elif LA43 == 61: + LA43 = self.input.LA(2) + if LA43 == 29 or LA43 == 30 or LA43 == 31 or LA43 == 32 or LA43 == 33 or LA43 == 34 or LA43 == 35 or LA43 == 36 or LA43 == 37 or LA43 == 38 or LA43 == 39 or LA43 == 40 or LA43 == 41 or LA43 == 42 or LA43 == 45 or LA43 == 46 or LA43 == 48 or LA43 == 49 or LA43 == 50 or LA43 == 51 or LA43 == 52 or LA43 == 53 or LA43 == 54 or LA43 == 55 or LA43 == 56 or LA43 == 57 or LA43 == 62 or LA43 == 63: + alt43 = 2 + elif LA43 == IDENTIFIER: + LA43_37 = self.input.LA(3) + + if (self.synpred82()) : + alt43 = 1 + elif (self.synpred83()) : + alt43 = 2 + + + elif LA43 == 58: + LA43_38 = self.input.LA(3) + + if (self.synpred82()) : + alt43 = 1 + elif (self.synpred83()) : + alt43 = 2 + + + elif LA43 == 65: + LA43_39 = self.input.LA(3) + + if (self.synpred82()) : + alt43 = 1 + elif (self.synpred83()) : + alt43 = 2 + + + elif LA43 == 59: + LA43_40 = self.input.LA(3) + + if (self.synpred82()) : + alt43 = 1 + elif (self.synpred83()) : + alt43 = 2 + + + elif LA43 == 60: + LA43_41 = self.input.LA(3) + + if (self.synpred82()) : + alt43 = 1 + elif (self.synpred83()) : + alt43 = 2 + + + elif LA43 == 61: + LA43_43 = self.input.LA(3) + + if (self.synpred82()) : + alt43 = 1 + elif (self.synpred83()) : + alt43 = 2 + + + + elif LA43 == 63: + alt43 = 2 + + if alt43 == 1: + # C.g:277:28: declarator + self.following.append(self.FOLLOW_declarator_in_parameter_declaration982) + self.declarator() + self.following.pop() + if self.failed: + return + + + elif alt43 == 2: + # C.g:277:39: abstract_declarator + self.following.append(self.FOLLOW_abstract_declarator_in_parameter_declaration984) + self.abstract_declarator() + self.following.pop() + if self.failed: + return + + + else: + break #loop43 + + + # C.g:277:61: ( 'OPTIONAL' )? + alt44 = 2 + LA44_0 = self.input.LA(1) + + if (LA44_0 == 53) : + alt44 = 1 + if alt44 == 1: + # C.g:277:62: 'OPTIONAL' + self.match(self.input, 53, self.FOLLOW_53_in_parameter_declaration989) + if self.failed: + return + + + + + + elif alt46 == 2: + # C.g:279:4: ( pointer )* IDENTIFIER + # C.g:279:4: ( pointer )* + while True: #loop45 + alt45 = 2 + LA45_0 = self.input.LA(1) + + if (LA45_0 == 65) : + alt45 = 1 + + + if alt45 == 1: + # C.g:0:0: pointer + self.following.append(self.FOLLOW_pointer_in_parameter_declaration998) + self.pointer() + self.following.pop() + if self.failed: + return + + + else: + break #loop45 + + + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_parameter_declaration1001) + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 28, parameter_declaration_StartIndex) + + pass + + return + + # $ANTLR end parameter_declaration + + + # $ANTLR start identifier_list + # C.g:282:1: identifier_list : IDENTIFIER ( ',' IDENTIFIER )* ; + def identifier_list(self, ): + + identifier_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 29): + return + + # C.g:283:2: ( IDENTIFIER ( ',' IDENTIFIER )* ) + # C.g:283:4: IDENTIFIER ( ',' IDENTIFIER )* + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_identifier_list1012) + if self.failed: + return + # C.g:284:2: ( ',' IDENTIFIER )* + while True: #loop47 + alt47 = 2 + LA47_0 = self.input.LA(1) + + if (LA47_0 == 27) : + alt47 = 1 + + + if alt47 == 1: + # C.g:284:3: ',' IDENTIFIER + self.match(self.input, 27, self.FOLLOW_27_in_identifier_list1016) + if self.failed: + return + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_identifier_list1018) + if self.failed: + return + + + else: + break #loop47 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 29, identifier_list_StartIndex) + + pass + + return + + # $ANTLR end identifier_list + + + # $ANTLR start type_name + # C.g:287:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id ); + def type_name(self, ): + + type_name_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 30): + return + + # C.g:288:2: ( specifier_qualifier_list ( abstract_declarator )? | type_id ) + alt49 = 2 + LA49_0 = self.input.LA(1) + + if ((34 <= LA49_0 <= 42) or (45 <= LA49_0 <= 46) or (48 <= LA49_0 <= 60)) : + alt49 = 1 + elif (LA49_0 == IDENTIFIER) : + LA49_13 = self.input.LA(2) + + if (self.synpred89()) : + alt49 = 1 + elif (True) : + alt49 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("287:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );", 49, 13, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("287:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );", 49, 0, self.input) + + raise nvae + + if alt49 == 1: + # C.g:288:4: specifier_qualifier_list ( abstract_declarator )? + self.following.append(self.FOLLOW_specifier_qualifier_list_in_type_name1031) + self.specifier_qualifier_list() + self.following.pop() + if self.failed: + return + # C.g:288:29: ( abstract_declarator )? + alt48 = 2 + LA48_0 = self.input.LA(1) + + if (LA48_0 == 61 or LA48_0 == 63 or LA48_0 == 65) : + alt48 = 1 + if alt48 == 1: + # C.g:0:0: abstract_declarator + self.following.append(self.FOLLOW_abstract_declarator_in_type_name1033) + self.abstract_declarator() + self.following.pop() + if self.failed: + return + + + + + + elif alt49 == 2: + # C.g:289:4: type_id + self.following.append(self.FOLLOW_type_id_in_type_name1039) + self.type_id() + self.following.pop() + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 30, type_name_StartIndex) + + pass + + return + + # $ANTLR end type_name + + + # $ANTLR start abstract_declarator + # C.g:292:1: abstract_declarator : ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator ); + def abstract_declarator(self, ): + + abstract_declarator_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 31): + return + + # C.g:293:2: ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator ) + alt51 = 2 + LA51_0 = self.input.LA(1) + + if (LA51_0 == 65) : + alt51 = 1 + elif (LA51_0 == 61 or LA51_0 == 63) : + alt51 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("292:1: abstract_declarator : ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator );", 51, 0, self.input) + + raise nvae + + if alt51 == 1: + # C.g:293:4: pointer ( direct_abstract_declarator )? + self.following.append(self.FOLLOW_pointer_in_abstract_declarator1050) + self.pointer() + self.following.pop() + if self.failed: + return + # C.g:293:12: ( direct_abstract_declarator )? + alt50 = 2 + LA50_0 = self.input.LA(1) + + if (LA50_0 == 61) : + LA50 = self.input.LA(2) + if LA50 == 62: + LA50_12 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 58: + LA50_13 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 65: + LA50_14 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 59: + LA50_15 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 60: + LA50_16 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == IDENTIFIER: + LA50_17 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 61: + LA50_18 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 29 or LA50 == 30 or LA50 == 31 or LA50 == 32 or LA50 == 33: + LA50_19 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 34: + LA50_20 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 35: + LA50_21 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 36: + LA50_22 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 37: + LA50_23 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 38: + LA50_24 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 39: + LA50_25 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 40: + LA50_26 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 41: + LA50_27 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 42: + LA50_28 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 45 or LA50 == 46: + LA50_29 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 48: + LA50_30 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 49 or LA50 == 50 or LA50 == 51 or LA50 == 52 or LA50 == 53 or LA50 == 54 or LA50 == 55 or LA50 == 56 or LA50 == 57: + LA50_31 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 63: + LA50_32 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif (LA50_0 == 63) : + LA50 = self.input.LA(2) + if LA50 == 64: + LA50_33 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 61: + LA50_34 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == IDENTIFIER: + LA50_35 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == HEX_LITERAL: + LA50_36 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == OCTAL_LITERAL: + LA50_37 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == DECIMAL_LITERAL: + LA50_38 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == CHARACTER_LITERAL: + LA50_39 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == STRING_LITERAL: + LA50_40 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == FLOATING_POINT_LITERAL: + LA50_41 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 71: + LA50_42 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 72: + LA50_43 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 65 or LA50 == 67 or LA50 == 68 or LA50 == 76 or LA50 == 77 or LA50 == 78: + LA50_44 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + elif LA50 == 73: + LA50_45 = self.input.LA(3) + + if (self.synpred90()) : + alt50 = 1 + if alt50 == 1: + # C.g:0:0: direct_abstract_declarator + self.following.append(self.FOLLOW_direct_abstract_declarator_in_abstract_declarator1052) + self.direct_abstract_declarator() + self.following.pop() + if self.failed: + return + + + + + + elif alt51 == 2: + # C.g:294:4: direct_abstract_declarator + self.following.append(self.FOLLOW_direct_abstract_declarator_in_abstract_declarator1058) + self.direct_abstract_declarator() + self.following.pop() + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 31, abstract_declarator_StartIndex) + + pass + + return + + # $ANTLR end abstract_declarator + + + # $ANTLR start direct_abstract_declarator + # C.g:297:1: direct_abstract_declarator : ( '(' abstract_declarator ')' | abstract_declarator_suffix ) ( abstract_declarator_suffix )* ; + def direct_abstract_declarator(self, ): + + direct_abstract_declarator_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 32): + return + + # C.g:298:2: ( ( '(' abstract_declarator ')' | abstract_declarator_suffix ) ( abstract_declarator_suffix )* ) + # C.g:298:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix ) ( abstract_declarator_suffix )* + # C.g:298:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix ) + alt52 = 2 + LA52_0 = self.input.LA(1) + + if (LA52_0 == 61) : + LA52 = self.input.LA(2) + if LA52 == IDENTIFIER or LA52 == 29 or LA52 == 30 or LA52 == 31 or LA52 == 32 or LA52 == 33 or LA52 == 34 or LA52 == 35 or LA52 == 36 or LA52 == 37 or LA52 == 38 or LA52 == 39 or LA52 == 40 or LA52 == 41 or LA52 == 42 or LA52 == 45 or LA52 == 46 or LA52 == 48 or LA52 == 49 or LA52 == 50 or LA52 == 51 or LA52 == 52 or LA52 == 53 or LA52 == 54 or LA52 == 55 or LA52 == 56 or LA52 == 57 or LA52 == 58 or LA52 == 59 or LA52 == 60 or LA52 == 62: + alt52 = 2 + elif LA52 == 65: + LA52_18 = self.input.LA(3) + + if (self.synpred92()) : + alt52 = 1 + elif (True) : + alt52 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("298:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix )", 52, 18, self.input) + + raise nvae + + elif LA52 == 61 or LA52 == 63: + alt52 = 1 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("298:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix )", 52, 1, self.input) + + raise nvae + + elif (LA52_0 == 63) : + alt52 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("298:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix )", 52, 0, self.input) + + raise nvae + + if alt52 == 1: + # C.g:298:6: '(' abstract_declarator ')' + self.match(self.input, 61, self.FOLLOW_61_in_direct_abstract_declarator1071) + if self.failed: + return + self.following.append(self.FOLLOW_abstract_declarator_in_direct_abstract_declarator1073) + self.abstract_declarator() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_direct_abstract_declarator1075) + if self.failed: + return + + + elif alt52 == 2: + # C.g:298:36: abstract_declarator_suffix + self.following.append(self.FOLLOW_abstract_declarator_suffix_in_direct_abstract_declarator1079) + self.abstract_declarator_suffix() + self.following.pop() + if self.failed: + return + + + + # C.g:298:65: ( abstract_declarator_suffix )* + while True: #loop53 + alt53 = 2 + LA53_0 = self.input.LA(1) + + if (LA53_0 == 61) : + LA53 = self.input.LA(2) + if LA53 == 62: + LA53_12 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 58: + LA53_13 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 65: + LA53_14 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 59: + LA53_15 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 60: + LA53_16 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == IDENTIFIER: + LA53_17 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 29 or LA53 == 30 or LA53 == 31 or LA53 == 32 or LA53 == 33: + LA53_19 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 34: + LA53_20 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 35: + LA53_21 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 36: + LA53_22 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 37: + LA53_23 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 38: + LA53_24 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 39: + LA53_25 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 40: + LA53_26 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 41: + LA53_27 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 42: + LA53_28 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 45 or LA53 == 46: + LA53_29 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 48: + LA53_30 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 49 or LA53 == 50 or LA53 == 51 or LA53 == 52 or LA53 == 53 or LA53 == 54 or LA53 == 55 or LA53 == 56 or LA53 == 57: + LA53_31 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + + elif (LA53_0 == 63) : + LA53 = self.input.LA(2) + if LA53 == 64: + LA53_33 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 61: + LA53_34 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == IDENTIFIER: + LA53_35 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == HEX_LITERAL: + LA53_36 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == OCTAL_LITERAL: + LA53_37 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == DECIMAL_LITERAL: + LA53_38 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == CHARACTER_LITERAL: + LA53_39 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == STRING_LITERAL: + LA53_40 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == FLOATING_POINT_LITERAL: + LA53_41 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 71: + LA53_42 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 72: + LA53_43 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 65 or LA53 == 67 or LA53 == 68 or LA53 == 76 or LA53 == 77 or LA53 == 78: + LA53_44 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + elif LA53 == 73: + LA53_45 = self.input.LA(3) + + if (self.synpred93()) : + alt53 = 1 + + + + + + if alt53 == 1: + # C.g:0:0: abstract_declarator_suffix + self.following.append(self.FOLLOW_abstract_declarator_suffix_in_direct_abstract_declarator1083) + self.abstract_declarator_suffix() + self.following.pop() + if self.failed: + return + + + else: + break #loop53 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 32, direct_abstract_declarator_StartIndex) + + pass + + return + + # $ANTLR end direct_abstract_declarator + + + # $ANTLR start abstract_declarator_suffix + # C.g:301:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' ); + def abstract_declarator_suffix(self, ): + + abstract_declarator_suffix_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 33): + return + + # C.g:302:2: ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' ) + alt54 = 4 + LA54_0 = self.input.LA(1) + + if (LA54_0 == 63) : + LA54_1 = self.input.LA(2) + + if (LA54_1 == 64) : + alt54 = 1 + elif ((IDENTIFIER <= LA54_1 <= FLOATING_POINT_LITERAL) or LA54_1 == 61 or LA54_1 == 65 or (67 <= LA54_1 <= 68) or (71 <= LA54_1 <= 73) or (76 <= LA54_1 <= 78)) : + alt54 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("301:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );", 54, 1, self.input) + + raise nvae + + elif (LA54_0 == 61) : + LA54_2 = self.input.LA(2) + + if (LA54_2 == 62) : + alt54 = 3 + elif (LA54_2 == IDENTIFIER or (29 <= LA54_2 <= 42) or (45 <= LA54_2 <= 46) or (48 <= LA54_2 <= 60) or LA54_2 == 65) : + alt54 = 4 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("301:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );", 54, 2, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("301:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );", 54, 0, self.input) + + raise nvae + + if alt54 == 1: + # C.g:302:4: '[' ']' + self.match(self.input, 63, self.FOLLOW_63_in_abstract_declarator_suffix1095) + if self.failed: + return + self.match(self.input, 64, self.FOLLOW_64_in_abstract_declarator_suffix1097) + if self.failed: + return + + + elif alt54 == 2: + # C.g:303:4: '[' constant_expression ']' + self.match(self.input, 63, self.FOLLOW_63_in_abstract_declarator_suffix1102) + if self.failed: + return + self.following.append(self.FOLLOW_constant_expression_in_abstract_declarator_suffix1104) + self.constant_expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 64, self.FOLLOW_64_in_abstract_declarator_suffix1106) + if self.failed: + return + + + elif alt54 == 3: + # C.g:304:4: '(' ')' + self.match(self.input, 61, self.FOLLOW_61_in_abstract_declarator_suffix1111) + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_abstract_declarator_suffix1113) + if self.failed: + return + + + elif alt54 == 4: + # C.g:305:4: '(' parameter_type_list ')' + self.match(self.input, 61, self.FOLLOW_61_in_abstract_declarator_suffix1118) + if self.failed: + return + self.following.append(self.FOLLOW_parameter_type_list_in_abstract_declarator_suffix1120) + self.parameter_type_list() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_abstract_declarator_suffix1122) + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 33, abstract_declarator_suffix_StartIndex) + + pass + + return + + # $ANTLR end abstract_declarator_suffix + + + # $ANTLR start initializer + # C.g:308:1: initializer : ( assignment_expression | '{' initializer_list ( ',' )? '}' ); + def initializer(self, ): + + initializer_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 34): + return + + # C.g:310:2: ( assignment_expression | '{' initializer_list ( ',' )? '}' ) + alt56 = 2 + LA56_0 = self.input.LA(1) + + if ((IDENTIFIER <= LA56_0 <= FLOATING_POINT_LITERAL) or LA56_0 == 61 or LA56_0 == 65 or (67 <= LA56_0 <= 68) or (71 <= LA56_0 <= 73) or (76 <= LA56_0 <= 78)) : + alt56 = 1 + elif (LA56_0 == 43) : + alt56 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("308:1: initializer : ( assignment_expression | '{' initializer_list ( ',' )? '}' );", 56, 0, self.input) + + raise nvae + + if alt56 == 1: + # C.g:310:4: assignment_expression + self.following.append(self.FOLLOW_assignment_expression_in_initializer1135) + self.assignment_expression() + self.following.pop() + if self.failed: + return + + + elif alt56 == 2: + # C.g:311:4: '{' initializer_list ( ',' )? '}' + self.match(self.input, 43, self.FOLLOW_43_in_initializer1140) + if self.failed: + return + self.following.append(self.FOLLOW_initializer_list_in_initializer1142) + self.initializer_list() + self.following.pop() + if self.failed: + return + # C.g:311:25: ( ',' )? + alt55 = 2 + LA55_0 = self.input.LA(1) + + if (LA55_0 == 27) : + alt55 = 1 + if alt55 == 1: + # C.g:0:0: ',' + self.match(self.input, 27, self.FOLLOW_27_in_initializer1144) + if self.failed: + return + + + + self.match(self.input, 44, self.FOLLOW_44_in_initializer1147) + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 34, initializer_StartIndex) + + pass + + return + + # $ANTLR end initializer + + + # $ANTLR start initializer_list + # C.g:314:1: initializer_list : initializer ( ',' initializer )* ; + def initializer_list(self, ): + + initializer_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 35): + return + + # C.g:315:2: ( initializer ( ',' initializer )* ) + # C.g:315:4: initializer ( ',' initializer )* + self.following.append(self.FOLLOW_initializer_in_initializer_list1158) + self.initializer() + self.following.pop() + if self.failed: + return + # C.g:315:16: ( ',' initializer )* + while True: #loop57 + alt57 = 2 + LA57_0 = self.input.LA(1) + + if (LA57_0 == 27) : + LA57_1 = self.input.LA(2) + + if ((IDENTIFIER <= LA57_1 <= FLOATING_POINT_LITERAL) or LA57_1 == 43 or LA57_1 == 61 or LA57_1 == 65 or (67 <= LA57_1 <= 68) or (71 <= LA57_1 <= 73) or (76 <= LA57_1 <= 78)) : + alt57 = 1 + + + + + if alt57 == 1: + # C.g:315:17: ',' initializer + self.match(self.input, 27, self.FOLLOW_27_in_initializer_list1161) + if self.failed: + return + self.following.append(self.FOLLOW_initializer_in_initializer_list1163) + self.initializer() + self.following.pop() + if self.failed: + return + + + else: + break #loop57 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 35, initializer_list_StartIndex) + + pass + + return + + # $ANTLR end initializer_list + + class argument_expression_list_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start argument_expression_list + # C.g:320:1: argument_expression_list : assignment_expression ( 'OPTIONAL' )? ( ',' assignment_expression ( 'OPTIONAL' )? )* ; + def argument_expression_list(self, ): + + retval = self.argument_expression_list_return() + retval.start = self.input.LT(1) + argument_expression_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 36): + return retval + + # C.g:321:2: ( assignment_expression ( 'OPTIONAL' )? ( ',' assignment_expression ( 'OPTIONAL' )? )* ) + # C.g:321:6: assignment_expression ( 'OPTIONAL' )? ( ',' assignment_expression ( 'OPTIONAL' )? )* + self.following.append(self.FOLLOW_assignment_expression_in_argument_expression_list1181) + self.assignment_expression() + self.following.pop() + if self.failed: + return retval + # C.g:321:28: ( 'OPTIONAL' )? + alt58 = 2 + LA58_0 = self.input.LA(1) + + if (LA58_0 == 53) : + alt58 = 1 + if alt58 == 1: + # C.g:321:29: 'OPTIONAL' + self.match(self.input, 53, self.FOLLOW_53_in_argument_expression_list1184) + if self.failed: + return retval + + + + # C.g:321:42: ( ',' assignment_expression ( 'OPTIONAL' )? )* + while True: #loop60 + alt60 = 2 + LA60_0 = self.input.LA(1) + + if (LA60_0 == 27) : + alt60 = 1 + + + if alt60 == 1: + # C.g:321:43: ',' assignment_expression ( 'OPTIONAL' )? + self.match(self.input, 27, self.FOLLOW_27_in_argument_expression_list1189) + if self.failed: + return retval + self.following.append(self.FOLLOW_assignment_expression_in_argument_expression_list1191) + self.assignment_expression() + self.following.pop() + if self.failed: + return retval + # C.g:321:69: ( 'OPTIONAL' )? + alt59 = 2 + LA59_0 = self.input.LA(1) + + if (LA59_0 == 53) : + alt59 = 1 + if alt59 == 1: + # C.g:321:70: 'OPTIONAL' + self.match(self.input, 53, self.FOLLOW_53_in_argument_expression_list1194) + if self.failed: + return retval + + + + + + else: + break #loop60 + + + + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 36, argument_expression_list_StartIndex) + + pass + + return retval + + # $ANTLR end argument_expression_list + + + # $ANTLR start additive_expression + # C.g:324:1: additive_expression : ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )* ; + def additive_expression(self, ): + + additive_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 37): + return + + # C.g:325:2: ( ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )* ) + # C.g:325:4: ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )* + # C.g:325:4: ( multiplicative_expression ) + # C.g:325:5: multiplicative_expression + self.following.append(self.FOLLOW_multiplicative_expression_in_additive_expression1210) + self.multiplicative_expression() + self.following.pop() + if self.failed: + return + + + + # C.g:325:32: ( '+' multiplicative_expression | '-' multiplicative_expression )* + while True: #loop61 + alt61 = 3 + LA61_0 = self.input.LA(1) + + if (LA61_0 == 67) : + alt61 = 1 + elif (LA61_0 == 68) : + alt61 = 2 + + + if alt61 == 1: + # C.g:325:33: '+' multiplicative_expression + self.match(self.input, 67, self.FOLLOW_67_in_additive_expression1214) + if self.failed: + return + self.following.append(self.FOLLOW_multiplicative_expression_in_additive_expression1216) + self.multiplicative_expression() + self.following.pop() + if self.failed: + return + + + elif alt61 == 2: + # C.g:325:65: '-' multiplicative_expression + self.match(self.input, 68, self.FOLLOW_68_in_additive_expression1220) + if self.failed: + return + self.following.append(self.FOLLOW_multiplicative_expression_in_additive_expression1222) + self.multiplicative_expression() + self.following.pop() + if self.failed: + return + + + else: + break #loop61 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 37, additive_expression_StartIndex) + + pass + + return + + # $ANTLR end additive_expression + + + # $ANTLR start multiplicative_expression + # C.g:328:1: multiplicative_expression : ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* ; + def multiplicative_expression(self, ): + + multiplicative_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 38): + return + + # C.g:329:2: ( ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* ) + # C.g:329:4: ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* + # C.g:329:4: ( cast_expression ) + # C.g:329:5: cast_expression + self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1236) + self.cast_expression() + self.following.pop() + if self.failed: + return + + + + # C.g:329:22: ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* + while True: #loop62 + alt62 = 4 + LA62 = self.input.LA(1) + if LA62 == 65: + alt62 = 1 + elif LA62 == 69: + alt62 = 2 + elif LA62 == 70: + alt62 = 3 + + if alt62 == 1: + # C.g:329:23: '*' cast_expression + self.match(self.input, 65, self.FOLLOW_65_in_multiplicative_expression1240) + if self.failed: + return + self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1242) + self.cast_expression() + self.following.pop() + if self.failed: + return + + + elif alt62 == 2: + # C.g:329:45: '/' cast_expression + self.match(self.input, 69, self.FOLLOW_69_in_multiplicative_expression1246) + if self.failed: + return + self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1248) + self.cast_expression() + self.following.pop() + if self.failed: + return + + + elif alt62 == 3: + # C.g:329:67: '%' cast_expression + self.match(self.input, 70, self.FOLLOW_70_in_multiplicative_expression1252) + if self.failed: + return + self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1254) + self.cast_expression() + self.following.pop() + if self.failed: + return + + + else: + break #loop62 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 38, multiplicative_expression_StartIndex) + + pass + + return + + # $ANTLR end multiplicative_expression + + + # $ANTLR start cast_expression + # C.g:332:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression ); + def cast_expression(self, ): + + cast_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 39): + return + + # C.g:333:2: ( '(' type_name ')' cast_expression | unary_expression ) + alt63 = 2 + LA63_0 = self.input.LA(1) + + if (LA63_0 == 61) : + LA63 = self.input.LA(2) + if LA63 == IDENTIFIER: + LA63_13 = self.input.LA(3) + + if (self.synpred108()) : + alt63 = 1 + elif (True) : + alt63 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("332:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );", 63, 13, self.input) + + raise nvae + + elif LA63 == HEX_LITERAL or LA63 == OCTAL_LITERAL or LA63 == DECIMAL_LITERAL or LA63 == CHARACTER_LITERAL or LA63 == STRING_LITERAL or LA63 == FLOATING_POINT_LITERAL or LA63 == 61 or LA63 == 65 or LA63 == 67 or LA63 == 68 or LA63 == 71 or LA63 == 72 or LA63 == 73 or LA63 == 76 or LA63 == 77 or LA63 == 78: + alt63 = 2 + elif LA63 == 34 or LA63 == 35 or LA63 == 36 or LA63 == 37 or LA63 == 38 or LA63 == 39 or LA63 == 40 or LA63 == 41 or LA63 == 42 or LA63 == 45 or LA63 == 46 or LA63 == 48 or LA63 == 49 or LA63 == 50 or LA63 == 51 or LA63 == 52 or LA63 == 53 or LA63 == 54 or LA63 == 55 or LA63 == 56 or LA63 == 57 or LA63 == 58 or LA63 == 59 or LA63 == 60: + alt63 = 1 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("332:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );", 63, 1, self.input) + + raise nvae + + elif ((IDENTIFIER <= LA63_0 <= FLOATING_POINT_LITERAL) or LA63_0 == 65 or (67 <= LA63_0 <= 68) or (71 <= LA63_0 <= 73) or (76 <= LA63_0 <= 78)) : + alt63 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("332:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );", 63, 0, self.input) + + raise nvae + + if alt63 == 1: + # C.g:333:4: '(' type_name ')' cast_expression + self.match(self.input, 61, self.FOLLOW_61_in_cast_expression1267) + if self.failed: + return + self.following.append(self.FOLLOW_type_name_in_cast_expression1269) + self.type_name() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_cast_expression1271) + if self.failed: + return + self.following.append(self.FOLLOW_cast_expression_in_cast_expression1273) + self.cast_expression() + self.following.pop() + if self.failed: + return + + + elif alt63 == 2: + # C.g:334:4: unary_expression + self.following.append(self.FOLLOW_unary_expression_in_cast_expression1278) + self.unary_expression() + self.following.pop() + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 39, cast_expression_StartIndex) + + pass + + return + + # $ANTLR end cast_expression + + + # $ANTLR start unary_expression + # C.g:337:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' ); + def unary_expression(self, ): + + unary_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 40): + return + + # C.g:338:2: ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' ) + alt64 = 6 + LA64 = self.input.LA(1) + if LA64 == IDENTIFIER or LA64 == HEX_LITERAL or LA64 == OCTAL_LITERAL or LA64 == DECIMAL_LITERAL or LA64 == CHARACTER_LITERAL or LA64 == STRING_LITERAL or LA64 == FLOATING_POINT_LITERAL or LA64 == 61: + alt64 = 1 + elif LA64 == 71: + alt64 = 2 + elif LA64 == 72: + alt64 = 3 + elif LA64 == 65 or LA64 == 67 or LA64 == 68 or LA64 == 76 or LA64 == 77 or LA64 == 78: + alt64 = 4 + elif LA64 == 73: + LA64_12 = self.input.LA(2) + + if (LA64_12 == 61) : + LA64_13 = self.input.LA(3) + + if (self.synpred113()) : + alt64 = 5 + elif (True) : + alt64 = 6 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("337:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );", 64, 13, self.input) + + raise nvae + + elif ((IDENTIFIER <= LA64_12 <= FLOATING_POINT_LITERAL) or LA64_12 == 65 or (67 <= LA64_12 <= 68) or (71 <= LA64_12 <= 73) or (76 <= LA64_12 <= 78)) : + alt64 = 5 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("337:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );", 64, 12, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("337:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );", 64, 0, self.input) + + raise nvae + + if alt64 == 1: + # C.g:338:4: postfix_expression + self.following.append(self.FOLLOW_postfix_expression_in_unary_expression1289) + self.postfix_expression() + self.following.pop() + if self.failed: + return + + + elif alt64 == 2: + # C.g:339:4: '++' unary_expression + self.match(self.input, 71, self.FOLLOW_71_in_unary_expression1294) + if self.failed: + return + self.following.append(self.FOLLOW_unary_expression_in_unary_expression1296) + self.unary_expression() + self.following.pop() + if self.failed: + return + + + elif alt64 == 3: + # C.g:340:4: '--' unary_expression + self.match(self.input, 72, self.FOLLOW_72_in_unary_expression1301) + if self.failed: + return + self.following.append(self.FOLLOW_unary_expression_in_unary_expression1303) + self.unary_expression() + self.following.pop() + if self.failed: + return + + + elif alt64 == 4: + # C.g:341:4: unary_operator cast_expression + self.following.append(self.FOLLOW_unary_operator_in_unary_expression1308) + self.unary_operator() + self.following.pop() + if self.failed: + return + self.following.append(self.FOLLOW_cast_expression_in_unary_expression1310) + self.cast_expression() + self.following.pop() + if self.failed: + return + + + elif alt64 == 5: + # C.g:342:4: 'sizeof' unary_expression + self.match(self.input, 73, self.FOLLOW_73_in_unary_expression1315) + if self.failed: + return + self.following.append(self.FOLLOW_unary_expression_in_unary_expression1317) + self.unary_expression() + self.following.pop() + if self.failed: + return + + + elif alt64 == 6: + # C.g:343:4: 'sizeof' '(' type_name ')' + self.match(self.input, 73, self.FOLLOW_73_in_unary_expression1322) + if self.failed: + return + self.match(self.input, 61, self.FOLLOW_61_in_unary_expression1324) + if self.failed: + return + self.following.append(self.FOLLOW_type_name_in_unary_expression1326) + self.type_name() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_unary_expression1328) + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 40, unary_expression_StartIndex) + + pass + + return + + # $ANTLR end unary_expression + + + # $ANTLR start postfix_expression + # C.g:346:1: postfix_expression : p= primary_expression ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '(' macro_parameter_list ')' | '.' x= IDENTIFIER | '*' y= IDENTIFIER | '->' z= IDENTIFIER | '++' | '--' )* ; + def postfix_expression(self, ): + self.postfix_expression_stack.append(postfix_expression_scope()) + postfix_expression_StartIndex = self.input.index() + a = None + b = None + x = None + y = None + z = None + p = None + + c = None + + + + self.postfix_expression_stack[-1].FuncCallText = '' + + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 41): + return + + # C.g:353:2: (p= primary_expression ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '(' macro_parameter_list ')' | '.' x= IDENTIFIER | '*' y= IDENTIFIER | '->' z= IDENTIFIER | '++' | '--' )* ) + # C.g:353:6: p= primary_expression ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '(' macro_parameter_list ')' | '.' x= IDENTIFIER | '*' y= IDENTIFIER | '->' z= IDENTIFIER | '++' | '--' )* + self.following.append(self.FOLLOW_primary_expression_in_postfix_expression1352) + p = self.primary_expression() + self.following.pop() + if self.failed: + return + if self.backtracking == 0: + self.postfix_expression_stack[-1].FuncCallText += self.input.toString(p.start,p.stop) + + # C.g:354:9: ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '(' macro_parameter_list ')' | '.' x= IDENTIFIER | '*' y= IDENTIFIER | '->' z= IDENTIFIER | '++' | '--' )* + while True: #loop65 + alt65 = 10 + LA65 = self.input.LA(1) + if LA65 == 65: + LA65_1 = self.input.LA(2) + + if (LA65_1 == IDENTIFIER) : + LA65_30 = self.input.LA(3) + + if (self.synpred119()) : + alt65 = 6 + + + + + elif LA65 == 63: + alt65 = 1 + elif LA65 == 61: + LA65 = self.input.LA(2) + if LA65 == 62: + alt65 = 2 + elif LA65 == IDENTIFIER: + LA65_43 = self.input.LA(3) + + if (self.synpred116()) : + alt65 = 3 + elif (self.synpred117()) : + alt65 = 4 + + + elif LA65 == HEX_LITERAL or LA65 == OCTAL_LITERAL or LA65 == DECIMAL_LITERAL or LA65 == CHARACTER_LITERAL or LA65 == STRING_LITERAL or LA65 == FLOATING_POINT_LITERAL or LA65 == 61 or LA65 == 67 or LA65 == 68 or LA65 == 71 or LA65 == 72 or LA65 == 73 or LA65 == 76 or LA65 == 77 or LA65 == 78: + alt65 = 3 + elif LA65 == 65: + LA65_53 = self.input.LA(3) + + if (self.synpred116()) : + alt65 = 3 + elif (self.synpred117()) : + alt65 = 4 + + + elif LA65 == 29 or LA65 == 30 or LA65 == 31 or LA65 == 32 or LA65 == 33 or LA65 == 34 or LA65 == 35 or LA65 == 36 or LA65 == 37 or LA65 == 38 or LA65 == 39 or LA65 == 40 or LA65 == 41 or LA65 == 42 or LA65 == 45 or LA65 == 46 or LA65 == 48 or LA65 == 49 or LA65 == 50 or LA65 == 51 or LA65 == 52 or LA65 == 53 or LA65 == 54 or LA65 == 55 or LA65 == 56 or LA65 == 57 or LA65 == 58 or LA65 == 59 or LA65 == 60: + alt65 = 4 + + elif LA65 == 74: + alt65 = 5 + elif LA65 == 75: + alt65 = 7 + elif LA65 == 71: + alt65 = 8 + elif LA65 == 72: + alt65 = 9 + + if alt65 == 1: + # C.g:354:13: '[' expression ']' + self.match(self.input, 63, self.FOLLOW_63_in_postfix_expression1368) + if self.failed: + return + self.following.append(self.FOLLOW_expression_in_postfix_expression1370) + self.expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 64, self.FOLLOW_64_in_postfix_expression1372) + if self.failed: + return + + + elif alt65 == 2: + # C.g:355:13: '(' a= ')' + self.match(self.input, 61, self.FOLLOW_61_in_postfix_expression1386) + if self.failed: + return + a = self.input.LT(1) + self.match(self.input, 62, self.FOLLOW_62_in_postfix_expression1390) + if self.failed: + return + if self.backtracking == 0: + self.StoreFunctionCalling(p.start.line, p.start.charPositionInLine, a.line, a.charPositionInLine, self.postfix_expression_stack[-1].FuncCallText, '') + + + + elif alt65 == 3: + # C.g:356:13: '(' c= argument_expression_list b= ')' + self.match(self.input, 61, self.FOLLOW_61_in_postfix_expression1405) + if self.failed: + return + self.following.append(self.FOLLOW_argument_expression_list_in_postfix_expression1409) + c = self.argument_expression_list() + self.following.pop() + if self.failed: + return + b = self.input.LT(1) + self.match(self.input, 62, self.FOLLOW_62_in_postfix_expression1413) + if self.failed: + return + if self.backtracking == 0: + self.StoreFunctionCalling(p.start.line, p.start.charPositionInLine, b.line, b.charPositionInLine, self.postfix_expression_stack[-1].FuncCallText, self.input.toString(c.start,c.stop)) + + + + elif alt65 == 4: + # C.g:357:13: '(' macro_parameter_list ')' + self.match(self.input, 61, self.FOLLOW_61_in_postfix_expression1429) + if self.failed: + return + self.following.append(self.FOLLOW_macro_parameter_list_in_postfix_expression1431) + self.macro_parameter_list() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_postfix_expression1433) + if self.failed: + return + + + elif alt65 == 5: + # C.g:358:13: '.' x= IDENTIFIER + self.match(self.input, 74, self.FOLLOW_74_in_postfix_expression1447) + if self.failed: + return + x = self.input.LT(1) + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_postfix_expression1451) + if self.failed: + return + if self.backtracking == 0: + self.postfix_expression_stack[-1].FuncCallText += '.' + x.text + + + + elif alt65 == 6: + # C.g:359:13: '*' y= IDENTIFIER + self.match(self.input, 65, self.FOLLOW_65_in_postfix_expression1467) + if self.failed: + return + y = self.input.LT(1) + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_postfix_expression1471) + if self.failed: + return + if self.backtracking == 0: + self.postfix_expression_stack[-1].FuncCallText = y.text + + + + elif alt65 == 7: + # C.g:360:13: '->' z= IDENTIFIER + self.match(self.input, 75, self.FOLLOW_75_in_postfix_expression1487) + if self.failed: + return + z = self.input.LT(1) + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_postfix_expression1491) + if self.failed: + return + if self.backtracking == 0: + self.postfix_expression_stack[-1].FuncCallText += '->' + z.text + + + + elif alt65 == 8: + # C.g:361:13: '++' + self.match(self.input, 71, self.FOLLOW_71_in_postfix_expression1507) + if self.failed: + return + + + elif alt65 == 9: + # C.g:362:13: '--' + self.match(self.input, 72, self.FOLLOW_72_in_postfix_expression1521) + if self.failed: + return + + + else: + break #loop65 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 41, postfix_expression_StartIndex) + + self.postfix_expression_stack.pop() + pass + + return + + # $ANTLR end postfix_expression + + + # $ANTLR start macro_parameter_list + # C.g:366:1: macro_parameter_list : parameter_declaration ( ',' parameter_declaration )* ; + def macro_parameter_list(self, ): + + macro_parameter_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 42): + return + + # C.g:367:2: ( parameter_declaration ( ',' parameter_declaration )* ) + # C.g:367:4: parameter_declaration ( ',' parameter_declaration )* + self.following.append(self.FOLLOW_parameter_declaration_in_macro_parameter_list1544) + self.parameter_declaration() + self.following.pop() + if self.failed: + return + # C.g:367:26: ( ',' parameter_declaration )* + while True: #loop66 + alt66 = 2 + LA66_0 = self.input.LA(1) + + if (LA66_0 == 27) : + alt66 = 1 + + + if alt66 == 1: + # C.g:367:27: ',' parameter_declaration + self.match(self.input, 27, self.FOLLOW_27_in_macro_parameter_list1547) + if self.failed: + return + self.following.append(self.FOLLOW_parameter_declaration_in_macro_parameter_list1549) + self.parameter_declaration() + self.following.pop() + if self.failed: + return + + + else: + break #loop66 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 42, macro_parameter_list_StartIndex) + + pass + + return + + # $ANTLR end macro_parameter_list + + + # $ANTLR start unary_operator + # C.g:370:1: unary_operator : ( '&' | '*' | '+' | '-' | '~' | '!' ); + def unary_operator(self, ): + + unary_operator_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 43): + return + + # C.g:371:2: ( '&' | '*' | '+' | '-' | '~' | '!' ) + # C.g: + if self.input.LA(1) == 65 or (67 <= self.input.LA(1) <= 68) or (76 <= self.input.LA(1) <= 78): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_unary_operator0 + ) + raise mse + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 43, unary_operator_StartIndex) + + pass + + return + + # $ANTLR end unary_operator + + class primary_expression_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start primary_expression + # C.g:379:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' ); + def primary_expression(self, ): + + retval = self.primary_expression_return() + retval.start = self.input.LT(1) + primary_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 44): + return retval + + # C.g:380:2: ( IDENTIFIER | constant | '(' expression ')' ) + alt67 = 3 + LA67 = self.input.LA(1) + if LA67 == IDENTIFIER: + LA67_1 = self.input.LA(2) + + if (LA67_1 == IDENTIFIER or LA67_1 == STRING_LITERAL) : + alt67 = 2 + elif (LA67_1 == EOF or LA67_1 == 25 or (27 <= LA67_1 <= 28) or LA67_1 == 44 or LA67_1 == 47 or LA67_1 == 53 or (61 <= LA67_1 <= 65) or (67 <= LA67_1 <= 72) or (74 <= LA67_1 <= 76) or (79 <= LA67_1 <= 101)) : + alt67 = 1 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("379:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' );", 67, 1, self.input) + + raise nvae + + elif LA67 == HEX_LITERAL or LA67 == OCTAL_LITERAL or LA67 == DECIMAL_LITERAL or LA67 == CHARACTER_LITERAL or LA67 == STRING_LITERAL or LA67 == FLOATING_POINT_LITERAL: + alt67 = 2 + elif LA67 == 61: + alt67 = 3 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("379:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' );", 67, 0, self.input) + + raise nvae + + if alt67 == 1: + # C.g:380:4: IDENTIFIER + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_primary_expression1598) + if self.failed: + return retval + + + elif alt67 == 2: + # C.g:381:4: constant + self.following.append(self.FOLLOW_constant_in_primary_expression1603) + self.constant() + self.following.pop() + if self.failed: + return retval + + + elif alt67 == 3: + # C.g:382:4: '(' expression ')' + self.match(self.input, 61, self.FOLLOW_61_in_primary_expression1608) + if self.failed: + return retval + self.following.append(self.FOLLOW_expression_in_primary_expression1610) + self.expression() + self.following.pop() + if self.failed: + return retval + self.match(self.input, 62, self.FOLLOW_62_in_primary_expression1612) + if self.failed: + return retval + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 44, primary_expression_StartIndex) + + pass + + return retval + + # $ANTLR end primary_expression + + + # $ANTLR start constant + # C.g:385:1: constant : ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | CHARACTER_LITERAL | ( ( IDENTIFIER )* ( STRING_LITERAL )+ )+ ( IDENTIFIER )* | FLOATING_POINT_LITERAL ); + def constant(self, ): + + constant_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 45): + return + + # C.g:386:5: ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | CHARACTER_LITERAL | ( ( IDENTIFIER )* ( STRING_LITERAL )+ )+ ( IDENTIFIER )* | FLOATING_POINT_LITERAL ) + alt72 = 6 + LA72 = self.input.LA(1) + if LA72 == HEX_LITERAL: + alt72 = 1 + elif LA72 == OCTAL_LITERAL: + alt72 = 2 + elif LA72 == DECIMAL_LITERAL: + alt72 = 3 + elif LA72 == CHARACTER_LITERAL: + alt72 = 4 + elif LA72 == IDENTIFIER or LA72 == STRING_LITERAL: + alt72 = 5 + elif LA72 == FLOATING_POINT_LITERAL: + alt72 = 6 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("385:1: constant : ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | CHARACTER_LITERAL | ( ( IDENTIFIER )* ( STRING_LITERAL )+ )+ ( IDENTIFIER )* | FLOATING_POINT_LITERAL );", 72, 0, self.input) + + raise nvae + + if alt72 == 1: + # C.g:386:9: HEX_LITERAL + self.match(self.input, HEX_LITERAL, self.FOLLOW_HEX_LITERAL_in_constant1628) + if self.failed: + return + + + elif alt72 == 2: + # C.g:387:9: OCTAL_LITERAL + self.match(self.input, OCTAL_LITERAL, self.FOLLOW_OCTAL_LITERAL_in_constant1638) + if self.failed: + return + + + elif alt72 == 3: + # C.g:388:9: DECIMAL_LITERAL + self.match(self.input, DECIMAL_LITERAL, self.FOLLOW_DECIMAL_LITERAL_in_constant1648) + if self.failed: + return + + + elif alt72 == 4: + # C.g:389:7: CHARACTER_LITERAL + self.match(self.input, CHARACTER_LITERAL, self.FOLLOW_CHARACTER_LITERAL_in_constant1656) + if self.failed: + return + + + elif alt72 == 5: + # C.g:390:7: ( ( IDENTIFIER )* ( STRING_LITERAL )+ )+ ( IDENTIFIER )* + # C.g:390:7: ( ( IDENTIFIER )* ( STRING_LITERAL )+ )+ + cnt70 = 0 + while True: #loop70 + alt70 = 2 + LA70_0 = self.input.LA(1) + + if (LA70_0 == IDENTIFIER) : + LA70_1 = self.input.LA(2) + + if (LA70_1 == IDENTIFIER) : + LA70_61 = self.input.LA(3) + + if (self.synpred137()) : + alt70 = 1 + + + elif (LA70_1 == STRING_LITERAL) : + alt70 = 1 + + + elif (LA70_0 == STRING_LITERAL) : + alt70 = 1 + + + if alt70 == 1: + # C.g:390:8: ( IDENTIFIER )* ( STRING_LITERAL )+ + # C.g:390:8: ( IDENTIFIER )* + while True: #loop68 + alt68 = 2 + LA68_0 = self.input.LA(1) + + if (LA68_0 == IDENTIFIER) : + alt68 = 1 + + + if alt68 == 1: + # C.g:0:0: IDENTIFIER + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_constant1665) + if self.failed: + return + + + else: + break #loop68 + + + # C.g:390:20: ( STRING_LITERAL )+ + cnt69 = 0 + while True: #loop69 + alt69 = 2 + LA69_0 = self.input.LA(1) + + if (LA69_0 == STRING_LITERAL) : + LA69_31 = self.input.LA(2) + + if (self.synpred136()) : + alt69 = 1 + + + + + if alt69 == 1: + # C.g:0:0: STRING_LITERAL + self.match(self.input, STRING_LITERAL, self.FOLLOW_STRING_LITERAL_in_constant1668) + if self.failed: + return + + + else: + if cnt69 >= 1: + break #loop69 + + if self.backtracking > 0: + self.failed = True + return + + eee = EarlyExitException(69, self.input) + raise eee + + cnt69 += 1 + + + + + else: + if cnt70 >= 1: + break #loop70 + + if self.backtracking > 0: + self.failed = True + return + + eee = EarlyExitException(70, self.input) + raise eee + + cnt70 += 1 + + + # C.g:390:38: ( IDENTIFIER )* + while True: #loop71 + alt71 = 2 + LA71_0 = self.input.LA(1) + + if (LA71_0 == IDENTIFIER) : + alt71 = 1 + + + if alt71 == 1: + # C.g:0:0: IDENTIFIER + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_constant1673) + if self.failed: + return + + + else: + break #loop71 + + + + + elif alt72 == 6: + # C.g:391:9: FLOATING_POINT_LITERAL + self.match(self.input, FLOATING_POINT_LITERAL, self.FOLLOW_FLOATING_POINT_LITERAL_in_constant1684) + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 45, constant_StartIndex) + + pass + + return + + # $ANTLR end constant + + class expression_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start expression + # C.g:396:1: expression : assignment_expression ( ',' assignment_expression )* ; + def expression(self, ): + + retval = self.expression_return() + retval.start = self.input.LT(1) + expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 46): + return retval + + # C.g:397:2: ( assignment_expression ( ',' assignment_expression )* ) + # C.g:397:4: assignment_expression ( ',' assignment_expression )* + self.following.append(self.FOLLOW_assignment_expression_in_expression1700) + self.assignment_expression() + self.following.pop() + if self.failed: + return retval + # C.g:397:26: ( ',' assignment_expression )* + while True: #loop73 + alt73 = 2 + LA73_0 = self.input.LA(1) + + if (LA73_0 == 27) : + alt73 = 1 + + + if alt73 == 1: + # C.g:397:27: ',' assignment_expression + self.match(self.input, 27, self.FOLLOW_27_in_expression1703) + if self.failed: + return retval + self.following.append(self.FOLLOW_assignment_expression_in_expression1705) + self.assignment_expression() + self.following.pop() + if self.failed: + return retval + + + else: + break #loop73 + + + + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 46, expression_StartIndex) + + pass + + return retval + + # $ANTLR end expression + + + # $ANTLR start constant_expression + # C.g:400:1: constant_expression : conditional_expression ; + def constant_expression(self, ): + + constant_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 47): + return + + # C.g:401:2: ( conditional_expression ) + # C.g:401:4: conditional_expression + self.following.append(self.FOLLOW_conditional_expression_in_constant_expression1718) + self.conditional_expression() + self.following.pop() + if self.failed: + return + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 47, constant_expression_StartIndex) + + pass + + return + + # $ANTLR end constant_expression + + + # $ANTLR start assignment_expression + # C.g:404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression ); + def assignment_expression(self, ): + + assignment_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 48): + return + + # C.g:405:2: ( lvalue assignment_operator assignment_expression | conditional_expression ) + alt74 = 2 + LA74 = self.input.LA(1) + if LA74 == IDENTIFIER: + LA74 = self.input.LA(2) + if LA74 == STRING_LITERAL: + LA74_13 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 13, self.input) + + raise nvae + + elif LA74 == IDENTIFIER: + LA74_14 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 14, self.input) + + raise nvae + + elif LA74 == 63: + LA74_15 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 15, self.input) + + raise nvae + + elif LA74 == 61: + LA74_16 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 16, self.input) + + raise nvae + + elif LA74 == 74: + LA74_17 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 17, self.input) + + raise nvae + + elif LA74 == 65: + LA74_18 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 18, self.input) + + raise nvae + + elif LA74 == 75: + LA74_19 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 19, self.input) + + raise nvae + + elif LA74 == 71: + LA74_20 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 20, self.input) + + raise nvae + + elif LA74 == 72: + LA74_21 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 21, self.input) + + raise nvae + + elif LA74 == EOF or LA74 == 25 or LA74 == 27 or LA74 == 44 or LA74 == 47 or LA74 == 53 or LA74 == 62 or LA74 == 64 or LA74 == 67 or LA74 == 68 or LA74 == 69 or LA74 == 70 or LA74 == 76 or LA74 == 89 or LA74 == 90 or LA74 == 91 or LA74 == 92 or LA74 == 93 or LA74 == 94 or LA74 == 95 or LA74 == 96 or LA74 == 97 or LA74 == 98 or LA74 == 99 or LA74 == 100 or LA74 == 101: + alt74 = 2 + elif LA74 == 28 or LA74 == 79 or LA74 == 80 or LA74 == 81 or LA74 == 82 or LA74 == 83 or LA74 == 84 or LA74 == 85 or LA74 == 86 or LA74 == 87 or LA74 == 88: + alt74 = 1 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 1, self.input) + + raise nvae + + elif LA74 == HEX_LITERAL: + LA74 = self.input.LA(2) + if LA74 == 63: + LA74_44 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 44, self.input) + + raise nvae + + elif LA74 == 61: + LA74_45 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 45, self.input) + + raise nvae + + elif LA74 == 74: + LA74_46 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 46, self.input) + + raise nvae + + elif LA74 == 65: + LA74_47 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 47, self.input) + + raise nvae + + elif LA74 == 75: + LA74_48 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 48, self.input) + + raise nvae + + elif LA74 == 71: + LA74_49 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 49, self.input) + + raise nvae + + elif LA74 == 72: + LA74_50 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 50, self.input) + + raise nvae + + elif LA74 == 28 or LA74 == 79 or LA74 == 80 or LA74 == 81 or LA74 == 82 or LA74 == 83 or LA74 == 84 or LA74 == 85 or LA74 == 86 or LA74 == 87 or LA74 == 88: + alt74 = 1 + elif LA74 == EOF or LA74 == 25 or LA74 == 27 or LA74 == 44 or LA74 == 47 or LA74 == 53 or LA74 == 62 or LA74 == 64 or LA74 == 67 or LA74 == 68 or LA74 == 69 or LA74 == 70 or LA74 == 76 or LA74 == 89 or LA74 == 90 or LA74 == 91 or LA74 == 92 or LA74 == 93 or LA74 == 94 or LA74 == 95 or LA74 == 96 or LA74 == 97 or LA74 == 98 or LA74 == 99 or LA74 == 100 or LA74 == 101: + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 2, self.input) + + raise nvae + + elif LA74 == OCTAL_LITERAL: + LA74 = self.input.LA(2) + if LA74 == 63: + LA74_73 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 73, self.input) + + raise nvae + + elif LA74 == 61: + LA74_74 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 74, self.input) + + raise nvae + + elif LA74 == 74: + LA74_75 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 75, self.input) + + raise nvae + + elif LA74 == 65: + LA74_76 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 76, self.input) + + raise nvae + + elif LA74 == 75: + LA74_77 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 77, self.input) + + raise nvae + + elif LA74 == 71: + LA74_78 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 78, self.input) + + raise nvae + + elif LA74 == 72: + LA74_79 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 79, self.input) + + raise nvae + + elif LA74 == 28 or LA74 == 79 or LA74 == 80 or LA74 == 81 or LA74 == 82 or LA74 == 83 or LA74 == 84 or LA74 == 85 or LA74 == 86 or LA74 == 87 or LA74 == 88: + alt74 = 1 + elif LA74 == EOF or LA74 == 25 or LA74 == 27 or LA74 == 44 or LA74 == 47 or LA74 == 53 or LA74 == 62 or LA74 == 64 or LA74 == 67 or LA74 == 68 or LA74 == 69 or LA74 == 70 or LA74 == 76 or LA74 == 89 or LA74 == 90 or LA74 == 91 or LA74 == 92 or LA74 == 93 or LA74 == 94 or LA74 == 95 or LA74 == 96 or LA74 == 97 or LA74 == 98 or LA74 == 99 or LA74 == 100 or LA74 == 101: + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 3, self.input) + + raise nvae + + elif LA74 == DECIMAL_LITERAL: + LA74 = self.input.LA(2) + if LA74 == 63: + LA74_102 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 102, self.input) + + raise nvae + + elif LA74 == 61: + LA74_103 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 103, self.input) + + raise nvae + + elif LA74 == 74: + LA74_104 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 104, self.input) + + raise nvae + + elif LA74 == 65: + LA74_105 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 105, self.input) + + raise nvae + + elif LA74 == 75: + LA74_106 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 106, self.input) + + raise nvae + + elif LA74 == 71: + LA74_107 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 107, self.input) + + raise nvae + + elif LA74 == 72: + LA74_108 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 108, self.input) + + raise nvae + + elif LA74 == EOF or LA74 == 25 or LA74 == 27 or LA74 == 44 or LA74 == 47 or LA74 == 53 or LA74 == 62 or LA74 == 64 or LA74 == 67 or LA74 == 68 or LA74 == 69 or LA74 == 70 or LA74 == 76 or LA74 == 89 or LA74 == 90 or LA74 == 91 or LA74 == 92 or LA74 == 93 or LA74 == 94 or LA74 == 95 or LA74 == 96 or LA74 == 97 or LA74 == 98 or LA74 == 99 or LA74 == 100 or LA74 == 101: + alt74 = 2 + elif LA74 == 28 or LA74 == 79 or LA74 == 80 or LA74 == 81 or LA74 == 82 or LA74 == 83 or LA74 == 84 or LA74 == 85 or LA74 == 86 or LA74 == 87 or LA74 == 88: + alt74 = 1 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 4, self.input) + + raise nvae + + elif LA74 == CHARACTER_LITERAL: + LA74 = self.input.LA(2) + if LA74 == 63: + LA74_131 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 131, self.input) + + raise nvae + + elif LA74 == 61: + LA74_132 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 132, self.input) + + raise nvae + + elif LA74 == 74: + LA74_133 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 133, self.input) + + raise nvae + + elif LA74 == 65: + LA74_134 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 134, self.input) + + raise nvae + + elif LA74 == 75: + LA74_135 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 135, self.input) + + raise nvae + + elif LA74 == 71: + LA74_136 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 136, self.input) + + raise nvae + + elif LA74 == 72: + LA74_137 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 137, self.input) + + raise nvae + + elif LA74 == 28 or LA74 == 79 or LA74 == 80 or LA74 == 81 or LA74 == 82 or LA74 == 83 or LA74 == 84 or LA74 == 85 or LA74 == 86 or LA74 == 87 or LA74 == 88: + alt74 = 1 + elif LA74 == EOF or LA74 == 25 or LA74 == 27 or LA74 == 44 or LA74 == 47 or LA74 == 53 or LA74 == 62 or LA74 == 64 or LA74 == 67 or LA74 == 68 or LA74 == 69 or LA74 == 70 or LA74 == 76 or LA74 == 89 or LA74 == 90 or LA74 == 91 or LA74 == 92 or LA74 == 93 or LA74 == 94 or LA74 == 95 or LA74 == 96 or LA74 == 97 or LA74 == 98 or LA74 == 99 or LA74 == 100 or LA74 == 101: + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 5, self.input) + + raise nvae + + elif LA74 == STRING_LITERAL: + LA74 = self.input.LA(2) + if LA74 == IDENTIFIER: + LA74_160 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 160, self.input) + + raise nvae + + elif LA74 == 63: + LA74_161 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 161, self.input) + + raise nvae + + elif LA74 == 61: + LA74_162 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 162, self.input) + + raise nvae + + elif LA74 == 74: + LA74_163 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 163, self.input) + + raise nvae + + elif LA74 == 65: + LA74_164 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 164, self.input) + + raise nvae + + elif LA74 == 75: + LA74_165 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 165, self.input) + + raise nvae + + elif LA74 == 71: + LA74_166 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 166, self.input) + + raise nvae + + elif LA74 == 72: + LA74_167 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 167, self.input) + + raise nvae + + elif LA74 == 28 or LA74 == 79 or LA74 == 80 or LA74 == 81 or LA74 == 82 or LA74 == 83 or LA74 == 84 or LA74 == 85 or LA74 == 86 or LA74 == 87 or LA74 == 88: + alt74 = 1 + elif LA74 == STRING_LITERAL: + LA74_169 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 169, self.input) + + raise nvae + + elif LA74 == EOF or LA74 == 25 or LA74 == 27 or LA74 == 44 or LA74 == 47 or LA74 == 53 or LA74 == 62 or LA74 == 64 or LA74 == 67 or LA74 == 68 or LA74 == 69 or LA74 == 70 or LA74 == 76 or LA74 == 89 or LA74 == 90 or LA74 == 91 or LA74 == 92 or LA74 == 93 or LA74 == 94 or LA74 == 95 or LA74 == 96 or LA74 == 97 or LA74 == 98 or LA74 == 99 or LA74 == 100 or LA74 == 101: + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 6, self.input) + + raise nvae + + elif LA74 == FLOATING_POINT_LITERAL: + LA74 = self.input.LA(2) + if LA74 == 63: + LA74_191 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 191, self.input) + + raise nvae + + elif LA74 == 61: + LA74_192 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 192, self.input) + + raise nvae + + elif LA74 == 74: + LA74_193 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 193, self.input) + + raise nvae + + elif LA74 == 65: + LA74_194 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 194, self.input) + + raise nvae + + elif LA74 == 75: + LA74_195 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 195, self.input) + + raise nvae + + elif LA74 == 71: + LA74_196 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 196, self.input) + + raise nvae + + elif LA74 == 72: + LA74_197 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 197, self.input) + + raise nvae + + elif LA74 == EOF or LA74 == 25 or LA74 == 27 or LA74 == 44 or LA74 == 47 or LA74 == 53 or LA74 == 62 or LA74 == 64 or LA74 == 67 or LA74 == 68 or LA74 == 69 or LA74 == 70 or LA74 == 76 or LA74 == 89 or LA74 == 90 or LA74 == 91 or LA74 == 92 or LA74 == 93 or LA74 == 94 or LA74 == 95 or LA74 == 96 or LA74 == 97 or LA74 == 98 or LA74 == 99 or LA74 == 100 or LA74 == 101: + alt74 = 2 + elif LA74 == 28 or LA74 == 79 or LA74 == 80 or LA74 == 81 or LA74 == 82 or LA74 == 83 or LA74 == 84 or LA74 == 85 or LA74 == 86 or LA74 == 87 or LA74 == 88: + alt74 = 1 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 7, self.input) + + raise nvae + + elif LA74 == 61: + LA74 = self.input.LA(2) + if LA74 == IDENTIFIER: + LA74_220 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 220, self.input) + + raise nvae + + elif LA74 == HEX_LITERAL: + LA74_221 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 221, self.input) + + raise nvae + + elif LA74 == OCTAL_LITERAL: + LA74_222 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 222, self.input) + + raise nvae + + elif LA74 == DECIMAL_LITERAL: + LA74_223 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 223, self.input) + + raise nvae + + elif LA74 == CHARACTER_LITERAL: + LA74_224 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 224, self.input) + + raise nvae + + elif LA74 == STRING_LITERAL: + LA74_225 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 225, self.input) + + raise nvae + + elif LA74 == FLOATING_POINT_LITERAL: + LA74_226 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 226, self.input) + + raise nvae + + elif LA74 == 61: + LA74_227 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 227, self.input) + + raise nvae + + elif LA74 == 71: + LA74_228 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 228, self.input) + + raise nvae + + elif LA74 == 72: + LA74_229 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 229, self.input) + + raise nvae + + elif LA74 == 65 or LA74 == 67 or LA74 == 68 or LA74 == 76 or LA74 == 77 or LA74 == 78: + LA74_230 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 230, self.input) + + raise nvae + + elif LA74 == 73: + LA74_231 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 231, self.input) + + raise nvae + + elif LA74 == 34 or LA74 == 35 or LA74 == 36 or LA74 == 37 or LA74 == 38 or LA74 == 39 or LA74 == 40 or LA74 == 41 or LA74 == 42 or LA74 == 45 or LA74 == 46 or LA74 == 48 or LA74 == 49 or LA74 == 50 or LA74 == 51 or LA74 == 52 or LA74 == 53 or LA74 == 54 or LA74 == 55 or LA74 == 56 or LA74 == 57 or LA74 == 58 or LA74 == 59 or LA74 == 60: + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 8, self.input) + + raise nvae + + elif LA74 == 71: + LA74 = self.input.LA(2) + if LA74 == IDENTIFIER: + LA74_244 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 244, self.input) + + raise nvae + + elif LA74 == HEX_LITERAL: + LA74_245 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 245, self.input) + + raise nvae + + elif LA74 == OCTAL_LITERAL: + LA74_246 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 246, self.input) + + raise nvae + + elif LA74 == DECIMAL_LITERAL: + LA74_247 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 247, self.input) + + raise nvae + + elif LA74 == CHARACTER_LITERAL: + LA74_248 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 248, self.input) + + raise nvae + + elif LA74 == STRING_LITERAL: + LA74_249 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 249, self.input) + + raise nvae + + elif LA74 == FLOATING_POINT_LITERAL: + LA74_250 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 250, self.input) + + raise nvae + + elif LA74 == 61: + LA74_251 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 251, self.input) + + raise nvae + + elif LA74 == 71: + LA74_252 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 252, self.input) + + raise nvae + + elif LA74 == 72: + LA74_253 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 253, self.input) + + raise nvae + + elif LA74 == 65 or LA74 == 67 or LA74 == 68 or LA74 == 76 or LA74 == 77 or LA74 == 78: + LA74_254 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 254, self.input) + + raise nvae + + elif LA74 == 73: + LA74_255 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 255, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 9, self.input) + + raise nvae + + elif LA74 == 72: + LA74 = self.input.LA(2) + if LA74 == IDENTIFIER: + LA74_256 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 256, self.input) + + raise nvae + + elif LA74 == HEX_LITERAL: + LA74_257 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 257, self.input) + + raise nvae + + elif LA74 == OCTAL_LITERAL: + LA74_258 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 258, self.input) + + raise nvae + + elif LA74 == DECIMAL_LITERAL: + LA74_259 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 259, self.input) + + raise nvae + + elif LA74 == CHARACTER_LITERAL: + LA74_260 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 260, self.input) + + raise nvae + + elif LA74 == STRING_LITERAL: + LA74_261 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 261, self.input) + + raise nvae + + elif LA74 == FLOATING_POINT_LITERAL: + LA74_262 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 262, self.input) + + raise nvae + + elif LA74 == 61: + LA74_263 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 263, self.input) + + raise nvae + + elif LA74 == 71: + LA74_264 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 264, self.input) + + raise nvae + + elif LA74 == 72: + LA74_265 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 265, self.input) + + raise nvae + + elif LA74 == 65 or LA74 == 67 or LA74 == 68 or LA74 == 76 or LA74 == 77 or LA74 == 78: + LA74_266 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 266, self.input) + + raise nvae + + elif LA74 == 73: + LA74_267 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 267, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 10, self.input) + + raise nvae + + elif LA74 == 65 or LA74 == 67 or LA74 == 68 or LA74 == 76 or LA74 == 77 or LA74 == 78: + LA74 = self.input.LA(2) + if LA74 == 61: + LA74_268 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 268, self.input) + + raise nvae + + elif LA74 == IDENTIFIER: + LA74_269 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 269, self.input) + + raise nvae + + elif LA74 == HEX_LITERAL: + LA74_270 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 270, self.input) + + raise nvae + + elif LA74 == OCTAL_LITERAL: + LA74_271 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 271, self.input) + + raise nvae + + elif LA74 == DECIMAL_LITERAL: + LA74_272 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 272, self.input) + + raise nvae + + elif LA74 == CHARACTER_LITERAL: + LA74_273 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 273, self.input) + + raise nvae + + elif LA74 == STRING_LITERAL: + LA74_274 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 274, self.input) + + raise nvae + + elif LA74 == FLOATING_POINT_LITERAL: + LA74_275 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 275, self.input) + + raise nvae + + elif LA74 == 71: + LA74_276 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 276, self.input) + + raise nvae + + elif LA74 == 72: + LA74_277 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 277, self.input) + + raise nvae + + elif LA74 == 65 or LA74 == 67 or LA74 == 68 or LA74 == 76 or LA74 == 77 or LA74 == 78: + LA74_278 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 278, self.input) + + raise nvae + + elif LA74 == 73: + LA74_279 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 279, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 11, self.input) + + raise nvae + + elif LA74 == 73: + LA74 = self.input.LA(2) + if LA74 == 61: + LA74_280 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 280, self.input) + + raise nvae + + elif LA74 == IDENTIFIER: + LA74_281 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 281, self.input) + + raise nvae + + elif LA74 == HEX_LITERAL: + LA74_282 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 282, self.input) + + raise nvae + + elif LA74 == OCTAL_LITERAL: + LA74_283 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 283, self.input) + + raise nvae + + elif LA74 == DECIMAL_LITERAL: + LA74_284 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 284, self.input) + + raise nvae + + elif LA74 == CHARACTER_LITERAL: + LA74_285 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 285, self.input) + + raise nvae + + elif LA74 == STRING_LITERAL: + LA74_286 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 286, self.input) + + raise nvae + + elif LA74 == FLOATING_POINT_LITERAL: + LA74_287 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 287, self.input) + + raise nvae + + elif LA74 == 71: + LA74_288 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 288, self.input) + + raise nvae + + elif LA74 == 72: + LA74_289 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 289, self.input) + + raise nvae + + elif LA74 == 65 or LA74 == 67 or LA74 == 68 or LA74 == 76 or LA74 == 77 or LA74 == 78: + LA74_290 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 290, self.input) + + raise nvae + + elif LA74 == 73: + LA74_291 = self.input.LA(3) + + if (self.synpred141()) : + alt74 = 1 + elif (True) : + alt74 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 291, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 12, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("404:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );", 74, 0, self.input) + + raise nvae + + if alt74 == 1: + # C.g:405:4: lvalue assignment_operator assignment_expression + self.following.append(self.FOLLOW_lvalue_in_assignment_expression1729) + self.lvalue() + self.following.pop() + if self.failed: + return + self.following.append(self.FOLLOW_assignment_operator_in_assignment_expression1731) + self.assignment_operator() + self.following.pop() + if self.failed: + return + self.following.append(self.FOLLOW_assignment_expression_in_assignment_expression1733) + self.assignment_expression() + self.following.pop() + if self.failed: + return + + + elif alt74 == 2: + # C.g:406:4: conditional_expression + self.following.append(self.FOLLOW_conditional_expression_in_assignment_expression1738) + self.conditional_expression() + self.following.pop() + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 48, assignment_expression_StartIndex) + + pass + + return + + # $ANTLR end assignment_expression + + + # $ANTLR start lvalue + # C.g:409:1: lvalue : unary_expression ; + def lvalue(self, ): + + lvalue_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 49): + return + + # C.g:410:2: ( unary_expression ) + # C.g:410:4: unary_expression + self.following.append(self.FOLLOW_unary_expression_in_lvalue1750) + self.unary_expression() + self.following.pop() + if self.failed: + return + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 49, lvalue_StartIndex) + + pass + + return + + # $ANTLR end lvalue + + + # $ANTLR start assignment_operator + # C.g:413:1: assignment_operator : ( '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' | '|=' ); + def assignment_operator(self, ): + + assignment_operator_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 50): + return + + # C.g:414:2: ( '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' | '|=' ) + # C.g: + if self.input.LA(1) == 28 or (79 <= self.input.LA(1) <= 88): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_assignment_operator0 + ) + raise mse + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 50, assignment_operator_StartIndex) + + pass + + return + + # $ANTLR end assignment_operator + + + # $ANTLR start conditional_expression + # C.g:427:1: conditional_expression : e= logical_or_expression ( '?' expression ':' conditional_expression )? ; + def conditional_expression(self, ): + + conditional_expression_StartIndex = self.input.index() + e = None + + + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 51): + return + + # C.g:428:2: (e= logical_or_expression ( '?' expression ':' conditional_expression )? ) + # C.g:428:4: e= logical_or_expression ( '?' expression ':' conditional_expression )? + self.following.append(self.FOLLOW_logical_or_expression_in_conditional_expression1824) + e = self.logical_or_expression() + self.following.pop() + if self.failed: + return + # C.g:428:28: ( '?' expression ':' conditional_expression )? + alt75 = 2 + LA75_0 = self.input.LA(1) + + if (LA75_0 == 89) : + alt75 = 1 + if alt75 == 1: + # C.g:428:29: '?' expression ':' conditional_expression + self.match(self.input, 89, self.FOLLOW_89_in_conditional_expression1827) + if self.failed: + return + self.following.append(self.FOLLOW_expression_in_conditional_expression1829) + self.expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 47, self.FOLLOW_47_in_conditional_expression1831) + if self.failed: + return + self.following.append(self.FOLLOW_conditional_expression_in_conditional_expression1833) + self.conditional_expression() + self.following.pop() + if self.failed: + return + if self.backtracking == 0: + self.StorePredicateExpression(e.start.line, e.start.charPositionInLine, e.stop.line, e.stop.charPositionInLine, self.input.toString(e.start,e.stop)) + + + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 51, conditional_expression_StartIndex) + + pass + + return + + # $ANTLR end conditional_expression + + class logical_or_expression_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start logical_or_expression + # C.g:431:1: logical_or_expression : logical_and_expression ( '||' logical_and_expression )* ; + def logical_or_expression(self, ): + + retval = self.logical_or_expression_return() + retval.start = self.input.LT(1) + logical_or_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 52): + return retval + + # C.g:432:2: ( logical_and_expression ( '||' logical_and_expression )* ) + # C.g:432:4: logical_and_expression ( '||' logical_and_expression )* + self.following.append(self.FOLLOW_logical_and_expression_in_logical_or_expression1848) + self.logical_and_expression() + self.following.pop() + if self.failed: + return retval + # C.g:432:27: ( '||' logical_and_expression )* + while True: #loop76 + alt76 = 2 + LA76_0 = self.input.LA(1) + + if (LA76_0 == 90) : + alt76 = 1 + + + if alt76 == 1: + # C.g:432:28: '||' logical_and_expression + self.match(self.input, 90, self.FOLLOW_90_in_logical_or_expression1851) + if self.failed: + return retval + self.following.append(self.FOLLOW_logical_and_expression_in_logical_or_expression1853) + self.logical_and_expression() + self.following.pop() + if self.failed: + return retval + + + else: + break #loop76 + + + + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 52, logical_or_expression_StartIndex) + + pass + + return retval + + # $ANTLR end logical_or_expression + + + # $ANTLR start logical_and_expression + # C.g:435:1: logical_and_expression : inclusive_or_expression ( '&&' inclusive_or_expression )* ; + def logical_and_expression(self, ): + + logical_and_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 53): + return + + # C.g:436:2: ( inclusive_or_expression ( '&&' inclusive_or_expression )* ) + # C.g:436:4: inclusive_or_expression ( '&&' inclusive_or_expression )* + self.following.append(self.FOLLOW_inclusive_or_expression_in_logical_and_expression1866) + self.inclusive_or_expression() + self.following.pop() + if self.failed: + return + # C.g:436:28: ( '&&' inclusive_or_expression )* + while True: #loop77 + alt77 = 2 + LA77_0 = self.input.LA(1) + + if (LA77_0 == 91) : + alt77 = 1 + + + if alt77 == 1: + # C.g:436:29: '&&' inclusive_or_expression + self.match(self.input, 91, self.FOLLOW_91_in_logical_and_expression1869) + if self.failed: + return + self.following.append(self.FOLLOW_inclusive_or_expression_in_logical_and_expression1871) + self.inclusive_or_expression() + self.following.pop() + if self.failed: + return + + + else: + break #loop77 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 53, logical_and_expression_StartIndex) + + pass + + return + + # $ANTLR end logical_and_expression + + + # $ANTLR start inclusive_or_expression + # C.g:439:1: inclusive_or_expression : exclusive_or_expression ( '|' exclusive_or_expression )* ; + def inclusive_or_expression(self, ): + + inclusive_or_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 54): + return + + # C.g:440:2: ( exclusive_or_expression ( '|' exclusive_or_expression )* ) + # C.g:440:4: exclusive_or_expression ( '|' exclusive_or_expression )* + self.following.append(self.FOLLOW_exclusive_or_expression_in_inclusive_or_expression1884) + self.exclusive_or_expression() + self.following.pop() + if self.failed: + return + # C.g:440:28: ( '|' exclusive_or_expression )* + while True: #loop78 + alt78 = 2 + LA78_0 = self.input.LA(1) + + if (LA78_0 == 92) : + alt78 = 1 + + + if alt78 == 1: + # C.g:440:29: '|' exclusive_or_expression + self.match(self.input, 92, self.FOLLOW_92_in_inclusive_or_expression1887) + if self.failed: + return + self.following.append(self.FOLLOW_exclusive_or_expression_in_inclusive_or_expression1889) + self.exclusive_or_expression() + self.following.pop() + if self.failed: + return + + + else: + break #loop78 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 54, inclusive_or_expression_StartIndex) + + pass + + return + + # $ANTLR end inclusive_or_expression + + + # $ANTLR start exclusive_or_expression + # C.g:443:1: exclusive_or_expression : and_expression ( '^' and_expression )* ; + def exclusive_or_expression(self, ): + + exclusive_or_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 55): + return + + # C.g:444:2: ( and_expression ( '^' and_expression )* ) + # C.g:444:4: and_expression ( '^' and_expression )* + self.following.append(self.FOLLOW_and_expression_in_exclusive_or_expression1902) + self.and_expression() + self.following.pop() + if self.failed: + return + # C.g:444:19: ( '^' and_expression )* + while True: #loop79 + alt79 = 2 + LA79_0 = self.input.LA(1) + + if (LA79_0 == 93) : + alt79 = 1 + + + if alt79 == 1: + # C.g:444:20: '^' and_expression + self.match(self.input, 93, self.FOLLOW_93_in_exclusive_or_expression1905) + if self.failed: + return + self.following.append(self.FOLLOW_and_expression_in_exclusive_or_expression1907) + self.and_expression() + self.following.pop() + if self.failed: + return + + + else: + break #loop79 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 55, exclusive_or_expression_StartIndex) + + pass + + return + + # $ANTLR end exclusive_or_expression + + + # $ANTLR start and_expression + # C.g:447:1: and_expression : equality_expression ( '&' equality_expression )* ; + def and_expression(self, ): + + and_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 56): + return + + # C.g:448:2: ( equality_expression ( '&' equality_expression )* ) + # C.g:448:4: equality_expression ( '&' equality_expression )* + self.following.append(self.FOLLOW_equality_expression_in_and_expression1920) + self.equality_expression() + self.following.pop() + if self.failed: + return + # C.g:448:24: ( '&' equality_expression )* + while True: #loop80 + alt80 = 2 + LA80_0 = self.input.LA(1) + + if (LA80_0 == 76) : + alt80 = 1 + + + if alt80 == 1: + # C.g:448:25: '&' equality_expression + self.match(self.input, 76, self.FOLLOW_76_in_and_expression1923) + if self.failed: + return + self.following.append(self.FOLLOW_equality_expression_in_and_expression1925) + self.equality_expression() + self.following.pop() + if self.failed: + return + + + else: + break #loop80 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 56, and_expression_StartIndex) + + pass + + return + + # $ANTLR end and_expression + + + # $ANTLR start equality_expression + # C.g:450:1: equality_expression : relational_expression ( ( '==' | '!=' ) relational_expression )* ; + def equality_expression(self, ): + + equality_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 57): + return + + # C.g:451:2: ( relational_expression ( ( '==' | '!=' ) relational_expression )* ) + # C.g:451:4: relational_expression ( ( '==' | '!=' ) relational_expression )* + self.following.append(self.FOLLOW_relational_expression_in_equality_expression1937) + self.relational_expression() + self.following.pop() + if self.failed: + return + # C.g:451:26: ( ( '==' | '!=' ) relational_expression )* + while True: #loop81 + alt81 = 2 + LA81_0 = self.input.LA(1) + + if ((94 <= LA81_0 <= 95)) : + alt81 = 1 + + + if alt81 == 1: + # C.g:451:27: ( '==' | '!=' ) relational_expression + if (94 <= self.input.LA(1) <= 95): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_equality_expression1940 + ) + raise mse + + + self.following.append(self.FOLLOW_relational_expression_in_equality_expression1946) + self.relational_expression() + self.following.pop() + if self.failed: + return + + + else: + break #loop81 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 57, equality_expression_StartIndex) + + pass + + return + + # $ANTLR end equality_expression + + + # $ANTLR start relational_expression + # C.g:454:1: relational_expression : shift_expression ( ( '<' | '>' | '<=' | '>=' ) shift_expression )* ; + def relational_expression(self, ): + + relational_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 58): + return + + # C.g:455:2: ( shift_expression ( ( '<' | '>' | '<=' | '>=' ) shift_expression )* ) + # C.g:455:4: shift_expression ( ( '<' | '>' | '<=' | '>=' ) shift_expression )* + self.following.append(self.FOLLOW_shift_expression_in_relational_expression1960) + self.shift_expression() + self.following.pop() + if self.failed: + return + # C.g:455:21: ( ( '<' | '>' | '<=' | '>=' ) shift_expression )* + while True: #loop82 + alt82 = 2 + LA82_0 = self.input.LA(1) + + if ((96 <= LA82_0 <= 99)) : + alt82 = 1 + + + if alt82 == 1: + # C.g:455:22: ( '<' | '>' | '<=' | '>=' ) shift_expression + if (96 <= self.input.LA(1) <= 99): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_relational_expression1963 + ) + raise mse + + + self.following.append(self.FOLLOW_shift_expression_in_relational_expression1973) + self.shift_expression() + self.following.pop() + if self.failed: + return + + + else: + break #loop82 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 58, relational_expression_StartIndex) + + pass + + return + + # $ANTLR end relational_expression + + + # $ANTLR start shift_expression + # C.g:458:1: shift_expression : additive_expression ( ( '<<' | '>>' ) additive_expression )* ; + def shift_expression(self, ): + + shift_expression_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 59): + return + + # C.g:459:2: ( additive_expression ( ( '<<' | '>>' ) additive_expression )* ) + # C.g:459:4: additive_expression ( ( '<<' | '>>' ) additive_expression )* + self.following.append(self.FOLLOW_additive_expression_in_shift_expression1986) + self.additive_expression() + self.following.pop() + if self.failed: + return + # C.g:459:24: ( ( '<<' | '>>' ) additive_expression )* + while True: #loop83 + alt83 = 2 + LA83_0 = self.input.LA(1) + + if ((100 <= LA83_0 <= 101)) : + alt83 = 1 + + + if alt83 == 1: + # C.g:459:25: ( '<<' | '>>' ) additive_expression + if (100 <= self.input.LA(1) <= 101): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_shift_expression1989 + ) + raise mse + + + self.following.append(self.FOLLOW_additive_expression_in_shift_expression1995) + self.additive_expression() + self.following.pop() + if self.failed: + return + + + else: + break #loop83 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 59, shift_expression_StartIndex) + + pass + + return + + # $ANTLR end shift_expression + + + # $ANTLR start statement + # C.g:464:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | macro_statement | asm2_statement | asm1_statement | asm_statement | declaration ); + def statement(self, ): + + statement_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 60): + return + + # C.g:465:2: ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | macro_statement | asm2_statement | asm1_statement | asm_statement | declaration ) + alt84 = 11 + LA84 = self.input.LA(1) + if LA84 == IDENTIFIER: + LA84 = self.input.LA(2) + if LA84 == 47: + alt84 = 1 + elif LA84 == 61: + LA84_44 = self.input.LA(3) + + if (self.synpred168()) : + alt84 = 3 + elif (self.synpred172()) : + alt84 = 7 + elif (self.synpred173()) : + alt84 = 8 + elif (True) : + alt84 = 11 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("464:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | macro_statement | asm2_statement | asm1_statement | asm_statement | declaration );", 84, 44, self.input) + + raise nvae + + elif LA84 == STRING_LITERAL or LA84 == 27 or LA84 == 28 or LA84 == 63 or LA84 == 67 or LA84 == 68 or LA84 == 69 or LA84 == 70 or LA84 == 71 or LA84 == 72 or LA84 == 74 or LA84 == 75 or LA84 == 76 or LA84 == 79 or LA84 == 80 or LA84 == 81 or LA84 == 82 or LA84 == 83 or LA84 == 84 or LA84 == 85 or LA84 == 86 or LA84 == 87 or LA84 == 88 or LA84 == 89 or LA84 == 90 or LA84 == 91 or LA84 == 92 or LA84 == 93 or LA84 == 94 or LA84 == 95 or LA84 == 96 or LA84 == 97 or LA84 == 98 or LA84 == 99 or LA84 == 100 or LA84 == 101: + alt84 = 3 + elif LA84 == 65: + LA84_47 = self.input.LA(3) + + if (self.synpred168()) : + alt84 = 3 + elif (True) : + alt84 = 11 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("464:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | macro_statement | asm2_statement | asm1_statement | asm_statement | declaration );", 84, 47, self.input) + + raise nvae + + elif LA84 == 25: + LA84_65 = self.input.LA(3) + + if (self.synpred168()) : + alt84 = 3 + elif (True) : + alt84 = 11 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("464:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | macro_statement | asm2_statement | asm1_statement | asm_statement | declaration );", 84, 65, self.input) + + raise nvae + + elif LA84 == IDENTIFIER: + LA84_67 = self.input.LA(3) + + if (self.synpred168()) : + alt84 = 3 + elif (True) : + alt84 = 11 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("464:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | macro_statement | asm2_statement | asm1_statement | asm_statement | declaration );", 84, 67, self.input) + + raise nvae + + elif LA84 == 29 or LA84 == 30 or LA84 == 31 or LA84 == 32 or LA84 == 33 or LA84 == 34 or LA84 == 35 or LA84 == 36 or LA84 == 37 or LA84 == 38 or LA84 == 39 or LA84 == 40 or LA84 == 41 or LA84 == 42 or LA84 == 45 or LA84 == 46 or LA84 == 48 or LA84 == 49 or LA84 == 50 or LA84 == 51 or LA84 == 52 or LA84 == 53 or LA84 == 54 or LA84 == 55 or LA84 == 56 or LA84 == 57 or LA84 == 58 or LA84 == 59 or LA84 == 60: + alt84 = 11 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("464:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | macro_statement | asm2_statement | asm1_statement | asm_statement | declaration );", 84, 1, self.input) + + raise nvae + + elif LA84 == 105 or LA84 == 106: + alt84 = 1 + elif LA84 == 43: + alt84 = 2 + elif LA84 == HEX_LITERAL or LA84 == OCTAL_LITERAL or LA84 == DECIMAL_LITERAL or LA84 == CHARACTER_LITERAL or LA84 == STRING_LITERAL or LA84 == FLOATING_POINT_LITERAL or LA84 == 25 or LA84 == 61 or LA84 == 65 or LA84 == 67 or LA84 == 68 or LA84 == 71 or LA84 == 72 or LA84 == 73 or LA84 == 76 or LA84 == 77 or LA84 == 78: + alt84 = 3 + elif LA84 == 107 or LA84 == 109: + alt84 = 4 + elif LA84 == 110 or LA84 == 111 or LA84 == 112: + alt84 = 5 + elif LA84 == 113 or LA84 == 114 or LA84 == 115 or LA84 == 116: + alt84 = 6 + elif LA84 == 102: + alt84 = 8 + elif LA84 == 103: + alt84 = 9 + elif LA84 == 104: + alt84 = 10 + elif LA84 == 26 or LA84 == 29 or LA84 == 30 or LA84 == 31 or LA84 == 32 or LA84 == 33 or LA84 == 34 or LA84 == 35 or LA84 == 36 or LA84 == 37 or LA84 == 38 or LA84 == 39 or LA84 == 40 or LA84 == 41 or LA84 == 42 or LA84 == 45 or LA84 == 46 or LA84 == 48 or LA84 == 49 or LA84 == 50 or LA84 == 51 or LA84 == 52 or LA84 == 53 or LA84 == 54 or LA84 == 55 or LA84 == 56 or LA84 == 57 or LA84 == 58 or LA84 == 59 or LA84 == 60: + alt84 = 11 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("464:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | macro_statement | asm2_statement | asm1_statement | asm_statement | declaration );", 84, 0, self.input) + + raise nvae + + if alt84 == 1: + # C.g:465:4: labeled_statement + self.following.append(self.FOLLOW_labeled_statement_in_statement2010) + self.labeled_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 2: + # C.g:466:4: compound_statement + self.following.append(self.FOLLOW_compound_statement_in_statement2015) + self.compound_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 3: + # C.g:467:4: expression_statement + self.following.append(self.FOLLOW_expression_statement_in_statement2020) + self.expression_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 4: + # C.g:468:4: selection_statement + self.following.append(self.FOLLOW_selection_statement_in_statement2025) + self.selection_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 5: + # C.g:469:4: iteration_statement + self.following.append(self.FOLLOW_iteration_statement_in_statement2030) + self.iteration_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 6: + # C.g:470:4: jump_statement + self.following.append(self.FOLLOW_jump_statement_in_statement2035) + self.jump_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 7: + # C.g:471:4: macro_statement + self.following.append(self.FOLLOW_macro_statement_in_statement2040) + self.macro_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 8: + # C.g:472:4: asm2_statement + self.following.append(self.FOLLOW_asm2_statement_in_statement2045) + self.asm2_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 9: + # C.g:473:4: asm1_statement + self.following.append(self.FOLLOW_asm1_statement_in_statement2050) + self.asm1_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 10: + # C.g:474:4: asm_statement + self.following.append(self.FOLLOW_asm_statement_in_statement2055) + self.asm_statement() + self.following.pop() + if self.failed: + return + + + elif alt84 == 11: + # C.g:475:4: declaration + self.following.append(self.FOLLOW_declaration_in_statement2060) + self.declaration() + self.following.pop() + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 60, statement_StartIndex) + + pass + + return + + # $ANTLR end statement + + + # $ANTLR start asm2_statement + # C.g:478:1: asm2_statement : ( '__asm__' )? IDENTIFIER '(' (~ ( ';' ) )* ')' ';' ; + def asm2_statement(self, ): + + asm2_statement_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 61): + return + + # C.g:479:2: ( ( '__asm__' )? IDENTIFIER '(' (~ ( ';' ) )* ')' ';' ) + # C.g:479:4: ( '__asm__' )? IDENTIFIER '(' (~ ( ';' ) )* ')' ';' + # C.g:479:4: ( '__asm__' )? + alt85 = 2 + LA85_0 = self.input.LA(1) + + if (LA85_0 == 102) : + alt85 = 1 + if alt85 == 1: + # C.g:0:0: '__asm__' + self.match(self.input, 102, self.FOLLOW_102_in_asm2_statement2071) + if self.failed: + return + + + + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_asm2_statement2074) + if self.failed: + return + self.match(self.input, 61, self.FOLLOW_61_in_asm2_statement2076) + if self.failed: + return + # C.g:479:30: (~ ( ';' ) )* + while True: #loop86 + alt86 = 2 + LA86_0 = self.input.LA(1) + + if (LA86_0 == 62) : + LA86_1 = self.input.LA(2) + + if ((IDENTIFIER <= LA86_1 <= LINE_COMMAND) or (26 <= LA86_1 <= 116)) : + alt86 = 1 + + + elif ((IDENTIFIER <= LA86_0 <= LINE_COMMAND) or (26 <= LA86_0 <= 61) or (63 <= LA86_0 <= 116)) : + alt86 = 1 + + + if alt86 == 1: + # C.g:479:31: ~ ( ';' ) + if (IDENTIFIER <= self.input.LA(1) <= LINE_COMMAND) or (26 <= self.input.LA(1) <= 116): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_asm2_statement2079 + ) + raise mse + + + + + else: + break #loop86 + + + self.match(self.input, 62, self.FOLLOW_62_in_asm2_statement2086) + if self.failed: + return + self.match(self.input, 25, self.FOLLOW_25_in_asm2_statement2088) + if self.failed: + return + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 61, asm2_statement_StartIndex) + + pass + + return + + # $ANTLR end asm2_statement + + + # $ANTLR start asm1_statement + # C.g:482:1: asm1_statement : '_asm' '{' (~ ( '}' ) )* '}' ; + def asm1_statement(self, ): + + asm1_statement_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 62): + return + + # C.g:483:2: ( '_asm' '{' (~ ( '}' ) )* '}' ) + # C.g:483:4: '_asm' '{' (~ ( '}' ) )* '}' + self.match(self.input, 103, self.FOLLOW_103_in_asm1_statement2100) + if self.failed: + return + self.match(self.input, 43, self.FOLLOW_43_in_asm1_statement2102) + if self.failed: + return + # C.g:483:15: (~ ( '}' ) )* + while True: #loop87 + alt87 = 2 + LA87_0 = self.input.LA(1) + + if ((IDENTIFIER <= LA87_0 <= 43) or (45 <= LA87_0 <= 116)) : + alt87 = 1 + + + if alt87 == 1: + # C.g:483:16: ~ ( '}' ) + if (IDENTIFIER <= self.input.LA(1) <= 43) or (45 <= self.input.LA(1) <= 116): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_asm1_statement2105 + ) + raise mse + + + + + else: + break #loop87 + + + self.match(self.input, 44, self.FOLLOW_44_in_asm1_statement2112) + if self.failed: + return + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 62, asm1_statement_StartIndex) + + pass + + return + + # $ANTLR end asm1_statement + + + # $ANTLR start asm_statement + # C.g:486:1: asm_statement : '__asm' '{' (~ ( '}' ) )* '}' ; + def asm_statement(self, ): + + asm_statement_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 63): + return + + # C.g:487:2: ( '__asm' '{' (~ ( '}' ) )* '}' ) + # C.g:487:4: '__asm' '{' (~ ( '}' ) )* '}' + self.match(self.input, 104, self.FOLLOW_104_in_asm_statement2123) + if self.failed: + return + self.match(self.input, 43, self.FOLLOW_43_in_asm_statement2125) + if self.failed: + return + # C.g:487:16: (~ ( '}' ) )* + while True: #loop88 + alt88 = 2 + LA88_0 = self.input.LA(1) + + if ((IDENTIFIER <= LA88_0 <= 43) or (45 <= LA88_0 <= 116)) : + alt88 = 1 + + + if alt88 == 1: + # C.g:487:17: ~ ( '}' ) + if (IDENTIFIER <= self.input.LA(1) <= 43) or (45 <= self.input.LA(1) <= 116): + self.input.consume(); + self.errorRecovery = False + self.failed = False + + else: + if self.backtracking > 0: + self.failed = True + return + + mse = MismatchedSetException(None, self.input) + self.recoverFromMismatchedSet( + self.input, mse, self.FOLLOW_set_in_asm_statement2128 + ) + raise mse + + + + + else: + break #loop88 + + + self.match(self.input, 44, self.FOLLOW_44_in_asm_statement2135) + if self.failed: + return + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 63, asm_statement_StartIndex) + + pass + + return + + # $ANTLR end asm_statement + + + # $ANTLR start macro_statement + # C.g:490:1: macro_statement : IDENTIFIER '(' ( declaration )* ( statement_list )? ( expression )? ')' ; + def macro_statement(self, ): + + macro_statement_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 64): + return + + # C.g:491:2: ( IDENTIFIER '(' ( declaration )* ( statement_list )? ( expression )? ')' ) + # C.g:491:4: IDENTIFIER '(' ( declaration )* ( statement_list )? ( expression )? ')' + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_macro_statement2147) + if self.failed: + return + self.match(self.input, 61, self.FOLLOW_61_in_macro_statement2149) + if self.failed: + return + # C.g:491:19: ( declaration )* + while True: #loop89 + alt89 = 2 + LA89 = self.input.LA(1) + if LA89 == IDENTIFIER: + LA89 = self.input.LA(2) + if LA89 == 61: + LA89_45 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 65: + LA89_48 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_66 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_69 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_70 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_71 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_72 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_73 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_74 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_75 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_76 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_77 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_78 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_79 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_80 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_81 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_82 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_83 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_84 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_85 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 26: + LA89 = self.input.LA(2) + if LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_87 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_88 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_89 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_90 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_91 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_92 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_93 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_94 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_95 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_96 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_97 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_98 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_99 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_100 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 65: + LA89_101 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_102 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_103 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_104 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_105 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_106 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_107 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_108 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_109 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_110 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_111 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_112 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_113 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_114 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_115 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_116 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_117 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_118 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_119 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_120 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_121 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_122 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_123 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_124 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_125 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 34: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_126 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_127 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_128 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_129 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_130 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_131 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_132 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_133 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_134 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_135 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_136 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_137 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_138 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_139 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_140 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_141 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_142 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_143 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_144 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_145 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 35: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_146 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_147 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_148 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_149 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_150 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_151 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_152 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_153 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_154 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_155 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_156 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_157 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_158 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_159 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_160 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_161 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_162 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_163 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_164 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_165 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 36: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_166 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_167 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_168 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_169 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_170 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_171 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_172 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_173 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_174 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_175 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_176 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_177 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_178 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_179 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_180 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_181 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_182 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_183 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_184 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_185 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 37: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_186 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_187 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_188 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_189 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_190 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_191 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_192 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_193 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_194 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_195 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_196 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_197 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_198 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_199 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_200 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_201 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_202 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_203 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_204 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_205 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 38: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_206 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_207 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_208 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_209 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_210 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_211 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_212 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_213 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_214 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_215 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_216 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_217 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_218 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_219 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_220 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_221 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_222 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_223 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_224 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_225 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 39: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_226 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_227 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_228 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_229 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_230 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_231 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_232 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_233 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_234 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_235 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_236 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_237 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_238 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_239 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_240 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_241 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_242 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_243 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_244 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_245 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 40: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_246 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_247 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_248 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_249 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_250 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_251 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_252 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_253 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_254 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_255 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_256 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_257 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_258 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_259 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_260 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_261 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_262 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_263 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_264 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_265 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 41: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_266 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_267 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_268 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_269 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_270 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_271 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_272 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_273 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_274 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_275 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_276 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_277 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_278 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_279 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_280 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_281 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_282 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_283 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_284 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_285 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 42: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_286 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_287 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_288 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_289 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_290 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_291 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_292 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_293 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_294 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_295 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_296 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_297 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_298 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_299 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_300 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_301 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_302 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_303 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_304 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_305 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + elif LA89 == 45 or LA89 == 46: + LA89_40 = self.input.LA(2) + + if (LA89_40 == IDENTIFIER) : + LA89_306 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif (LA89_40 == 43) : + LA89_307 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + + elif LA89 == 48: + LA89_41 = self.input.LA(2) + + if (LA89_41 == IDENTIFIER) : + LA89_308 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif (LA89_41 == 43) : + LA89_309 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57 or LA89 == 58 or LA89 == 59 or LA89 == 60: + LA89 = self.input.LA(2) + if LA89 == 65: + LA89_310 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 58: + LA89_311 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 59: + LA89_312 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 60: + LA89_313 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == IDENTIFIER: + LA89_314 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 61: + LA89_315 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 25: + LA89_316 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 29 or LA89 == 30 or LA89 == 31 or LA89 == 32 or LA89 == 33: + LA89_317 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 34: + LA89_318 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 35: + LA89_319 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 36: + LA89_320 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 37: + LA89_321 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 38: + LA89_322 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 39: + LA89_323 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 40: + LA89_324 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 41: + LA89_325 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 42: + LA89_326 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 45 or LA89 == 46: + LA89_327 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 48: + LA89_328 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + elif LA89 == 49 or LA89 == 50 or LA89 == 51 or LA89 == 52 or LA89 == 53 or LA89 == 54 or LA89 == 55 or LA89 == 56 or LA89 == 57: + LA89_329 = self.input.LA(3) + + if (self.synpred180()) : + alt89 = 1 + + + + + if alt89 == 1: + # C.g:0:0: declaration + self.following.append(self.FOLLOW_declaration_in_macro_statement2151) + self.declaration() + self.following.pop() + if self.failed: + return + + + else: + break #loop89 + + + # C.g:491:33: ( statement_list )? + alt90 = 2 + LA90 = self.input.LA(1) + if LA90 == IDENTIFIER: + LA90 = self.input.LA(2) + if LA90 == 61: + LA90_44 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 25 or LA90 == 29 or LA90 == 30 or LA90 == 31 or LA90 == 32 or LA90 == 33 or LA90 == 34 or LA90 == 35 or LA90 == 36 or LA90 == 37 or LA90 == 38 or LA90 == 39 or LA90 == 40 or LA90 == 41 or LA90 == 42 or LA90 == 45 or LA90 == 46 or LA90 == 47 or LA90 == 48 or LA90 == 49 or LA90 == 50 or LA90 == 51 or LA90 == 52 or LA90 == 53 or LA90 == 54 or LA90 == 55 or LA90 == 56 or LA90 == 57 or LA90 == 58 or LA90 == 59 or LA90 == 60: + alt90 = 1 + elif LA90 == STRING_LITERAL: + LA90_46 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == IDENTIFIER: + LA90_47 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 63: + LA90_48 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 74: + LA90_49 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65: + LA90_50 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 75: + LA90_51 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_52 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_53 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 28 or LA90 == 79 or LA90 == 80 or LA90 == 81 or LA90 == 82 or LA90 == 83 or LA90 == 84 or LA90 == 85 or LA90 == 86 or LA90 == 87 or LA90 == 88: + LA90_54 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 69: + LA90_72 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 70: + LA90_73 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 67: + LA90_74 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 68: + LA90_75 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 100 or LA90 == 101: + LA90_76 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 96 or LA90 == 97 or LA90 == 98 or LA90 == 99: + LA90_77 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 94 or LA90 == 95: + LA90_78 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 76: + LA90_79 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 93: + LA90_80 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 92: + LA90_81 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 91: + LA90_82 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 90: + LA90_83 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 89: + LA90_84 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 27: + LA90_85 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 25 or LA90 == 26 or LA90 == 29 or LA90 == 30 or LA90 == 31 or LA90 == 32 or LA90 == 33 or LA90 == 34 or LA90 == 35 or LA90 == 36 or LA90 == 37 or LA90 == 38 or LA90 == 39 or LA90 == 40 or LA90 == 41 or LA90 == 42 or LA90 == 43 or LA90 == 45 or LA90 == 46 or LA90 == 48 or LA90 == 49 or LA90 == 50 or LA90 == 51 or LA90 == 52 or LA90 == 53 or LA90 == 54 or LA90 == 55 or LA90 == 56 or LA90 == 57 or LA90 == 58 or LA90 == 59 or LA90 == 60 or LA90 == 102 or LA90 == 103 or LA90 == 104 or LA90 == 105 or LA90 == 106 or LA90 == 107 or LA90 == 109 or LA90 == 110 or LA90 == 111 or LA90 == 112 or LA90 == 113 or LA90 == 114 or LA90 == 115 or LA90 == 116: + alt90 = 1 + elif LA90 == HEX_LITERAL: + LA90 = self.input.LA(2) + if LA90 == 63: + LA90_87 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90_88 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 74: + LA90_89 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65: + LA90_90 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 75: + LA90_91 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_92 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_93 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 69: + LA90_94 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 70: + LA90_95 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 67: + LA90_96 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 68: + LA90_97 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 100 or LA90 == 101: + LA90_98 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 96 or LA90 == 97 or LA90 == 98 or LA90 == 99: + LA90_99 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 94 or LA90 == 95: + LA90_100 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 76: + LA90_101 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 93: + LA90_102 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 92: + LA90_103 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 91: + LA90_104 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 90: + LA90_105 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 89: + LA90_106 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 27: + LA90_107 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 25: + alt90 = 1 + elif LA90 == 28 or LA90 == 79 or LA90 == 80 or LA90 == 81 or LA90 == 82 or LA90 == 83 or LA90 == 84 or LA90 == 85 or LA90 == 86 or LA90 == 87 or LA90 == 88: + LA90_110 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == OCTAL_LITERAL: + LA90 = self.input.LA(2) + if LA90 == 63: + LA90_111 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90_112 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 74: + LA90_113 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65: + LA90_114 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 75: + LA90_115 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_116 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_117 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 28 or LA90 == 79 or LA90 == 80 or LA90 == 81 or LA90 == 82 or LA90 == 83 or LA90 == 84 or LA90 == 85 or LA90 == 86 or LA90 == 87 or LA90 == 88: + LA90_118 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 69: + LA90_119 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 70: + LA90_120 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 67: + LA90_121 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 68: + LA90_122 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 100 or LA90 == 101: + LA90_123 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 96 or LA90 == 97 or LA90 == 98 or LA90 == 99: + LA90_124 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 94 or LA90 == 95: + LA90_125 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 76: + LA90_126 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 93: + LA90_127 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 92: + LA90_128 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 91: + LA90_129 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 90: + LA90_130 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 89: + LA90_131 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 27: + LA90_132 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 25: + alt90 = 1 + elif LA90 == DECIMAL_LITERAL: + LA90 = self.input.LA(2) + if LA90 == 63: + LA90_135 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90_136 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 74: + LA90_137 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65: + LA90_138 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 75: + LA90_139 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_140 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_141 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 28 or LA90 == 79 or LA90 == 80 or LA90 == 81 or LA90 == 82 or LA90 == 83 or LA90 == 84 or LA90 == 85 or LA90 == 86 or LA90 == 87 or LA90 == 88: + LA90_142 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 69: + LA90_143 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 70: + LA90_144 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 67: + LA90_145 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 68: + LA90_146 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 100 or LA90 == 101: + LA90_147 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 96 or LA90 == 97 or LA90 == 98 or LA90 == 99: + LA90_148 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 94 or LA90 == 95: + LA90_149 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 76: + LA90_150 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 93: + LA90_151 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 92: + LA90_152 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 91: + LA90_153 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 90: + LA90_154 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 89: + LA90_155 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 27: + LA90_156 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 25: + alt90 = 1 + elif LA90 == CHARACTER_LITERAL: + LA90 = self.input.LA(2) + if LA90 == 63: + LA90_159 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90_160 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 74: + LA90_161 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65: + LA90_162 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 75: + LA90_163 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_164 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_165 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 28 or LA90 == 79 or LA90 == 80 or LA90 == 81 or LA90 == 82 or LA90 == 83 or LA90 == 84 or LA90 == 85 or LA90 == 86 or LA90 == 87 or LA90 == 88: + LA90_166 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 69: + LA90_167 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 70: + LA90_168 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 67: + LA90_169 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 68: + LA90_170 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 100 or LA90 == 101: + LA90_171 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 96 or LA90 == 97 or LA90 == 98 or LA90 == 99: + LA90_172 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 94 or LA90 == 95: + LA90_173 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 76: + LA90_174 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 93: + LA90_175 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 92: + LA90_176 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 91: + LA90_177 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 90: + LA90_178 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 89: + LA90_179 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 27: + LA90_180 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 25: + alt90 = 1 + elif LA90 == STRING_LITERAL: + LA90 = self.input.LA(2) + if LA90 == IDENTIFIER: + LA90_183 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 63: + LA90_184 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90_185 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 74: + LA90_186 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65: + LA90_187 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 75: + LA90_188 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_189 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_190 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 69: + LA90_191 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 70: + LA90_192 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 67: + LA90_193 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 68: + LA90_194 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 100 or LA90 == 101: + LA90_195 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 96 or LA90 == 97 or LA90 == 98 or LA90 == 99: + LA90_196 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 94 or LA90 == 95: + LA90_197 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 76: + LA90_198 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 93: + LA90_199 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 92: + LA90_200 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 91: + LA90_201 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 90: + LA90_202 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 89: + LA90_203 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 27: + LA90_204 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 25: + alt90 = 1 + elif LA90 == STRING_LITERAL: + LA90_206 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 28 or LA90 == 79 or LA90 == 80 or LA90 == 81 or LA90 == 82 or LA90 == 83 or LA90 == 84 or LA90 == 85 or LA90 == 86 or LA90 == 87 or LA90 == 88: + LA90_207 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == FLOATING_POINT_LITERAL: + LA90 = self.input.LA(2) + if LA90 == 63: + LA90_209 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90_210 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 74: + LA90_211 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65: + LA90_212 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 75: + LA90_213 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_214 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_215 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 69: + LA90_216 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 70: + LA90_217 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 67: + LA90_218 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 68: + LA90_219 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 100 or LA90 == 101: + LA90_220 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 96 or LA90 == 97 or LA90 == 98 or LA90 == 99: + LA90_221 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 94 or LA90 == 95: + LA90_222 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 76: + LA90_223 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 93: + LA90_224 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 92: + LA90_225 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 91: + LA90_226 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 90: + LA90_227 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 89: + LA90_228 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 27: + LA90_229 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 25: + alt90 = 1 + elif LA90 == 28 or LA90 == 79 or LA90 == 80 or LA90 == 81 or LA90 == 82 or LA90 == 83 or LA90 == 84 or LA90 == 85 or LA90 == 86 or LA90 == 87 or LA90 == 88: + LA90_231 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90 = self.input.LA(2) + if LA90 == IDENTIFIER: + LA90_233 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == HEX_LITERAL: + LA90_234 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == OCTAL_LITERAL: + LA90_235 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == DECIMAL_LITERAL: + LA90_236 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == CHARACTER_LITERAL: + LA90_237 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == STRING_LITERAL: + LA90_238 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == FLOATING_POINT_LITERAL: + LA90_239 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90_240 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_241 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_242 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65 or LA90 == 67 or LA90 == 68 or LA90 == 76 or LA90 == 77 or LA90 == 78: + LA90_243 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 73: + LA90_244 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 49 or LA90 == 50 or LA90 == 51 or LA90 == 52 or LA90 == 53 or LA90 == 54 or LA90 == 55 or LA90 == 56 or LA90 == 57 or LA90 == 58 or LA90 == 59 or LA90 == 60: + LA90_245 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 34: + LA90_246 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 35: + LA90_247 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 36: + LA90_248 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 37: + LA90_249 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 38: + LA90_250 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 39: + LA90_251 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 40: + LA90_252 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 41: + LA90_253 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 42: + LA90_254 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 45 or LA90 == 46: + LA90_255 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 48: + LA90_256 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90 = self.input.LA(2) + if LA90 == IDENTIFIER: + LA90_257 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == HEX_LITERAL: + LA90_258 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == OCTAL_LITERAL: + LA90_259 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == DECIMAL_LITERAL: + LA90_260 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == CHARACTER_LITERAL: + LA90_261 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == STRING_LITERAL: + LA90_262 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == FLOATING_POINT_LITERAL: + LA90_263 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90_264 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_265 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_266 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65 or LA90 == 67 or LA90 == 68 or LA90 == 76 or LA90 == 77 or LA90 == 78: + LA90_267 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 73: + LA90_268 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90 = self.input.LA(2) + if LA90 == IDENTIFIER: + LA90_269 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == HEX_LITERAL: + LA90_270 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == OCTAL_LITERAL: + LA90_271 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == DECIMAL_LITERAL: + LA90_272 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == CHARACTER_LITERAL: + LA90_273 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == STRING_LITERAL: + LA90_274 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == FLOATING_POINT_LITERAL: + LA90_275 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 61: + LA90_276 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_277 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_278 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65 or LA90 == 67 or LA90 == 68 or LA90 == 76 or LA90 == 77 or LA90 == 78: + LA90_279 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 73: + LA90_280 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65 or LA90 == 67 or LA90 == 68 or LA90 == 76 or LA90 == 77 or LA90 == 78: + LA90 = self.input.LA(2) + if LA90 == 61: + LA90_281 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == IDENTIFIER: + LA90_282 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == HEX_LITERAL: + LA90_283 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == OCTAL_LITERAL: + LA90_284 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == DECIMAL_LITERAL: + LA90_285 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == CHARACTER_LITERAL: + LA90_286 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == STRING_LITERAL: + LA90_287 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == FLOATING_POINT_LITERAL: + LA90_288 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_289 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_290 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65 or LA90 == 67 or LA90 == 68 or LA90 == 76 or LA90 == 77 or LA90 == 78: + LA90_291 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 73: + LA90_292 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 73: + LA90 = self.input.LA(2) + if LA90 == 61: + LA90_293 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == IDENTIFIER: + LA90_294 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == HEX_LITERAL: + LA90_295 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == OCTAL_LITERAL: + LA90_296 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == DECIMAL_LITERAL: + LA90_297 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == CHARACTER_LITERAL: + LA90_298 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == STRING_LITERAL: + LA90_299 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == FLOATING_POINT_LITERAL: + LA90_300 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 71: + LA90_301 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 72: + LA90_302 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 65 or LA90 == 67 or LA90 == 68 or LA90 == 76 or LA90 == 77 or LA90 == 78: + LA90_303 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + elif LA90 == 73: + LA90_304 = self.input.LA(3) + + if (self.synpred181()) : + alt90 = 1 + if alt90 == 1: + # C.g:0:0: statement_list + self.following.append(self.FOLLOW_statement_list_in_macro_statement2155) + self.statement_list() + self.following.pop() + if self.failed: + return + + + + # C.g:491:49: ( expression )? + alt91 = 2 + LA91_0 = self.input.LA(1) + + if ((IDENTIFIER <= LA91_0 <= FLOATING_POINT_LITERAL) or LA91_0 == 61 or LA91_0 == 65 or (67 <= LA91_0 <= 68) or (71 <= LA91_0 <= 73) or (76 <= LA91_0 <= 78)) : + alt91 = 1 + if alt91 == 1: + # C.g:0:0: expression + self.following.append(self.FOLLOW_expression_in_macro_statement2158) + self.expression() + self.following.pop() + if self.failed: + return + + + + self.match(self.input, 62, self.FOLLOW_62_in_macro_statement2161) + if self.failed: + return + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 64, macro_statement_StartIndex) + + pass + + return + + # $ANTLR end macro_statement + + + # $ANTLR start labeled_statement + # C.g:494:1: labeled_statement : ( IDENTIFIER ':' statement | 'case' constant_expression ':' statement | 'default' ':' statement ); + def labeled_statement(self, ): + + labeled_statement_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 65): + return + + # C.g:495:2: ( IDENTIFIER ':' statement | 'case' constant_expression ':' statement | 'default' ':' statement ) + alt92 = 3 + LA92 = self.input.LA(1) + if LA92 == IDENTIFIER: + alt92 = 1 + elif LA92 == 105: + alt92 = 2 + elif LA92 == 106: + alt92 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("494:1: labeled_statement : ( IDENTIFIER ':' statement | 'case' constant_expression ':' statement | 'default' ':' statement );", 92, 0, self.input) + + raise nvae + + if alt92 == 1: + # C.g:495:4: IDENTIFIER ':' statement + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_labeled_statement2173) + if self.failed: + return + self.match(self.input, 47, self.FOLLOW_47_in_labeled_statement2175) + if self.failed: + return + self.following.append(self.FOLLOW_statement_in_labeled_statement2177) + self.statement() + self.following.pop() + if self.failed: + return + + + elif alt92 == 2: + # C.g:496:4: 'case' constant_expression ':' statement + self.match(self.input, 105, self.FOLLOW_105_in_labeled_statement2182) + if self.failed: + return + self.following.append(self.FOLLOW_constant_expression_in_labeled_statement2184) + self.constant_expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 47, self.FOLLOW_47_in_labeled_statement2186) + if self.failed: + return + self.following.append(self.FOLLOW_statement_in_labeled_statement2188) + self.statement() + self.following.pop() + if self.failed: + return + + + elif alt92 == 3: + # C.g:497:4: 'default' ':' statement + self.match(self.input, 106, self.FOLLOW_106_in_labeled_statement2193) + if self.failed: + return + self.match(self.input, 47, self.FOLLOW_47_in_labeled_statement2195) + if self.failed: + return + self.following.append(self.FOLLOW_statement_in_labeled_statement2197) + self.statement() + self.following.pop() + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 65, labeled_statement_StartIndex) + + pass + + return + + # $ANTLR end labeled_statement + + class compound_statement_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start compound_statement + # C.g:500:1: compound_statement : '{' ( declaration )* ( statement_list )? '}' ; + def compound_statement(self, ): + + retval = self.compound_statement_return() + retval.start = self.input.LT(1) + compound_statement_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 66): + return retval + + # C.g:501:2: ( '{' ( declaration )* ( statement_list )? '}' ) + # C.g:501:4: '{' ( declaration )* ( statement_list )? '}' + self.match(self.input, 43, self.FOLLOW_43_in_compound_statement2208) + if self.failed: + return retval + # C.g:501:8: ( declaration )* + while True: #loop93 + alt93 = 2 + LA93 = self.input.LA(1) + if LA93 == IDENTIFIER: + LA93 = self.input.LA(2) + if LA93 == 61: + LA93_44 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 65: + LA93_48 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_67 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_69 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_70 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_71 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_72 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_73 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_74 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_75 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_76 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_77 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_78 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_79 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_80 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_81 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_82 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_83 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_84 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_85 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 26: + LA93 = self.input.LA(2) + if LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_86 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_87 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_88 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_89 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_90 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_91 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_92 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_93 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_94 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_95 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_96 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_97 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_98 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_99 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 65: + LA93_100 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_101 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_102 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_103 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_104 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_105 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_106 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_107 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_108 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_109 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_110 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_111 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_112 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_113 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_114 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_115 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_116 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_117 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_118 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_119 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_120 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_121 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_122 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_123 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_124 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 34: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_125 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_126 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_127 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_128 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_129 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_130 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_131 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_132 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_133 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_134 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_135 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_136 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_137 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_138 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_139 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_140 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_141 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_142 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_143 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_144 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 35: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_145 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_146 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_147 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_148 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_149 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_150 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_151 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_152 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_153 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_154 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_155 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_156 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_157 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_158 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_159 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_160 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_161 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_162 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_163 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_164 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 36: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_165 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_166 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_167 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_168 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_169 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_170 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_171 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_172 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_173 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_174 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_175 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_176 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_177 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_178 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_179 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_180 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_181 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_182 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_183 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_184 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 37: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_185 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_186 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_187 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_188 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_189 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_190 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_191 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_192 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_193 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_194 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_195 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_196 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_197 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_198 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_199 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_200 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_201 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_202 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_203 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_204 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 38: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_205 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_206 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_207 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_208 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_209 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_210 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_211 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_212 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_213 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_214 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_215 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_216 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_217 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_218 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_219 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_220 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_221 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_222 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_223 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_224 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 39: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_225 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_226 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_227 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_228 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_229 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_230 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_231 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_232 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_233 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_234 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_235 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_236 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_237 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_238 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_239 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_240 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_241 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_242 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_243 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_244 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 40: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_245 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_246 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_247 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_248 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_249 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_250 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_251 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_252 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_253 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_254 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_255 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_256 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_257 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_258 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_259 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_260 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_261 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_262 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_263 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_264 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 41: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_265 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_266 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_267 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_268 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_269 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_270 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_271 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_272 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_273 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_274 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_275 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_276 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_277 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_278 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_279 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_280 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_281 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_282 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_283 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_284 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 42: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_285 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_286 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_287 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_288 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_289 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_290 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_291 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_292 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_293 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_294 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_295 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_296 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_297 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_298 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_299 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_300 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_301 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_302 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_303 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_304 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + elif LA93 == 45 or LA93 == 46: + LA93_40 = self.input.LA(2) + + if (LA93_40 == IDENTIFIER) : + LA93_305 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif (LA93_40 == 43) : + LA93_306 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + + elif LA93 == 48: + LA93_41 = self.input.LA(2) + + if (LA93_41 == IDENTIFIER) : + LA93_307 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif (LA93_41 == 43) : + LA93_308 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57 or LA93 == 58 or LA93 == 59 or LA93 == 60: + LA93 = self.input.LA(2) + if LA93 == 65: + LA93_309 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 58: + LA93_310 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 59: + LA93_311 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 60: + LA93_312 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == IDENTIFIER: + LA93_313 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 61: + LA93_314 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 25: + LA93_315 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 29 or LA93 == 30 or LA93 == 31 or LA93 == 32 or LA93 == 33: + LA93_316 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 34: + LA93_317 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 35: + LA93_318 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 36: + LA93_319 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 37: + LA93_320 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 38: + LA93_321 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 39: + LA93_322 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 40: + LA93_323 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 41: + LA93_324 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 42: + LA93_325 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 45 or LA93 == 46: + LA93_326 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 48: + LA93_327 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + elif LA93 == 49 or LA93 == 50 or LA93 == 51 or LA93 == 52 or LA93 == 53 or LA93 == 54 or LA93 == 55 or LA93 == 56 or LA93 == 57: + LA93_328 = self.input.LA(3) + + if (self.synpred185()) : + alt93 = 1 + + + + + if alt93 == 1: + # C.g:0:0: declaration + self.following.append(self.FOLLOW_declaration_in_compound_statement2210) + self.declaration() + self.following.pop() + if self.failed: + return retval + + + else: + break #loop93 + + + # C.g:501:21: ( statement_list )? + alt94 = 2 + LA94_0 = self.input.LA(1) + + if ((IDENTIFIER <= LA94_0 <= FLOATING_POINT_LITERAL) or (25 <= LA94_0 <= 26) or (29 <= LA94_0 <= 43) or (45 <= LA94_0 <= 46) or (48 <= LA94_0 <= 61) or LA94_0 == 65 or (67 <= LA94_0 <= 68) or (71 <= LA94_0 <= 73) or (76 <= LA94_0 <= 78) or (102 <= LA94_0 <= 107) or (109 <= LA94_0 <= 116)) : + alt94 = 1 + if alt94 == 1: + # C.g:0:0: statement_list + self.following.append(self.FOLLOW_statement_list_in_compound_statement2213) + self.statement_list() + self.following.pop() + if self.failed: + return retval + + + + self.match(self.input, 44, self.FOLLOW_44_in_compound_statement2216) + if self.failed: + return retval + + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 66, compound_statement_StartIndex) + + pass + + return retval + + # $ANTLR end compound_statement + + + # $ANTLR start statement_list + # C.g:504:1: statement_list : ( statement )+ ; + def statement_list(self, ): + + statement_list_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 67): + return + + # C.g:505:2: ( ( statement )+ ) + # C.g:505:4: ( statement )+ + # C.g:505:4: ( statement )+ + cnt95 = 0 + while True: #loop95 + alt95 = 2 + LA95 = self.input.LA(1) + if LA95 == IDENTIFIER: + LA95 = self.input.LA(2) + if LA95 == 25 or LA95 == 29 or LA95 == 30 or LA95 == 31 or LA95 == 32 or LA95 == 33 or LA95 == 34 or LA95 == 35 or LA95 == 36 or LA95 == 37 or LA95 == 38 or LA95 == 39 or LA95 == 40 or LA95 == 41 or LA95 == 42 or LA95 == 45 or LA95 == 46 or LA95 == 47 or LA95 == 48 or LA95 == 49 or LA95 == 50 or LA95 == 51 or LA95 == 52 or LA95 == 53 or LA95 == 54 or LA95 == 55 or LA95 == 56 or LA95 == 57 or LA95 == 58 or LA95 == 59 or LA95 == 60: + alt95 = 1 + elif LA95 == 61: + LA95_47 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 63: + LA95_48 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 74: + LA95_49 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65: + LA95_50 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 75: + LA95_51 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_52 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_53 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 28 or LA95 == 79 or LA95 == 80 or LA95 == 81 or LA95 == 82 or LA95 == 83 or LA95 == 84 or LA95 == 85 or LA95 == 86 or LA95 == 87 or LA95 == 88: + LA95_54 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == STRING_LITERAL: + LA95_55 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == IDENTIFIER: + LA95_56 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 69: + LA95_57 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 70: + LA95_58 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 67: + LA95_59 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 68: + LA95_60 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 100 or LA95 == 101: + LA95_61 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 96 or LA95 == 97 or LA95 == 98 or LA95 == 99: + LA95_62 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 94 or LA95 == 95: + LA95_63 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 76: + LA95_64 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 93: + LA95_65 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 92: + LA95_66 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 91: + LA95_67 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 90: + LA95_68 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 89: + LA95_69 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 27: + LA95_70 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + + elif LA95 == HEX_LITERAL: + LA95 = self.input.LA(2) + if LA95 == 63: + LA95_89 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 61: + LA95_90 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 74: + LA95_91 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65: + LA95_92 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 75: + LA95_93 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_94 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_95 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 69: + LA95_96 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 70: + LA95_97 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 67: + LA95_98 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 68: + LA95_99 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 100 or LA95 == 101: + LA95_100 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 96 or LA95 == 97 or LA95 == 98 or LA95 == 99: + LA95_101 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 94 or LA95 == 95: + LA95_102 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 76: + LA95_103 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 93: + LA95_104 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 92: + LA95_105 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 91: + LA95_106 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 90: + LA95_107 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 89: + LA95_108 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 27: + LA95_109 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 25: + alt95 = 1 + elif LA95 == 28 or LA95 == 79 or LA95 == 80 or LA95 == 81 or LA95 == 82 or LA95 == 83 or LA95 == 84 or LA95 == 85 or LA95 == 86 or LA95 == 87 or LA95 == 88: + LA95_112 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + + elif LA95 == OCTAL_LITERAL: + LA95 = self.input.LA(2) + if LA95 == 63: + LA95_113 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 61: + LA95_114 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 74: + LA95_115 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65: + LA95_116 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 75: + LA95_117 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_118 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_119 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 28 or LA95 == 79 or LA95 == 80 or LA95 == 81 or LA95 == 82 or LA95 == 83 or LA95 == 84 or LA95 == 85 or LA95 == 86 or LA95 == 87 or LA95 == 88: + LA95_120 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 69: + LA95_121 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 70: + LA95_122 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 67: + LA95_123 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 68: + LA95_124 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 100 or LA95 == 101: + LA95_125 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 96 or LA95 == 97 or LA95 == 98 or LA95 == 99: + LA95_126 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 94 or LA95 == 95: + LA95_127 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 76: + LA95_128 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 93: + LA95_129 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 92: + LA95_130 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 91: + LA95_131 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 90: + LA95_132 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 89: + LA95_133 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 27: + LA95_134 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 25: + alt95 = 1 + + elif LA95 == DECIMAL_LITERAL: + LA95 = self.input.LA(2) + if LA95 == 63: + LA95_137 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 61: + LA95_138 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 74: + LA95_139 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65: + LA95_140 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 75: + LA95_141 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_142 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_143 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 28 or LA95 == 79 or LA95 == 80 or LA95 == 81 or LA95 == 82 or LA95 == 83 or LA95 == 84 or LA95 == 85 or LA95 == 86 or LA95 == 87 or LA95 == 88: + LA95_144 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 69: + LA95_145 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 70: + LA95_146 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 67: + LA95_147 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 68: + LA95_148 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 100 or LA95 == 101: + LA95_149 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 96 or LA95 == 97 or LA95 == 98 or LA95 == 99: + LA95_150 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 94 or LA95 == 95: + LA95_151 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 76: + LA95_152 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 93: + LA95_153 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 92: + LA95_154 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 91: + LA95_155 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 90: + LA95_156 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 89: + LA95_157 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 27: + LA95_158 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 25: + alt95 = 1 + + elif LA95 == CHARACTER_LITERAL: + LA95 = self.input.LA(2) + if LA95 == 63: + LA95_161 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 61: + LA95_162 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 74: + LA95_163 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65: + LA95_164 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 75: + LA95_165 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_166 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_167 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 28 or LA95 == 79 or LA95 == 80 or LA95 == 81 or LA95 == 82 or LA95 == 83 or LA95 == 84 or LA95 == 85 or LA95 == 86 or LA95 == 87 or LA95 == 88: + LA95_168 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 69: + LA95_169 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 70: + LA95_170 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 67: + LA95_171 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 68: + LA95_172 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 100 or LA95 == 101: + LA95_173 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 96 or LA95 == 97 or LA95 == 98 or LA95 == 99: + LA95_174 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 94 or LA95 == 95: + LA95_175 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 76: + LA95_176 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 93: + LA95_177 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 92: + LA95_178 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 91: + LA95_179 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 90: + LA95_180 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 89: + LA95_181 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 27: + LA95_182 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 25: + alt95 = 1 + + elif LA95 == STRING_LITERAL: + LA95 = self.input.LA(2) + if LA95 == IDENTIFIER: + LA95_185 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 63: + LA95_186 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 61: + LA95_187 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 74: + LA95_188 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65: + LA95_189 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 75: + LA95_190 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_191 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_192 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 69: + LA95_193 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 70: + LA95_194 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 67: + LA95_195 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 68: + LA95_196 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 100 or LA95 == 101: + LA95_197 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 96 or LA95 == 97 or LA95 == 98 or LA95 == 99: + LA95_198 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 94 or LA95 == 95: + LA95_199 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 76: + LA95_200 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 93: + LA95_201 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 92: + LA95_202 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 91: + LA95_203 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 90: + LA95_204 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 89: + LA95_205 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 27: + LA95_206 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 25: + alt95 = 1 + elif LA95 == STRING_LITERAL: + LA95_208 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 28 or LA95 == 79 or LA95 == 80 or LA95 == 81 or LA95 == 82 or LA95 == 83 or LA95 == 84 or LA95 == 85 or LA95 == 86 or LA95 == 87 or LA95 == 88: + LA95_210 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + + elif LA95 == FLOATING_POINT_LITERAL: + LA95 = self.input.LA(2) + if LA95 == 63: + LA95_211 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 61: + LA95_212 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 74: + LA95_213 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65: + LA95_214 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 75: + LA95_215 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_216 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_217 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 69: + LA95_218 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 70: + LA95_219 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 67: + LA95_220 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 68: + LA95_221 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 100 or LA95 == 101: + LA95_222 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 96 or LA95 == 97 or LA95 == 98 or LA95 == 99: + LA95_223 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 94 or LA95 == 95: + LA95_224 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 76: + LA95_225 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 93: + LA95_226 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 92: + LA95_227 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 91: + LA95_228 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 90: + LA95_229 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 89: + LA95_230 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 27: + LA95_231 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 28 or LA95 == 79 or LA95 == 80 or LA95 == 81 or LA95 == 82 or LA95 == 83 or LA95 == 84 or LA95 == 85 or LA95 == 86 or LA95 == 87 or LA95 == 88: + LA95_233 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 25: + alt95 = 1 + + elif LA95 == 61: + LA95 = self.input.LA(2) + if LA95 == IDENTIFIER: + LA95_235 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == HEX_LITERAL: + LA95_236 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == OCTAL_LITERAL: + LA95_237 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == DECIMAL_LITERAL: + LA95_238 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == CHARACTER_LITERAL: + LA95_239 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == STRING_LITERAL: + LA95_240 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == FLOATING_POINT_LITERAL: + LA95_241 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 61: + LA95_242 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_243 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_244 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65 or LA95 == 67 or LA95 == 68 or LA95 == 76 or LA95 == 77 or LA95 == 78: + LA95_245 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 73: + LA95_246 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 49 or LA95 == 50 or LA95 == 51 or LA95 == 52 or LA95 == 53 or LA95 == 54 or LA95 == 55 or LA95 == 56 or LA95 == 57 or LA95 == 58 or LA95 == 59 or LA95 == 60: + LA95_247 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 34: + LA95_248 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 35: + LA95_249 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 36: + LA95_250 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 37: + LA95_251 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 38: + LA95_252 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 39: + LA95_253 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 40: + LA95_254 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 41: + LA95_255 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 42: + LA95_256 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 45 or LA95 == 46: + LA95_257 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 48: + LA95_258 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + + elif LA95 == 71: + LA95 = self.input.LA(2) + if LA95 == IDENTIFIER: + LA95_259 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == HEX_LITERAL: + LA95_260 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == OCTAL_LITERAL: + LA95_261 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == DECIMAL_LITERAL: + LA95_262 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == CHARACTER_LITERAL: + LA95_263 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == STRING_LITERAL: + LA95_264 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == FLOATING_POINT_LITERAL: + LA95_265 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 61: + LA95_266 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_267 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_268 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65 or LA95 == 67 or LA95 == 68 or LA95 == 76 or LA95 == 77 or LA95 == 78: + LA95_269 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 73: + LA95_270 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + + elif LA95 == 72: + LA95 = self.input.LA(2) + if LA95 == IDENTIFIER: + LA95_271 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == HEX_LITERAL: + LA95_272 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == OCTAL_LITERAL: + LA95_273 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == DECIMAL_LITERAL: + LA95_274 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == CHARACTER_LITERAL: + LA95_275 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == STRING_LITERAL: + LA95_276 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == FLOATING_POINT_LITERAL: + LA95_277 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 61: + LA95_278 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_279 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_280 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65 or LA95 == 67 or LA95 == 68 or LA95 == 76 or LA95 == 77 or LA95 == 78: + LA95_281 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 73: + LA95_282 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + + elif LA95 == 65 or LA95 == 67 or LA95 == 68 or LA95 == 76 or LA95 == 77 or LA95 == 78: + LA95 = self.input.LA(2) + if LA95 == 61: + LA95_283 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == IDENTIFIER: + LA95_284 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == HEX_LITERAL: + LA95_285 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == OCTAL_LITERAL: + LA95_286 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == DECIMAL_LITERAL: + LA95_287 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == CHARACTER_LITERAL: + LA95_288 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == STRING_LITERAL: + LA95_289 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == FLOATING_POINT_LITERAL: + LA95_290 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_291 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_292 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65 or LA95 == 67 or LA95 == 68 or LA95 == 76 or LA95 == 77 or LA95 == 78: + LA95_293 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 73: + LA95_294 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + + elif LA95 == 73: + LA95 = self.input.LA(2) + if LA95 == 61: + LA95_295 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == IDENTIFIER: + LA95_296 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == HEX_LITERAL: + LA95_297 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == OCTAL_LITERAL: + LA95_298 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == DECIMAL_LITERAL: + LA95_299 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == CHARACTER_LITERAL: + LA95_300 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == STRING_LITERAL: + LA95_301 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == FLOATING_POINT_LITERAL: + LA95_302 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 71: + LA95_303 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 72: + LA95_304 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 65 or LA95 == 67 or LA95 == 68 or LA95 == 76 or LA95 == 77 or LA95 == 78: + LA95_305 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + elif LA95 == 73: + LA95_306 = self.input.LA(3) + + if (self.synpred187()) : + alt95 = 1 + + + + elif LA95 == 25 or LA95 == 26 or LA95 == 29 or LA95 == 30 or LA95 == 31 or LA95 == 32 or LA95 == 33 or LA95 == 34 or LA95 == 35 or LA95 == 36 or LA95 == 37 or LA95 == 38 or LA95 == 39 or LA95 == 40 or LA95 == 41 or LA95 == 42 or LA95 == 43 or LA95 == 45 or LA95 == 46 or LA95 == 48 or LA95 == 49 or LA95 == 50 or LA95 == 51 or LA95 == 52 or LA95 == 53 or LA95 == 54 or LA95 == 55 or LA95 == 56 or LA95 == 57 or LA95 == 58 or LA95 == 59 or LA95 == 60 or LA95 == 102 or LA95 == 103 or LA95 == 104 or LA95 == 105 or LA95 == 106 or LA95 == 107 or LA95 == 109 or LA95 == 110 or LA95 == 111 or LA95 == 112 or LA95 == 113 or LA95 == 114 or LA95 == 115 or LA95 == 116: + alt95 = 1 + + if alt95 == 1: + # C.g:0:0: statement + self.following.append(self.FOLLOW_statement_in_statement_list2227) + self.statement() + self.following.pop() + if self.failed: + return + + + else: + if cnt95 >= 1: + break #loop95 + + if self.backtracking > 0: + self.failed = True + return + + eee = EarlyExitException(95, self.input) + raise eee + + cnt95 += 1 + + + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 67, statement_list_StartIndex) + + pass + + return + + # $ANTLR end statement_list + + class expression_statement_return(object): + def __init__(self): + self.start = None + self.stop = None + + + + # $ANTLR start expression_statement + # C.g:508:1: expression_statement : ( ';' | expression ';' ); + def expression_statement(self, ): + + retval = self.expression_statement_return() + retval.start = self.input.LT(1) + expression_statement_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 68): + return retval + + # C.g:509:2: ( ';' | expression ';' ) + alt96 = 2 + LA96_0 = self.input.LA(1) + + if (LA96_0 == 25) : + alt96 = 1 + elif ((IDENTIFIER <= LA96_0 <= FLOATING_POINT_LITERAL) or LA96_0 == 61 or LA96_0 == 65 or (67 <= LA96_0 <= 68) or (71 <= LA96_0 <= 73) or (76 <= LA96_0 <= 78)) : + alt96 = 2 + else: + if self.backtracking > 0: + self.failed = True + return retval + + nvae = NoViableAltException("508:1: expression_statement : ( ';' | expression ';' );", 96, 0, self.input) + + raise nvae + + if alt96 == 1: + # C.g:509:4: ';' + self.match(self.input, 25, self.FOLLOW_25_in_expression_statement2239) + if self.failed: + return retval + + + elif alt96 == 2: + # C.g:510:4: expression ';' + self.following.append(self.FOLLOW_expression_in_expression_statement2244) + self.expression() + self.following.pop() + if self.failed: + return retval + self.match(self.input, 25, self.FOLLOW_25_in_expression_statement2246) + if self.failed: + return retval + + + retval.stop = self.input.LT(-1) + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 68, expression_statement_StartIndex) + + pass + + return retval + + # $ANTLR end expression_statement + + + # $ANTLR start selection_statement + # C.g:513:1: selection_statement : ( 'if' '(' e= expression ')' statement ( options {k=1; backtrack=false; } : 'else' statement )? | 'switch' '(' expression ')' statement ); + def selection_statement(self, ): + + selection_statement_StartIndex = self.input.index() + e = None + + + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 69): + return + + # C.g:514:2: ( 'if' '(' e= expression ')' statement ( options {k=1; backtrack=false; } : 'else' statement )? | 'switch' '(' expression ')' statement ) + alt98 = 2 + LA98_0 = self.input.LA(1) + + if (LA98_0 == 107) : + alt98 = 1 + elif (LA98_0 == 109) : + alt98 = 2 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("513:1: selection_statement : ( 'if' '(' e= expression ')' statement ( options {k=1; backtrack=false; } : 'else' statement )? | 'switch' '(' expression ')' statement );", 98, 0, self.input) + + raise nvae + + if alt98 == 1: + # C.g:514:4: 'if' '(' e= expression ')' statement ( options {k=1; backtrack=false; } : 'else' statement )? + self.match(self.input, 107, self.FOLLOW_107_in_selection_statement2257) + if self.failed: + return + self.match(self.input, 61, self.FOLLOW_61_in_selection_statement2259) + if self.failed: + return + self.following.append(self.FOLLOW_expression_in_selection_statement2263) + e = self.expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_selection_statement2265) + if self.failed: + return + if self.backtracking == 0: + self.StorePredicateExpression(e.start.line, e.start.charPositionInLine, e.stop.line, e.stop.charPositionInLine, self.input.toString(e.start,e.stop)) + + self.following.append(self.FOLLOW_statement_in_selection_statement2269) + self.statement() + self.following.pop() + if self.failed: + return + # C.g:514:167: ( options {k=1; backtrack=false; } : 'else' statement )? + alt97 = 2 + LA97_0 = self.input.LA(1) + + if (LA97_0 == 108) : + alt97 = 1 + if alt97 == 1: + # C.g:514:200: 'else' statement + self.match(self.input, 108, self.FOLLOW_108_in_selection_statement2284) + if self.failed: + return + self.following.append(self.FOLLOW_statement_in_selection_statement2286) + self.statement() + self.following.pop() + if self.failed: + return + + + + + + elif alt98 == 2: + # C.g:515:4: 'switch' '(' expression ')' statement + self.match(self.input, 109, self.FOLLOW_109_in_selection_statement2293) + if self.failed: + return + self.match(self.input, 61, self.FOLLOW_61_in_selection_statement2295) + if self.failed: + return + self.following.append(self.FOLLOW_expression_in_selection_statement2297) + self.expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_selection_statement2299) + if self.failed: + return + self.following.append(self.FOLLOW_statement_in_selection_statement2301) + self.statement() + self.following.pop() + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 69, selection_statement_StartIndex) + + pass + + return + + # $ANTLR end selection_statement + + + # $ANTLR start iteration_statement + # C.g:518:1: iteration_statement : ( 'while' '(' e= expression ')' statement | 'do' statement 'while' '(' e= expression ')' ';' | 'for' '(' expression_statement e= expression_statement ( expression )? ')' statement ); + def iteration_statement(self, ): + + iteration_statement_StartIndex = self.input.index() + e = None + + + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 70): + return + + # C.g:519:2: ( 'while' '(' e= expression ')' statement | 'do' statement 'while' '(' e= expression ')' ';' | 'for' '(' expression_statement e= expression_statement ( expression )? ')' statement ) + alt100 = 3 + LA100 = self.input.LA(1) + if LA100 == 110: + alt100 = 1 + elif LA100 == 111: + alt100 = 2 + elif LA100 == 112: + alt100 = 3 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("518:1: iteration_statement : ( 'while' '(' e= expression ')' statement | 'do' statement 'while' '(' e= expression ')' ';' | 'for' '(' expression_statement e= expression_statement ( expression )? ')' statement );", 100, 0, self.input) + + raise nvae + + if alt100 == 1: + # C.g:519:4: 'while' '(' e= expression ')' statement + self.match(self.input, 110, self.FOLLOW_110_in_iteration_statement2312) + if self.failed: + return + self.match(self.input, 61, self.FOLLOW_61_in_iteration_statement2314) + if self.failed: + return + self.following.append(self.FOLLOW_expression_in_iteration_statement2318) + e = self.expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_iteration_statement2320) + if self.failed: + return + self.following.append(self.FOLLOW_statement_in_iteration_statement2322) + self.statement() + self.following.pop() + if self.failed: + return + if self.backtracking == 0: + self.StorePredicateExpression(e.start.line, e.start.charPositionInLine, e.stop.line, e.stop.charPositionInLine, self.input.toString(e.start,e.stop)) + + + + elif alt100 == 2: + # C.g:520:4: 'do' statement 'while' '(' e= expression ')' ';' + self.match(self.input, 111, self.FOLLOW_111_in_iteration_statement2329) + if self.failed: + return + self.following.append(self.FOLLOW_statement_in_iteration_statement2331) + self.statement() + self.following.pop() + if self.failed: + return + self.match(self.input, 110, self.FOLLOW_110_in_iteration_statement2333) + if self.failed: + return + self.match(self.input, 61, self.FOLLOW_61_in_iteration_statement2335) + if self.failed: + return + self.following.append(self.FOLLOW_expression_in_iteration_statement2339) + e = self.expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_iteration_statement2341) + if self.failed: + return + self.match(self.input, 25, self.FOLLOW_25_in_iteration_statement2343) + if self.failed: + return + if self.backtracking == 0: + self.StorePredicateExpression(e.start.line, e.start.charPositionInLine, e.stop.line, e.stop.charPositionInLine, self.input.toString(e.start,e.stop)) + + + + elif alt100 == 3: + # C.g:521:4: 'for' '(' expression_statement e= expression_statement ( expression )? ')' statement + self.match(self.input, 112, self.FOLLOW_112_in_iteration_statement2350) + if self.failed: + return + self.match(self.input, 61, self.FOLLOW_61_in_iteration_statement2352) + if self.failed: + return + self.following.append(self.FOLLOW_expression_statement_in_iteration_statement2354) + self.expression_statement() + self.following.pop() + if self.failed: + return + self.following.append(self.FOLLOW_expression_statement_in_iteration_statement2358) + e = self.expression_statement() + self.following.pop() + if self.failed: + return + # C.g:521:58: ( expression )? + alt99 = 2 + LA99_0 = self.input.LA(1) + + if ((IDENTIFIER <= LA99_0 <= FLOATING_POINT_LITERAL) or LA99_0 == 61 or LA99_0 == 65 or (67 <= LA99_0 <= 68) or (71 <= LA99_0 <= 73) or (76 <= LA99_0 <= 78)) : + alt99 = 1 + if alt99 == 1: + # C.g:0:0: expression + self.following.append(self.FOLLOW_expression_in_iteration_statement2360) + self.expression() + self.following.pop() + if self.failed: + return + + + + self.match(self.input, 62, self.FOLLOW_62_in_iteration_statement2363) + if self.failed: + return + self.following.append(self.FOLLOW_statement_in_iteration_statement2365) + self.statement() + self.following.pop() + if self.failed: + return + if self.backtracking == 0: + self.StorePredicateExpression(e.start.line, e.start.charPositionInLine, e.stop.line, e.stop.charPositionInLine, self.input.toString(e.start,e.stop)) + + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 70, iteration_statement_StartIndex) + + pass + + return + + # $ANTLR end iteration_statement + + + # $ANTLR start jump_statement + # C.g:524:1: jump_statement : ( 'goto' IDENTIFIER ';' | 'continue' ';' | 'break' ';' | 'return' ';' | 'return' expression ';' ); + def jump_statement(self, ): + + jump_statement_StartIndex = self.input.index() + try: + try: + if self.backtracking > 0 and self.alreadyParsedRule(self.input, 71): + return + + # C.g:525:2: ( 'goto' IDENTIFIER ';' | 'continue' ';' | 'break' ';' | 'return' ';' | 'return' expression ';' ) + alt101 = 5 + LA101 = self.input.LA(1) + if LA101 == 113: + alt101 = 1 + elif LA101 == 114: + alt101 = 2 + elif LA101 == 115: + alt101 = 3 + elif LA101 == 116: + LA101_4 = self.input.LA(2) + + if (LA101_4 == 25) : + alt101 = 4 + elif ((IDENTIFIER <= LA101_4 <= FLOATING_POINT_LITERAL) or LA101_4 == 61 or LA101_4 == 65 or (67 <= LA101_4 <= 68) or (71 <= LA101_4 <= 73) or (76 <= LA101_4 <= 78)) : + alt101 = 5 + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("524:1: jump_statement : ( 'goto' IDENTIFIER ';' | 'continue' ';' | 'break' ';' | 'return' ';' | 'return' expression ';' );", 101, 4, self.input) + + raise nvae + + else: + if self.backtracking > 0: + self.failed = True + return + + nvae = NoViableAltException("524:1: jump_statement : ( 'goto' IDENTIFIER ';' | 'continue' ';' | 'break' ';' | 'return' ';' | 'return' expression ';' );", 101, 0, self.input) + + raise nvae + + if alt101 == 1: + # C.g:525:4: 'goto' IDENTIFIER ';' + self.match(self.input, 113, self.FOLLOW_113_in_jump_statement2378) + if self.failed: + return + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_jump_statement2380) + if self.failed: + return + self.match(self.input, 25, self.FOLLOW_25_in_jump_statement2382) + if self.failed: + return + + + elif alt101 == 2: + # C.g:526:4: 'continue' ';' + self.match(self.input, 114, self.FOLLOW_114_in_jump_statement2387) + if self.failed: + return + self.match(self.input, 25, self.FOLLOW_25_in_jump_statement2389) + if self.failed: + return + + + elif alt101 == 3: + # C.g:527:4: 'break' ';' + self.match(self.input, 115, self.FOLLOW_115_in_jump_statement2394) + if self.failed: + return + self.match(self.input, 25, self.FOLLOW_25_in_jump_statement2396) + if self.failed: + return + + + elif alt101 == 4: + # C.g:528:4: 'return' ';' + self.match(self.input, 116, self.FOLLOW_116_in_jump_statement2401) + if self.failed: + return + self.match(self.input, 25, self.FOLLOW_25_in_jump_statement2403) + if self.failed: + return + + + elif alt101 == 5: + # C.g:529:4: 'return' expression ';' + self.match(self.input, 116, self.FOLLOW_116_in_jump_statement2408) + if self.failed: + return + self.following.append(self.FOLLOW_expression_in_jump_statement2410) + self.expression() + self.following.pop() + if self.failed: + return + self.match(self.input, 25, self.FOLLOW_25_in_jump_statement2412) + if self.failed: + return + + + + except RecognitionException, re: + self.reportError(re) + self.recover(self.input, re) + finally: + if self.backtracking > 0: + self.memoize(self.input, 71, jump_statement_StartIndex) + + pass + + return + + # $ANTLR end jump_statement + + # $ANTLR start synpred2 + def synpred2_fragment(self, ): + # C.g:67:6: ( declaration_specifiers ) + # C.g:67:6: declaration_specifiers + self.following.append(self.FOLLOW_declaration_specifiers_in_synpred290) + self.declaration_specifiers() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred2 + + + + # $ANTLR start synpred4 + def synpred4_fragment(self, ): + # C.g:67:4: ( ( declaration_specifiers )? declarator ( declaration )* '{' ) + # C.g:67:6: ( declaration_specifiers )? declarator ( declaration )* '{' + # C.g:67:6: ( declaration_specifiers )? + alt102 = 2 + LA102 = self.input.LA(1) + if LA102 == 29 or LA102 == 30 or LA102 == 31 or LA102 == 32 or LA102 == 33 or LA102 == 34 or LA102 == 35 or LA102 == 36 or LA102 == 37 or LA102 == 38 or LA102 == 39 or LA102 == 40 or LA102 == 41 or LA102 == 42 or LA102 == 45 or LA102 == 46 or LA102 == 48 or LA102 == 49 or LA102 == 50 or LA102 == 51 or LA102 == 52 or LA102 == 53 or LA102 == 54 or LA102 == 55 or LA102 == 56 or LA102 == 57: + alt102 = 1 + elif LA102 == IDENTIFIER: + LA102 = self.input.LA(2) + if LA102 == 65: + alt102 = 1 + elif LA102 == 58: + LA102_21 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 59: + LA102_22 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 60: + LA102_23 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == IDENTIFIER: + LA102_24 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 61: + LA102_25 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 29 or LA102 == 30 or LA102 == 31 or LA102 == 32 or LA102 == 33: + LA102_26 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 34: + LA102_27 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 35: + LA102_28 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 36: + LA102_29 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 37: + LA102_30 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 38: + LA102_31 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 39: + LA102_32 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 40: + LA102_33 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 41: + LA102_34 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 42: + LA102_35 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 45 or LA102 == 46: + LA102_36 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 48: + LA102_37 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 49 or LA102 == 50 or LA102 == 51 or LA102 == 52 or LA102 == 53 or LA102 == 54 or LA102 == 55 or LA102 == 56 or LA102 == 57: + LA102_38 = self.input.LA(3) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 58: + LA102_14 = self.input.LA(2) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 59: + LA102_16 = self.input.LA(2) + + if (self.synpred2()) : + alt102 = 1 + elif LA102 == 60: + LA102_17 = self.input.LA(2) + + if (self.synpred2()) : + alt102 = 1 + if alt102 == 1: + # C.g:0:0: declaration_specifiers + self.following.append(self.FOLLOW_declaration_specifiers_in_synpred490) + self.declaration_specifiers() + self.following.pop() + if self.failed: + return + + + + self.following.append(self.FOLLOW_declarator_in_synpred493) + self.declarator() + self.following.pop() + if self.failed: + return + # C.g:67:41: ( declaration )* + while True: #loop103 + alt103 = 2 + LA103_0 = self.input.LA(1) + + if (LA103_0 == IDENTIFIER or LA103_0 == 26 or (29 <= LA103_0 <= 42) or (45 <= LA103_0 <= 46) or (48 <= LA103_0 <= 60)) : + alt103 = 1 + + + if alt103 == 1: + # C.g:0:0: declaration + self.following.append(self.FOLLOW_declaration_in_synpred495) + self.declaration() + self.following.pop() + if self.failed: + return + + + else: + break #loop103 + + + self.match(self.input, 43, self.FOLLOW_43_in_synpred498) + if self.failed: + return + + + # $ANTLR end synpred4 + + + + # $ANTLR start synpred5 + def synpred5_fragment(self, ): + # C.g:68:4: ( declaration ) + # C.g:68:4: declaration + self.following.append(self.FOLLOW_declaration_in_synpred5108) + self.declaration() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred5 + + + + # $ANTLR start synpred7 + def synpred7_fragment(self, ): + # C.g:94:6: ( declaration_specifiers ) + # C.g:94:6: declaration_specifiers + self.following.append(self.FOLLOW_declaration_specifiers_in_synpred7147) + self.declaration_specifiers() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred7 + + + + # $ANTLR start synpred10 + def synpred10_fragment(self, ): + # C.g:115:18: ( declaration_specifiers ) + # C.g:115:18: declaration_specifiers + self.following.append(self.FOLLOW_declaration_specifiers_in_synpred10197) + self.declaration_specifiers() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred10 + + + + # $ANTLR start synpred14 + def synpred14_fragment(self, ): + # C.g:132:7: ( type_specifier ) + # C.g:132:7: type_specifier + self.following.append(self.FOLLOW_type_specifier_in_synpred14262) + self.type_specifier() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred14 + + + + # $ANTLR start synpred15 + def synpred15_fragment(self, ): + # C.g:133:13: ( type_qualifier ) + # C.g:133:13: type_qualifier + self.following.append(self.FOLLOW_type_qualifier_in_synpred15276) + self.type_qualifier() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred15 + + + + # $ANTLR start synpred33 + def synpred33_fragment(self, ): + # C.g:173:16: ( type_qualifier ) + # C.g:173:16: type_qualifier + self.following.append(self.FOLLOW_type_qualifier_in_synpred33434) + self.type_qualifier() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred33 + + + + # $ANTLR start synpred34 + def synpred34_fragment(self, ): + # C.g:173:4: ( IDENTIFIER ( type_qualifier )* declarator ) + # C.g:173:5: IDENTIFIER ( type_qualifier )* declarator + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_synpred34432) + if self.failed: + return + # C.g:173:16: ( type_qualifier )* + while True: #loop106 + alt106 = 2 + LA106 = self.input.LA(1) + if LA106 == 58: + LA106_2 = self.input.LA(2) + + if (self.synpred33()) : + alt106 = 1 + + + elif LA106 == 59: + LA106_3 = self.input.LA(2) + + if (self.synpred33()) : + alt106 = 1 + + + elif LA106 == 60: + LA106_4 = self.input.LA(2) + + if (self.synpred33()) : + alt106 = 1 + + + elif LA106 == 49 or LA106 == 50 or LA106 == 51 or LA106 == 52 or LA106 == 53 or LA106 == 54 or LA106 == 55 or LA106 == 56 or LA106 == 57: + alt106 = 1 + + if alt106 == 1: + # C.g:0:0: type_qualifier + self.following.append(self.FOLLOW_type_qualifier_in_synpred34434) + self.type_qualifier() + self.following.pop() + if self.failed: + return + + + else: + break #loop106 + + + self.following.append(self.FOLLOW_declarator_in_synpred34437) + self.declarator() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred34 + + + + # $ANTLR start synpred39 + def synpred39_fragment(self, ): + # C.g:201:6: ( type_qualifier ) + # C.g:201:6: type_qualifier + self.following.append(self.FOLLOW_type_qualifier_in_synpred39556) + self.type_qualifier() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred39 + + + + # $ANTLR start synpred40 + def synpred40_fragment(self, ): + # C.g:201:23: ( type_specifier ) + # C.g:201:23: type_specifier + self.following.append(self.FOLLOW_type_specifier_in_synpred40560) + self.type_specifier() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred40 + + + + # $ANTLR start synpred65 + def synpred65_fragment(self, ): + # C.g:244:4: ( ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator ) + # C.g:244:4: ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator + # C.g:244:4: ( pointer )? + alt111 = 2 + LA111_0 = self.input.LA(1) + + if (LA111_0 == 65) : + alt111 = 1 + if alt111 == 1: + # C.g:0:0: pointer + self.following.append(self.FOLLOW_pointer_in_synpred65769) + self.pointer() + self.following.pop() + if self.failed: + return + + + + # C.g:244:13: ( 'EFIAPI' )? + alt112 = 2 + LA112_0 = self.input.LA(1) + + if (LA112_0 == 58) : + alt112 = 1 + if alt112 == 1: + # C.g:244:14: 'EFIAPI' + self.match(self.input, 58, self.FOLLOW_58_in_synpred65773) + if self.failed: + return + + + + # C.g:244:25: ( 'EFI_BOOTSERVICE' )? + alt113 = 2 + LA113_0 = self.input.LA(1) + + if (LA113_0 == 59) : + alt113 = 1 + if alt113 == 1: + # C.g:244:26: 'EFI_BOOTSERVICE' + self.match(self.input, 59, self.FOLLOW_59_in_synpred65778) + if self.failed: + return + + + + # C.g:244:46: ( 'EFI_RUNTIMESERVICE' )? + alt114 = 2 + LA114_0 = self.input.LA(1) + + if (LA114_0 == 60) : + alt114 = 1 + if alt114 == 1: + # C.g:244:47: 'EFI_RUNTIMESERVICE' + self.match(self.input, 60, self.FOLLOW_60_in_synpred65783) + if self.failed: + return + + + + self.following.append(self.FOLLOW_direct_declarator_in_synpred65787) + self.direct_declarator() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred65 + + + + # $ANTLR start synpred66 + def synpred66_fragment(self, ): + # C.g:250:15: ( declarator_suffix ) + # C.g:250:15: declarator_suffix + self.following.append(self.FOLLOW_declarator_suffix_in_synpred66806) + self.declarator_suffix() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred66 + + + + # $ANTLR start synpred68 + def synpred68_fragment(self, ): + # C.g:251:9: ( 'EFIAPI' ) + # C.g:251:9: 'EFIAPI' + self.match(self.input, 58, self.FOLLOW_58_in_synpred68815) + if self.failed: + return + + + # $ANTLR end synpred68 + + + + # $ANTLR start synpred69 + def synpred69_fragment(self, ): + # C.g:251:35: ( declarator_suffix ) + # C.g:251:35: declarator_suffix + self.following.append(self.FOLLOW_declarator_suffix_in_synpred69823) + self.declarator_suffix() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred69 + + + + # $ANTLR start synpred72 + def synpred72_fragment(self, ): + # C.g:257:9: ( '(' parameter_type_list ')' ) + # C.g:257:9: '(' parameter_type_list ')' + self.match(self.input, 61, self.FOLLOW_61_in_synpred72863) + if self.failed: + return + self.following.append(self.FOLLOW_parameter_type_list_in_synpred72865) + self.parameter_type_list() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_synpred72867) + if self.failed: + return + + + # $ANTLR end synpred72 + + + + # $ANTLR start synpred73 + def synpred73_fragment(self, ): + # C.g:258:9: ( '(' identifier_list ')' ) + # C.g:258:9: '(' identifier_list ')' + self.match(self.input, 61, self.FOLLOW_61_in_synpred73877) + if self.failed: + return + self.following.append(self.FOLLOW_identifier_list_in_synpred73879) + self.identifier_list() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_synpred73881) + if self.failed: + return + + + # $ANTLR end synpred73 + + + + # $ANTLR start synpred74 + def synpred74_fragment(self, ): + # C.g:263:8: ( type_qualifier ) + # C.g:263:8: type_qualifier + self.following.append(self.FOLLOW_type_qualifier_in_synpred74906) + self.type_qualifier() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred74 + + + + # $ANTLR start synpred75 + def synpred75_fragment(self, ): + # C.g:263:24: ( pointer ) + # C.g:263:24: pointer + self.following.append(self.FOLLOW_pointer_in_synpred75909) + self.pointer() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred75 + + + + # $ANTLR start synpred76 + def synpred76_fragment(self, ): + # C.g:263:4: ( '*' ( type_qualifier )+ ( pointer )? ) + # C.g:263:4: '*' ( type_qualifier )+ ( pointer )? + self.match(self.input, 65, self.FOLLOW_65_in_synpred76904) + if self.failed: + return + # C.g:263:8: ( type_qualifier )+ + cnt116 = 0 + while True: #loop116 + alt116 = 2 + LA116_0 = self.input.LA(1) + + if ((49 <= LA116_0 <= 60)) : + alt116 = 1 + + + if alt116 == 1: + # C.g:0:0: type_qualifier + self.following.append(self.FOLLOW_type_qualifier_in_synpred76906) + self.type_qualifier() + self.following.pop() + if self.failed: + return + + + else: + if cnt116 >= 1: + break #loop116 + + if self.backtracking > 0: + self.failed = True + return + + eee = EarlyExitException(116, self.input) + raise eee + + cnt116 += 1 + + + # C.g:263:24: ( pointer )? + alt117 = 2 + LA117_0 = self.input.LA(1) + + if (LA117_0 == 65) : + alt117 = 1 + if alt117 == 1: + # C.g:0:0: pointer + self.following.append(self.FOLLOW_pointer_in_synpred76909) + self.pointer() + self.following.pop() + if self.failed: + return + + + + + + # $ANTLR end synpred76 + + + + # $ANTLR start synpred77 + def synpred77_fragment(self, ): + # C.g:264:4: ( '*' pointer ) + # C.g:264:4: '*' pointer + self.match(self.input, 65, self.FOLLOW_65_in_synpred77915) + if self.failed: + return + self.following.append(self.FOLLOW_pointer_in_synpred77917) + self.pointer() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred77 + + + + # $ANTLR start synpred80 + def synpred80_fragment(self, ): + # C.g:273:32: ( 'OPTIONAL' ) + # C.g:273:32: 'OPTIONAL' + self.match(self.input, 53, self.FOLLOW_53_in_synpred80962) + if self.failed: + return + + + # $ANTLR end synpred80 + + + + # $ANTLR start synpred81 + def synpred81_fragment(self, ): + # C.g:273:27: ( ',' ( 'OPTIONAL' )? parameter_declaration ) + # C.g:273:27: ',' ( 'OPTIONAL' )? parameter_declaration + self.match(self.input, 27, self.FOLLOW_27_in_synpred81959) + if self.failed: + return + # C.g:273:31: ( 'OPTIONAL' )? + alt119 = 2 + LA119_0 = self.input.LA(1) + + if (LA119_0 == 53) : + LA119_1 = self.input.LA(2) + + if (self.synpred80()) : + alt119 = 1 + if alt119 == 1: + # C.g:273:32: 'OPTIONAL' + self.match(self.input, 53, self.FOLLOW_53_in_synpred81962) + if self.failed: + return + + + + self.following.append(self.FOLLOW_parameter_declaration_in_synpred81966) + self.parameter_declaration() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred81 + + + + # $ANTLR start synpred82 + def synpred82_fragment(self, ): + # C.g:277:28: ( declarator ) + # C.g:277:28: declarator + self.following.append(self.FOLLOW_declarator_in_synpred82982) + self.declarator() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred82 + + + + # $ANTLR start synpred83 + def synpred83_fragment(self, ): + # C.g:277:39: ( abstract_declarator ) + # C.g:277:39: abstract_declarator + self.following.append(self.FOLLOW_abstract_declarator_in_synpred83984) + self.abstract_declarator() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred83 + + + + # $ANTLR start synpred85 + def synpred85_fragment(self, ): + # C.g:277:4: ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? ) + # C.g:277:4: declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? + self.following.append(self.FOLLOW_declaration_specifiers_in_synpred85979) + self.declaration_specifiers() + self.following.pop() + if self.failed: + return + # C.g:277:27: ( declarator | abstract_declarator )* + while True: #loop120 + alt120 = 3 + LA120 = self.input.LA(1) + if LA120 == 65: + LA120_3 = self.input.LA(2) + + if (self.synpred82()) : + alt120 = 1 + elif (self.synpred83()) : + alt120 = 2 + + + elif LA120 == IDENTIFIER or LA120 == 58 or LA120 == 59 or LA120 == 60: + alt120 = 1 + elif LA120 == 61: + LA120 = self.input.LA(2) + if LA120 == 29 or LA120 == 30 or LA120 == 31 or LA120 == 32 or LA120 == 33 or LA120 == 34 or LA120 == 35 or LA120 == 36 or LA120 == 37 or LA120 == 38 or LA120 == 39 or LA120 == 40 or LA120 == 41 or LA120 == 42 or LA120 == 45 or LA120 == 46 or LA120 == 48 or LA120 == 49 or LA120 == 50 or LA120 == 51 or LA120 == 52 or LA120 == 53 or LA120 == 54 or LA120 == 55 or LA120 == 56 or LA120 == 57 or LA120 == 62 or LA120 == 63: + alt120 = 2 + elif LA120 == 58: + LA120_21 = self.input.LA(3) + + if (self.synpred82()) : + alt120 = 1 + elif (self.synpred83()) : + alt120 = 2 + + + elif LA120 == 65: + LA120_22 = self.input.LA(3) + + if (self.synpred82()) : + alt120 = 1 + elif (self.synpred83()) : + alt120 = 2 + + + elif LA120 == 59: + LA120_23 = self.input.LA(3) + + if (self.synpred82()) : + alt120 = 1 + elif (self.synpred83()) : + alt120 = 2 + + + elif LA120 == 60: + LA120_24 = self.input.LA(3) + + if (self.synpred82()) : + alt120 = 1 + elif (self.synpred83()) : + alt120 = 2 + + + elif LA120 == IDENTIFIER: + LA120_25 = self.input.LA(3) + + if (self.synpred82()) : + alt120 = 1 + elif (self.synpred83()) : + alt120 = 2 + + + elif LA120 == 61: + LA120_26 = self.input.LA(3) + + if (self.synpred82()) : + alt120 = 1 + elif (self.synpred83()) : + alt120 = 2 + + + + elif LA120 == 63: + alt120 = 2 + + if alt120 == 1: + # C.g:277:28: declarator + self.following.append(self.FOLLOW_declarator_in_synpred85982) + self.declarator() + self.following.pop() + if self.failed: + return + + + elif alt120 == 2: + # C.g:277:39: abstract_declarator + self.following.append(self.FOLLOW_abstract_declarator_in_synpred85984) + self.abstract_declarator() + self.following.pop() + if self.failed: + return + + + else: + break #loop120 + + + # C.g:277:61: ( 'OPTIONAL' )? + alt121 = 2 + LA121_0 = self.input.LA(1) + + if (LA121_0 == 53) : + alt121 = 1 + if alt121 == 1: + # C.g:277:62: 'OPTIONAL' + self.match(self.input, 53, self.FOLLOW_53_in_synpred85989) + if self.failed: + return + + + + + + # $ANTLR end synpred85 + + + + # $ANTLR start synpred89 + def synpred89_fragment(self, ): + # C.g:288:4: ( specifier_qualifier_list ( abstract_declarator )? ) + # C.g:288:4: specifier_qualifier_list ( abstract_declarator )? + self.following.append(self.FOLLOW_specifier_qualifier_list_in_synpred891031) + self.specifier_qualifier_list() + self.following.pop() + if self.failed: + return + # C.g:288:29: ( abstract_declarator )? + alt122 = 2 + LA122_0 = self.input.LA(1) + + if (LA122_0 == 61 or LA122_0 == 63 or LA122_0 == 65) : + alt122 = 1 + if alt122 == 1: + # C.g:0:0: abstract_declarator + self.following.append(self.FOLLOW_abstract_declarator_in_synpred891033) + self.abstract_declarator() + self.following.pop() + if self.failed: + return + + + + + + # $ANTLR end synpred89 + + + + # $ANTLR start synpred90 + def synpred90_fragment(self, ): + # C.g:293:12: ( direct_abstract_declarator ) + # C.g:293:12: direct_abstract_declarator + self.following.append(self.FOLLOW_direct_abstract_declarator_in_synpred901052) + self.direct_abstract_declarator() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred90 + + + + # $ANTLR start synpred92 + def synpred92_fragment(self, ): + # C.g:298:6: ( '(' abstract_declarator ')' ) + # C.g:298:6: '(' abstract_declarator ')' + self.match(self.input, 61, self.FOLLOW_61_in_synpred921071) + if self.failed: + return + self.following.append(self.FOLLOW_abstract_declarator_in_synpred921073) + self.abstract_declarator() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_synpred921075) + if self.failed: + return + + + # $ANTLR end synpred92 + + + + # $ANTLR start synpred93 + def synpred93_fragment(self, ): + # C.g:298:65: ( abstract_declarator_suffix ) + # C.g:298:65: abstract_declarator_suffix + self.following.append(self.FOLLOW_abstract_declarator_suffix_in_synpred931083) + self.abstract_declarator_suffix() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred93 + + + + # $ANTLR start synpred108 + def synpred108_fragment(self, ): + # C.g:333:4: ( '(' type_name ')' cast_expression ) + # C.g:333:4: '(' type_name ')' cast_expression + self.match(self.input, 61, self.FOLLOW_61_in_synpred1081267) + if self.failed: + return + self.following.append(self.FOLLOW_type_name_in_synpred1081269) + self.type_name() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_synpred1081271) + if self.failed: + return + self.following.append(self.FOLLOW_cast_expression_in_synpred1081273) + self.cast_expression() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred108 + + + + # $ANTLR start synpred113 + def synpred113_fragment(self, ): + # C.g:342:4: ( 'sizeof' unary_expression ) + # C.g:342:4: 'sizeof' unary_expression + self.match(self.input, 73, self.FOLLOW_73_in_synpred1131315) + if self.failed: + return + self.following.append(self.FOLLOW_unary_expression_in_synpred1131317) + self.unary_expression() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred113 + + + + # $ANTLR start synpred116 + def synpred116_fragment(self, ): + # C.g:356:13: ( '(' argument_expression_list ')' ) + # C.g:356:13: '(' argument_expression_list ')' + self.match(self.input, 61, self.FOLLOW_61_in_synpred1161405) + if self.failed: + return + self.following.append(self.FOLLOW_argument_expression_list_in_synpred1161409) + self.argument_expression_list() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_synpred1161413) + if self.failed: + return + + + # $ANTLR end synpred116 + + + + # $ANTLR start synpred117 + def synpred117_fragment(self, ): + # C.g:357:13: ( '(' macro_parameter_list ')' ) + # C.g:357:13: '(' macro_parameter_list ')' + self.match(self.input, 61, self.FOLLOW_61_in_synpred1171429) + if self.failed: + return + self.following.append(self.FOLLOW_macro_parameter_list_in_synpred1171431) + self.macro_parameter_list() + self.following.pop() + if self.failed: + return + self.match(self.input, 62, self.FOLLOW_62_in_synpred1171433) + if self.failed: + return + + + # $ANTLR end synpred117 + + + + # $ANTLR start synpred119 + def synpred119_fragment(self, ): + # C.g:359:13: ( '*' IDENTIFIER ) + # C.g:359:13: '*' IDENTIFIER + self.match(self.input, 65, self.FOLLOW_65_in_synpred1191467) + if self.failed: + return + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_synpred1191471) + if self.failed: + return + + + # $ANTLR end synpred119 + + + + # $ANTLR start synpred136 + def synpred136_fragment(self, ): + # C.g:390:20: ( STRING_LITERAL ) + # C.g:390:20: STRING_LITERAL + self.match(self.input, STRING_LITERAL, self.FOLLOW_STRING_LITERAL_in_synpred1361668) + if self.failed: + return + + + # $ANTLR end synpred136 + + + + # $ANTLR start synpred137 + def synpred137_fragment(self, ): + # C.g:390:8: ( ( IDENTIFIER )* ( STRING_LITERAL )+ ) + # C.g:390:8: ( IDENTIFIER )* ( STRING_LITERAL )+ + # C.g:390:8: ( IDENTIFIER )* + while True: #loop125 + alt125 = 2 + LA125_0 = self.input.LA(1) + + if (LA125_0 == IDENTIFIER) : + alt125 = 1 + + + if alt125 == 1: + # C.g:0:0: IDENTIFIER + self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_synpred1371665) + if self.failed: + return + + + else: + break #loop125 + + + # C.g:390:20: ( STRING_LITERAL )+ + cnt126 = 0 + while True: #loop126 + alt126 = 2 + LA126_0 = self.input.LA(1) + + if (LA126_0 == STRING_LITERAL) : + alt126 = 1 + + + if alt126 == 1: + # C.g:0:0: STRING_LITERAL + self.match(self.input, STRING_LITERAL, self.FOLLOW_STRING_LITERAL_in_synpred1371668) + if self.failed: + return + + + else: + if cnt126 >= 1: + break #loop126 + + if self.backtracking > 0: + self.failed = True + return + + eee = EarlyExitException(126, self.input) + raise eee + + cnt126 += 1 + + + + + # $ANTLR end synpred137 + + + + # $ANTLR start synpred141 + def synpred141_fragment(self, ): + # C.g:405:4: ( lvalue assignment_operator assignment_expression ) + # C.g:405:4: lvalue assignment_operator assignment_expression + self.following.append(self.FOLLOW_lvalue_in_synpred1411729) + self.lvalue() + self.following.pop() + if self.failed: + return + self.following.append(self.FOLLOW_assignment_operator_in_synpred1411731) + self.assignment_operator() + self.following.pop() + if self.failed: + return + self.following.append(self.FOLLOW_assignment_expression_in_synpred1411733) + self.assignment_expression() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred141 + + + + # $ANTLR start synpred168 + def synpred168_fragment(self, ): + # C.g:467:4: ( expression_statement ) + # C.g:467:4: expression_statement + self.following.append(self.FOLLOW_expression_statement_in_synpred1682020) + self.expression_statement() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred168 + + + + # $ANTLR start synpred172 + def synpred172_fragment(self, ): + # C.g:471:4: ( macro_statement ) + # C.g:471:4: macro_statement + self.following.append(self.FOLLOW_macro_statement_in_synpred1722040) + self.macro_statement() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred172 + + + + # $ANTLR start synpred173 + def synpred173_fragment(self, ): + # C.g:472:4: ( asm2_statement ) + # C.g:472:4: asm2_statement + self.following.append(self.FOLLOW_asm2_statement_in_synpred1732045) + self.asm2_statement() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred173 + + + + # $ANTLR start synpred180 + def synpred180_fragment(self, ): + # C.g:491:19: ( declaration ) + # C.g:491:19: declaration + self.following.append(self.FOLLOW_declaration_in_synpred1802151) + self.declaration() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred180 + + + + # $ANTLR start synpred181 + def synpred181_fragment(self, ): + # C.g:491:33: ( statement_list ) + # C.g:491:33: statement_list + self.following.append(self.FOLLOW_statement_list_in_synpred1812155) + self.statement_list() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred181 + + + + # $ANTLR start synpred185 + def synpred185_fragment(self, ): + # C.g:501:8: ( declaration ) + # C.g:501:8: declaration + self.following.append(self.FOLLOW_declaration_in_synpred1852210) + self.declaration() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred185 + + + + # $ANTLR start synpred187 + def synpred187_fragment(self, ): + # C.g:505:4: ( statement ) + # C.g:505:4: statement + self.following.append(self.FOLLOW_statement_in_synpred1872227) + self.statement() + self.following.pop() + if self.failed: + return + + + # $ANTLR end synpred187 + + + + def synpred185(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred185_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred7(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred7_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred14(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred14_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred65(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred65_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred15(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred15_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred117(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred117_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred173(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred173_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred68(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred68_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred40(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred40_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred141(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred141_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred75(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred75_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred92(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred92_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred4(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred4_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred85(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred85_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred39(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred39_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred76(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred76_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred119(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred119_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred90(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred90_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred187(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred187_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred33(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred33_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred2(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred2_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred83(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred83_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred69(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred69_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred72(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred72_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred168(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred168_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred34(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred34_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred181(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred181_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred116(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred116_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred113(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred113_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred80(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred80_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred73(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred73_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred89(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred89_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred10(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred10_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred81(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred81_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred180(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred180_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred136(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred136_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred77(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred77_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred172(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred172_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred137(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred137_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred74(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred74_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred5(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred5_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred108(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred108_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred82(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred82_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred93(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred93_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + def synpred66(self): + self.backtracking += 1 + start = self.input.mark() + self.synpred66_fragment() + success = not self.failed + self.input.rewind(start) + self.backtracking -= 1 + self.failed = False + return success + + + + + + FOLLOW_external_declaration_in_translation_unit64 = frozenset([1, 4, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65]) + FOLLOW_function_definition_in_external_declaration103 = frozenset([1]) + FOLLOW_declaration_in_external_declaration108 = frozenset([1]) + FOLLOW_macro_statement_in_external_declaration113 = frozenset([1, 25]) + FOLLOW_25_in_external_declaration116 = frozenset([1]) + FOLLOW_declaration_specifiers_in_function_definition147 = frozenset([4, 58, 59, 60, 61, 65]) + FOLLOW_declarator_in_function_definition150 = frozenset([4, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_declaration_in_function_definition156 = frozenset([4, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_compound_statement_in_function_definition161 = frozenset([1]) + FOLLOW_compound_statement_in_function_definition170 = frozenset([1]) + FOLLOW_26_in_declaration193 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65]) + FOLLOW_declaration_specifiers_in_declaration197 = frozenset([4, 58, 59, 60, 61, 65]) + FOLLOW_init_declarator_list_in_declaration206 = frozenset([25]) + FOLLOW_25_in_declaration210 = frozenset([1]) + FOLLOW_declaration_specifiers_in_declaration224 = frozenset([4, 25, 58, 59, 60, 61, 65]) + FOLLOW_init_declarator_list_in_declaration228 = frozenset([25]) + FOLLOW_25_in_declaration233 = frozenset([1]) + FOLLOW_storage_class_specifier_in_declaration_specifiers254 = frozenset([1, 4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_type_specifier_in_declaration_specifiers262 = frozenset([1, 4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_type_qualifier_in_declaration_specifiers276 = frozenset([1, 4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_init_declarator_in_init_declarator_list298 = frozenset([1, 27]) + FOLLOW_27_in_init_declarator_list301 = frozenset([4, 58, 59, 60, 61, 65]) + FOLLOW_init_declarator_in_init_declarator_list303 = frozenset([1, 27]) + FOLLOW_declarator_in_init_declarator316 = frozenset([1, 28]) + FOLLOW_28_in_init_declarator319 = frozenset([4, 5, 6, 7, 8, 9, 10, 43, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_initializer_in_init_declarator321 = frozenset([1]) + FOLLOW_set_in_storage_class_specifier0 = frozenset([1]) + FOLLOW_34_in_type_specifier366 = frozenset([1]) + FOLLOW_35_in_type_specifier371 = frozenset([1]) + FOLLOW_36_in_type_specifier376 = frozenset([1]) + FOLLOW_37_in_type_specifier381 = frozenset([1]) + FOLLOW_38_in_type_specifier386 = frozenset([1]) + FOLLOW_39_in_type_specifier391 = frozenset([1]) + FOLLOW_40_in_type_specifier396 = frozenset([1]) + FOLLOW_41_in_type_specifier401 = frozenset([1]) + FOLLOW_42_in_type_specifier406 = frozenset([1]) + FOLLOW_struct_or_union_specifier_in_type_specifier413 = frozenset([1]) + FOLLOW_enum_specifier_in_type_specifier423 = frozenset([1]) + FOLLOW_type_id_in_type_specifier441 = frozenset([1]) + FOLLOW_IDENTIFIER_in_type_id457 = frozenset([1]) + FOLLOW_struct_or_union_in_struct_or_union_specifier484 = frozenset([4, 43]) + FOLLOW_IDENTIFIER_in_struct_or_union_specifier486 = frozenset([43]) + FOLLOW_43_in_struct_or_union_specifier489 = frozenset([4, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_struct_declaration_list_in_struct_or_union_specifier491 = frozenset([44]) + FOLLOW_44_in_struct_or_union_specifier493 = frozenset([1]) + FOLLOW_struct_or_union_in_struct_or_union_specifier498 = frozenset([4]) + FOLLOW_IDENTIFIER_in_struct_or_union_specifier500 = frozenset([1]) + FOLLOW_set_in_struct_or_union0 = frozenset([1]) + FOLLOW_struct_declaration_in_struct_declaration_list527 = frozenset([1, 4, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_specifier_qualifier_list_in_struct_declaration539 = frozenset([4, 47, 58, 59, 60, 61, 65]) + FOLLOW_struct_declarator_list_in_struct_declaration541 = frozenset([25]) + FOLLOW_25_in_struct_declaration543 = frozenset([1]) + FOLLOW_type_qualifier_in_specifier_qualifier_list556 = frozenset([1, 4, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_type_specifier_in_specifier_qualifier_list560 = frozenset([1, 4, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_struct_declarator_in_struct_declarator_list574 = frozenset([1, 27]) + FOLLOW_27_in_struct_declarator_list577 = frozenset([4, 47, 58, 59, 60, 61, 65]) + FOLLOW_struct_declarator_in_struct_declarator_list579 = frozenset([1, 27]) + FOLLOW_declarator_in_struct_declarator592 = frozenset([1, 47]) + FOLLOW_47_in_struct_declarator595 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_constant_expression_in_struct_declarator597 = frozenset([1]) + FOLLOW_47_in_struct_declarator604 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_constant_expression_in_struct_declarator606 = frozenset([1]) + FOLLOW_48_in_enum_specifier624 = frozenset([43]) + FOLLOW_43_in_enum_specifier626 = frozenset([4]) + FOLLOW_enumerator_list_in_enum_specifier628 = frozenset([27, 44]) + FOLLOW_27_in_enum_specifier630 = frozenset([44]) + FOLLOW_44_in_enum_specifier633 = frozenset([1]) + FOLLOW_48_in_enum_specifier638 = frozenset([4]) + FOLLOW_IDENTIFIER_in_enum_specifier640 = frozenset([43]) + FOLLOW_43_in_enum_specifier642 = frozenset([4]) + FOLLOW_enumerator_list_in_enum_specifier644 = frozenset([27, 44]) + FOLLOW_27_in_enum_specifier646 = frozenset([44]) + FOLLOW_44_in_enum_specifier649 = frozenset([1]) + FOLLOW_48_in_enum_specifier654 = frozenset([4]) + FOLLOW_IDENTIFIER_in_enum_specifier656 = frozenset([1]) + FOLLOW_enumerator_in_enumerator_list667 = frozenset([1, 27]) + FOLLOW_27_in_enumerator_list670 = frozenset([4]) + FOLLOW_enumerator_in_enumerator_list672 = frozenset([1, 27]) + FOLLOW_IDENTIFIER_in_enumerator685 = frozenset([1, 28]) + FOLLOW_28_in_enumerator688 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_constant_expression_in_enumerator690 = frozenset([1]) + FOLLOW_set_in_type_qualifier0 = frozenset([1]) + FOLLOW_pointer_in_declarator769 = frozenset([4, 58, 59, 60, 61]) + FOLLOW_58_in_declarator773 = frozenset([4, 59, 60, 61]) + FOLLOW_59_in_declarator778 = frozenset([4, 60, 61]) + FOLLOW_60_in_declarator783 = frozenset([4, 61]) + FOLLOW_direct_declarator_in_declarator787 = frozenset([1]) + FOLLOW_pointer_in_declarator793 = frozenset([1]) + FOLLOW_IDENTIFIER_in_direct_declarator804 = frozenset([1, 61, 63]) + FOLLOW_declarator_suffix_in_direct_declarator806 = frozenset([1, 61, 63]) + FOLLOW_61_in_direct_declarator812 = frozenset([4, 58, 59, 60, 61, 65]) + FOLLOW_58_in_direct_declarator815 = frozenset([4, 58, 59, 60, 61, 65]) + FOLLOW_declarator_in_direct_declarator819 = frozenset([62]) + FOLLOW_62_in_direct_declarator821 = frozenset([61, 63]) + FOLLOW_declarator_suffix_in_direct_declarator823 = frozenset([1, 61, 63]) + FOLLOW_63_in_declarator_suffix837 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_constant_expression_in_declarator_suffix839 = frozenset([64]) + FOLLOW_64_in_declarator_suffix841 = frozenset([1]) + FOLLOW_63_in_declarator_suffix851 = frozenset([64]) + FOLLOW_64_in_declarator_suffix853 = frozenset([1]) + FOLLOW_61_in_declarator_suffix863 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_parameter_type_list_in_declarator_suffix865 = frozenset([62]) + FOLLOW_62_in_declarator_suffix867 = frozenset([1]) + FOLLOW_61_in_declarator_suffix877 = frozenset([4]) + FOLLOW_identifier_list_in_declarator_suffix879 = frozenset([62]) + FOLLOW_62_in_declarator_suffix881 = frozenset([1]) + FOLLOW_61_in_declarator_suffix891 = frozenset([62]) + FOLLOW_62_in_declarator_suffix893 = frozenset([1]) + FOLLOW_65_in_pointer904 = frozenset([49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_type_qualifier_in_pointer906 = frozenset([1, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_pointer_in_pointer909 = frozenset([1]) + FOLLOW_65_in_pointer915 = frozenset([65]) + FOLLOW_pointer_in_pointer917 = frozenset([1]) + FOLLOW_65_in_pointer922 = frozenset([1]) + FOLLOW_parameter_list_in_parameter_type_list933 = frozenset([1, 27]) + FOLLOW_27_in_parameter_type_list936 = frozenset([53, 66]) + FOLLOW_53_in_parameter_type_list939 = frozenset([66]) + FOLLOW_66_in_parameter_type_list943 = frozenset([1]) + FOLLOW_parameter_declaration_in_parameter_list956 = frozenset([1, 27]) + FOLLOW_27_in_parameter_list959 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_53_in_parameter_list962 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_parameter_declaration_in_parameter_list966 = frozenset([1, 27]) + FOLLOW_declaration_specifiers_in_parameter_declaration979 = frozenset([1, 4, 53, 58, 59, 60, 61, 63, 65]) + FOLLOW_declarator_in_parameter_declaration982 = frozenset([1, 4, 53, 58, 59, 60, 61, 63, 65]) + FOLLOW_abstract_declarator_in_parameter_declaration984 = frozenset([1, 4, 53, 58, 59, 60, 61, 63, 65]) + FOLLOW_53_in_parameter_declaration989 = frozenset([1]) + FOLLOW_pointer_in_parameter_declaration998 = frozenset([4, 65]) + FOLLOW_IDENTIFIER_in_parameter_declaration1001 = frozenset([1]) + FOLLOW_IDENTIFIER_in_identifier_list1012 = frozenset([1, 27]) + FOLLOW_27_in_identifier_list1016 = frozenset([4]) + FOLLOW_IDENTIFIER_in_identifier_list1018 = frozenset([1, 27]) + FOLLOW_specifier_qualifier_list_in_type_name1031 = frozenset([1, 61, 63, 65]) + FOLLOW_abstract_declarator_in_type_name1033 = frozenset([1]) + FOLLOW_type_id_in_type_name1039 = frozenset([1]) + FOLLOW_pointer_in_abstract_declarator1050 = frozenset([1, 61, 63]) + FOLLOW_direct_abstract_declarator_in_abstract_declarator1052 = frozenset([1]) + FOLLOW_direct_abstract_declarator_in_abstract_declarator1058 = frozenset([1]) + FOLLOW_61_in_direct_abstract_declarator1071 = frozenset([61, 63, 65]) + FOLLOW_abstract_declarator_in_direct_abstract_declarator1073 = frozenset([62]) + FOLLOW_62_in_direct_abstract_declarator1075 = frozenset([1, 61, 63]) + FOLLOW_abstract_declarator_suffix_in_direct_abstract_declarator1079 = frozenset([1, 61, 63]) + FOLLOW_abstract_declarator_suffix_in_direct_abstract_declarator1083 = frozenset([1, 61, 63]) + FOLLOW_63_in_abstract_declarator_suffix1095 = frozenset([64]) + FOLLOW_64_in_abstract_declarator_suffix1097 = frozenset([1]) + FOLLOW_63_in_abstract_declarator_suffix1102 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_constant_expression_in_abstract_declarator_suffix1104 = frozenset([64]) + FOLLOW_64_in_abstract_declarator_suffix1106 = frozenset([1]) + FOLLOW_61_in_abstract_declarator_suffix1111 = frozenset([62]) + FOLLOW_62_in_abstract_declarator_suffix1113 = frozenset([1]) + FOLLOW_61_in_abstract_declarator_suffix1118 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_parameter_type_list_in_abstract_declarator_suffix1120 = frozenset([62]) + FOLLOW_62_in_abstract_declarator_suffix1122 = frozenset([1]) + FOLLOW_assignment_expression_in_initializer1135 = frozenset([1]) + FOLLOW_43_in_initializer1140 = frozenset([4, 5, 6, 7, 8, 9, 10, 43, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_initializer_list_in_initializer1142 = frozenset([27, 44]) + FOLLOW_27_in_initializer1144 = frozenset([44]) + FOLLOW_44_in_initializer1147 = frozenset([1]) + FOLLOW_initializer_in_initializer_list1158 = frozenset([1, 27]) + FOLLOW_27_in_initializer_list1161 = frozenset([4, 5, 6, 7, 8, 9, 10, 43, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_initializer_in_initializer_list1163 = frozenset([1, 27]) + FOLLOW_assignment_expression_in_argument_expression_list1181 = frozenset([1, 27, 53]) + FOLLOW_53_in_argument_expression_list1184 = frozenset([1, 27]) + FOLLOW_27_in_argument_expression_list1189 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_assignment_expression_in_argument_expression_list1191 = frozenset([1, 27, 53]) + FOLLOW_53_in_argument_expression_list1194 = frozenset([1, 27]) + FOLLOW_multiplicative_expression_in_additive_expression1210 = frozenset([1, 67, 68]) + FOLLOW_67_in_additive_expression1214 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_multiplicative_expression_in_additive_expression1216 = frozenset([1, 67, 68]) + FOLLOW_68_in_additive_expression1220 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_multiplicative_expression_in_additive_expression1222 = frozenset([1, 67, 68]) + FOLLOW_cast_expression_in_multiplicative_expression1236 = frozenset([1, 65, 69, 70]) + FOLLOW_65_in_multiplicative_expression1240 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_cast_expression_in_multiplicative_expression1242 = frozenset([1, 65, 69, 70]) + FOLLOW_69_in_multiplicative_expression1246 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_cast_expression_in_multiplicative_expression1248 = frozenset([1, 65, 69, 70]) + FOLLOW_70_in_multiplicative_expression1252 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_cast_expression_in_multiplicative_expression1254 = frozenset([1, 65, 69, 70]) + FOLLOW_61_in_cast_expression1267 = frozenset([4, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_type_name_in_cast_expression1269 = frozenset([62]) + FOLLOW_62_in_cast_expression1271 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_cast_expression_in_cast_expression1273 = frozenset([1]) + FOLLOW_unary_expression_in_cast_expression1278 = frozenset([1]) + FOLLOW_postfix_expression_in_unary_expression1289 = frozenset([1]) + FOLLOW_71_in_unary_expression1294 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_unary_expression_in_unary_expression1296 = frozenset([1]) + FOLLOW_72_in_unary_expression1301 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_unary_expression_in_unary_expression1303 = frozenset([1]) + FOLLOW_unary_operator_in_unary_expression1308 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_cast_expression_in_unary_expression1310 = frozenset([1]) + FOLLOW_73_in_unary_expression1315 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_unary_expression_in_unary_expression1317 = frozenset([1]) + FOLLOW_73_in_unary_expression1322 = frozenset([61]) + FOLLOW_61_in_unary_expression1324 = frozenset([4, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_type_name_in_unary_expression1326 = frozenset([62]) + FOLLOW_62_in_unary_expression1328 = frozenset([1]) + FOLLOW_primary_expression_in_postfix_expression1352 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_63_in_postfix_expression1368 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_postfix_expression1370 = frozenset([64]) + FOLLOW_64_in_postfix_expression1372 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_61_in_postfix_expression1386 = frozenset([62]) + FOLLOW_62_in_postfix_expression1390 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_61_in_postfix_expression1405 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_argument_expression_list_in_postfix_expression1409 = frozenset([62]) + FOLLOW_62_in_postfix_expression1413 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_61_in_postfix_expression1429 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_macro_parameter_list_in_postfix_expression1431 = frozenset([62]) + FOLLOW_62_in_postfix_expression1433 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_74_in_postfix_expression1447 = frozenset([4]) + FOLLOW_IDENTIFIER_in_postfix_expression1451 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_65_in_postfix_expression1467 = frozenset([4]) + FOLLOW_IDENTIFIER_in_postfix_expression1471 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_75_in_postfix_expression1487 = frozenset([4]) + FOLLOW_IDENTIFIER_in_postfix_expression1491 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_71_in_postfix_expression1507 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_72_in_postfix_expression1521 = frozenset([1, 61, 63, 65, 71, 72, 74, 75]) + FOLLOW_parameter_declaration_in_macro_parameter_list1544 = frozenset([1, 27]) + FOLLOW_27_in_macro_parameter_list1547 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_parameter_declaration_in_macro_parameter_list1549 = frozenset([1, 27]) + FOLLOW_set_in_unary_operator0 = frozenset([1]) + FOLLOW_IDENTIFIER_in_primary_expression1598 = frozenset([1]) + FOLLOW_constant_in_primary_expression1603 = frozenset([1]) + FOLLOW_61_in_primary_expression1608 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_primary_expression1610 = frozenset([62]) + FOLLOW_62_in_primary_expression1612 = frozenset([1]) + FOLLOW_HEX_LITERAL_in_constant1628 = frozenset([1]) + FOLLOW_OCTAL_LITERAL_in_constant1638 = frozenset([1]) + FOLLOW_DECIMAL_LITERAL_in_constant1648 = frozenset([1]) + FOLLOW_CHARACTER_LITERAL_in_constant1656 = frozenset([1]) + FOLLOW_IDENTIFIER_in_constant1665 = frozenset([4, 9]) + FOLLOW_STRING_LITERAL_in_constant1668 = frozenset([1, 4, 9]) + FOLLOW_IDENTIFIER_in_constant1673 = frozenset([1, 4]) + FOLLOW_FLOATING_POINT_LITERAL_in_constant1684 = frozenset([1]) + FOLLOW_assignment_expression_in_expression1700 = frozenset([1, 27]) + FOLLOW_27_in_expression1703 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_assignment_expression_in_expression1705 = frozenset([1, 27]) + FOLLOW_conditional_expression_in_constant_expression1718 = frozenset([1]) + FOLLOW_lvalue_in_assignment_expression1729 = frozenset([28, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88]) + FOLLOW_assignment_operator_in_assignment_expression1731 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_assignment_expression_in_assignment_expression1733 = frozenset([1]) + FOLLOW_conditional_expression_in_assignment_expression1738 = frozenset([1]) + FOLLOW_unary_expression_in_lvalue1750 = frozenset([1]) + FOLLOW_set_in_assignment_operator0 = frozenset([1]) + FOLLOW_logical_or_expression_in_conditional_expression1824 = frozenset([1, 89]) + FOLLOW_89_in_conditional_expression1827 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_conditional_expression1829 = frozenset([47]) + FOLLOW_47_in_conditional_expression1831 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_conditional_expression_in_conditional_expression1833 = frozenset([1]) + FOLLOW_logical_and_expression_in_logical_or_expression1848 = frozenset([1, 90]) + FOLLOW_90_in_logical_or_expression1851 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_logical_and_expression_in_logical_or_expression1853 = frozenset([1, 90]) + FOLLOW_inclusive_or_expression_in_logical_and_expression1866 = frozenset([1, 91]) + FOLLOW_91_in_logical_and_expression1869 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_inclusive_or_expression_in_logical_and_expression1871 = frozenset([1, 91]) + FOLLOW_exclusive_or_expression_in_inclusive_or_expression1884 = frozenset([1, 92]) + FOLLOW_92_in_inclusive_or_expression1887 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_exclusive_or_expression_in_inclusive_or_expression1889 = frozenset([1, 92]) + FOLLOW_and_expression_in_exclusive_or_expression1902 = frozenset([1, 93]) + FOLLOW_93_in_exclusive_or_expression1905 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_and_expression_in_exclusive_or_expression1907 = frozenset([1, 93]) + FOLLOW_equality_expression_in_and_expression1920 = frozenset([1, 76]) + FOLLOW_76_in_and_expression1923 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_equality_expression_in_and_expression1925 = frozenset([1, 76]) + FOLLOW_relational_expression_in_equality_expression1937 = frozenset([1, 94, 95]) + FOLLOW_set_in_equality_expression1940 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_relational_expression_in_equality_expression1946 = frozenset([1, 94, 95]) + FOLLOW_shift_expression_in_relational_expression1960 = frozenset([1, 96, 97, 98, 99]) + FOLLOW_set_in_relational_expression1963 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_shift_expression_in_relational_expression1973 = frozenset([1, 96, 97, 98, 99]) + FOLLOW_additive_expression_in_shift_expression1986 = frozenset([1, 100, 101]) + FOLLOW_set_in_shift_expression1989 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_additive_expression_in_shift_expression1995 = frozenset([1, 100, 101]) + FOLLOW_labeled_statement_in_statement2010 = frozenset([1]) + FOLLOW_compound_statement_in_statement2015 = frozenset([1]) + FOLLOW_expression_statement_in_statement2020 = frozenset([1]) + FOLLOW_selection_statement_in_statement2025 = frozenset([1]) + FOLLOW_iteration_statement_in_statement2030 = frozenset([1]) + FOLLOW_jump_statement_in_statement2035 = frozenset([1]) + FOLLOW_macro_statement_in_statement2040 = frozenset([1]) + FOLLOW_asm2_statement_in_statement2045 = frozenset([1]) + FOLLOW_asm1_statement_in_statement2050 = frozenset([1]) + FOLLOW_asm_statement_in_statement2055 = frozenset([1]) + FOLLOW_declaration_in_statement2060 = frozenset([1]) + FOLLOW_102_in_asm2_statement2071 = frozenset([4]) + FOLLOW_IDENTIFIER_in_asm2_statement2074 = frozenset([61]) + FOLLOW_61_in_asm2_statement2076 = frozenset([4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_set_in_asm2_statement2079 = frozenset([4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_62_in_asm2_statement2086 = frozenset([25]) + FOLLOW_25_in_asm2_statement2088 = frozenset([1]) + FOLLOW_103_in_asm1_statement2100 = frozenset([43]) + FOLLOW_43_in_asm1_statement2102 = frozenset([4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_set_in_asm1_statement2105 = frozenset([4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_44_in_asm1_statement2112 = frozenset([1]) + FOLLOW_104_in_asm_statement2123 = frozenset([43]) + FOLLOW_43_in_asm_statement2125 = frozenset([4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_set_in_asm_statement2128 = frozenset([4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_44_in_asm_statement2135 = frozenset([1]) + FOLLOW_IDENTIFIER_in_macro_statement2147 = frozenset([61]) + FOLLOW_61_in_macro_statement2149 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_declaration_in_macro_statement2151 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_list_in_macro_statement2155 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 62, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_macro_statement2158 = frozenset([62]) + FOLLOW_62_in_macro_statement2161 = frozenset([1]) + FOLLOW_IDENTIFIER_in_labeled_statement2173 = frozenset([47]) + FOLLOW_47_in_labeled_statement2175 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_in_labeled_statement2177 = frozenset([1]) + FOLLOW_105_in_labeled_statement2182 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_constant_expression_in_labeled_statement2184 = frozenset([47]) + FOLLOW_47_in_labeled_statement2186 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_in_labeled_statement2188 = frozenset([1]) + FOLLOW_106_in_labeled_statement2193 = frozenset([47]) + FOLLOW_47_in_labeled_statement2195 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_in_labeled_statement2197 = frozenset([1]) + FOLLOW_43_in_compound_statement2208 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_declaration_in_compound_statement2210 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_list_in_compound_statement2213 = frozenset([44]) + FOLLOW_44_in_compound_statement2216 = frozenset([1]) + FOLLOW_statement_in_statement_list2227 = frozenset([1, 4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_25_in_expression_statement2239 = frozenset([1]) + FOLLOW_expression_in_expression_statement2244 = frozenset([25]) + FOLLOW_25_in_expression_statement2246 = frozenset([1]) + FOLLOW_107_in_selection_statement2257 = frozenset([61]) + FOLLOW_61_in_selection_statement2259 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_selection_statement2263 = frozenset([62]) + FOLLOW_62_in_selection_statement2265 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_in_selection_statement2269 = frozenset([1, 108]) + FOLLOW_108_in_selection_statement2284 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_in_selection_statement2286 = frozenset([1]) + FOLLOW_109_in_selection_statement2293 = frozenset([61]) + FOLLOW_61_in_selection_statement2295 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_selection_statement2297 = frozenset([62]) + FOLLOW_62_in_selection_statement2299 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_in_selection_statement2301 = frozenset([1]) + FOLLOW_110_in_iteration_statement2312 = frozenset([61]) + FOLLOW_61_in_iteration_statement2314 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_iteration_statement2318 = frozenset([62]) + FOLLOW_62_in_iteration_statement2320 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_in_iteration_statement2322 = frozenset([1]) + FOLLOW_111_in_iteration_statement2329 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_in_iteration_statement2331 = frozenset([110]) + FOLLOW_110_in_iteration_statement2333 = frozenset([61]) + FOLLOW_61_in_iteration_statement2335 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_iteration_statement2339 = frozenset([62]) + FOLLOW_62_in_iteration_statement2341 = frozenset([25]) + FOLLOW_25_in_iteration_statement2343 = frozenset([1]) + FOLLOW_112_in_iteration_statement2350 = frozenset([61]) + FOLLOW_61_in_iteration_statement2352 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_statement_in_iteration_statement2354 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_statement_in_iteration_statement2358 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 62, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_iteration_statement2360 = frozenset([62]) + FOLLOW_62_in_iteration_statement2363 = frozenset([4, 5, 6, 7, 8, 9, 10, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 113, 114, 115, 116]) + FOLLOW_statement_in_iteration_statement2365 = frozenset([1]) + FOLLOW_113_in_jump_statement2378 = frozenset([4]) + FOLLOW_IDENTIFIER_in_jump_statement2380 = frozenset([25]) + FOLLOW_25_in_jump_statement2382 = frozenset([1]) + FOLLOW_114_in_jump_statement2387 = frozenset([25]) + FOLLOW_25_in_jump_statement2389 = frozenset([1]) + FOLLOW_115_in_jump_statement2394 = frozenset([25]) + FOLLOW_25_in_jump_statement2396 = frozenset([1]) + FOLLOW_116_in_jump_statement2401 = frozenset([25]) + FOLLOW_25_in_jump_statement2403 = frozenset([1]) + FOLLOW_116_in_jump_statement2408 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_expression_in_jump_statement2410 = frozenset([25]) + FOLLOW_25_in_jump_statement2412 = frozenset([1]) + FOLLOW_declaration_specifiers_in_synpred290 = frozenset([1]) + FOLLOW_declaration_specifiers_in_synpred490 = frozenset([4, 58, 59, 60, 61, 65]) + FOLLOW_declarator_in_synpred493 = frozenset([4, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_declaration_in_synpred495 = frozenset([4, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_43_in_synpred498 = frozenset([1]) + FOLLOW_declaration_in_synpred5108 = frozenset([1]) + FOLLOW_declaration_specifiers_in_synpred7147 = frozenset([1]) + FOLLOW_declaration_specifiers_in_synpred10197 = frozenset([1]) + FOLLOW_type_specifier_in_synpred14262 = frozenset([1]) + FOLLOW_type_qualifier_in_synpred15276 = frozenset([1]) + FOLLOW_type_qualifier_in_synpred33434 = frozenset([1]) + FOLLOW_IDENTIFIER_in_synpred34432 = frozenset([4, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65]) + FOLLOW_type_qualifier_in_synpred34434 = frozenset([4, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65]) + FOLLOW_declarator_in_synpred34437 = frozenset([1]) + FOLLOW_type_qualifier_in_synpred39556 = frozenset([1]) + FOLLOW_type_specifier_in_synpred40560 = frozenset([1]) + FOLLOW_pointer_in_synpred65769 = frozenset([4, 58, 59, 60, 61]) + FOLLOW_58_in_synpred65773 = frozenset([4, 59, 60, 61]) + FOLLOW_59_in_synpred65778 = frozenset([4, 60, 61]) + FOLLOW_60_in_synpred65783 = frozenset([4, 61]) + FOLLOW_direct_declarator_in_synpred65787 = frozenset([1]) + FOLLOW_declarator_suffix_in_synpred66806 = frozenset([1]) + FOLLOW_58_in_synpred68815 = frozenset([1]) + FOLLOW_declarator_suffix_in_synpred69823 = frozenset([1]) + FOLLOW_61_in_synpred72863 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_parameter_type_list_in_synpred72865 = frozenset([62]) + FOLLOW_62_in_synpred72867 = frozenset([1]) + FOLLOW_61_in_synpred73877 = frozenset([4]) + FOLLOW_identifier_list_in_synpred73879 = frozenset([62]) + FOLLOW_62_in_synpred73881 = frozenset([1]) + FOLLOW_type_qualifier_in_synpred74906 = frozenset([1]) + FOLLOW_pointer_in_synpred75909 = frozenset([1]) + FOLLOW_65_in_synpred76904 = frozenset([49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_type_qualifier_in_synpred76906 = frozenset([1, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_pointer_in_synpred76909 = frozenset([1]) + FOLLOW_65_in_synpred77915 = frozenset([65]) + FOLLOW_pointer_in_synpred77917 = frozenset([1]) + FOLLOW_53_in_synpred80962 = frozenset([1]) + FOLLOW_27_in_synpred81959 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_53_in_synpred81962 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_parameter_declaration_in_synpred81966 = frozenset([1]) + FOLLOW_declarator_in_synpred82982 = frozenset([1]) + FOLLOW_abstract_declarator_in_synpred83984 = frozenset([1]) + FOLLOW_declaration_specifiers_in_synpred85979 = frozenset([1, 4, 53, 58, 59, 60, 61, 63, 65]) + FOLLOW_declarator_in_synpred85982 = frozenset([1, 4, 53, 58, 59, 60, 61, 63, 65]) + FOLLOW_abstract_declarator_in_synpred85984 = frozenset([1, 4, 53, 58, 59, 60, 61, 63, 65]) + FOLLOW_53_in_synpred85989 = frozenset([1]) + FOLLOW_specifier_qualifier_list_in_synpred891031 = frozenset([1, 61, 63, 65]) + FOLLOW_abstract_declarator_in_synpred891033 = frozenset([1]) + FOLLOW_direct_abstract_declarator_in_synpred901052 = frozenset([1]) + FOLLOW_61_in_synpred921071 = frozenset([61, 63, 65]) + FOLLOW_abstract_declarator_in_synpred921073 = frozenset([62]) + FOLLOW_62_in_synpred921075 = frozenset([1]) + FOLLOW_abstract_declarator_suffix_in_synpred931083 = frozenset([1]) + FOLLOW_61_in_synpred1081267 = frozenset([4, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]) + FOLLOW_type_name_in_synpred1081269 = frozenset([62]) + FOLLOW_62_in_synpred1081271 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_cast_expression_in_synpred1081273 = frozenset([1]) + FOLLOW_73_in_synpred1131315 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_unary_expression_in_synpred1131317 = frozenset([1]) + FOLLOW_61_in_synpred1161405 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_argument_expression_list_in_synpred1161409 = frozenset([62]) + FOLLOW_62_in_synpred1161413 = frozenset([1]) + FOLLOW_61_in_synpred1171429 = frozenset([4, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65]) + FOLLOW_macro_parameter_list_in_synpred1171431 = frozenset([62]) + FOLLOW_62_in_synpred1171433 = frozenset([1]) + FOLLOW_65_in_synpred1191467 = frozenset([4]) + FOLLOW_IDENTIFIER_in_synpred1191471 = frozenset([1]) + FOLLOW_STRING_LITERAL_in_synpred1361668 = frozenset([1]) + FOLLOW_IDENTIFIER_in_synpred1371665 = frozenset([4, 9]) + FOLLOW_STRING_LITERAL_in_synpred1371668 = frozenset([1, 9]) + FOLLOW_lvalue_in_synpred1411729 = frozenset([28, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88]) + FOLLOW_assignment_operator_in_synpred1411731 = frozenset([4, 5, 6, 7, 8, 9, 10, 61, 65, 67, 68, 71, 72, 73, 76, 77, 78]) + FOLLOW_assignment_expression_in_synpred1411733 = frozenset([1]) + FOLLOW_expression_statement_in_synpred1682020 = frozenset([1]) + FOLLOW_macro_statement_in_synpred1722040 = frozenset([1]) + FOLLOW_asm2_statement_in_synpred1732045 = frozenset([1]) + FOLLOW_declaration_in_synpred1802151 = frozenset([1]) + FOLLOW_statement_list_in_synpred1812155 = frozenset([1]) + FOLLOW_declaration_in_synpred1852210 = frozenset([1]) + FOLLOW_statement_in_synpred1872227 = frozenset([1]) + diff --git a/BaseTools/Source/Python/Ecc/Check.py b/BaseTools/Source/Python/Ecc/Check.py new file mode 100644 index 0000000000..c8bc54de3e --- /dev/null +++ b/BaseTools/Source/Python/Ecc/Check.py @@ -0,0 +1,865 @@ +## @file +# This file is used to define checkpoints used by ECC tool +# +# Copyright (c) 2008, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# +import os +import re +from CommonDataClass.DataClass import * +from Common.DataType import SUP_MODULE_LIST_STRING, TAB_VALUE_SPLIT +from EccToolError import * +import EccGlobalData +import c + +## Check +# +# This class is to define checkpoints used by ECC tool +# +# @param object: Inherited from object class +# +class Check(object): + def __init__(self): + pass + + # Check all required checkpoints + def Check(self): + self.MetaDataFileCheck() + self.DoxygenCheck() + self.IncludeFileCheck() + self.PredicateExpressionCheck() + self.DeclAndDataTypeCheck() + self.FunctionLayoutCheck() + self.NamingConventionCheck() + + # C Function Layout Checking + def FunctionLayoutCheck(self): + self.FunctionLayoutCheckReturnType() + self.FunctionLayoutCheckModifier() + self.FunctionLayoutCheckName() + self.FunctionLayoutCheckPrototype() + self.FunctionLayoutCheckBody() + self.FunctionLayoutCheckLocalVariable() + + def WalkTree(self): + IgnoredPattern = c.GetIgnoredDirListPattern() + for Dirpath, Dirnames, Filenames in os.walk(EccGlobalData.gTarget): + for Dir in Dirnames: + Dirname = os.path.join(Dirpath, Dir) + if os.path.islink(Dirname): + Dirname = os.path.realpath(Dirname) + if os.path.isdir(Dirname): + # symlinks to directories are treated as directories + Dirnames.remove(Dir) + Dirnames.append(Dirname) + if IgnoredPattern.match(Dirpath.upper()): + continue + yield (Dirpath, Dirnames, Filenames) + + # Check whether return type exists and in the first line + def FunctionLayoutCheckReturnType(self): + if EccGlobalData.gConfig.CFunctionLayoutCheckReturnType == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking function layout return type ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.c', '.h'): + FullName = os.path.join(Dirpath, F) + c.CheckFuncLayoutReturnType(FullName) + + # Check whether any optional functional modifiers exist and next to the return type + def FunctionLayoutCheckModifier(self): + if EccGlobalData.gConfig.CFunctionLayoutCheckOptionalFunctionalModifier == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking function layout modifier ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.c', '.h'): + FullName = os.path.join(Dirpath, F) + c.CheckFuncLayoutModifier(FullName) + + # Check whether the next line contains the function name, left justified, followed by the beginning of the parameter list + # Check whether the closing parenthesis is on its own line and also indented two spaces + def FunctionLayoutCheckName(self): + if EccGlobalData.gConfig.CFunctionLayoutCheckFunctionName == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking function layout function name ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.c', '.h'): + FullName = os.path.join(Dirpath, F) + c.CheckFuncLayoutName(FullName) + # Check whether the function prototypes in include files have the same form as function definitions + def FunctionLayoutCheckPrototype(self): + if EccGlobalData.gConfig.CFunctionLayoutCheckFunctionPrototype == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking function layout function prototype ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.c'): + FullName = os.path.join(Dirpath, F) + EdkLogger.quiet("[PROTOTYPE]" + FullName) + c.CheckFuncLayoutPrototype(FullName) + + # Check whether the body of a function is contained by open and close braces that must be in the first column + def FunctionLayoutCheckBody(self): + if EccGlobalData.gConfig.CFunctionLayoutCheckFunctionBody == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking function layout function body ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.c'): + FullName = os.path.join(Dirpath, F) + c.CheckFuncLayoutBody(FullName) + + # Check whether the data declarations is the first code in a module. + # self.CFunctionLayoutCheckDataDeclaration = 1 + # Check whether no initialization of a variable as part of its declaration + def FunctionLayoutCheckLocalVariable(self): + if EccGlobalData.gConfig.CFunctionLayoutCheckNoInitOfVariable == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking function layout local variables ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.c'): + FullName = os.path.join(Dirpath, F) + c.CheckFuncLayoutLocalVariable(FullName) + + # Check whether no use of STATIC for functions + # self.CFunctionLayoutCheckNoStatic = 1 + + # Declarations and Data Types Checking + def DeclAndDataTypeCheck(self): + self.DeclCheckNoUseCType() + self.DeclCheckInOutModifier() + self.DeclCheckEFIAPIModifier() + self.DeclCheckEnumeratedType() + self.DeclCheckStructureDeclaration() + self.DeclCheckSameStructure() + self.DeclCheckUnionType() + + + # Check whether no use of int, unsigned, char, void, static, long in any .c, .h or .asl files. + def DeclCheckNoUseCType(self): + if EccGlobalData.gConfig.DeclarationDataTypeCheckNoUseCType == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking Declaration No use C type ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + c.CheckDeclNoUseCType(FullName) + + # Check whether the modifiers IN, OUT, OPTIONAL, and UNALIGNED are used only to qualify arguments to a function and should not appear in a data type declaration + def DeclCheckInOutModifier(self): + if EccGlobalData.gConfig.DeclarationDataTypeCheckInOutModifier == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking Declaration argument modifier ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + c.CheckDeclArgModifier(FullName) + + # Check whether the EFIAPI modifier should be used at the entry of drivers, events, and member functions of protocols + def DeclCheckEFIAPIModifier(self): + if EccGlobalData.gConfig.DeclarationDataTypeCheckEFIAPIModifier == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + pass + + # Check whether Enumerated Type has a 'typedef' and the name is capital + def DeclCheckEnumeratedType(self): + if EccGlobalData.gConfig.DeclarationDataTypeCheckEnumeratedType == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking Declaration enum typedef ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + EdkLogger.quiet("[ENUM]" + FullName) + c.CheckDeclEnumTypedef(FullName) + + # Check whether Structure Type has a 'typedef' and the name is capital + def DeclCheckStructureDeclaration(self): + if EccGlobalData.gConfig.DeclarationDataTypeCheckStructureDeclaration == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking Declaration struct typedef ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + EdkLogger.quiet("[STRUCT]" + FullName) + c.CheckDeclStructTypedef(FullName) + + # Check whether having same Structure + def DeclCheckSameStructure(self): + if EccGlobalData.gConfig.DeclarationDataTypeCheckSameStructure == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking same struct ...") + AllStructure = {} + for IdentifierTable in EccGlobalData.gIdentifierTableList: + SqlCommand = """select ID, Name, BelongsToFile from %s where Model = %s""" %(IdentifierTable, MODEL_IDENTIFIER_STRUCTURE) + RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Record in RecordSet: + if Record[1] != '': + if Record[1] not in AllStructure.keys(): + AllStructure[Record[1]] = Record[2] + else: + ID = AllStructure[Record[1]] + SqlCommand = """select FullPath from File where ID = %s """ % ID + NewRecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + OtherMsg = "The structure name '%s' is duplicate" % Record[1] + if NewRecordSet != []: + OtherMsg = "The structure name [%s] is duplicate with the one defined in %s, maybe struct NOT typedefed or the typedef new type NOT used to qualify variables" % (Record[1], NewRecordSet[0][0]) + if not EccGlobalData.gException.IsException(ERROR_DECLARATION_DATA_TYPE_CHECK_SAME_STRUCTURE, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_DECLARATION_DATA_TYPE_CHECK_SAME_STRUCTURE, OtherMsg = OtherMsg, BelongsToTable = IdentifierTable, BelongsToItem = Record[0]) + + # Check whether Union Type has a 'typedef' and the name is capital + def DeclCheckUnionType(self): + if EccGlobalData.gConfig.DeclarationDataTypeCheckUnionType == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking Declaration union typedef ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + EdkLogger.quiet("[UNION]" + FullName) + c.CheckDeclUnionTypedef(FullName) + + # Predicate Expression Checking + def PredicateExpressionCheck(self): + self.PredicateExpressionCheckBooleanValue() + self.PredicateExpressionCheckNonBooleanOperator() + self.PredicateExpressionCheckComparisonNullType() + + # Check whether Boolean values, variable type BOOLEAN not use explicit comparisons to TRUE or FALSE + def PredicateExpressionCheckBooleanValue(self): + if EccGlobalData.gConfig.PredicateExpressionCheckBooleanValue == '1' or EccGlobalData.gConfig.PredicateExpressionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking predicate expression Boolean value ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.c'): + FullName = os.path.join(Dirpath, F) + EdkLogger.quiet("[BOOLEAN]" + FullName) + c.CheckBooleanValueComparison(FullName) + + # Check whether Non-Boolean comparisons use a compare operator (==, !=, >, < >=, <=). + def PredicateExpressionCheckNonBooleanOperator(self): + if EccGlobalData.gConfig.PredicateExpressionCheckNonBooleanOperator == '1' or EccGlobalData.gConfig.PredicateExpressionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking predicate expression Non-Boolean variable...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.c'): + FullName = os.path.join(Dirpath, F) + EdkLogger.quiet("[NON-BOOLEAN]" + FullName) + c.CheckNonBooleanValueComparison(FullName) + # Check whether a comparison of any pointer to zero must be done via the NULL type + def PredicateExpressionCheckComparisonNullType(self): + if EccGlobalData.gConfig.PredicateExpressionCheckComparisonNullType == '1' or EccGlobalData.gConfig.PredicateExpressionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking predicate expression NULL pointer ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.c'): + FullName = os.path.join(Dirpath, F) + EdkLogger.quiet("[POINTER]" + FullName) + c.CheckPointerNullComparison(FullName) + # Include file checking + def IncludeFileCheck(self): + self.IncludeFileCheckIfndef() + self.IncludeFileCheckData() + self.IncludeFileCheckSameName() + + # Check whether having include files with same name + def IncludeFileCheckSameName(self): + if EccGlobalData.gConfig.IncludeFileCheckSameName == '1' or EccGlobalData.gConfig.IncludeFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking same header file name ...") + SqlCommand = """select ID, FullPath from File + where Model = 1002 order by Name """ + RecordDict = {} + RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Record in RecordSet: + List = Record[1].replace('/', '\\').split('\\') + if len(List) >= 2: + Key = List[-2] + '\\' + List[-1] + else: + Key = List[0] + if Key not in RecordDict: + RecordDict[Key] = [Record] + else: + RecordDict[Key].append(Record) + + for Key in RecordDict: + if len(RecordDict[Key]) > 1: + for Item in RecordDict[Key]: + EccGlobalData.gDb.TblReport.Insert(ERROR_INCLUDE_FILE_CHECK_NAME, OtherMsg = "The file name for '%s' is duplicate" % (Item[1]), BelongsToTable = 'File', BelongsToItem = Item[0]) + + # Check whether all include file contents is guarded by a #ifndef statement. + def IncludeFileCheckIfndef(self): + if EccGlobalData.gConfig.IncludeFileCheckIfndefStatement == '1' or EccGlobalData.gConfig.IncludeFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking header file ifndef ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h'): + FullName = os.path.join(Dirpath, F) + MsgList = c.CheckHeaderFileIfndef(FullName) + + # Check whether include files NOT contain code or define data variables + def IncludeFileCheckData(self): + if EccGlobalData.gConfig.IncludeFileCheckData == '1' or EccGlobalData.gConfig.IncludeFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking header file data ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h'): + FullName = os.path.join(Dirpath, F) + MsgList = c.CheckHeaderFileData(FullName) + + # Doxygen document checking + def DoxygenCheck(self): + self.DoxygenCheckFileHeader() + self.DoxygenCheckFunctionHeader() + self.DoxygenCheckCommentDescription() + self.DoxygenCheckCommentFormat() + self.DoxygenCheckCommand() + + # Check whether the file headers are followed Doxygen special documentation blocks in section 2.3.5 + def DoxygenCheckFileHeader(self): + if EccGlobalData.gConfig.DoxygenCheckFileHeader == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking Doxygen file header ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + MsgList = c.CheckFileHeaderDoxygenComments(FullName) + + # Check whether the function headers are followed Doxygen special documentation blocks in section 2.3.5 + def DoxygenCheckFunctionHeader(self): + if EccGlobalData.gConfig.DoxygenCheckFunctionHeader == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking Doxygen function header ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + MsgList = c.CheckFuncHeaderDoxygenComments(FullName) + + # Check whether the first line of text in a comment block is a brief description of the element being documented. + # The brief description must end with a period. + def DoxygenCheckCommentDescription(self): + if EccGlobalData.gConfig.DoxygenCheckCommentDescription == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + pass + + # Check whether comment lines with '///< ... text ...' format, if it is used, it should be after the code section. + def DoxygenCheckCommentFormat(self): + if EccGlobalData.gConfig.DoxygenCheckCommentFormat == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking Doxygen comment ///< ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + MsgList = c.CheckDoxygenTripleForwardSlash(FullName) + + # Check whether only Doxygen commands allowed to mark the code are @bug and @todo. + def DoxygenCheckCommand(self): + if EccGlobalData.gConfig.DoxygenCheckCommand == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking Doxygen command ...") + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + MsgList = c.CheckDoxygenCommand(FullName) + + # Meta-Data File Processing Checking + def MetaDataFileCheck(self): + self.MetaDataFileCheckPathName() + self.MetaDataFileCheckGenerateFileList() + self.MetaDataFileCheckLibraryInstance() + self.MetaDataFileCheckLibraryInstanceDependent() + self.MetaDataFileCheckLibraryInstanceOrder() + self.MetaDataFileCheckLibraryNoUse() + self.MetaDataFileCheckBinaryInfInFdf() + self.MetaDataFileCheckPcdDuplicate() + self.MetaDataFileCheckPcdFlash() + self.MetaDataFileCheckPcdNoUse() + self.MetaDataFileCheckGuidDuplicate() + self.MetaDataFileCheckModuleFileNoUse() + self.MetaDataFileCheckPcdType() + + # Check whether each file defined in meta-data exists + def MetaDataFileCheckPathName(self): + if EccGlobalData.gConfig.MetaDataFileCheckPathName == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + # This item is covered when parsing Inf/Dec/Dsc files + pass + + # Generate a list for all files defined in meta-data files + def MetaDataFileCheckGenerateFileList(self): + if EccGlobalData.gConfig.MetaDataFileCheckGenerateFileList == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + # This item is covered when parsing Inf/Dec/Dsc files + pass + + # Check whether all Library Instances defined for a given module (or dependent library instance) match the module's type. + # Each Library Instance must specify the Supported Module Types in its Inf file, + # and any module specifying the library instance must be one of the supported types. + def MetaDataFileCheckLibraryInstance(self): + if EccGlobalData.gConfig.MetaDataFileCheckLibraryInstance == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking for library instance type issue ...") + SqlCommand = """select A.ID, A.Value2, B.Value2 from Inf as A left join Inf as B + where A.Value1 = 'LIBRARY_CLASS' and A.Model = %s + and B.Value1 = 'MODULE_TYPE' and B.Model = %s and A.BelongsToFile = B.BelongsToFile + group by A.BelongsToFile""" % (MODEL_META_DATA_HEADER, MODEL_META_DATA_HEADER) + RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand) + LibraryClasses = {} + for Record in RecordSet: + List = Record[1].split('|', 1) + SupModType = [] + if len(List) == 1: + SupModType = SUP_MODULE_LIST_STRING.split(TAB_VALUE_SPLIT) + elif len(List) == 2: + SupModType = List[1].split() + + if List[0] not in LibraryClasses: + LibraryClasses[List[0]] = SupModType + else: + for Item in SupModType: + if Item not in LibraryClasses[List[0]]: + LibraryClasses[List[0]].append(Item) + + if Record[2] != 'BASE' and Record[2] not in SupModType: + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_2, OtherMsg = "The Library Class '%s' does not specify its supported module types" % (List[0]), BelongsToTable = 'Inf', BelongsToItem = Record[0]) + + SqlCommand = """select A.ID, A.Value1, B.Value2 from Inf as A left join Inf as B + where A.Model = %s and B.Value1 = '%s' and B.Model = %s + and B.BelongsToFile = A.BelongsToFile""" \ + % (MODEL_EFI_LIBRARY_CLASS, 'MODULE_TYPE', MODEL_META_DATA_HEADER) + RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand) + # Merge all LibraryClasses' supmodlist + RecordDict = {} + for Record in RecordSet: + if Record[1] not in RecordDict: + RecordDict[Record[1]] = [str(Record[2])] + else: + if Record[2] not in RecordDict[Record[1]]: + RecordDict[Record[1]].append(Record[2]) + + for Record in RecordSet: + if Record[1] in LibraryClasses: + if Record[2] not in LibraryClasses[Record[1]] and 'BASE' not in RecordDict[Record[1]]: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_1, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_1, OtherMsg = "The type of Library Class [%s] defined in Inf file does not match the type of the module" % (Record[1]), BelongsToTable = 'Inf', BelongsToItem = Record[0]) + else: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_1, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_1, OtherMsg = "The type of Library Class [%s] defined in Inf file does not match the type of the module" % (Record[1]), BelongsToTable = 'Inf', BelongsToItem = Record[0]) + + # Check whether a Library Instance has been defined for all dependent library classes + def MetaDataFileCheckLibraryInstanceDependent(self): + if EccGlobalData.gConfig.MetaDataFileCheckLibraryInstanceDependent == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking for library instance dependent issue ...") + SqlCommand = """select ID, Value1, Value2 from Dsc where Model = %s""" % MODEL_EFI_LIBRARY_CLASS + LibraryClasses = EccGlobalData.gDb.TblDsc.Exec(SqlCommand) + for LibraryClass in LibraryClasses: + if LibraryClass[1].upper() != 'NULL': + LibraryIns = os.path.normpath(os.path.join(EccGlobalData.gWorkspace, LibraryClass[2])) + SqlCommand = """select Value2 from Inf where BelongsToFile = + (select ID from File where lower(FullPath) = lower('%s')) + and Value1 = '%s'""" % (LibraryIns, 'LIBRARY_CLASS') + RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand) + IsFound = False + for Record in RecordSet: + LibName = Record[0].split('|', 1)[0] + if LibraryClass[1] == LibName: + IsFound = True + if not IsFound: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_DEPENDENT, LibraryClass[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_DEPENDENT, OtherMsg = "The Library Class [%s] is not specified in '%s'" % (LibraryClass[1], LibraryClass[2]), BelongsToTable = 'Dsc', BelongsToItem = LibraryClass[0]) + + # Check whether the Library Instances specified by the LibraryClasses sections are listed in order of dependencies + def MetaDataFileCheckLibraryInstanceOrder(self): + if EccGlobalData.gConfig.MetaDataFileCheckLibraryInstanceOrder == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + # This checkpoint is not necessary for Ecc check + pass + + # Check whether the unnecessary inclusion of library classes in the Inf file + def MetaDataFileCheckLibraryNoUse(self): + if EccGlobalData.gConfig.MetaDataFileCheckLibraryNoUse == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking for library instance not used ...") + SqlCommand = """select ID, Value1 from Inf as A where A.Model = %s and A.Value1 not in (select B.Value1 from Dsc as B where Model = %s)""" % (MODEL_EFI_LIBRARY_CLASS, MODEL_EFI_LIBRARY_CLASS) + RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand) + for Record in RecordSet: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_LIBRARY_NO_USE, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_LIBRARY_NO_USE, OtherMsg = "The Library Class [%s] is not used in any platform" % (Record[1]), BelongsToTable = 'Inf', BelongsToItem = Record[0]) + + # Check whether an Inf file is specified in the FDF file, but not in the Dsc file, then the Inf file must be for a Binary module only + def MetaDataFileCheckBinaryInfInFdf(self): + if EccGlobalData.gConfig.MetaDataFileCheckBinaryInfInFdf == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking for non-binary modules defined in FDF files ...") + SqlCommand = """select A.ID, A.Value1 from Fdf as A + where A.Model = %s + and A.Enabled > -1 + and A.Value1 not in + (select B.Value1 from Dsc as B + where B.Model = %s + and B.Enabled > -1)""" % (MODEL_META_DATA_COMPONENT, MODEL_META_DATA_COMPONENT) + RecordSet = EccGlobalData.gDb.TblFdf.Exec(SqlCommand) + for Record in RecordSet: + FdfID = Record[0] + FilePath = Record[1] + FilePath = os.path.normpath(os.path.join(EccGlobalData.gWorkspace, FilePath)) + SqlCommand = """select ID from Inf where Model = %s and BelongsToFile = (select ID from File where FullPath like '%s') + """ % (MODEL_EFI_SOURCE_FILE, FilePath) + NewRecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + if NewRecordSet!= []: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_BINARY_INF_IN_FDF, FilePath): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_BINARY_INF_IN_FDF, OtherMsg = "File [%s] defined in FDF file and not in DSC file must be a binary module" % (FilePath), BelongsToTable = 'Fdf', BelongsToItem = FdfID) + + # Check whether a PCD is set in a Dsc file or the FDF file, but not in both. + def MetaDataFileCheckPcdDuplicate(self): + if EccGlobalData.gConfig.MetaDataFileCheckPcdDuplicate == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking for duplicate PCDs defined in both DSC and FDF files ...") + SqlCommand = """ + select A.ID, A.Value2, B.ID, B.Value2 from Dsc as A, Fdf as B + where A.Model >= %s and A.Model < %s + and B.Model >= %s and B.Model < %s + and A.Value2 = B.Value2 + and A.Enabled > -1 + and B.Enabled > -1 + group by A.ID + """% (MODEL_PCD, MODEL_META_DATA_HEADER, MODEL_PCD, MODEL_META_DATA_HEADER) + RecordSet = EccGlobalData.gDb.TblDsc.Exec(SqlCommand) + for Record in RecordSet: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE, OtherMsg = "The PCD [%s] is defined in both FDF file and DSC file" % (Record[1]), BelongsToTable = 'Dsc', BelongsToItem = Record[0]) + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE, Record[3]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE, OtherMsg = "The PCD [%s] is defined in both FDF file and DSC file" % (Record[3]), BelongsToTable = 'Fdf', BelongsToItem = Record[2]) + + EdkLogger.quiet("Checking for duplicate PCDs defined in DEC files ...") + SqlCommand = """ + select A.ID, A.Value2 from Dec as A, Dec as B + where A.Model >= %s and A.Model < %s + and B.Model >= %s and B.Model < %s + and A.Value2 = B.Value2 + and ((A.Arch = B.Arch) and (A.Arch != 'COMMON' or B.Arch != 'COMMON')) + and A.ID != B.ID + and A.Enabled > -1 + and B.Enabled > -1 + and A.BelongsToFile = B.BelongsToFile + group by A.ID + """% (MODEL_PCD, MODEL_META_DATA_HEADER, MODEL_PCD, MODEL_META_DATA_HEADER) + RecordSet = EccGlobalData.gDb.TblDsc.Exec(SqlCommand) + for Record in RecordSet: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE, OtherMsg = "The PCD [%s] is defined duplicated in DEC file" % (Record[1]), BelongsToTable = 'Dec', BelongsToItem = Record[0]) + + # Check whether PCD settings in the FDF file can only be related to flash. + def MetaDataFileCheckPcdFlash(self): + if EccGlobalData.gConfig.MetaDataFileCheckPcdFlash == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking only Flash related PCDs are used in FDF ...") + SqlCommand = """ + select ID, Value2, BelongsToFile from Fdf as A + where A.Model >= %s and Model < %s + and A.Enabled > -1 + and A.Value2 not like '%%Flash%%' + """% (MODEL_PCD, MODEL_META_DATA_HEADER) + RecordSet = EccGlobalData.gDb.TblFdf.Exec(SqlCommand) + for Record in RecordSet: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_PCD_FLASH, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_FLASH, OtherMsg = "The PCD [%s] defined in FDF file is not related to Flash" % (Record[1]), BelongsToTable = 'Fdf', BelongsToItem = Record[0]) + + # Check whether PCDs used in Inf files but not specified in Dsc or FDF files + def MetaDataFileCheckPcdNoUse(self): + if EccGlobalData.gConfig.MetaDataFileCheckPcdNoUse == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking for non-specified PCDs ...") + SqlCommand = """ + select ID, Value2, BelongsToFile from Inf as A + where A.Model >= %s and Model < %s + and A.Enabled > -1 + and A.Value2 not in + (select Value2 from Dsc as B + where B.Model >= %s and B.Model < %s + and B.Enabled > -1) + and A.Value2 not in + (select Value2 from Fdf as C + where C.Model >= %s and C.Model < %s + and C.Enabled > -1) + """% (MODEL_PCD, MODEL_META_DATA_HEADER, MODEL_PCD, MODEL_META_DATA_HEADER, MODEL_PCD, MODEL_META_DATA_HEADER) + RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand) + for Record in RecordSet: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_PCD_NO_USE, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_NO_USE, OtherMsg = "The PCD [%s] defined in INF file is not specified in either DSC or FDF files" % (Record[1]), BelongsToTable = 'Inf', BelongsToItem = Record[0]) + + # Check whether having duplicate guids defined for Guid/Protocol/Ppi + def MetaDataFileCheckGuidDuplicate(self): + if EccGlobalData.gConfig.MetaDataFileCheckGuidDuplicate == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking for duplicate GUID/PPI/PROTOCOL ...") + # Check Guid + self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_GUID, MODEL_EFI_GUID, EccGlobalData.gDb.TblDec) + self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_GUID, MODEL_EFI_GUID, EccGlobalData.gDb.TblDsc) + self.CheckGuidProtocolPpiValue(ERROR_META_DATA_FILE_CHECK_DUPLICATE_GUID, MODEL_EFI_GUID) + # Check protocol + self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PROTOCOL, MODEL_EFI_PROTOCOL, EccGlobalData.gDb.TblDec) + self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PROTOCOL, MODEL_EFI_PROTOCOL, EccGlobalData.gDb.TblDsc) + self.CheckGuidProtocolPpiValue(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PROTOCOL, MODEL_EFI_PROTOCOL) + # Check ppi + self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PPI, MODEL_EFI_PPI, EccGlobalData.gDb.TblDec) + self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PPI, MODEL_EFI_PPI, EccGlobalData.gDb.TblDsc) + self.CheckGuidProtocolPpiValue(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PPI, MODEL_EFI_PPI) + + # Check whether all files under module directory are described in INF files + def MetaDataFileCheckModuleFileNoUse(self): + if EccGlobalData.gConfig.MetaDataFileCheckModuleFileNoUse == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking for no used module files ...") + SqlCommand = """ + select upper(Path) from File where ID in (select BelongsToFile from INF where BelongsToFile != -1) + """ + InfPathSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand) + InfPathList = [] + for Item in InfPathSet: + if Item[0] not in InfPathList: + InfPathList.append(Item[0]) + SqlCommand = """ + select ID, Path, FullPath from File where upper(FullPath) not in + (select upper(A.Path) || '\\' || upper(B.Value1) from File as A, INF as B + where A.ID in (select BelongsToFile from INF where Model = %s group by BelongsToFile) and + B.BelongsToFile = A.ID and B.Model = %s) + and (Model = %s or Model = %s) + """ % (MODEL_EFI_SOURCE_FILE, MODEL_EFI_SOURCE_FILE, MODEL_FILE_C, MODEL_FILE_H) + RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand) + for Record in RecordSet: + Path = Record[1] + Path = Path.upper().replace('\X64', '').replace('\IA32', '').replace('\EBC', '').replace('\IPF', '').replace('\ARM', '') + if Path in InfPathList: + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_MODULE_FILE_NO_USE, Record[2]): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_MODULE_FILE_NO_USE, OtherMsg = "The source file [%s] is existing in module directory but it is not described in INF file." % (Record[2]), BelongsToTable = 'File', BelongsToItem = Record[0]) + + # Check whether the PCD is correctly used in C function via its type + def MetaDataFileCheckPcdType(self): + if EccGlobalData.gConfig.MetaDataFileCheckPcdType == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking for pcd type in c code function usage ...") + SqlCommand = """ + select ID, Model, Value1, BelongsToFile from INF where Model > %s and Model < %s + """ % (MODEL_PCD, MODEL_META_DATA_HEADER) + PcdSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand) + for Pcd in PcdSet: + Model = Pcd[1] + PcdName = Pcd[2] + if len(Pcd[2].split(".")) > 1: + PcdName = Pcd[2].split(".")[1] + BelongsToFile = Pcd[3] + SqlCommand = """ + select ID from File where FullPath in + (select B.Path || '\\' || A.Value1 from INF as A, File as B where A.Model = %s and A.BelongsToFile = %s + and B.ID = %s) + """ %(MODEL_EFI_SOURCE_FILE, BelongsToFile, BelongsToFile) + TableSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Tbl in TableSet: + TblName = 'Identifier' + str(Tbl[0]) + SqlCommand = """ + select Name, ID from %s where value like '%%%s%%' and Model = %s + """ % (TblName, PcdName, MODEL_IDENTIFIER_FUNCTION_CALLING) + RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand) + TblNumber = TblName.replace('Identifier', '') + for Record in RecordSet: + FunName = Record[0] + if not EccGlobalData.gException.IsException(ERROR_META_DATA_FILE_CHECK_PCD_TYPE, FunName): + if Model in [MODEL_PCD_FIXED_AT_BUILD] and not FunName.startswith('FixedPcdGet'): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_TYPE, OtherMsg = "The pcd '%s' is defined as a FixPcd but now it is called by c function [%s]" % (PcdName, FunName), BelongsToTable = TblName, BelongsToItem = Record[1]) + if Model in [MODEL_PCD_FEATURE_FLAG] and (not FunName.startswith('FeaturePcdGet') and not FunName.startswith('FeaturePcdSet')): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_TYPE, OtherMsg = "The pcd '%s' is defined as a FeaturePcd but now it is called by c function [%s]" % (PcdName, FunName), BelongsToTable = TblName, BelongsToItem = Record[1]) + if Model in [MODEL_PCD_PATCHABLE_IN_MODULE] and (not FunName.startswith('PatchablePcdGet') and not FunName.startswith('PatchablePcdSet')): + EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_TYPE, OtherMsg = "The pcd '%s' is defined as a PatchablePcd but now it is called by c function [%s]" % (PcdName, FunName), BelongsToTable = TblName, BelongsToItem = Record[1]) + + #ERROR_META_DATA_FILE_CHECK_PCD_TYPE + pass + + # Check whether these is duplicate Guid/Ppi/Protocol name + def CheckGuidProtocolPpi(self, ErrorID, Model, Table): + Name = '' + if Model == MODEL_EFI_GUID: + Name = 'guid' + if Model == MODEL_EFI_PROTOCOL: + Name = 'protocol' + if Model == MODEL_EFI_PPI: + Name = 'ppi' + SqlCommand = """ + select A.ID, A.Value1 from %s as A, %s as B + where A.Model = %s and B.Model = %s + and A.Value1 = B.Value1 and A.ID <> B.ID + and A.Enabled > -1 + and B.Enabled > -1 + group by A.ID + """ % (Table.Table, Table.Table, Model, Model) + RecordSet = Table.Exec(SqlCommand) + for Record in RecordSet: + if not EccGlobalData.gException.IsException(ErrorID, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ErrorID, OtherMsg = "The %s name [%s] is defined more than one time" % (Name.upper(), Record[1]), BelongsToTable = Table.Table, BelongsToItem = Record[0]) + + # Check whether these is duplicate Guid/Ppi/Protocol value + def CheckGuidProtocolPpiValue(self, ErrorID, Model): + Name = '' + Table = EccGlobalData.gDb.TblDec + if Model == MODEL_EFI_GUID: + Name = 'guid' + if Model == MODEL_EFI_PROTOCOL: + Name = 'protocol' + if Model == MODEL_EFI_PPI: + Name = 'ppi' + SqlCommand = """ + select A.ID, A.Value2 from %s as A, %s as B + where A.Model = %s and B.Model = %s + and A.Value2 = B.Value2 and A.ID <> B.ID + group by A.ID + """ % (Table.Table, Table.Table, Model, Model) + RecordSet = Table.Exec(SqlCommand) + for Record in RecordSet: + if not EccGlobalData.gException.IsException(ErrorID, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ErrorID, OtherMsg = "The %s value [%s] is used more than one time" % (Name.upper(), Record[1]), BelongsToTable = Table.Table, BelongsToItem = Record[0]) + + # Naming Convention Check + def NamingConventionCheck(self): + + for Dirpath, Dirnames, Filenames in self.WalkTree(): + for F in Filenames: + if os.path.splitext(F)[1] in ('.h', '.c'): + FullName = os.path.join(Dirpath, F) + Id = c.GetTableID(FullName) + if Id < 0: + continue + FileTable = 'Identifier' + str(Id) + self.NamingConventionCheckDefineStatement(FileTable) + self.NamingConventionCheckTypedefStatement(FileTable) + self.NamingConventionCheckIfndefStatement(FileTable) + self.NamingConventionCheckVariableName(FileTable) + self.NamingConventionCheckSingleCharacterVariable(FileTable) + + self.NamingConventionCheckPathName() + self.NamingConventionCheckFunctionName() + + # Check whether only capital letters are used for #define declarations + def NamingConventionCheckDefineStatement(self, FileTable): + if EccGlobalData.gConfig.NamingConventionCheckDefineStatement == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking naming covention of #define statement ...") + + SqlCommand = """select ID, Value from %s where Model = %s""" %(FileTable, MODEL_IDENTIFIER_MACRO_DEFINE) + RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Record in RecordSet: + Name = Record[1].strip().split()[1] + if Name.find('(') != -1: + Name = Name[0:Name.find('(')] + if Name.upper() != Name: + if not EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_DEFINE_STATEMENT, Name): + EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_DEFINE_STATEMENT, OtherMsg = "The #define name [%s] does not follow the rules" % (Name), BelongsToTable = FileTable, BelongsToItem = Record[0]) + + # Check whether only capital letters are used for typedef declarations + def NamingConventionCheckTypedefStatement(self, FileTable): + if EccGlobalData.gConfig.NamingConventionCheckTypedefStatement == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking naming covention of #typedef statement ...") + + SqlCommand = """select ID, Name from %s where Model = %s""" %(FileTable, MODEL_IDENTIFIER_TYPEDEF) + RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Record in RecordSet: + Name = Record[1].strip() + if Name != '' and Name != None: + if Name[0] == '(': + Name = Name[1:Name.find(')')] + if Name.find('(') > -1: + Name = Name[Name.find('(') + 1 : Name.find(')')] + Name = Name.replace('WINAPI', '') + Name = Name.replace('*', '').strip() + if Name.upper() != Name: + if not EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_TYPEDEF_STATEMENT, Name): + EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_TYPEDEF_STATEMENT, OtherMsg = "The #typedef name [%s] does not follow the rules" % (Name), BelongsToTable = FileTable, BelongsToItem = Record[0]) + + # Check whether the #ifndef at the start of an include file uses both prefix and postfix underscore characters, '_'. + def NamingConventionCheckIfndefStatement(self, FileTable): + if EccGlobalData.gConfig.NamingConventionCheckTypedefStatement == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking naming covention of #ifndef statement ...") + + SqlCommand = """select ID, Value from %s where Model = %s""" %(FileTable, MODEL_IDENTIFIER_MACRO_IFNDEF) + RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Record in RecordSet: + Name = Record[1].replace('#ifndef', '').strip() + if Name[0] != '_' or Name[-1] != '_': + if not EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_IFNDEF_STATEMENT, Name): + EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_IFNDEF_STATEMENT, OtherMsg = "The #ifndef name [%s] does not follow the rules" % (Name), BelongsToTable = FileTable, BelongsToItem = Record[0]) + + # Rule for path name, variable name and function name + # 1. First character should be upper case + # 2. Existing lower case in a word + # 3. No space existence + # Check whether the path name followed the rule + def NamingConventionCheckPathName(self): + if EccGlobalData.gConfig.NamingConventionCheckPathName == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking naming covention of file path name ...") + Pattern = re.compile(r'^[A-Z]+\S*[a-z]\S*$') + SqlCommand = """select ID, Name from File""" + RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Record in RecordSet: + if not Pattern.match(Record[1]): + if not EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_PATH_NAME, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_PATH_NAME, OtherMsg = "The file path [%s] does not follow the rules" % (Record[1]), BelongsToTable = 'File', BelongsToItem = Record[0]) + + # Rule for path name, variable name and function name + # 1. First character should be upper case + # 2. Existing lower case in a word + # 3. No space existence + # 4. Global variable name must start with a 'g' + # Check whether the variable name followed the rule + def NamingConventionCheckVariableName(self, FileTable): + if EccGlobalData.gConfig.NamingConventionCheckVariableName == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking naming covention of variable name ...") + Pattern = re.compile(r'^[A-Zgm]+\S*[a-z]\S*$') + + SqlCommand = """select ID, Name from %s where Model = %s""" %(FileTable, MODEL_IDENTIFIER_VARIABLE) + RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Record in RecordSet: + if not Pattern.match(Record[1]): + if not EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, OtherMsg = "The variable name [%s] does not follow the rules" % (Record[1]), BelongsToTable = FileTable, BelongsToItem = Record[0]) + + # Rule for path name, variable name and function name + # 1. First character should be upper case + # 2. Existing lower case in a word + # 3. No space existence + # Check whether the function name followed the rule + def NamingConventionCheckFunctionName(self): + if EccGlobalData.gConfig.NamingConventionCheckFunctionName == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking naming covention of function name ...") + Pattern = re.compile(r'^[A-Z]+\S*[a-z]\S*$') + SqlCommand = """select ID, Name from Function""" + RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Record in RecordSet: + if not Pattern.match(Record[1]): + if not EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_FUNCTION_NAME, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_FUNCTION_NAME, OtherMsg = "The function name [%s] does not follow the rules" % (Record[1]), BelongsToTable = 'Function', BelongsToItem = Record[0]) + + # Check whether NO use short variable name with single character + def NamingConventionCheckSingleCharacterVariable(self, FileTable): + if EccGlobalData.gConfig.NamingConventionCheckSingleCharacterVariable == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1' or EccGlobalData.gConfig.CheckAll == '1': + EdkLogger.quiet("Checking naming covention of single character variable name ...") + + SqlCommand = """select ID, Name from %s where Model = %s""" %(FileTable, MODEL_IDENTIFIER_VARIABLE) + RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand) + for Record in RecordSet: + Variable = Record[1].replace('*', '') + if len(Variable) == 1: + if not EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_SINGLE_CHARACTER_VARIABLE, Record[1]): + EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_SINGLE_CHARACTER_VARIABLE, OtherMsg = "The variable name [%s] does not follow the rules" % (Record[1]), BelongsToTable = FileTable, BelongsToItem = Record[0]) + +## +# +# This acts like the main() function for the script, unless it is 'import'ed into another +# script. +# +if __name__ == '__main__': + Check = Check() + Check.Check() diff --git a/BaseTools/Source/Python/Ecc/CodeFragment.py b/BaseTools/Source/Python/Ecc/CodeFragment.py new file mode 100644 index 0000000000..1c5c5e4df2 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/CodeFragment.py @@ -0,0 +1,165 @@ +## @file +# fragments of source file +# +# Copyright (c) 2007, Intel Corporation +# +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + + +## The description of comment contents and start & end position +# +# +class Comment : + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param Begin The start position tuple. + # @param End The end position tuple. + # @param CommentType The type of comment (T_COMMENT_TWO_SLASH or T_COMMENT_SLASH_STAR). + # + def __init__(self, Str, Begin, End, CommentType): + self.Content = Str + self.StartPos = Begin + self.EndPos = End + self.Type = CommentType + +## The description of preprocess directives and start & end position +# +# +class PP_Directive : + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param Begin The start position tuple. + # @param End The end position tuple. + # + def __init__(self, Str, Begin, End): + self.Content = Str + self.StartPos = Begin + self.EndPos = End + +## The description of predicate expression and start & end position +# +# +class PredicateExpression : + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param Begin The start position tuple. + # @param End The end position tuple. + # + def __init__(self, Str, Begin, End): + self.Content = Str + self.StartPos = Begin + self.EndPos = End + +## The description of function definition and start & end position +# +# +class FunctionDefinition : + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param Begin The start position tuple. + # @param End The end position tuple. + # @param LBPos The left brace position tuple. + # + def __init__(self, ModifierStr, DeclStr, Begin, End, LBPos, NamePos): + self.Modifier = ModifierStr + self.Declarator = DeclStr + self.StartPos = Begin + self.EndPos = End + self.LeftBracePos = LBPos + self.NamePos = NamePos + +## The description of variable declaration and start & end position +# +# +class VariableDeclaration : + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param Begin The start position tuple. + # @param NamePos The name position tuple. + # + def __init__(self, ModifierStr, DeclStr, Begin, NamePos): + self.Modifier = ModifierStr + self.Declarator = DeclStr + self.StartPos = Begin + self.NameStartPos = NamePos + +## The description of enum definition and start & end position +# +# +class EnumerationDefinition : + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param Begin The start position tuple. + # @param End The end position tuple. + # + def __init__(self, Str, Begin, End): + self.Content = Str + self.StartPos = Begin + self.EndPos = End + +## The description of struct/union definition and start & end position +# +# +class StructUnionDefinition : + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param Begin The start position tuple. + # @param End The end position tuple. + # + def __init__(self, Str, Begin, End): + self.Content = Str + self.StartPos = Begin + self.EndPos = End + +## The description of 'Typedef' definition and start & end position +# +# +class TypedefDefinition : + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param Begin The start position tuple. + # @param End The end position tuple. + # + def __init__(self, FromStr, ToStr, Begin, End): + self.FromType = FromStr + self.ToType = ToStr + self.StartPos = Begin + self.EndPos = End + +class FunctionCalling: + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param Begin The start position tuple. + # @param End The end position tuple. + # + def __init__(self, Name, Param, Begin, End): + self.FuncName = Name + self.ParamList = Param + self.StartPos = Begin + self.EndPos = End + \ No newline at end of file diff --git a/BaseTools/Source/Python/Ecc/CodeFragmentCollector.py b/BaseTools/Source/Python/Ecc/CodeFragmentCollector.py new file mode 100644 index 0000000000..d95faeef6a --- /dev/null +++ b/BaseTools/Source/Python/Ecc/CodeFragmentCollector.py @@ -0,0 +1,624 @@ +## @file +# preprocess source file +# +# Copyright (c) 2007, Intel Corporation +# +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# + +import re +import os +import sys + +import antlr3 +from CLexer import CLexer +from CParser import CParser + +import FileProfile +from CodeFragment import Comment +from CodeFragment import PP_Directive +from ParserWarning import Warning + + +##define T_CHAR_SPACE ' ' +##define T_CHAR_NULL '\0' +##define T_CHAR_CR '\r' +##define T_CHAR_TAB '\t' +##define T_CHAR_LF '\n' +##define T_CHAR_SLASH '/' +##define T_CHAR_BACKSLASH '\\' +##define T_CHAR_DOUBLE_QUOTE '\"' +##define T_CHAR_SINGLE_QUOTE '\'' +##define T_CHAR_STAR '*' +##define T_CHAR_HASH '#' + +(T_CHAR_SPACE, T_CHAR_NULL, T_CHAR_CR, T_CHAR_TAB, T_CHAR_LF, T_CHAR_SLASH, \ +T_CHAR_BACKSLASH, T_CHAR_DOUBLE_QUOTE, T_CHAR_SINGLE_QUOTE, T_CHAR_STAR, T_CHAR_HASH) = \ +(' ', '\0', '\r', '\t', '\n', '/', '\\', '\"', '\'', '*', '#') + +SEPERATOR_TUPLE = ('=', '|', ',', '{', '}') + +(T_COMMENT_TWO_SLASH, T_COMMENT_SLASH_STAR) = (0, 1) + +(T_PP_INCLUDE, T_PP_DEFINE, T_PP_OTHERS) = (0, 1, 2) + +## The collector for source code fragments. +# +# PreprocessFile method should be called prior to ParseFile +# +# GetNext*** procedures mean these procedures will get next token first, then make judgement. +# Get*** procedures mean these procedures will make judgement on current token only. +# +class CodeFragmentCollector: + ## The constructor + # + # @param self The object pointer + # @param FileName The file that to be parsed + # + def __init__(self, FileName): + self.Profile = FileProfile.FileProfile(FileName) + self.Profile.FileLinesList.append(T_CHAR_LF) + self.FileName = FileName + self.CurrentLineNumber = 1 + self.CurrentOffsetWithinLine = 0 + + self.__Token = "" + self.__SkippedChars = "" + + ## __IsWhiteSpace() method + # + # Whether char at current FileBufferPos is whitespace + # + # @param self The object pointer + # @param Char The char to test + # @retval True The char is a kind of white space + # @retval False The char is NOT a kind of white space + # + def __IsWhiteSpace(self, Char): + if Char in (T_CHAR_NULL, T_CHAR_CR, T_CHAR_SPACE, T_CHAR_TAB, T_CHAR_LF): + return True + else: + return False + + ## __SkipWhiteSpace() method + # + # Skip white spaces from current char, return number of chars skipped + # + # @param self The object pointer + # @retval Count The number of chars skipped + # + def __SkipWhiteSpace(self): + Count = 0 + while not self.__EndOfFile(): + Count += 1 + if self.__CurrentChar() in (T_CHAR_NULL, T_CHAR_CR, T_CHAR_LF, T_CHAR_SPACE, T_CHAR_TAB): + self.__SkippedChars += str(self.__CurrentChar()) + self.__GetOneChar() + + else: + Count = Count - 1 + return Count + + ## __EndOfFile() method + # + # Judge current buffer pos is at file end + # + # @param self The object pointer + # @retval True Current File buffer position is at file end + # @retval False Current File buffer position is NOT at file end + # + def __EndOfFile(self): + NumberOfLines = len(self.Profile.FileLinesList) + SizeOfLastLine = NumberOfLines + if NumberOfLines > 0: + SizeOfLastLine = len(self.Profile.FileLinesList[-1]) + + if self.CurrentLineNumber == NumberOfLines and self.CurrentOffsetWithinLine >= SizeOfLastLine - 1: + return True + elif self.CurrentLineNumber > NumberOfLines: + return True + else: + return False + + ## __EndOfLine() method + # + # Judge current buffer pos is at line end + # + # @param self The object pointer + # @retval True Current File buffer position is at line end + # @retval False Current File buffer position is NOT at line end + # + def __EndOfLine(self): + SizeOfCurrentLine = len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) + if self.CurrentOffsetWithinLine >= SizeOfCurrentLine - 1: + return True + else: + return False + + ## Rewind() method + # + # Reset file data buffer to the initial state + # + # @param self The object pointer + # + def Rewind(self): + self.CurrentLineNumber = 1 + self.CurrentOffsetWithinLine = 0 + + ## __UndoOneChar() method + # + # Go back one char in the file buffer + # + # @param self The object pointer + # @retval True Successfully go back one char + # @retval False Not able to go back one char as file beginning reached + # + def __UndoOneChar(self): + + if self.CurrentLineNumber == 1 and self.CurrentOffsetWithinLine == 0: + return False + elif self.CurrentOffsetWithinLine == 0: + self.CurrentLineNumber -= 1 + self.CurrentOffsetWithinLine = len(self.__CurrentLine()) - 1 + else: + self.CurrentOffsetWithinLine -= 1 + return True + + ## __GetOneChar() method + # + # Move forward one char in the file buffer + # + # @param self The object pointer + # + def __GetOneChar(self): + if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1: + self.CurrentLineNumber += 1 + self.CurrentOffsetWithinLine = 0 + else: + self.CurrentOffsetWithinLine += 1 + + ## __CurrentChar() method + # + # Get the char pointed to by the file buffer pointer + # + # @param self The object pointer + # @retval Char Current char + # + def __CurrentChar(self): + CurrentChar = self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] +# if CurrentChar > 255: +# raise Warning("Non-Ascii char found At Line %d, offset %d" % (self.CurrentLineNumber, self.CurrentOffsetWithinLine), self.FileName, self.CurrentLineNumber) + return CurrentChar + + ## __NextChar() method + # + # Get the one char pass the char pointed to by the file buffer pointer + # + # @param self The object pointer + # @retval Char Next char + # + def __NextChar(self): + if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1: + return self.Profile.FileLinesList[self.CurrentLineNumber][0] + else: + return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine + 1] + + ## __SetCurrentCharValue() method + # + # Modify the value of current char + # + # @param self The object pointer + # @param Value The new value of current char + # + def __SetCurrentCharValue(self, Value): + self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] = Value + + ## __SetCharValue() method + # + # Modify the value of current char + # + # @param self The object pointer + # @param Value The new value of current char + # + def __SetCharValue(self, Line, Offset, Value): + self.Profile.FileLinesList[Line - 1][Offset] = Value + + ## __CurrentLine() method + # + # Get the list that contains current line contents + # + # @param self The object pointer + # @retval List current line contents + # + def __CurrentLine(self): + return self.Profile.FileLinesList[self.CurrentLineNumber - 1] + + ## __InsertComma() method + # + # Insert ',' to replace PP + # + # @param self The object pointer + # @retval List current line contents + # + def __InsertComma(self, Line): + + + if self.Profile.FileLinesList[Line - 1][0] != T_CHAR_HASH: + BeforeHashPart = str(self.Profile.FileLinesList[Line - 1]).split(T_CHAR_HASH)[0] + if BeforeHashPart.rstrip().endswith(T_CHAR_COMMA) or BeforeHashPart.rstrip().endswith(';'): + return + + if Line - 2 >= 0 and str(self.Profile.FileLinesList[Line - 2]).rstrip().endswith(','): + return + + if Line - 2 >= 0 and str(self.Profile.FileLinesList[Line - 2]).rstrip().endswith(';'): + return + + if str(self.Profile.FileLinesList[Line]).lstrip().startswith(',') or str(self.Profile.FileLinesList[Line]).lstrip().startswith(';'): + return + + self.Profile.FileLinesList[Line - 1].insert(self.CurrentOffsetWithinLine, ',') + + ## PreprocessFile() method + # + # Preprocess file contents, replace comments with spaces. + # In the end, rewind the file buffer pointer to the beginning + # BUGBUG: No !include statement processing contained in this procedure + # !include statement should be expanded at the same FileLinesList[CurrentLineNumber - 1] + # + # @param self The object pointer + # + def PreprocessFile(self): + + self.Rewind() + InComment = False + DoubleSlashComment = False + HashComment = False + PPExtend = False + CommentObj = None + PPDirectiveObj = None + # HashComment in quoted string " " is ignored. + InString = False + InCharLiteral = False + + self.Profile.FileLinesList = [list(s) for s in self.Profile.FileLinesListFromFile] + while not self.__EndOfFile(): + + if not InComment and self.__CurrentChar() == T_CHAR_DOUBLE_QUOTE: + InString = not InString + + if not InComment and self.__CurrentChar() == T_CHAR_SINGLE_QUOTE: + InCharLiteral = not InCharLiteral + # meet new line, then no longer in a comment for // and '#' + if self.__CurrentChar() == T_CHAR_LF: + if HashComment and PPDirectiveObj != None: + if PPDirectiveObj.Content.rstrip(T_CHAR_CR).endswith(T_CHAR_BACKSLASH): + PPDirectiveObj.Content += T_CHAR_LF + PPExtend = True + else: + PPExtend = False + + EndLinePos = (self.CurrentLineNumber, self.CurrentOffsetWithinLine) + + if InComment and DoubleSlashComment: + InComment = False + DoubleSlashComment = False + CommentObj.Content += T_CHAR_LF + CommentObj.EndPos = EndLinePos + FileProfile.CommentList.append(CommentObj) + CommentObj = None + if InComment and HashComment and not PPExtend: + InComment = False + HashComment = False + PPDirectiveObj.Content += T_CHAR_LF + PPDirectiveObj.EndPos = EndLinePos + FileProfile.PPDirectiveList.append(PPDirectiveObj) + PPDirectiveObj = None + + if InString or InCharLiteral: + CurrentLine = "".join(self.__CurrentLine()) + if CurrentLine.rstrip(T_CHAR_LF).rstrip(T_CHAR_CR).endswith(T_CHAR_BACKSLASH): + SlashIndex = CurrentLine.rindex(T_CHAR_BACKSLASH) + self.__SetCharValue(self.CurrentLineNumber, SlashIndex, T_CHAR_SPACE) + + if InComment and not DoubleSlashComment and not HashComment: + CommentObj.Content += T_CHAR_LF + self.CurrentLineNumber += 1 + self.CurrentOffsetWithinLine = 0 + # check for */ comment end + elif InComment and not DoubleSlashComment and not HashComment and self.__CurrentChar() == T_CHAR_STAR and self.__NextChar() == T_CHAR_SLASH: + CommentObj.Content += self.__CurrentChar() +# self.__SetCurrentCharValue(T_CHAR_SPACE) + self.__GetOneChar() + CommentObj.Content += self.__CurrentChar() +# self.__SetCurrentCharValue(T_CHAR_SPACE) + CommentObj.EndPos = (self.CurrentLineNumber, self.CurrentOffsetWithinLine) + FileProfile.CommentList.append(CommentObj) + CommentObj = None + self.__GetOneChar() + InComment = False + # set comments to spaces + elif InComment: + if HashComment: + # // follows hash PP directive + if self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_SLASH: + InComment = False + HashComment = False + PPDirectiveObj.EndPos = (self.CurrentLineNumber, self.CurrentOffsetWithinLine - 1) + FileProfile.PPDirectiveList.append(PPDirectiveObj) + PPDirectiveObj = None + continue + else: + PPDirectiveObj.Content += self.__CurrentChar() + if PPExtend: + self.__SetCurrentCharValue(T_CHAR_SPACE) + else: + CommentObj.Content += self.__CurrentChar() +# self.__SetCurrentCharValue(T_CHAR_SPACE) + self.__GetOneChar() + # check for // comment + elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_SLASH: + InComment = True + DoubleSlashComment = True + CommentObj = Comment('', (self.CurrentLineNumber, self.CurrentOffsetWithinLine), None, T_COMMENT_TWO_SLASH) + # check for '#' comment + elif self.__CurrentChar() == T_CHAR_HASH and not InString and not InCharLiteral: + InComment = True + HashComment = True + PPDirectiveObj = PP_Directive('', (self.CurrentLineNumber, self.CurrentOffsetWithinLine), None) + # check for /* comment start + elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_STAR: + CommentObj = Comment('', (self.CurrentLineNumber, self.CurrentOffsetWithinLine), None, T_COMMENT_SLASH_STAR) + CommentObj.Content += self.__CurrentChar() +# self.__SetCurrentCharValue( T_CHAR_SPACE) + self.__GetOneChar() + CommentObj.Content += self.__CurrentChar() +# self.__SetCurrentCharValue( T_CHAR_SPACE) + self.__GetOneChar() + InComment = True + else: + self.__GetOneChar() + + EndLinePos = (self.CurrentLineNumber, self.CurrentOffsetWithinLine) + + if InComment and DoubleSlashComment: + CommentObj.EndPos = EndLinePos + FileProfile.CommentList.append(CommentObj) + if InComment and HashComment and not PPExtend: + PPDirectiveObj.EndPos = EndLinePos + FileProfile.PPDirectiveList.append(PPDirectiveObj) + + self.Rewind() + + def PreprocessFileWithClear(self): + + self.Rewind() + InComment = False + DoubleSlashComment = False + HashComment = False + PPExtend = False + CommentObj = None + PPDirectiveObj = None + # HashComment in quoted string " " is ignored. + InString = False + InCharLiteral = False + + self.Profile.FileLinesList = [list(s) for s in self.Profile.FileLinesListFromFile] + while not self.__EndOfFile(): + + if not InComment and self.__CurrentChar() == T_CHAR_DOUBLE_QUOTE: + InString = not InString + + if not InComment and self.__CurrentChar() == T_CHAR_SINGLE_QUOTE: + InCharLiteral = not InCharLiteral + # meet new line, then no longer in a comment for // and '#' + if self.__CurrentChar() == T_CHAR_LF: + if HashComment and PPDirectiveObj != None: + if PPDirectiveObj.Content.rstrip(T_CHAR_CR).endswith(T_CHAR_BACKSLASH): + PPDirectiveObj.Content += T_CHAR_LF + PPExtend = True + else: + PPExtend = False + + EndLinePos = (self.CurrentLineNumber, self.CurrentOffsetWithinLine) + + if InComment and DoubleSlashComment: + InComment = False + DoubleSlashComment = False + CommentObj.Content += T_CHAR_LF + CommentObj.EndPos = EndLinePos + FileProfile.CommentList.append(CommentObj) + CommentObj = None + if InComment and HashComment and not PPExtend: + InComment = False + HashComment = False + PPDirectiveObj.Content += T_CHAR_LF + PPDirectiveObj.EndPos = EndLinePos + FileProfile.PPDirectiveList.append(PPDirectiveObj) + PPDirectiveObj = None + + if InString or InCharLiteral: + CurrentLine = "".join(self.__CurrentLine()) + if CurrentLine.rstrip(T_CHAR_LF).rstrip(T_CHAR_CR).endswith(T_CHAR_BACKSLASH): + SlashIndex = CurrentLine.rindex(T_CHAR_BACKSLASH) + self.__SetCharValue(self.CurrentLineNumber, SlashIndex, T_CHAR_SPACE) + + if InComment and not DoubleSlashComment and not HashComment: + CommentObj.Content += T_CHAR_LF + self.CurrentLineNumber += 1 + self.CurrentOffsetWithinLine = 0 + # check for */ comment end + elif InComment and not DoubleSlashComment and not HashComment and self.__CurrentChar() == T_CHAR_STAR and self.__NextChar() == T_CHAR_SLASH: + CommentObj.Content += self.__CurrentChar() + self.__SetCurrentCharValue(T_CHAR_SPACE) + self.__GetOneChar() + CommentObj.Content += self.__CurrentChar() + self.__SetCurrentCharValue(T_CHAR_SPACE) + CommentObj.EndPos = (self.CurrentLineNumber, self.CurrentOffsetWithinLine) + FileProfile.CommentList.append(CommentObj) + CommentObj = None + self.__GetOneChar() + InComment = False + # set comments to spaces + elif InComment: + if HashComment: + # // follows hash PP directive + if self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_SLASH: + InComment = False + HashComment = False + PPDirectiveObj.EndPos = (self.CurrentLineNumber, self.CurrentOffsetWithinLine - 1) + FileProfile.PPDirectiveList.append(PPDirectiveObj) + PPDirectiveObj = None + continue + else: + PPDirectiveObj.Content += self.__CurrentChar() +# if PPExtend: +# self.__SetCurrentCharValue(T_CHAR_SPACE) + else: + CommentObj.Content += self.__CurrentChar() + self.__SetCurrentCharValue(T_CHAR_SPACE) + self.__GetOneChar() + # check for // comment + elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_SLASH: + InComment = True + DoubleSlashComment = True + CommentObj = Comment('', (self.CurrentLineNumber, self.CurrentOffsetWithinLine), None, T_COMMENT_TWO_SLASH) + # check for '#' comment + elif self.__CurrentChar() == T_CHAR_HASH and not InString and not InCharLiteral: + InComment = True + HashComment = True + PPDirectiveObj = PP_Directive('', (self.CurrentLineNumber, self.CurrentOffsetWithinLine), None) + # check for /* comment start + elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_STAR: + CommentObj = Comment('', (self.CurrentLineNumber, self.CurrentOffsetWithinLine), None, T_COMMENT_SLASH_STAR) + CommentObj.Content += self.__CurrentChar() + self.__SetCurrentCharValue( T_CHAR_SPACE) + self.__GetOneChar() + CommentObj.Content += self.__CurrentChar() + self.__SetCurrentCharValue( T_CHAR_SPACE) + self.__GetOneChar() + InComment = True + else: + self.__GetOneChar() + + EndLinePos = (self.CurrentLineNumber, self.CurrentOffsetWithinLine) + + if InComment and DoubleSlashComment: + CommentObj.EndPos = EndLinePos + FileProfile.CommentList.append(CommentObj) + if InComment and HashComment and not PPExtend: + PPDirectiveObj.EndPos = EndLinePos + FileProfile.PPDirectiveList.append(PPDirectiveObj) + self.Rewind() + + ## ParseFile() method + # + # Parse the file profile buffer to extract fd, fv ... information + # Exception will be raised if syntax error found + # + # @param self The object pointer + # + def ParseFile(self): + self.PreprocessFile() + # restore from ListOfList to ListOfString + self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList] + FileStringContents = '' + for fileLine in self.Profile.FileLinesList: + FileStringContents += fileLine + cStream = antlr3.StringStream(FileStringContents) + lexer = CLexer(cStream) + tStream = antlr3.CommonTokenStream(lexer) + parser = CParser(tStream) + parser.translation_unit() + + def ParseFileWithClearedPPDirective(self): + self.PreprocessFileWithClear() + # restore from ListOfList to ListOfString + self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList] + FileStringContents = '' + for fileLine in self.Profile.FileLinesList: + FileStringContents += fileLine + cStream = antlr3.StringStream(FileStringContents) + lexer = CLexer(cStream) + tStream = antlr3.CommonTokenStream(lexer) + parser = CParser(tStream) + parser.translation_unit() + + def CleanFileProfileBuffer(self): + FileProfile.CommentList = [] + FileProfile.PPDirectiveList = [] + FileProfile.PredicateExpressionList = [] + FileProfile.FunctionDefinitionList = [] + FileProfile.VariableDeclarationList = [] + FileProfile.EnumerationDefinitionList = [] + FileProfile.StructUnionDefinitionList = [] + FileProfile.TypedefDefinitionList = [] + FileProfile.FunctionCallingList = [] + + def PrintFragments(self): + + print '################# ' + self.FileName + '#####################' + + print '/****************************************/' + print '/*************** COMMENTS ***************/' + print '/****************************************/' + for comment in FileProfile.CommentList: + print str(comment.StartPos) + comment.Content + + print '/****************************************/' + print '/********* PREPROCESS DIRECTIVES ********/' + print '/****************************************/' + for pp in FileProfile.PPDirectiveList: + print str(pp.StartPos) + pp.Content + + print '/****************************************/' + print '/********* VARIABLE DECLARATIONS ********/' + print '/****************************************/' + for var in FileProfile.VariableDeclarationList: + print str(var.StartPos) + var.Modifier + ' '+ var.Declarator + + print '/****************************************/' + print '/********* FUNCTION DEFINITIONS *********/' + print '/****************************************/' + for func in FileProfile.FunctionDefinitionList: + print str(func.StartPos) + func.Modifier + ' '+ func.Declarator + ' ' + str(func.NamePos) + + print '/****************************************/' + print '/************ ENUMERATIONS **************/' + print '/****************************************/' + for enum in FileProfile.EnumerationDefinitionList: + print str(enum.StartPos) + enum.Content + + print '/****************************************/' + print '/*********** STRUCTS/UNIONS *************/' + print '/****************************************/' + for su in FileProfile.StructUnionDefinitionList: + print str(su.StartPos) + su.Content + + print '/****************************************/' + print '/********* PREDICATE EXPRESSIONS ********/' + print '/****************************************/' + for predexp in FileProfile.PredicateExpressionList: + print str(predexp.StartPos) + predexp.Content + + print '/****************************************/' + print '/************** TYPEDEFS ****************/' + print '/****************************************/' + for typedef in FileProfile.TypedefDefinitionList: + print str(typedef.StartPos) + typedef.ToType + +if __name__ == "__main__": + + collector = CodeFragmentCollector(sys.argv[1]) + collector.PreprocessFile() + print "For Test." diff --git a/BaseTools/Source/Python/Ecc/Configuration.py b/BaseTools/Source/Python/Ecc/Configuration.py new file mode 100644 index 0000000000..bd9313cef4 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/Configuration.py @@ -0,0 +1,264 @@ +## @file +# This file is used to define class Configuration +# +# Copyright (c) 2008, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import os +import Common.EdkLogger as EdkLogger +from Common.DataType import * +from Common.String import * + +## Configuration +# +# This class is used to define all items in configuration file +# +# @param Filename: The name of configuration file, the default is config.ini +# +class Configuration(object): + def __init__(self, Filename): + self.Filename = Filename + + self.Version = 0.1 + + ## Identify to if check all items + # 1 - Check all items and ignore all other detailed items + # 0 - Not check all items, the tool will go through all other detailed items to decide to check or not + # + self.CheckAll = 0 + + ## Identify to if automatically correct mistakes + # 1 - Automatically correct + # 0 - Not automatically correct + # Only the following check points can be automatically corrected, others not listed below are not supported even it is 1 + # + # GeneralCheckTab + # GeneralCheckIndentation + # GeneralCheckLine + # GeneralCheckCarriageReturn + # SpaceCheckAll + # + self.AutoCorrect = 0 + + # List customized Modifer here, split with ',' + # Defaultly use the definition in class DataType + self.ModifierList = MODIFIER_LIST + + ## General Checking + self.GeneralCheckAll = 0 + + # Check whether NO Tab is used, replaced with spaces + self.GeneralCheckNoTab = 1 + # The width of Tab + self.GeneralCheckTabWidth = 2 + # Check whether the indentation is followed coding style + self.GeneralCheckIndentation = 1 + # The width of indentation + self.GeneralCheckIndentationWidth = 2 + # Check whether no line is exceeding defined widty + self.GeneralCheckLine = 1 + # The width of a line + self.GeneralCheckLineWidth = 120 + # Check whether no use of _asm in the source file + self.GeneralCheckNo_Asm = 1 + # Check whether no use of "#progma" in source file except "#pragma pack(#)". + self.GeneralCheckNoProgma = 1 + # Check whether there is a carriage return at the end of the file + self.GeneralCheckCarriageReturn = 1 + # Check whether the file exists + self.GeneralCheckFileExistence = 1 + + ## Space Checking + self.SpaceCheckAll = 1 + + ## Predicate Expression Checking + self.PredicateExpressionCheckAll = 0 + + # Check whether Boolean values, variable type BOOLEAN not use explicit comparisons to TRUE or FALSE + self.PredicateExpressionCheckBooleanValue = 1 + # Check whether Non-Boolean comparisons use a compare operator (==, !=, >, < >=, <=). + self.PredicateExpressionCheckNonBooleanOperator = 1 + # Check whether a comparison of any pointer to zero must be done via the NULL type + self.PredicateExpressionCheckComparisonNullType = 1 + + ## Headers Checking + self.HeaderCheckAll = 0 + + # Check whether File header exists + self.HeaderCheckFile = 1 + # Check whether Function header exists + self.HeaderCheckFunction = 1 + + ## C Function Layout Checking + self.CFunctionLayoutCheckAll = 0 + + # Check whether return type exists and in the first line + self.CFunctionLayoutCheckReturnType = 1 + # Check whether any optional functional modifiers exist and next to the return type + self.CFunctionLayoutCheckOptionalFunctionalModifier = 1 + # Check whether the next line contains the function name, left justified, followed by the beginning of the parameter list + # Check whether the closing parenthesis is on its own line and also indented two spaces + self.CFunctionLayoutCheckFunctionName = 1 + # Check whether the function prototypes in include files have the same form as function definitions + self.CFunctionLayoutCheckFunctionPrototype = 1 + # Check whether the body of a function is contained by open and close braces that must be in the first column + self.CFunctionLayoutCheckFunctionBody = 1 + # Check whether the data declarations is the first code in a module. + self.CFunctionLayoutCheckDataDeclaration = 1 + # Check whether no initialization of a variable as part of its declaration + self.CFunctionLayoutCheckNoInitOfVariable = 1 + # Check whether no use of STATIC for functions + self.CFunctionLayoutCheckNoStatic = 1 + + ## Include Files Checking + self.IncludeFileCheckAll = 0 + + #Check whether having include files with same name + self.IncludeFileCheckSameName = 1 + # Check whether all include file contents is guarded by a #ifndef statement. + # the #ifndef must be the first line of code following the file header comment + # the #endif must appear on the last line in the file + self.IncludeFileCheckIfndefStatement = 1 + # Check whether include files contain only public or only private data + # Check whether include files NOT contain code or define data variables + self.IncludeFileCheckData = 1 + + ## Declarations and Data Types Checking + self.DeclarationDataTypeCheckAll = 0 + + # Check whether no use of int, unsigned, char, void, static, long in any .c, .h or .asl files. + self.DeclarationDataTypeCheckNoUseCType = 1 + # Check whether the modifiers IN, OUT, OPTIONAL, and UNALIGNED are used only to qualify arguments to a function and should not appear in a data type declaration + self.DeclarationDataTypeCheckInOutModifier = 1 + # Check whether the EFIAPI modifier should be used at the entry of drivers, events, and member functions of protocols + self.DeclarationDataTypeCheckEFIAPIModifier = 1 + # Check whether Enumerated Type has a 'typedef' and the name is capital + self.DeclarationDataTypeCheckEnumeratedType = 1 + # Check whether Structure Type has a 'typedef' and the name is capital + self.DeclarationDataTypeCheckStructureDeclaration = 1 + # Check whether having same Structure + self.DeclarationDataTypeCheckSameStructure = 1 + # Check whether Union Type has a 'typedef' and the name is capital + self.DeclarationDataTypeCheckUnionType = 1 + + ## Naming Conventions Checking + self.NamingConventionCheckAll = 0 + + # Check whether only capital letters are used for #define declarations + self.NamingConventionCheckDefineStatement = 1 + # Check whether only capital letters are used for typedef declarations + self.NamingConventionCheckTypedefStatement = 1 + # Check whether the #ifndef at the start of an include file uses both prefix and postfix underscore characters, '_'. + self.NamingConventionCheckIfndefStatement = 1 + # Rule for path name, variable name and function name + # 1. First character should be upper case + # 2. Existing lower case in a word + # 3. No space existence + # Check whether the path name followed the rule + self.NamingConventionCheckPathName = 1 + # Check whether the variable name followed the rule + self.NamingConventionCheckVariableName = 1 + # Check whether the function name followed the rule + self.NamingConventionCheckFunctionName = 1 + # Check whether NO use short variable name with single character + self.NamingConventionCheckSingleCharacterVariable = 1 + + ## Doxygen Checking + self.DoxygenCheckAll = 0 + + # Check whether the file headers are followed Doxygen special documentation blocks in section 2.3.5 + self.DoxygenCheckFileHeader = 1 + # Check whether the function headers are followed Doxygen special documentation blocks in section 2.3.5 + self.DoxygenCheckFunctionHeader = 1 + # Check whether the first line of text in a comment block is a brief description of the element being documented. + # The brief description must end with a period. + self.DoxygenCheckCommentDescription = 1 + # Check whether comment lines with '///< ... text ...' format, if it is used, it should be after the code section. + self.DoxygenCheckCommentFormat = 1 + # Check whether only Doxygen commands allowed to mark the code are @bug and @todo. + self.DoxygenCheckCommand = 1 + + ## Meta-Data File Processing Checking + self.MetaDataFileCheckAll = 0 + + # Check whether each file defined in meta-data exists + self.MetaDataFileCheckPathName = 1 + # Generate a list for all files defined in meta-data files + self.MetaDataFileCheckGenerateFileList = 1 + # The path of log file + self.MetaDataFileCheckPathOfGenerateFileList = 'File.log' + # Check whether all Library Instances defined for a given module (or dependent library instance) match the module's type. + # Each Library Instance must specify the Supported Module Types in its INF file, + # and any module specifying the library instance must be one of the supported types. + self.MetaDataFileCheckLibraryInstance = 1 + # Check whether a Library Instance has been defined for all dependent library classes + self.MetaDataFileCheckLibraryInstanceDependent = 1 + # Check whether the Library Instances specified by the LibraryClasses sections are listed in order of dependencies + self.MetaDataFileCheckLibraryInstanceOrder = 1 + # Check whether the unnecessary inclusion of library classes in the INF file + self.MetaDataFileCheckLibraryNoUse = 1 + # Check whether an INF file is specified in the FDF file, but not in the DSC file, then the INF file must be for a Binary module only + self.MetaDataFileCheckBinaryInfInFdf = 1 + # Not to report error and warning related OS include file such as "windows.h" and "stdio.h" + # Check whether a PCD is set in a DSC file or the FDF file, but not in both. + self.MetaDataFileCheckPcdDuplicate = 1 + # Check whether PCD settings in the FDF file can only be related to flash. + self.MetaDataFileCheckPcdFlash = 1 + # Check whether PCDs used in INF files but not specified in DSC or FDF files + self.MetaDataFileCheckPcdNoUse = 1 + # Check whether having duplicate guids defined for Guid/Protocol/Ppi + self.MetaDataFileCheckGuidDuplicate = 1 + # Check whether all files under module directory are described in INF files + self.MetaDataFileCheckModuleFileNoUse = 1 + # Check whether the PCD is correctly used in C function via its type + self.MetaDataFileCheckPcdType = 1 + + # + # The check points in this section are reserved + # + # GotoStatementCheckAll = 0 + # + self.SpellingCheckAll = 0 + + # The directory listed here will not be parsed, split with ',' + self.SkipDirList = [] + + self.ParseConfig() + + def ParseConfig(self): + Filepath = os.path.normpath(self.Filename) + if not os.path.isfile(Filepath): + ErrorMsg = "Can't find configuration file '%s'" % Filepath + EdkLogger.error("Ecc", EdkLogger.ECC_ERROR, ErrorMsg, File = Filepath) + + LineNo = 0 + for Line in open(Filepath, 'r'): + LineNo = LineNo + 1 + Line = CleanString(Line) + if Line != '': + List = GetSplitValueList(Line, TAB_EQUAL_SPLIT) + if List[0] not in self.__dict__: + ErrorMsg = "Invalid configuration option '%s' was found" % List[0] + EdkLogger.error("Ecc", EdkLogger.ECC_ERROR, ErrorMsg, File = Filepath, Line = LineNo) + if List[0] == 'ModifierList': + List[1] = GetSplitValueList(List[1], TAB_COMMA_SPLIT) + if List[0] == 'MetaDataFileCheckPathOfGenerateFileList' and List[1] == "": + continue + if List[0] == 'SkipDirList': + List[1] = GetSplitValueList(List[1], TAB_COMMA_SPLIT) + self.__dict__[List[0]] = List[1] + + def ShowMe(self): + print self.Filename + for Key in self.__dict__.keys(): + print Key, '=', self.__dict__[Key] diff --git a/BaseTools/Source/Python/Ecc/Database.py b/BaseTools/Source/Python/Ecc/Database.py new file mode 100644 index 0000000000..c9311f65a5 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/Database.py @@ -0,0 +1,344 @@ +## @file +# This file is used to create a database used by ECC tool +# +# Copyright (c) 2007 ~ 2008, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import sqlite3 +import os, time + +import Common.EdkLogger as EdkLogger +import CommonDataClass.DataClass as DataClass + +from Table.TableDataModel import TableDataModel +from Table.TableFile import TableFile +from Table.TableFunction import TableFunction +from Table.TablePcd import TablePcd +from Table.TableIdentifier import TableIdentifier +from Table.TableReport import TableReport +from Table.TableInf import TableInf +from Table.TableDec import TableDec +from Table.TableDsc import TableDsc +from Table.TableFdf import TableFdf + +## +# Static definitions +# +DATABASE_PATH = "Ecc.db" + +## Database +# +# This class defined the ECC databse +# During the phase of initialization, the database will create all tables and +# insert all records of table DataModel +# +# @param object: Inherited from object class +# @param DbPath: A string for the path of the ECC database +# +# @var Conn: Connection of the ECC database +# @var Cur: Cursor of the connection +# @var TblDataModel: Local instance for TableDataModel +# +class Database(object): + def __init__(self, DbPath): + self.DbPath = DbPath + self.Conn = None + self.Cur = None + self.TblDataModel = None + self.TblFile = None + self.TblFunction = None + self.TblIdentifier = None + self.TblPcd = None + self.TblReport = None + self.TblInf = None + self.TblDec = None + self.TblDsc = None + self.TblFdf = None + + ## Initialize ECC database + # + # 1. Delete all old existing tables + # 2. Create new tables + # 3. Initialize table DataModel + # + def InitDatabase(self, NewDatabase = True): + EdkLogger.verbose("\nInitialize ECC database started ...") + # + # Drop all old existing tables + # + if NewDatabase: + if os.path.exists(self.DbPath): + os.remove(self.DbPath) + self.Conn = sqlite3.connect(self.DbPath, isolation_level = 'DEFERRED') + self.Conn.execute("PRAGMA page_size=4096") + self.Conn.execute("PRAGMA synchronous=OFF") + # to avoid non-ascii charater conversion error + self.Conn.text_factory = str + self.Cur = self.Conn.cursor() + + self.TblDataModel = TableDataModel(self.Cur) + self.TblFile = TableFile(self.Cur) + self.TblFunction = TableFunction(self.Cur) + self.TblIdentifier = TableIdentifier(self.Cur) + self.TblPcd = TablePcd(self.Cur) + self.TblReport = TableReport(self.Cur) + self.TblInf = TableInf(self.Cur) + self.TblDec = TableDec(self.Cur) + self.TblDsc = TableDsc(self.Cur) + self.TblFdf = TableFdf(self.Cur) + + # + # Create new tables + # + if NewDatabase: + self.TblDataModel.Create() + self.TblFile.Create() + self.TblFunction.Create() + self.TblPcd.Create() + self.TblReport.Create() + self.TblInf.Create() + self.TblDec.Create() + self.TblDsc.Create() + self.TblFdf.Create() + + # + # Init each table's ID + # + self.TblDataModel.InitID() + self.TblFile.InitID() + self.TblFunction.InitID() + self.TblPcd.InitID() + self.TblReport.InitID() + self.TblInf.InitID() + self.TblDec.InitID() + self.TblDsc.InitID() + self.TblFdf.InitID() + + # + # Initialize table DataModel + # + if NewDatabase: + self.TblDataModel.InitTable() + + EdkLogger.verbose("Initialize ECC database ... DONE!") + + ## Query a table + # + # @param Table: The instance of the table to be queried + # + def QueryTable(self, Table): + Table.Query() + + ## Close entire database + # + # Commit all first + # Close the connection and cursor + # + def Close(self): + # + # Commit to file + # + self.Conn.commit() + + # + # Close connection and cursor + # + self.Cur.close() + self.Conn.close() + + ## Insert one file information + # + # Insert one file's information to the database + # 1. Create a record in TableFile + # 2. Create functions one by one + # 2.1 Create variables of function one by one + # 2.2 Create pcds of function one by one + # 3. Create variables one by one + # 4. Create pcds one by one + # + def InsertOneFile(self, File): + # + # Insert a record for file + # + FileID = self.TblFile.Insert(File.Name, File.ExtName, File.Path, File.FullPath, Model = File.Model, TimeStamp = File.TimeStamp) + IdTable = TableIdentifier(self.Cur) + IdTable.Table = "Identifier%s" % FileID + IdTable.Create() + + # + # Insert function of file + # + for Function in File.FunctionList: + FunctionID = self.TblFunction.Insert(Function.Header, Function.Modifier, Function.Name, Function.ReturnStatement, \ + Function.StartLine, Function.StartColumn, Function.EndLine, Function.EndColumn, \ + Function.BodyStartLine, Function.BodyStartColumn, FileID, \ + Function.FunNameStartLine, Function.FunNameStartColumn) + # + # Insert Identifier of function + # + for Identifier in Function.IdentifierList: + IdentifierID = IdTable.Insert(Identifier.Modifier, Identifier.Type, Identifier.Name, Identifier.Value, Identifier.Model, \ + FileID, FunctionID, Identifier.StartLine, Identifier.StartColumn, Identifier.EndLine, Identifier.EndColumn) + # + # Insert Pcd of function + # + for Pcd in Function.PcdList: + PcdID = self.TblPcd.Insert(Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.Token, Pcd.DatumType, Pcd.Model, \ + FileID, FunctionID, Pcd.StartLine, Pcd.StartColumn, Pcd.EndLine, Pcd.EndColumn) + # + # Insert Identifier of file + # + for Identifier in File.IdentifierList: + IdentifierID = IdTable.Insert(Identifier.Modifier, Identifier.Type, Identifier.Name, Identifier.Value, Identifier.Model, \ + FileID, -1, Identifier.StartLine, Identifier.StartColumn, Identifier.EndLine, Identifier.EndColumn) + # + # Insert Pcd of file + # + for Pcd in File.PcdList: + PcdID = self.TblPcd.Insert(Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.Token, Pcd.DatumType, Pcd.Model, \ + FileID, -1, Pcd.StartLine, Pcd.StartColumn, Pcd.EndLine, Pcd.EndColumn) + + EdkLogger.verbose("Insert information from file %s ... DONE!" % File.FullPath) + + ## UpdateIdentifierBelongsToFunction + # + # Update the field "BelongsToFunction" for each Indentifier + # + # + def UpdateIdentifierBelongsToFunction_disabled(self): + EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers started ...") + + SqlCommand = """select ID, BelongsToFile, StartLine, EndLine, Model from Identifier""" + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + Records = self.Cur.fetchall() + for Record in Records: + IdentifierID = Record[0] + BelongsToFile = Record[1] + StartLine = Record[2] + EndLine = Record[3] + Model = Record[4] + + # + # Check whether an identifier belongs to a function + # + EdkLogger.debug(4, "For common identifiers ... ") + SqlCommand = """select ID from Function + where StartLine < %s and EndLine > %s + and BelongsToFile = %s""" % (StartLine, EndLine, BelongsToFile) + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + IDs = self.Cur.fetchall() + for ID in IDs: + SqlCommand = """Update Identifier set BelongsToFunction = %s where ID = %s""" % (ID[0], IdentifierID) + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + + # + # Check whether the identifier is a function header + # + EdkLogger.debug(4, "For function headers ... ") + if Model == DataClass.MODEL_IDENTIFIER_COMMENT: + SqlCommand = """select ID from Function + where StartLine = %s + 1 + and BelongsToFile = %s""" % (EndLine, BelongsToFile) + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + IDs = self.Cur.fetchall() + for ID in IDs: + SqlCommand = """Update Identifier set BelongsToFunction = %s, Model = %s where ID = %s""" % (ID[0], DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, IdentifierID) + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + + EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE") + + + ## UpdateIdentifierBelongsToFunction + # + # Update the field "BelongsToFunction" for each Indentifier + # + # + def UpdateIdentifierBelongsToFunction(self): + EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers started ...") + + SqlCommand = """select ID, BelongsToFile, StartLine, EndLine from Function""" + Records = self.TblFunction.Exec(SqlCommand) + Data1 = [] + Data2 = [] + for Record in Records: + FunctionID = Record[0] + BelongsToFile = Record[1] + StartLine = Record[2] + EndLine = Record[3] + #Data1.append(("'file%s'" % BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine)) + #Data2.append(("'file%s'" % BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1)) + + SqlCommand = """Update Identifier%s set BelongsToFunction = %s where BelongsToFile = %s and StartLine > %s and EndLine < %s""" % \ + (BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine) + self.TblIdentifier.Exec(SqlCommand) + + SqlCommand = """Update Identifier%s set BelongsToFunction = %s, Model = %s where BelongsToFile = %s and Model = %s and EndLine = %s""" % \ + (BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1) + self.TblIdentifier.Exec(SqlCommand) +# # +# # Check whether an identifier belongs to a function +# # +# print Data1 +# SqlCommand = """Update ? set BelongsToFunction = ? where BelongsToFile = ? and StartLine > ? and EndLine < ?""" +# print SqlCommand +# EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) +# self.Cur.executemany(SqlCommand, Data1) +# +# # +# # Check whether the identifier is a function header +# # +# EdkLogger.debug(4, "For function headers ... ") +# SqlCommand = """Update ? set BelongsToFunction = ?, Model = ? where BelongsToFile = ? and Model = ? and EndLine = ?""" +# EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) +# self.Cur.executemany(SqlCommand, Data2) +# +# EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE") + + +## +# +# This acts like the main() function for the script, unless it is 'import'ed into another +# script. +# +if __name__ == '__main__': + EdkLogger.Initialize() + #EdkLogger.SetLevel(EdkLogger.VERBOSE) + EdkLogger.SetLevel(EdkLogger.DEBUG_0) + EdkLogger.verbose("Start at " + time.strftime('%H:%M:%S', time.localtime())) + + Db = Database(DATABASE_PATH) + Db.InitDatabase() + Db.QueryTable(Db.TblDataModel) + + identifier1 = DataClass.IdentifierClass(-1, '', '', "i''1", 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 32, 43, 54, 43) + identifier2 = DataClass.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 15, 43, 20, 43) + identifier3 = DataClass.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 55, 43, 58, 43) + identifier4 = DataClass.IdentifierClass(-1, '', '', "i1'", 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 77, 43, 88, 43) + fun1 = DataClass.FunctionClass(-1, '', '', 'fun1', '', 21, 2, 60, 45, 1, 23, 0, [], []) + file = DataClass.FileClass(-1, 'F1', 'c', 'C:\\', 'C:\\F1.exe', DataClass.MODEL_FILE_C, '2007-12-28', [fun1], [identifier1, identifier2, identifier3, identifier4], []) + Db.InsertOneFile(file) + Db.UpdateIdentifierBelongsToFunction() + + Db.QueryTable(Db.TblFile) + Db.QueryTable(Db.TblFunction) + Db.QueryTable(Db.TblPcd) + Db.QueryTable(Db.TblIdentifier) + + Db.Close() + EdkLogger.verbose("End at " + time.strftime('%H:%M:%S', time.localtime())) + diff --git a/BaseTools/Source/Python/Ecc/Ecc.py b/BaseTools/Source/Python/Ecc/Ecc.py new file mode 100644 index 0000000000..4767645d05 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/Ecc.py @@ -0,0 +1,329 @@ +## @file +# This file is used to be the main entrance of ECC tool +# +# Copyright (c) 2009, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import os, time, glob, sys +import Common.EdkLogger as EdkLogger +import Database +import EccGlobalData +from MetaDataParser import * +from optparse import OptionParser +from Configuration import Configuration +from Check import Check +from Common.InfClassObject import Inf +from Common.DecClassObject import Dec +from Common.DscClassObject import Dsc +from Common.FdfClassObject import Fdf +from Common.String import NormPath +from Common import BuildToolError +import c +from Exception import * + +## Ecc +# +# This class is used to define Ecc main entrance +# +# @param object: Inherited from object class +# +class Ecc(object): + def __init__(self): + # Version and Copyright + self.VersionNumber = "0.01" + self.Version = "%prog Version " + self.VersionNumber + self.Copyright = "Copyright (c) 2009, Intel Corporation All rights reserved." + + self.InitDefaultConfigIni() + self.OutputFile = 'output.txt' + self.ReportFile = 'Report.csv' + self.ExceptionFile = 'exception.xml' + self.IsInit = True + self.ScanSourceCode = True + self.ScanMetaData = True + + # Parse the options and args + self.ParseOption() + + # Generate checkpoints list + EccGlobalData.gConfig = Configuration(self.ConfigFile) + + # Generate exception list + EccGlobalData.gException = ExceptionCheck(self.ExceptionFile) + + # Init Ecc database + EccGlobalData.gDb = Database.Database(Database.DATABASE_PATH) + EccGlobalData.gDb.InitDatabase(self.IsInit) + + # Build ECC database + self.BuildDatabase() + + # Start to check + self.Check() + + # Show report + self.GenReport() + + # Close Database + EccGlobalData.gDb.Close() + + def InitDefaultConfigIni(self): + paths = map(lambda p: os.path.join(p, 'Ecc', 'config.ini'), sys.path) + paths = (os.path.realpath('config.ini'),) + tuple(paths) + for path in paths: + if os.path.exists(path): + self.ConfigFile = path + return + self.ConfigFile = 'config.ini' + + ## BuildDatabase + # + # Build the database for target + # + def BuildDatabase(self): + # Clean report table + EccGlobalData.gDb.TblReport.Drop() + EccGlobalData.gDb.TblReport.Create() + + # Build database + if self.IsInit: + if self.ScanSourceCode: + EdkLogger.quiet("Building database for source code ...") + c.CollectSourceCodeDataIntoDB(EccGlobalData.gTarget) + if self.ScanMetaData: + EdkLogger.quiet("Building database for source code done!") + self.BuildMetaDataFileDatabase() + + EccGlobalData.gIdentifierTableList = GetTableList((MODEL_FILE_C, MODEL_FILE_H), 'Identifier', EccGlobalData.gDb) + + ## BuildMetaDataFileDatabase + # + # Build the database for meta data files + # + def BuildMetaDataFileDatabase(self): + EdkLogger.quiet("Building database for meta data files ...") + Op = open(EccGlobalData.gConfig.MetaDataFileCheckPathOfGenerateFileList, 'w+') + #SkipDirs = Read from config file + SkipDirs = EccGlobalData.gConfig.SkipDirList + for Root, Dirs, Files in os.walk(EccGlobalData.gTarget): + for Dir in Dirs: + if Dir.upper() in SkipDirs: + Dirs.remove(Dir) + + for Dir in Dirs: + Dirname = os.path.join(Root, Dir) + if os.path.islink(Dirname): + Dirname = os.path.realpath(Dirname) + if os.path.isdir(Dirname): + # symlinks to directories are treated as directories + Dirs.remove(Dir) + Dirs.append(Dirname) + + for File in Files: + if len(File) > 4 and File[-4:].upper() == ".DEC": + Filename = os.path.normpath(os.path.join(Root, File)) + EdkLogger.quiet("Parsing %s" % Filename) + Op.write("%s\r" % Filename) + Dec(Filename, True, True, EccGlobalData.gWorkspace, EccGlobalData.gDb) + continue + if len(File) > 4 and File[-4:].upper() == ".DSC": + Filename = os.path.normpath(os.path.join(Root, File)) + EdkLogger.quiet("Parsing %s" % Filename) + Op.write("%s\r" % Filename) + Dsc(Filename, True, True, EccGlobalData.gWorkspace, EccGlobalData.gDb) + continue + if len(File) > 4 and File[-4:].upper() == ".INF": + Filename = os.path.normpath(os.path.join(Root, File)) + EdkLogger.quiet("Parsing %s" % Filename) + Op.write("%s\r" % Filename) + Inf(Filename, True, True, EccGlobalData.gWorkspace, EccGlobalData.gDb) + continue + if len(File) > 4 and File[-4:].upper() == ".FDF": + Filename = os.path.normpath(os.path.join(Root, File)) + EdkLogger.quiet("Parsing %s" % Filename) + Op.write("%s\r" % Filename) + Fdf(Filename, True, EccGlobalData.gWorkspace, EccGlobalData.gDb) + continue + Op.close() + + # Commit to database + EccGlobalData.gDb.Conn.commit() + + EdkLogger.quiet("Building database for meta data files done!") + + ## + # + # Check each checkpoint + # + def Check(self): + EdkLogger.quiet("Checking ...") + EccCheck = Check() + EccCheck.Check() + EdkLogger.quiet("Checking done!") + + ## + # + # Generate the scan report + # + def GenReport(self): + EdkLogger.quiet("Generating report ...") + EccGlobalData.gDb.TblReport.ToCSV(self.ReportFile) + EdkLogger.quiet("Generating report done!") + + def GetRealPathCase(self, path): + TmpPath = path.rstrip(os.sep) + PathParts = TmpPath.split(os.sep) + if len(PathParts) == 0: + return path + if len(PathParts) == 1: + if PathParts[0].strip().endswith(':'): + return PathParts[0].upper() + # Relative dir, list . current dir + Dirs = os.listdir('.') + for Dir in Dirs: + if Dir.upper() == PathParts[0].upper(): + return Dir + + if PathParts[0].strip().endswith(':'): + PathParts[0] = PathParts[0].upper() + ParentDir = PathParts[0] + RealPath = ParentDir + if PathParts[0] == '': + RealPath = os.sep + ParentDir = os.sep + + PathParts.remove(PathParts[0]) # need to remove the parent + for Part in PathParts: + Dirs = os.listdir(ParentDir + os.sep) + for Dir in Dirs: + if Dir.upper() == Part.upper(): + RealPath += os.sep + RealPath += Dir + break + ParentDir += os.sep + ParentDir += Dir + + return RealPath + + ## ParseOption + # + # Parse options + # + def ParseOption(self): + EdkLogger.quiet("Loading ECC configuration ... done") + (Options, Target) = self.EccOptionParser() + + # Check workspace envirnoment + if "WORKSPACE" not in os.environ: + EdkLogger.error("ECC", BuildToolError.ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found", + ExtraData="WORKSPACE") + else: + EccGlobalData.gWorkspace = os.path.normpath(os.getenv("WORKSPACE")) + if not os.path.exists(EccGlobalData.gWorkspace): + EdkLogger.error("ECC", BuildToolError.FILE_NOT_FOUND, ExtraData="WORKSPACE = %s" % EccGlobalData.gWorkspace) + os.environ["WORKSPACE"] = EccGlobalData.gWorkspace + # Set log level + self.SetLogLevel(Options) + + # Set other options + if Options.ConfigFile != None: + self.ConfigFile = Options.ConfigFile + if Options.OutputFile != None: + self.OutputFile = Options.OutputFile + if Options.ReportFile != None: + self.ReportFile = Options.ReportFile + if Options.Target != None: + if not os.path.isdir(Options.Target): + EdkLogger.error("ECC", BuildToolError.OPTION_VALUE_INVALID, ExtraData="Target [%s] does NOT exist" % Options.Target) + else: + EccGlobalData.gTarget = self.GetRealPathCase(os.path.normpath(Options.Target)) + else: + EdkLogger.warn("Ecc", EdkLogger.ECC_ERROR, "The target source tree was not specified, using current WORKSPACE instead!") + EccGlobalData.gTarget = os.path.normpath(os.getenv("WORKSPACE")) + if Options.keepdatabase != None: + self.IsInit = False + if Options.metadata != None and Options.sourcecode != None: + EdkLogger.error("ECC", BuildToolError.OPTION_CONFLICT, ExtraData="-m and -s can't be specified at one time") + if Options.metadata != None: + self.ScanSourceCode = False + if Options.sourcecode != None: + self.ScanMetaData = False + + ## SetLogLevel + # + # Set current log level of the tool based on args + # + # @param Option: The option list including log level setting + # + def SetLogLevel(self, Option): + if Option.verbose != None: + EdkLogger.SetLevel(EdkLogger.VERBOSE) + elif Option.quiet != None: + EdkLogger.SetLevel(EdkLogger.QUIET) + elif Option.debug != None: + EdkLogger.SetLevel(Option.debug + 1) + else: + EdkLogger.SetLevel(EdkLogger.INFO) + + ## Parse command line options + # + # Using standard Python module optparse to parse command line option of this tool. + # + # @retval Opt A optparse.Values object containing the parsed options + # @retval Args Target of build command + # + def EccOptionParser(self): + Parser = OptionParser(description = self.Copyright, version = self.Version, prog = "Ecc.exe", usage = "%prog [options]") + Parser.add_option("-t", "--target sourcepath", action="store", type="string", dest='Target', + help="Check all files under the target workspace.") + Parser.add_option("-c", "--config filename", action="store", type="string", dest="ConfigFile", + help="Specify a configuration file. Defaultly use config.ini under ECC tool directory.") + Parser.add_option("-o", "--outfile filename", action="store", type="string", dest="OutputFile", + help="Specify the name of an output file, if and only if one filename was specified.") + Parser.add_option("-r", "--reportfile filename", action="store", type="string", dest="ReportFile", + help="Specify the name of an report file, if and only if one filename was specified.") + Parser.add_option("-m", "--metadata", action="store_true", type=None, help="Only scan meta-data files information if this option is specified.") + Parser.add_option("-s", "--sourcecode", action="store_true", type=None, help="Only scan source code files information if this option is specified.") + Parser.add_option("-k", "--keepdatabase", action="store_true", type=None, help="The existing Ecc database will not be cleaned except report information if this option is specified.") + Parser.add_option("-l", "--log filename", action="store", dest="LogFile", help="""If specified, the tool should emit the changes that + were made by the tool after printing the result message. + If filename, the emit to the file, otherwise emit to + standard output. If no modifications were made, then do not + create a log file, or output a log message.""") + Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.") + Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\ + "including library instances selected, final dependency expression, "\ + "and warning messages, etc.") + Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.") + + (Opt, Args)=Parser.parse_args() + + return (Opt, Args) + +## +# +# This acts like the main() function for the script, unless it is 'import'ed into another +# script. +# +if __name__ == '__main__': + # Initialize log system + EdkLogger.Initialize() + EdkLogger.IsRaiseError = False + EdkLogger.quiet(time.strftime("%H:%M:%S, %b.%d %Y ", time.localtime()) + "[00:00]" + "\n") + + StartTime = time.clock() + Ecc = Ecc() + FinishTime = time.clock() + + BuildDuration = time.strftime("%M:%S", time.gmtime(int(round(FinishTime - StartTime)))) + EdkLogger.quiet("\n%s [%s]" % (time.strftime("%H:%M:%S, %b.%d %Y", time.localtime()), BuildDuration)) diff --git a/BaseTools/Source/Python/Ecc/EccGlobalData.py b/BaseTools/Source/Python/Ecc/EccGlobalData.py new file mode 100644 index 0000000000..8e8f24b8c8 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/EccGlobalData.py @@ -0,0 +1,24 @@ +## @file +# This file is used to save global datas used by ECC tool +# +# Copyright (c) 2008, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import os + +gWorkspace = '' +gTarget = '' +gConfig = None +gDb = None +gIdentifierTableList = [] +gException = None \ No newline at end of file diff --git a/BaseTools/Source/Python/Ecc/EccToolError.py b/BaseTools/Source/Python/Ecc/EccToolError.py new file mode 100644 index 0000000000..9c4d10d55b --- /dev/null +++ b/BaseTools/Source/Python/Ecc/EccToolError.py @@ -0,0 +1,179 @@ +## @file +# Standardized Error Hanlding infrastructures. +# +# Copyright (c) 20087, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +ERROR_GENERAL_CHECK_ALL = 1000 +ERROR_GENERAL_CHECK_NO_TAB = 1001 +ERROR_GENERAL_CHECK_INDENTATION = 1002 +ERROR_GENERAL_CHECK_LINE = 1003 +ERROR_GENERAL_CHECK_NO_ASM = 1004 +ERROR_GENERAL_CHECK_NO_PROGMA = 1005 +ERROR_GENERAL_CHECK_CARRIAGE_RETURN = 1006 +ERROR_GENERAL_CHECK_FILE_EXISTENCE = 1007 + +ERROR_SPACE_CHECK_ALL = 2000 + +ERROR_PREDICATE_EXPRESSION_CHECK_ALL = 3000 +ERROR_PREDICATE_EXPRESSION_CHECK_BOOLEAN_VALUE = 3001 +ERROR_PREDICATE_EXPRESSION_CHECK_NO_BOOLEAN_OPERATOR = 3002 +ERROR_PREDICATE_EXPRESSION_CHECK_COMPARISON_NULL_TYPE = 3003 + +ERROR_HEADER_CHECK_ALL = 4000 +ERROR_HEADER_CHECK_FILE = 4001 +ERROR_HEADER_CHECK_FUNCTION = 4002 + +ERROR_C_FUNCTION_LAYOUT_CHECK_ALL = 5000 +ERROR_C_FUNCTION_LAYOUT_CHECK_RETURN_TYPE = 5001 +ERROR_C_FUNCTION_LAYOUT_CHECK_OPTIONAL_FUNCTIONAL_MODIFIER = 5002 +ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME = 5003 +ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE = 5004 +ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_BODY = 5005 +ERROR_C_FUNCTION_LAYOUT_CHECK_DATA_DECLARATION = 5006 +ERROR_C_FUNCTION_LAYOUT_CHECK_NO_INIT_OF_VARIABLE = 5007 +ERROR_C_FUNCTION_LAYOUT_CHECK_NO_STATIC = 5008 + +ERROR_INCLUDE_FILE_CHECK_ALL = 6000 +ERROR_INCLUDE_FILE_CHECK_IFNDEF_STATEMENT_1 = 6001 +ERROR_INCLUDE_FILE_CHECK_IFNDEF_STATEMENT_2 = 6002 +ERROR_INCLUDE_FILE_CHECK_IFNDEF_STATEMENT_3 = 6003 +ERROR_INCLUDE_FILE_CHECK_DATA = 6004 +ERROR_INCLUDE_FILE_CHECK_NAME = 6005 + +ERROR_DECLARATION_DATA_TYPE_CHECK_ALL = 7000 +ERROR_DECLARATION_DATA_TYPE_CHECK_NO_USE_C_TYPE = 7001 +ERROR_DECLARATION_DATA_TYPE_CHECK_IN_OUT_MODIFIER = 7002 +ERROR_DECLARATION_DATA_TYPE_CHECK_EFI_API_MODIFIER = 7003 +ERROR_DECLARATION_DATA_TYPE_CHECK_ENUMERATED_TYPE = 7004 +ERROR_DECLARATION_DATA_TYPE_CHECK_STRUCTURE_DECLARATION = 7005 +ERROR_DECLARATION_DATA_TYPE_CHECK_SAME_STRUCTURE = 7007 +ERROR_DECLARATION_DATA_TYPE_CHECK_UNION_TYPE = 7006 +ERROR_DECLARATION_DATA_TYPE_CHECK_NESTED_STRUCTURE = 7008 + +ERROR_NAMING_CONVENTION_CHECK_ALL = 8000 +ERROR_NAMING_CONVENTION_CHECK_DEFINE_STATEMENT = 8001 +ERROR_NAMING_CONVENTION_CHECK_TYPEDEF_STATEMENT = 8002 +ERROR_NAMING_CONVENTION_CHECK_IFNDEF_STATEMENT = 8003 +ERROR_NAMING_CONVENTION_CHECK_PATH_NAME = 8004 +ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME = 8005 +ERROR_NAMING_CONVENTION_CHECK_FUNCTION_NAME = 8006 +ERROR_NAMING_CONVENTION_CHECK_SINGLE_CHARACTER_VARIABLE = 8007 + +ERROR_DOXYGEN_CHECK_ALL = 9000 +ERROR_DOXYGEN_CHECK_FILE_HEADER = 9001 +ERROR_DOXYGEN_CHECK_FUNCTION_HEADER = 9002 +ERROR_DOXYGEN_CHECK_COMMENT_DESCRIPTION = 9003 +ERROR_DOXYGEN_CHECK_COMMENT_FORMAT = 9004 +ERROR_DOXYGEN_CHECK_COMMAND = 9005 + +ERROR_META_DATA_FILE_CHECK_ALL = 10000 +ERROR_META_DATA_FILE_CHECK_PATH_NAME = 10001 +ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_1 = 10002 +ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_2 = 10003 +ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_DEPENDENT = 10004 +ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_ORDER = 10005 +ERROR_META_DATA_FILE_CHECK_LIBRARY_NO_USE = 10006 +ERROR_META_DATA_FILE_CHECK_BINARY_INF_IN_FDF = 10007 +ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE = 10008 +ERROR_META_DATA_FILE_CHECK_PCD_FLASH = 10009 +ERROR_META_DATA_FILE_CHECK_PCD_NO_USE = 10010 +ERROR_META_DATA_FILE_CHECK_DUPLICATE_GUID = 10011 +ERROR_META_DATA_FILE_CHECK_DUPLICATE_PROTOCOL = 10012 +ERROR_META_DATA_FILE_CHECK_DUPLICATE_PPI = 10013 +ERROR_META_DATA_FILE_CHECK_MODULE_FILE_NO_USE = 10014 +ERROR_META_DATA_FILE_CHECK_PCD_TYPE = 10015 + +ERROR_SPELLING_CHECK_ALL = 11000 + +gEccErrorMessage = { + ERROR_GENERAL_CHECK_ALL : "", + ERROR_GENERAL_CHECK_NO_TAB : "'TAB' character is not allowed in source code, please replace each 'TAB' with two spaces", + ERROR_GENERAL_CHECK_INDENTATION : "Indentation does not follow coding style", + ERROR_GENERAL_CHECK_LINE : "The width of each line does not follow coding style", + ERROR_GENERAL_CHECK_NO_ASM : "There should be no use of _asm in the source file", + ERROR_GENERAL_CHECK_NO_PROGMA : """There should be no use of "#progma" in source file except "#pragma pack(#)\"""", + ERROR_GENERAL_CHECK_CARRIAGE_RETURN : "There should be a carriage return at the end of the file", + ERROR_GENERAL_CHECK_FILE_EXISTENCE : "File not found", + + ERROR_SPACE_CHECK_ALL : "", + + ERROR_PREDICATE_EXPRESSION_CHECK_ALL : "", + ERROR_PREDICATE_EXPRESSION_CHECK_BOOLEAN_VALUE : "Boolean values and variable type BOOLEAN should not use explicit comparisons to TRUE or FALSE", + ERROR_PREDICATE_EXPRESSION_CHECK_NO_BOOLEAN_OPERATOR : "Non-Boolean comparisons should use a compare operator (==, !=, >, < >=, <=)", + ERROR_PREDICATE_EXPRESSION_CHECK_COMPARISON_NULL_TYPE : "A comparison of any pointer to zero must be done via the NULL type", + + ERROR_HEADER_CHECK_ALL : "", + ERROR_HEADER_CHECK_FILE : "File header doesn't exist", + ERROR_HEADER_CHECK_FUNCTION : "Function header doesn't exist", + + ERROR_C_FUNCTION_LAYOUT_CHECK_ALL : "", + ERROR_C_FUNCTION_LAYOUT_CHECK_RETURN_TYPE : "Return type of a function should exist and in the first line", + ERROR_C_FUNCTION_LAYOUT_CHECK_OPTIONAL_FUNCTIONAL_MODIFIER : "Any optional functional modifiers should exist and next to the return type", + ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME : """Function name should be left justified, followed by the beginning of the parameter list, with the closing parenthesis on its own line, indented two spaces""", + ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE : "Function prototypes in include files have the same form as function definitions", + ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_BODY : "The body of a function should be contained by open and close braces that must be in the first column", + ERROR_C_FUNCTION_LAYOUT_CHECK_DATA_DECLARATION : "The data declarations should be the first code in a module", + ERROR_C_FUNCTION_LAYOUT_CHECK_NO_INIT_OF_VARIABLE : "There should be no initialization of a variable as part of its declaration", + ERROR_C_FUNCTION_LAYOUT_CHECK_NO_STATIC : "There should be no use of STATIC for functions", + + ERROR_INCLUDE_FILE_CHECK_ALL : "", + ERROR_INCLUDE_FILE_CHECK_IFNDEF_STATEMENT_1 : "All include file contents should be guarded by a #ifndef statement.", + ERROR_INCLUDE_FILE_CHECK_IFNDEF_STATEMENT_2 : "The #ifndef must be the first line of code following the file header comment", + ERROR_INCLUDE_FILE_CHECK_IFNDEF_STATEMENT_3 : "The #endif must appear on the last line in the file", + ERROR_INCLUDE_FILE_CHECK_DATA : "Include files should contain only public or only private data and cannot contain code or define data variables", + ERROR_INCLUDE_FILE_CHECK_NAME : "No permission for the inlcude file with same names", + + ERROR_DECLARATION_DATA_TYPE_CHECK_ALL : "", + ERROR_DECLARATION_DATA_TYPE_CHECK_NO_USE_C_TYPE : "There should be no use of int, unsigned, char, void, static, long in any .c, .h or .asl files", + ERROR_DECLARATION_DATA_TYPE_CHECK_IN_OUT_MODIFIER : """The modifiers IN, OUT, OPTIONAL, and UNALIGNED should be used only to qualify arguments to a function and should not appear in a data type declaration""", + ERROR_DECLARATION_DATA_TYPE_CHECK_EFI_API_MODIFIER : "The EFIAPI modifier should be used at the entry of drivers, events, and member functions of protocols", + ERROR_DECLARATION_DATA_TYPE_CHECK_ENUMERATED_TYPE : "Enumerated Type should have a 'typedef' and the name must be in capital letters", + ERROR_DECLARATION_DATA_TYPE_CHECK_STRUCTURE_DECLARATION : "Structure Type should have a 'typedef' and the name must be in capital letters", + ERROR_DECLARATION_DATA_TYPE_CHECK_SAME_STRUCTURE : "No permission for the structure with same names", + ERROR_DECLARATION_DATA_TYPE_CHECK_UNION_TYPE : "Union Type should have a 'typedef' and the name must be in capital letters", + ERROR_DECLARATION_DATA_TYPE_CHECK_NESTED_STRUCTURE : "Complex types should be typedef-ed", + + ERROR_NAMING_CONVENTION_CHECK_ALL : "", + ERROR_NAMING_CONVENTION_CHECK_DEFINE_STATEMENT : "Only capital letters are allowed to be used for #define declarations", + ERROR_NAMING_CONVENTION_CHECK_TYPEDEF_STATEMENT : "Only capital letters are allowed to be used for typedef declarations", + ERROR_NAMING_CONVENTION_CHECK_IFNDEF_STATEMENT : "The #ifndef at the start of an include file should use both prefix and postfix underscore characters, '_'", + ERROR_NAMING_CONVENTION_CHECK_PATH_NAME : """Path name does not follow the rules: 1. First character should be upper case 2. Must contain lower case characters 3. No white space characters""", + ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME : """Variable name does not follow the rules: 1. First character should be upper case 2. Must contain lower case characters 3. No white space characters 4. Global variable name must start with a 'g'""", + ERROR_NAMING_CONVENTION_CHECK_FUNCTION_NAME : """Function name does not follow the rules: 1. First character should be upper case 2. Must contain lower case characters 3. No white space characters""", + ERROR_NAMING_CONVENTION_CHECK_SINGLE_CHARACTER_VARIABLE : "There should be no use of short (single character) variable names", + + ERROR_DOXYGEN_CHECK_ALL : "", + ERROR_DOXYGEN_CHECK_FILE_HEADER : "The file headers should follow Doxygen special documentation blocks in section 2.3.5", + ERROR_DOXYGEN_CHECK_FUNCTION_HEADER : "The function headers should follow Doxygen special documentation blocks in section 2.3.5", + ERROR_DOXYGEN_CHECK_COMMENT_DESCRIPTION : """The first line of text in a comment block should be a brief description of the element being documented and the brief description must end with a period.""", + ERROR_DOXYGEN_CHECK_COMMENT_FORMAT : "For comment line with '///< ... text ...' format, if it is used, it should be after the code section", + ERROR_DOXYGEN_CHECK_COMMAND : "Only Doxygen commands @bug and @todo are allowed to mark the code", + + ERROR_META_DATA_FILE_CHECK_ALL : "", + ERROR_META_DATA_FILE_CHECK_PATH_NAME : "The file defined in meta-data does not exist", + ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_1 : "A library instances defined for a given module (or dependent library instance) doesn't match the module's type.", + ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_2 : "A library instance must specify the Supported Module Types in its INF file", + ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_DEPENDENT : "A library instance must be defined for all dependent library classes", + ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_ORDER : "The library Instances specified by the LibraryClasses sections should be listed in order of dependencies", + ERROR_META_DATA_FILE_CHECK_LIBRARY_NO_USE : "There should be no unnecessary inclusion of library classes in the INF file", + ERROR_META_DATA_FILE_CHECK_BINARY_INF_IN_FDF : "An INF file is specified in the FDF file, but not in the DSC file, therefore the INF file must be for a Binary module only", + ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE : "Duplicate PCDs found", + ERROR_META_DATA_FILE_CHECK_PCD_FLASH : "PCD settings in the FDF file should only be related to flash", + ERROR_META_DATA_FILE_CHECK_PCD_NO_USE : "There should be no PCDs declared in INF files that are not specified in in either a DSC or FDF file", + ERROR_META_DATA_FILE_CHECK_DUPLICATE_GUID : "Duplicate GUID found", + ERROR_META_DATA_FILE_CHECK_DUPLICATE_PROTOCOL : "Duplicate PROTOCOL found", + ERROR_META_DATA_FILE_CHECK_DUPLICATE_PPI : "Duplicate PPI found", + ERROR_META_DATA_FILE_CHECK_MODULE_FILE_NO_USE : "No used module files found", + ERROR_META_DATA_FILE_CHECK_PCD_TYPE : "Wrong C code function used for this kind of PCD", + + ERROR_SPELLING_CHECK_ALL : "", + } + diff --git a/BaseTools/Source/Python/Ecc/Exception.py b/BaseTools/Source/Python/Ecc/Exception.py new file mode 100644 index 0000000000..733408551a --- /dev/null +++ b/BaseTools/Source/Python/Ecc/Exception.py @@ -0,0 +1,87 @@ +## @file +# This file is used to parse exception items found by ECC tool +# +# Copyright (c) 2009, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +from Common.XmlRoutines import * +import os.path + +# ExceptionXml to parse Exception Node of XML file +class ExceptionXml(object): + def __init__(self): + self.KeyWord = '' + self.ErrorID = '' + self.FilePath = '' + + def FromXml(self, Item, Key): + self.KeyWord = XmlElement(Item, '%s/KeyWord' % Key) + self.ErrorID = XmlElement(Item, '%s/ErrorID' % Key) + self.FilePath = os.path.normpath(XmlElement(Item, '%s/FilePath' % Key)) + + def __str__(self): + return 'ErrorID = %s KeyWord = %s FilePath = %s' %(self.ErrorID, self.KeyWord, self.FilePath) + +# ExceptionListXml to parse Exception Node List of XML file +class ExceptionListXml(object): + def __init__(self): + self.List = [] + + def FromXmlFile(self, FilePath): + XmlContent = XmlParseFile(FilePath) + for Item in XmlList(XmlContent, '/ExceptionList/Exception'): + Exp = ExceptionXml() + Exp.FromXml(Item, 'Exception') + self.List.append(Exp) + + def ToList(self): + RtnList = [] + for Item in self.List: + #RtnList.append((Item.ErrorID, Item.KeyWord, Item.FilePath)) + RtnList.append((Item.ErrorID, Item.KeyWord)) + + return RtnList + + def __str__(self): + RtnStr = '' + if self.List: + for Item in self.List: + RtnStr = RtnStr + str(Item) + '\n' + return RtnStr + +# A class to check exception +class ExceptionCheck(object): + def __init__(self, FilePath = None): + self.ExceptionList = [] + self.ExceptionListXml = ExceptionListXml() + self.LoadExceptionListXml(FilePath) + + def LoadExceptionListXml(self, FilePath): + if FilePath and os.path.isfile(FilePath): + self.ExceptionListXml.FromXmlFile(FilePath) + self.ExceptionList = self.ExceptionListXml.ToList() + + def IsException(self, ErrorID, KeyWord, FileID=-1): + if (str(ErrorID), KeyWord) in self.ExceptionList: + return True + else: + return False + +## +# +# This acts like the main() function for the script, unless it is 'import'ed into another +# script. +# +if __name__ == '__main__': + El = ExceptionCheck('C:\\Hess\\Project\\BuildTool\\src\\Ecc\\exception.xml') + print El.ExceptionList diff --git a/BaseTools/Source/Python/Ecc/FileProfile.py b/BaseTools/Source/Python/Ecc/FileProfile.py new file mode 100644 index 0000000000..810087ea07 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/FileProfile.py @@ -0,0 +1,57 @@ +## @file +# fragments of source file +# +# Copyright (c) 2007, Intel Corporation +# +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# + +import re +import os +from ParserWarning import Warning + +CommentList = [] +PPDirectiveList = [] +PredicateExpressionList = [] +FunctionDefinitionList = [] +VariableDeclarationList = [] +EnumerationDefinitionList = [] +StructUnionDefinitionList = [] +TypedefDefinitionList = [] +FunctionCallingList = [] + +## record file data when parsing source +# +# May raise Exception when opening file. +# +class FileProfile : + + ## The constructor + # + # @param self The object pointer + # @param FileName The file that to be parsed + # + def __init__(self, FileName): + self.FileLinesList = [] + self.FileLinesListFromFile = [] + try: + fsock = open(FileName, "rb", 0) + try: + self.FileLinesListFromFile = fsock.readlines() + finally: + fsock.close() + + except IOError: + raise Warning("Error when opening file %s" % FileName) + + \ No newline at end of file diff --git a/BaseTools/Source/Python/Ecc/MetaDataParser.py b/BaseTools/Source/Python/Ecc/MetaDataParser.py new file mode 100644 index 0000000000..fb4239f474 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/MetaDataParser.py @@ -0,0 +1,65 @@ +## @file +# This file is used to define common parser functions for meta-data +# +# Copyright (c) 2008, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +import os +from CommonDataClass.DataClass import * + + +## Get the inlcude path list for a source file +# +# 1. Find the source file belongs to which inf file +# 2. Find the inf's package +# 3. Return the include path list of the package +# +def GetIncludeListOfFile(WorkSpace, Filepath, Db): + IncludeList = [] + Filepath = os.path.normpath(Filepath) + SqlCommand = """ + select Value1, FullPath from Inf, File where Inf.Model = %s and Inf.BelongsToFile in( + select distinct B.BelongsToFile from File as A left join Inf as B + where A.ID = B.BelongsToFile and B.Model = %s and (A.Path || '%s' || B.Value1) = '%s') + and Inf.BelongsToFile = File.ID""" \ + % (MODEL_META_DATA_PACKAGE, MODEL_EFI_SOURCE_FILE, '\\', Filepath) + RecordSet = Db.TblFile.Exec(SqlCommand) + for Record in RecordSet: + DecFullPath = os.path.normpath(os.path.join(WorkSpace, Record[0])) + InfFullPath = os.path.normpath(os.path.join(WorkSpace, Record[1])) + (DecPath, DecName) = os.path.split(DecFullPath) + (InfPath, InfName) = os.path.split(InfFullPath) + SqlCommand = """select Value1 from Dec where BelongsToFile = + (select ID from File where FullPath = '%s') and Model = %s""" \ + % (DecFullPath, MODEL_EFI_INCLUDE) + NewRecordSet = Db.TblDec.Exec(SqlCommand) + if InfPath not in IncludeList: + IncludeList.append(InfPath) + for NewRecord in NewRecordSet: + IncludePath = os.path.normpath(os.path.join(DecPath, NewRecord[0])) + if IncludePath not in IncludeList: + IncludeList.append(IncludePath) + + return IncludeList + +## Get the table list +# +# Search table file and find all small tables +# +def GetTableList(FileModelList, Table, Db): + TableList = [] + SqlCommand = """select ID from File where Model in %s""" % str(FileModelList) + RecordSet = Db.TblFile.Exec(SqlCommand) + for Record in RecordSet: + TableName = Table + str(Record[0]) + TableList.append(TableName) + + return TableList + diff --git a/BaseTools/Source/Python/Ecc/ParserWarning.py b/BaseTools/Source/Python/Ecc/ParserWarning.py new file mode 100644 index 0000000000..547360d927 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/ParserWarning.py @@ -0,0 +1,17 @@ +## The exception class that used to report error messages when preprocessing +# +# Currently the "ToolName" is set to be "ECC PP". +# +class Warning (Exception): + ## The constructor + # + # @param self The object pointer + # @param Str The message to record + # @param File The FDF name + # @param Line The Line number that error occurs + # + def __init__(self, Str, File = None, Line = None): + self.message = Str + self.FileName = File + self.LineNumber = Line + self.ToolName = 'ECC PP' \ No newline at end of file diff --git a/BaseTools/Source/Python/Ecc/__init__.py b/BaseTools/Source/Python/Ecc/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/BaseTools/Source/Python/Ecc/c.py b/BaseTools/Source/Python/Ecc/c.py new file mode 100644 index 0000000000..b8b1d2d6f5 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/c.py @@ -0,0 +1,2503 @@ +import sys +import os +import re +import string +import CodeFragmentCollector +import FileProfile +from CommonDataClass import DataClass +import Database +from Common import EdkLogger +from EccToolError import * +import EccGlobalData +import MetaDataParser + +IncludeFileListDict = {} +AllIncludeFileListDict = {} +IncludePathListDict = {} +ComplexTypeDict = {} +SUDict = {} +IgnoredKeywordList = ['EFI_ERROR'] + +def GetIgnoredDirListPattern(): + skipList = list(EccGlobalData.gConfig.SkipDirList) + ['.svn'] + DirString = string.join(skipList, '|') + p = re.compile(r'.*[\\/](?:%s)[\\/]?.*' % DirString) + return p + +def GetFuncDeclPattern(): + p = re.compile(r'(?:EFIAPI|EFI_BOOT_SERVICE|EFI_RUNTIME_SERVICE)?\s*[_\w]+\s*\(.*\)$', re.DOTALL) + return p + +def GetArrayPattern(): + p = re.compile(r'[_\w]*\s*[\[.*\]]+') + return p + +def GetTypedefFuncPointerPattern(): + p = re.compile('[_\w\s]*\([\w\s]*\*+\s*[_\w]+\s*\)\s*\(.*\)', re.DOTALL) + return p + +def GetDB(): + return EccGlobalData.gDb + +def GetConfig(): + return EccGlobalData.gConfig + +def PrintErrorMsg(ErrorType, Msg, TableName, ItemId): + Msg = Msg.replace('\n', '').replace('\r', '') + MsgPartList = Msg.split() + Msg = '' + for Part in MsgPartList: + Msg += Part + Msg += ' ' + GetDB().TblReport.Insert(ErrorType, OtherMsg = Msg, BelongsToTable = TableName, BelongsToItem = ItemId) + +def GetIdType(Str): + Type = DataClass.MODEL_UNKNOWN + Str = Str.replace('#', '# ') + List = Str.split() + if List[1] == 'include': + Type = DataClass.MODEL_IDENTIFIER_INCLUDE + elif List[1] == 'define': + Type = DataClass.MODEL_IDENTIFIER_MACRO_DEFINE + elif List[1] == 'ifdef': + Type = DataClass.MODEL_IDENTIFIER_MACRO_IFDEF + elif List[1] == 'ifndef': + Type = DataClass.MODEL_IDENTIFIER_MACRO_IFNDEF + elif List[1] == 'endif': + Type = DataClass.MODEL_IDENTIFIER_MACRO_ENDIF + elif List[1] == 'pragma': + Type = DataClass.MODEL_IDENTIFIER_MACRO_PROGMA + else: + Type = DataClass.MODEL_UNKNOWN + return Type + +def SuOccurInTypedef (Su, TdList): + for Td in TdList: + if Su.StartPos[0] == Td.StartPos[0] and Su.EndPos[0] == Td.EndPos[0]: + return True + return False + +def GetIdentifierList(): + IdList = [] + for comment in FileProfile.CommentList: + IdComment = DataClass.IdentifierClass(-1, '', '', '', comment.Content, DataClass.MODEL_IDENTIFIER_COMMENT, -1, -1, comment.StartPos[0],comment.StartPos[1],comment.EndPos[0],comment.EndPos[1]) + IdList.append(IdComment) + + for pp in FileProfile.PPDirectiveList: + Type = GetIdType(pp.Content) + IdPP = DataClass.IdentifierClass(-1, '', '', '', pp.Content, Type, -1, -1, pp.StartPos[0],pp.StartPos[1],pp.EndPos[0],pp.EndPos[1]) + IdList.append(IdPP) + + for pe in FileProfile.PredicateExpressionList: + IdPE = DataClass.IdentifierClass(-1, '', '', '', pe.Content, DataClass.MODEL_IDENTIFIER_PREDICATE_EXPRESSION, -1, -1, pe.StartPos[0],pe.StartPos[1],pe.EndPos[0],pe.EndPos[1]) + IdList.append(IdPE) + + FuncDeclPattern = GetFuncDeclPattern() + ArrayPattern = GetArrayPattern() + for var in FileProfile.VariableDeclarationList: + DeclText = var.Declarator.lstrip() + FuncPointerPattern = GetTypedefFuncPointerPattern() + if FuncPointerPattern.match(DeclText): + continue + VarNameStartLine = var.NameStartPos[0] + VarNameStartColumn = var.NameStartPos[1] + FirstChar = DeclText[0] + while not FirstChar.isalpha() and FirstChar != '_': + if FirstChar == '*': + var.Modifier += '*' + VarNameStartColumn += 1 + DeclText = DeclText.lstrip('*') + elif FirstChar == '\r': + DeclText = DeclText.lstrip('\r\n').lstrip('\r') + VarNameStartLine += 1 + VarNameStartColumn = 0 + elif FirstChar == '\n': + DeclText = DeclText.lstrip('\n') + VarNameStartLine += 1 + VarNameStartColumn = 0 + elif FirstChar == ' ': + DeclText = DeclText.lstrip(' ') + VarNameStartColumn += 1 + elif FirstChar == '\t': + DeclText = DeclText.lstrip('\t') + VarNameStartColumn += 8 + else: + DeclText = DeclText[1:] + VarNameStartColumn += 1 + FirstChar = DeclText[0] + + var.Declarator = DeclText + if FuncDeclPattern.match(var.Declarator): + DeclSplitList = var.Declarator.split('(') + FuncName = DeclSplitList[0].strip() + FuncNamePartList = FuncName.split() + if len(FuncNamePartList) > 1: + FuncName = FuncNamePartList[-1].strip() + NameStart = DeclSplitList[0].rfind(FuncName) + var.Declarator = var.Declarator[NameStart:] + if NameStart > 0: + var.Modifier += ' ' + DeclSplitList[0][0:NameStart] + Index = 0 + PreChar = '' + while Index < NameStart: + FirstChar = DeclSplitList[0][Index] + if DeclSplitList[0][Index:].startswith('EFIAPI'): + Index += 6 + VarNameStartColumn += 6 + PreChar = '' + continue + elif FirstChar == '\r': + Index += 1 + VarNameStartLine += 1 + VarNameStartColumn = 0 + elif FirstChar == '\n': + Index += 1 + if PreChar != '\r': + VarNameStartLine += 1 + VarNameStartColumn = 0 + elif FirstChar == ' ': + Index += 1 + VarNameStartColumn += 1 + elif FirstChar == '\t': + Index += 1 + VarNameStartColumn += 8 + else: + Index += 1 + VarNameStartColumn += 1 + PreChar = FirstChar + IdVar = DataClass.IdentifierClass(-1, var.Modifier, '', var.Declarator, FuncName, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION, -1, -1, var.StartPos[0], var.StartPos[1], VarNameStartLine, VarNameStartColumn) + IdList.append(IdVar) + continue + + if var.Declarator.find('{') == -1: + for decl in var.Declarator.split(','): + DeclList = decl.split('=') + Name = DeclList[0].strip() + if ArrayPattern.match(Name): + LSBPos = var.Declarator.find('[') + var.Modifier += ' ' + Name[LSBPos:] + Name = Name[0:LSBPos] + + IdVar = DataClass.IdentifierClass(-1, var.Modifier, '', Name, (len(DeclList) > 1 and [DeclList[1]]or [''])[0], DataClass.MODEL_IDENTIFIER_VARIABLE, -1, -1, var.StartPos[0],var.StartPos[1], VarNameStartLine, VarNameStartColumn) + IdList.append(IdVar) + else: + DeclList = var.Declarator.split('=') + Name = DeclList[0].strip() + if ArrayPattern.match(Name): + LSBPos = var.Declarator.find('[') + var.Modifier += ' ' + Name[LSBPos:] + Name = Name[0:LSBPos] + IdVar = DataClass.IdentifierClass(-1, var.Modifier, '', Name, (len(DeclList) > 1 and [DeclList[1]]or [''])[0], DataClass.MODEL_IDENTIFIER_VARIABLE, -1, -1, var.StartPos[0],var.StartPos[1], VarNameStartLine, VarNameStartColumn) + IdList.append(IdVar) + + for enum in FileProfile.EnumerationDefinitionList: + LBPos = enum.Content.find('{') + RBPos = enum.Content.find('}') + Name = enum.Content[4:LBPos].strip() + Value = enum.Content[LBPos+1:RBPos] + IdEnum = DataClass.IdentifierClass(-1, '', '', Name, Value, DataClass.MODEL_IDENTIFIER_ENUMERATE, -1, -1, enum.StartPos[0],enum.StartPos[1],enum.EndPos[0],enum.EndPos[1]) + IdList.append(IdEnum) + + for su in FileProfile.StructUnionDefinitionList: + if SuOccurInTypedef(su, FileProfile.TypedefDefinitionList): + continue + Type = DataClass.MODEL_IDENTIFIER_STRUCTURE + SkipLen = 6 + if su.Content.startswith('union'): + Type = DataClass.MODEL_IDENTIFIER_UNION + SkipLen = 5 + LBPos = su.Content.find('{') + RBPos = su.Content.find('}') + if LBPos == -1 or RBPos == -1: + Name = su.Content[SkipLen:].strip() + Value = '' + else: + Name = su.Content[SkipLen:LBPos].strip() + Value = su.Content[LBPos:RBPos+1] + IdPE = DataClass.IdentifierClass(-1, '', '', Name, Value, Type, -1, -1, su.StartPos[0],su.StartPos[1],su.EndPos[0],su.EndPos[1]) + IdList.append(IdPE) + + TdFuncPointerPattern = GetTypedefFuncPointerPattern() + for td in FileProfile.TypedefDefinitionList: + Modifier = '' + Name = td.ToType + Value = td.FromType + if TdFuncPointerPattern.match(td.ToType): + Modifier = td.FromType + LBPos = td.ToType.find('(') + TmpStr = td.ToType[LBPos+1:].strip() + StarPos = TmpStr.find('*') + if StarPos != -1: + Modifier += ' ' + TmpStr[0:StarPos] + while TmpStr[StarPos] == '*': +# Modifier += ' ' + '*' + StarPos += 1 + TmpStr = TmpStr[StarPos:].strip() + RBPos = TmpStr.find(')') + Name = TmpStr[0:RBPos] + Value = 'FP' + TmpStr[RBPos + 1:] + else: + while Name.startswith('*'): + Value += ' ' + '*' + Name = Name.lstrip('*').strip() + + if Name.find('[') != -1: + LBPos = Name.find('[') + RBPos = Name.rfind(']') + Value += Name[LBPos : RBPos + 1] + Name = Name[0 : LBPos] + + IdTd = DataClass.IdentifierClass(-1, Modifier, '', Name, Value, DataClass.MODEL_IDENTIFIER_TYPEDEF, -1, -1, td.StartPos[0],td.StartPos[1],td.EndPos[0],td.EndPos[1]) + IdList.append(IdTd) + + for funcCall in FileProfile.FunctionCallingList: + IdFC = DataClass.IdentifierClass(-1, '', '', funcCall.FuncName, funcCall.ParamList, DataClass.MODEL_IDENTIFIER_FUNCTION_CALLING, -1, -1, funcCall.StartPos[0],funcCall.StartPos[1],funcCall.EndPos[0],funcCall.EndPos[1]) + IdList.append(IdFC) + return IdList + +def StripNonAlnumChars(Str): + StrippedStr = '' + for Char in Str: + if Char.isalnum(): + StrippedStr += Char + return StrippedStr + +def GetParamList(FuncDeclarator, FuncNameLine = 0, FuncNameOffset = 0): + FuncDeclarator = StripComments(FuncDeclarator) + ParamIdList = [] + #DeclSplitList = FuncDeclarator.split('(') + LBPos = FuncDeclarator.find('(') + #if len(DeclSplitList) < 2: + if LBPos == -1: + return ParamIdList + #FuncName = DeclSplitList[0] + FuncName = FuncDeclarator[0:LBPos] + #ParamStr = DeclSplitList[1].rstrip(')') + ParamStr = FuncDeclarator[LBPos + 1:].rstrip(')') + LineSkipped = 0 + OffsetSkipped = 0 + TailChar = FuncName[-1] + while not TailChar.isalpha() and TailChar != '_': + + if TailChar == '\n': + FuncName = FuncName.rstrip('\r\n').rstrip('\n') + LineSkipped += 1 + OffsetSkipped = 0 + elif TailChar == '\r': + FuncName = FuncName.rstrip('\r') + LineSkipped += 1 + OffsetSkipped = 0 + elif TailChar == ' ': + FuncName = FuncName.rstrip(' ') + OffsetSkipped += 1 + elif TailChar == '\t': + FuncName = FuncName.rstrip('\t') + OffsetSkipped += 8 + else: + FuncName = FuncName[:-1] + TailChar = FuncName[-1] + + OffsetSkipped += 1 #skip '(' + + for p in ParamStr.split(','): + ListP = p.split() + if len(ListP) == 0: + continue + ParamName = ListP[-1] + DeclText = ParamName.strip() + RightSpacePos = p.rfind(ParamName) + ParamModifier = p[0:RightSpacePos] + if ParamName == 'OPTIONAL': + if ParamModifier == '': + ParamModifier += ' ' + 'OPTIONAL' + DeclText = '' + else: + ParamName = ListP[-2] + DeclText = ParamName.strip() + RightSpacePos = p.rfind(ParamName) + ParamModifier = p[0:RightSpacePos] + ParamModifier += 'OPTIONAL' + while DeclText.startswith('*'): + ParamModifier += ' ' + '*' + DeclText = DeclText.lstrip('*').strip() + ParamName = DeclText + # ignore array length if exists. + LBIndex = ParamName.find('[') + if LBIndex != -1: + ParamName = ParamName[0:LBIndex] + + Start = RightSpacePos + Index = 0 + PreChar = '' + while Index < Start: + FirstChar = p[Index] + + if FirstChar == '\r': + Index += 1 + LineSkipped += 1 + OffsetSkipped = 0 + elif FirstChar == '\n': + Index += 1 + if PreChar != '\r': + LineSkipped += 1 + OffsetSkipped = 0 + elif FirstChar == ' ': + Index += 1 + OffsetSkipped += 1 + elif FirstChar == '\t': + Index += 1 + OffsetSkipped += 8 + else: + Index += 1 + OffsetSkipped += 1 + PreChar = FirstChar + + ParamBeginLine = FuncNameLine + LineSkipped + ParamBeginOffset = FuncNameOffset + OffsetSkipped + + Index = Start + len(ParamName) + PreChar = '' + while Index < len(p): + FirstChar = p[Index] + + if FirstChar == '\r': + Index += 1 + LineSkipped += 1 + OffsetSkipped = 0 + elif FirstChar == '\n': + Index += 1 + if PreChar != '\r': + LineSkipped += 1 + OffsetSkipped = 0 + elif FirstChar == ' ': + Index += 1 + OffsetSkipped += 1 + elif FirstChar == '\t': + Index += 1 + OffsetSkipped += 8 + else: + Index += 1 + OffsetSkipped += 1 + PreChar = FirstChar + + ParamEndLine = FuncNameLine + LineSkipped + ParamEndOffset = FuncNameOffset + OffsetSkipped + if ParamName != '...': + ParamName = StripNonAlnumChars(ParamName) + IdParam = DataClass.IdentifierClass(-1, ParamModifier, '', ParamName, '', DataClass.MODEL_IDENTIFIER_PARAMETER, -1, -1, ParamBeginLine, ParamBeginOffset, ParamEndLine, ParamEndOffset) + ParamIdList.append(IdParam) + + OffsetSkipped += 1 #skip ',' + + return ParamIdList + +def GetFunctionList(): + FuncObjList = [] + for FuncDef in FileProfile.FunctionDefinitionList: + ParamIdList = [] + DeclText = FuncDef.Declarator.lstrip() + FuncNameStartLine = FuncDef.NamePos[0] + FuncNameStartColumn = FuncDef.NamePos[1] + FirstChar = DeclText[0] + while not FirstChar.isalpha() and FirstChar != '_': + if FirstChar == '*': + FuncDef.Modifier += '*' + FuncNameStartColumn += 1 + DeclText = DeclText.lstrip('*') + elif FirstChar == '\r': + DeclText = DeclText.lstrip('\r\n').lstrip('\r') + FuncNameStartLine += 1 + FuncNameStartColumn = 0 + elif FirstChar == '\n': + DeclText = DeclText.lstrip('\n') + FuncNameStartLine += 1 + FuncNameStartColumn = 0 + elif FirstChar == ' ': + DeclText = DeclText.lstrip(' ') + FuncNameStartColumn += 1 + elif FirstChar == '\t': + DeclText = DeclText.lstrip('\t') + FuncNameStartColumn += 8 + else: + DeclText = DeclText[1:] + FuncNameStartColumn += 1 + FirstChar = DeclText[0] + + FuncDef.Declarator = DeclText + DeclSplitList = FuncDef.Declarator.split('(') + if len(DeclSplitList) < 2: + continue + + FuncName = DeclSplitList[0] + FuncNamePartList = FuncName.split() + if len(FuncNamePartList) > 1: + FuncName = FuncNamePartList[-1] + NameStart = DeclSplitList[0].rfind(FuncName) + if NameStart > 0: + FuncDef.Modifier += ' ' + DeclSplitList[0][0:NameStart] + Index = 0 + PreChar = '' + while Index < NameStart: + FirstChar = DeclSplitList[0][Index] + if DeclSplitList[0][Index:].startswith('EFIAPI'): + Index += 6 + FuncNameStartColumn += 6 + PreChar = '' + continue + elif FirstChar == '\r': + Index += 1 + FuncNameStartLine += 1 + FuncNameStartColumn = 0 + elif FirstChar == '\n': + Index += 1 + if PreChar != '\r': + FuncNameStartLine += 1 + FuncNameStartColumn = 0 + elif FirstChar == ' ': + Index += 1 + FuncNameStartColumn += 1 + elif FirstChar == '\t': + Index += 1 + FuncNameStartColumn += 8 + else: + Index += 1 + FuncNameStartColumn += 1 + PreChar = FirstChar + + FuncObj = DataClass.FunctionClass(-1, FuncDef.Declarator, FuncDef.Modifier, FuncName.strip(), '', FuncDef.StartPos[0],FuncDef.StartPos[1],FuncDef.EndPos[0],FuncDef.EndPos[1], FuncDef.LeftBracePos[0], FuncDef.LeftBracePos[1], -1, ParamIdList, [], FuncNameStartLine, FuncNameStartColumn) + FuncObjList.append(FuncObj) + + return FuncObjList + +def GetFileModificationTimeFromDB(FullFileName): + TimeValue = 0.0 + Db = GetDB() + SqlStatement = """ select TimeStamp + from File + where FullPath = \'%s\' + """ % (FullFileName) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + TimeValue = Result[0] + return TimeValue + +def CollectSourceCodeDataIntoDB(RootDir): + FileObjList = [] + tuple = os.walk(RootDir) + IgnoredPattern = GetIgnoredDirListPattern() + ParseErrorFileList = [] + + for dirpath, dirnames, filenames in tuple: + if IgnoredPattern.match(dirpath.upper()): + continue + + for Dir in dirnames: + Dirname = os.path.join(dirpath, Dir) + if os.path.islink(Dirname): + Dirname = os.path.realpath(Dirname) + if os.path.isdir(Dirname): + # symlinks to directories are treated as directories + dirnames.remove(Dir) + dirnames.append(Dirname) + + for f in filenames: + FullName = os.path.normpath(os.path.join(dirpath, f)) + if os.path.splitext(f)[1] in ('.h', '.c'): + EdkLogger.info("Parsing " + FullName) + model = f.endswith('c') and DataClass.MODEL_FILE_C or DataClass.MODEL_FILE_H + collector = CodeFragmentCollector.CodeFragmentCollector(FullName) + try: + collector.ParseFile() + except UnicodeError: + ParseErrorFileList.append(FullName) + collector.CleanFileProfileBuffer() + collector.ParseFileWithClearedPPDirective() +# collector.PrintFragments() + BaseName = os.path.basename(f) + DirName = os.path.dirname(FullName) + Ext = os.path.splitext(f)[1].lstrip('.') + ModifiedTime = os.path.getmtime(FullName) + FileObj = DataClass.FileClass(-1, BaseName, Ext, DirName, FullName, model, ModifiedTime, GetFunctionList(), GetIdentifierList(), []) + FileObjList.append(FileObj) + collector.CleanFileProfileBuffer() + + if len(ParseErrorFileList) > 0: + EdkLogger.info("Found unrecoverable error during parsing:\n\t%s\n" % "\n\t".join(ParseErrorFileList)) + + Db = GetDB() + for file in FileObjList: + Db.InsertOneFile(file) + + Db.UpdateIdentifierBelongsToFunction() + +def GetTableID(FullFileName, ErrorMsgList = None): + if ErrorMsgList == None: + ErrorMsgList = [] + + Db = GetDB() + SqlStatement = """ select ID + from File + where FullPath like '%s' + """ % FullFileName + + ResultSet = Db.TblFile.Exec(SqlStatement) + + FileID = -1 + for Result in ResultSet: + if FileID != -1: + ErrorMsgList.append('Duplicate file ID found in DB for file %s' % FullFileName) + return -2 + FileID = Result[0] + if FileID == -1: + ErrorMsgList.append('NO file ID found in DB for file %s' % FullFileName) + return -1 + return FileID + +def GetIncludeFileList(FullFileName): + IFList = IncludeFileListDict.get(FullFileName) + if IFList != None: + return IFList + + FileID = GetTableID(FullFileName) + if FileID < 0: + return [] + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Value + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_INCLUDE) + ResultSet = Db.TblFile.Exec(SqlStatement) + IncludeFileListDict[FullFileName] = ResultSet + return ResultSet + +def GetFullPathOfIncludeFile(Str, IncludePathList): + for IncludePath in IncludePathList: + FullPath = os.path.join(IncludePath, Str) + FullPath = os.path.normpath(FullPath) + if os.path.exists(FullPath): + return FullPath + return None + +def GetAllIncludeFiles(FullFileName): + if AllIncludeFileListDict.get(FullFileName) != None: + return AllIncludeFileListDict.get(FullFileName) + + FileDirName = os.path.dirname(FullFileName) + IncludePathList = IncludePathListDict.get(FileDirName) + if IncludePathList == None: + IncludePathList = MetaDataParser.GetIncludeListOfFile(EccGlobalData.gWorkspace, FullFileName, GetDB()) + if FileDirName not in IncludePathList: + IncludePathList.insert(0, FileDirName) + IncludePathListDict[FileDirName] = IncludePathList + IncludeFileQueue = [] + for IncludeFile in GetIncludeFileList(FullFileName): + FileName = IncludeFile[0].lstrip('#').strip() + FileName = FileName.lstrip('include').strip() + FileName = FileName.strip('\"') + FileName = FileName.lstrip('<').rstrip('>').strip() + FullPath = GetFullPathOfIncludeFile(FileName, IncludePathList) + if FullPath != None: + IncludeFileQueue.append(FullPath) + + i = 0 + while i < len(IncludeFileQueue): + for IncludeFile in GetIncludeFileList(IncludeFileQueue[i]): + FileName = IncludeFile[0].lstrip('#').strip() + FileName = FileName.lstrip('include').strip() + FileName = FileName.strip('\"') + FileName = FileName.lstrip('<').rstrip('>').strip() + FullPath = GetFullPathOfIncludeFile(FileName, IncludePathList) + if FullPath != None and FullPath not in IncludeFileQueue: + IncludeFileQueue.insert(i + 1, FullPath) + i += 1 + + AllIncludeFileListDict[FullFileName] = IncludeFileQueue + return IncludeFileQueue + +def GetPredicateListFromPredicateExpStr(PES): + + PredicateList = [] + i = 0 + PredicateBegin = 0 + #PredicateEnd = 0 + LogicOpPos = -1 + p = GetFuncDeclPattern() + while i < len(PES) - 1: + if (PES[i].isalnum() or PES[i] == '_' or PES[i] == '*') and LogicOpPos > PredicateBegin: + PredicateBegin = i + if (PES[i] == '&' and PES[i+1] == '&') or (PES[i] == '|' and PES[i+1] == '|'): + LogicOpPos = i + Exp = PES[PredicateBegin:i].strip() + # Exp may contain '.' or '->' + TmpExp = Exp.replace('.', '').replace('->', '') + if p.match(TmpExp): + PredicateList.append(Exp) + else: + PredicateList.append(Exp.rstrip(';').rstrip(')').strip()) + i += 1 + + if PredicateBegin > LogicOpPos: + while PredicateBegin < len(PES): + if PES[PredicateBegin].isalnum() or PES[PredicateBegin] == '_' or PES[PredicateBegin] == '*': + break + PredicateBegin += 1 + Exp = PES[PredicateBegin:len(PES)].strip() + # Exp may contain '.' or '->' + TmpExp = Exp.replace('.', '').replace('->', '') + if p.match(TmpExp): + PredicateList.append(Exp) + else: + PredicateList.append(Exp.rstrip(';').rstrip(')').strip()) + return PredicateList + +def GetCNameList(Lvalue, StarList = []): + Lvalue += ' ' + i = 0 + SearchBegin = 0 + VarStart = -1 + VarEnd = -1 + VarList = [] + + while SearchBegin < len(Lvalue): + while i < len(Lvalue): + if Lvalue[i].isalnum() or Lvalue[i] == '_': + if VarStart == -1: + VarStart = i + VarEnd = i + i += 1 + elif VarEnd != -1: + VarList.append(Lvalue[VarStart:VarEnd+1]) + i += 1 + break + else: + if VarStart == -1 and Lvalue[i] == '*': + StarList.append('*') + i += 1 + if VarEnd == -1: + break + + + DotIndex = Lvalue[VarEnd:].find('.') + ArrowIndex = Lvalue[VarEnd:].find('->') + if DotIndex == -1 and ArrowIndex == -1: + break + elif DotIndex == -1 and ArrowIndex != -1: + SearchBegin = VarEnd + ArrowIndex + elif ArrowIndex == -1 and DotIndex != -1: + SearchBegin = VarEnd + DotIndex + else: + SearchBegin = VarEnd + ((DotIndex < ArrowIndex) and DotIndex or ArrowIndex) + + i = SearchBegin + VarStart = -1 + VarEnd = -1 + + return VarList + +def SplitPredicateByOp(Str, Op, IsFuncCalling = False): + + Name = Str.strip() + Value = None + + if IsFuncCalling: + Index = 0 + LBFound = False + UnmatchedLBCount = 0 + while Index < len(Str): + while not LBFound and Str[Index] != '_' and not Str[Index].isalnum(): + Index += 1 + + while not LBFound and (Str[Index].isalnum() or Str[Index] == '_'): + Index += 1 + # maybe type-cast at the begining, skip it. + RemainingStr = Str[Index:].lstrip() + if RemainingStr.startswith(')') and not LBFound: + Index += 1 + continue + + if RemainingStr.startswith('(') and not LBFound: + LBFound = True + + if Str[Index] == '(': + UnmatchedLBCount += 1 + Index += 1 + continue + + if Str[Index] == ')': + UnmatchedLBCount -= 1 + Index += 1 + if UnmatchedLBCount == 0: + break + continue + + Index += 1 + + if UnmatchedLBCount > 0: + return [Name] + + IndexInRemainingStr = Str[Index:].find(Op) + if IndexInRemainingStr == -1: + return [Name] + + Name = Str[0:Index + IndexInRemainingStr].strip() + Value = Str[Index+IndexInRemainingStr+len(Op):].strip() + return [Name, Value] + + TmpStr = Str.rstrip(';').rstrip(')') + while True: + Index = TmpStr.rfind(Op) + if Index == -1: + return [Name] + + if Str[Index - 1].isalnum() or Str[Index - 1].isspace() or Str[Index - 1] == ')': + Name = Str[0:Index].strip() + Value = Str[Index + len(Op):].strip() + return [Name, Value] + + TmpStr = Str[0:Index - 1] + +def SplitPredicateStr(Str): + IsFuncCalling = False + p = GetFuncDeclPattern() + TmpStr = Str.replace('.', '').replace('->', '') + if p.match(TmpStr): + IsFuncCalling = True + + PredPartList = SplitPredicateByOp(Str, '==', IsFuncCalling) + if len(PredPartList) > 1: + return [PredPartList, '=='] + + PredPartList = SplitPredicateByOp(Str, '!=', IsFuncCalling) + if len(PredPartList) > 1: + return [PredPartList, '!='] + + PredPartList = SplitPredicateByOp(Str, '>=', IsFuncCalling) + if len(PredPartList) > 1: + return [PredPartList, '>='] + + PredPartList = SplitPredicateByOp(Str, '<=', IsFuncCalling) + if len(PredPartList) > 1: + return [PredPartList, '<='] + + PredPartList = SplitPredicateByOp(Str, '>', IsFuncCalling) + if len(PredPartList) > 1: + return [PredPartList, '>'] + + PredPartList = SplitPredicateByOp(Str, '<', IsFuncCalling) + if len(PredPartList) > 1: + return [PredPartList, '<'] + + return [[Str, None], None] + +def GetFuncContainsPE(ExpLine, ResultSet): + for Result in ResultSet: + if Result[0] < ExpLine and Result[1] > ExpLine: + return Result + return None + +def PatternInModifier(Modifier, SubStr): + PartList = Modifier.split() + for Part in PartList: + if Part == SubStr: + return True + return False + +def GetDataTypeFromModifier(ModifierStr): + MList = ModifierStr.split() + for M in MList: + if M in EccGlobalData.gConfig.ModifierList: + MList.remove(M) + # remove array sufix + if M.startswith('['): + MList.remove(M) + + ReturnType = '' + for M in MList: + ReturnType += M + ' ' + + ReturnType = ReturnType.strip() + if len(ReturnType) == 0: + ReturnType = 'VOID' + return ReturnType + +def DiffModifier(Str1, Str2): + PartList1 = Str1.split() + PartList2 = Str2.split() + if PartList1 == PartList2: + return False + else: + return True + +def GetTypedefDict(FullFileName): + + Dict = ComplexTypeDict.get(FullFileName) + if Dict != None: + return Dict + + FileID = GetTableID(FullFileName) + FileTable = 'Identifier' + str(FileID) + Db = GetDB() + SqlStatement = """ select Modifier, Name, Value, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_TYPEDEF) + ResultSet = Db.TblFile.Exec(SqlStatement) + + Dict = {} + for Result in ResultSet: + if len(Result[0]) == 0: + Dict[Result[1]] = Result[2] + + IncludeFileList = GetAllIncludeFiles(FullFileName) + for F in IncludeFileList: + FileID = GetTableID(F) + if FileID < 0: + continue + + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, Name, Value, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_TYPEDEF) + ResultSet = Db.TblFile.Exec(SqlStatement) + + for Result in ResultSet: + if not Result[2].startswith('FP ('): + Dict[Result[1]] = Result[2] + else: + if len(Result[0]) == 0: + Dict[Result[1]] = 'VOID' + else: + Dict[Result[1]] = GetDataTypeFromModifier(Result[0]) + + ComplexTypeDict[FullFileName] = Dict + return Dict + +def GetSUDict(FullFileName): + + Dict = SUDict.get(FullFileName) + if Dict != None: + return Dict + + FileID = GetTableID(FullFileName) + FileTable = 'Identifier' + str(FileID) + Db = GetDB() + SqlStatement = """ select Name, Value, ID + from %s + where Model = %d or Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_STRUCTURE, DataClass.MODEL_IDENTIFIER_UNION) + ResultSet = Db.TblFile.Exec(SqlStatement) + + Dict = {} + for Result in ResultSet: + if len(Result[1]) > 0: + Dict[Result[0]] = Result[1] + + IncludeFileList = GetAllIncludeFiles(FullFileName) + for F in IncludeFileList: + FileID = GetTableID(F) + if FileID < 0: + continue + + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Name, Value, ID + from %s + where Model = %d or Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_STRUCTURE, DataClass.MODEL_IDENTIFIER_UNION) + ResultSet = Db.TblFile.Exec(SqlStatement) + + for Result in ResultSet: + if len(Result[1]) > 0: + Dict[Result[0]] = Result[1] + + SUDict[FullFileName] = Dict + return Dict + +def StripComments(Str): + Str += ' ' + ListFromStr = list(Str) + + InComment = False + DoubleSlashComment = False + Index = 0 + while Index < len(ListFromStr): + # meet new line, then no longer in a comment for // + if ListFromStr[Index] == '\n': + if InComment and DoubleSlashComment: + InComment = False + DoubleSlashComment = False + Index += 1 + # check for */ comment end + elif InComment and not DoubleSlashComment and ListFromStr[Index] == '*' and ListFromStr[Index+1] == '/': + ListFromStr[Index] = ' ' + Index += 1 + ListFromStr[Index] = ' ' + Index += 1 + InComment = False + # set comments to spaces + elif InComment: + ListFromStr[Index] = ' ' + Index += 1 + # check for // comment + elif ListFromStr[Index] == '/' and ListFromStr[Index+1] == '/' and ListFromStr[Index+2] != '\n': + InComment = True + DoubleSlashComment = True + + # check for /* comment start + elif ListFromStr[Index] == '/' and ListFromStr[Index+1] == '*': + ListFromStr[Index] = ' ' + Index += 1 + ListFromStr[Index] = ' ' + Index += 1 + InComment = True + else: + Index += 1 + + # restore from List to String + Str = "".join(ListFromStr) + Str = Str.rstrip(' ') + + return Str + +def GetFinalTypeValue(Type, FieldName, TypedefDict, SUDict): + Value = TypedefDict.get(Type) + if Value == None: + Value = SUDict.get(Type) + if Value == None: + return None + + LBPos = Value.find('{') + while LBPos == -1: + FTList = Value.split() + for FT in FTList: + if FT not in ('struct', 'union'): + Value = TypedefDict.get(FT) + if Value == None: + Value = SUDict.get(FT) + break + + if Value == None: + return None + + LBPos = Value.find('{') + +# RBPos = Value.find('}') + Fields = Value[LBPos + 1:] + Fields = StripComments(Fields) + FieldsList = Fields.split(';') + for Field in FieldsList: + Field = Field.strip() + Index = Field.rfind(FieldName) + if Index < 1: + continue + if not Field[Index - 1].isalnum(): + if Index + len(FieldName) == len(Field): + Type = GetDataTypeFromModifier(Field[0:Index]) + return Type.strip() + else: + # For the condition that the field in struct is an array with [] sufixes... + if not Field[Index + len(FieldName)].isalnum(): + Type = GetDataTypeFromModifier(Field[0:Index]) + return Type.strip() + + return None + +def GetRealType(Type, TypedefDict, TargetType = None): + if TargetType != None and Type == TargetType: + return Type + while TypedefDict.get(Type): + Type = TypedefDict.get(Type) + if TargetType != None and Type == TargetType: + return Type + return Type + +def GetTypeInfo(RefList, Modifier, FullFileName, TargetType = None): + TypedefDict = GetTypedefDict(FullFileName) + SUDict = GetSUDict(FullFileName) + Type = GetDataTypeFromModifier(Modifier).replace('*', '').strip() + + Type = Type.split()[-1] + Index = 0 + while Index < len(RefList): + FieldName = RefList[Index] + FromType = GetFinalTypeValue(Type, FieldName, TypedefDict, SUDict) + if FromType == None: + return None + # we want to determine the exact type. + if TargetType != None: + Type = FromType.split()[0] + # we only want to check if it is a pointer + else: + Type = FromType + if Type.find('*') != -1 and Index == len(RefList)-1: + return Type + Type = FromType.split()[0] + + Index += 1 + + Type = GetRealType(Type, TypedefDict, TargetType) + + return Type + +def GetVarInfo(PredVarList, FuncRecord, FullFileName, IsFuncCall = False, TargetType = None, StarList = None): + + PredVar = PredVarList[0] + FileID = GetTableID(FullFileName) + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + # search variable in include files + + # it is a function call, search function declarations and definitions + if IsFuncCall: + SqlStatement = """ select Modifier, ID + from %s + where Model = %d and Value = \'%s\' + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION, PredVar) + ResultSet = Db.TblFile.Exec(SqlStatement) + + for Result in ResultSet: + Type = GetDataTypeFromModifier(Result[0]).split()[-1] + TypedefDict = GetTypedefDict(FullFileName) + Type = GetRealType(Type, TypedefDict, TargetType) + return Type + + IncludeFileList = GetAllIncludeFiles(FullFileName) + for F in IncludeFileList: + FileID = GetTableID(F) + if FileID < 0: + continue + + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, ID + from %s + where Model = %d and Value = \'%s\' + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION, PredVar) + ResultSet = Db.TblFile.Exec(SqlStatement) + + for Result in ResultSet: + Type = GetDataTypeFromModifier(Result[0]).split()[-1] + TypedefDict = GetTypedefDict(FullFileName) + Type = GetRealType(Type, TypedefDict, TargetType) + return Type + + FileID = GetTableID(FullFileName) + SqlStatement = """ select Modifier, ID + from Function + where BelongsToFile = %d and Name = \'%s\' + """ % (FileID, PredVar) + ResultSet = Db.TblFile.Exec(SqlStatement) + + for Result in ResultSet: + Type = GetDataTypeFromModifier(Result[0]).split()[-1] + TypedefDict = GetTypedefDict(FullFileName) + Type = GetRealType(Type, TypedefDict, TargetType) + return Type + + for F in IncludeFileList: + FileID = GetTableID(F) + if FileID < 0: + continue + + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, ID + from Function + where BelongsToFile = %d and Name = \'%s\' + """ % (FileID, PredVar) + ResultSet = Db.TblFile.Exec(SqlStatement) + + for Result in ResultSet: + Type = GetDataTypeFromModifier(Result[0]).split()[-1] + TypedefDict = GetTypedefDict(FullFileName) + Type = GetRealType(Type, TypedefDict, TargetType) + return Type + + return None + + # really variable, search local variable first + SqlStatement = """ select Modifier, ID + from %s + where Model = %d and Name = \'%s\' and StartLine >= %d and StartLine <= %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_VARIABLE, PredVar, FuncRecord[0], FuncRecord[1]) + ResultSet = Db.TblFile.Exec(SqlStatement) + VarFound = False + for Result in ResultSet: + if len(PredVarList) > 1: + Type = GetTypeInfo(PredVarList[1:], Result[0], FullFileName, TargetType) + return Type + else: +# Type = GetDataTypeFromModifier(Result[0]).split()[-1] + TypeList = GetDataTypeFromModifier(Result[0]).split() + Type = TypeList[-1] + if len(TypeList) > 1 and StarList != None: + for Star in StarList: + Type = Type.strip() + Type = Type.rstrip(Star) + # Get real type after de-reference pointers. + if len(Type.strip()) == 0: + Type = TypeList[-2] + TypedefDict = GetTypedefDict(FullFileName) + Type = GetRealType(Type, TypedefDict, TargetType) + return Type + + # search function parameters second + ParamList = GetParamList(FuncRecord[2]) + for Param in ParamList: + if Param.Name.strip() == PredVar: + if len(PredVarList) > 1: + Type = GetTypeInfo(PredVarList[1:], Param.Modifier, FullFileName, TargetType) + return Type + else: + TypeList = GetDataTypeFromModifier(Param.Modifier).split() + Type = TypeList[-1] + if len(TypeList) > 1 and StarList != None: + for Star in StarList: + Type = Type.strip() + Type = Type.rstrip(Star) + # Get real type after de-reference pointers. + if len(Type.strip()) == 0: + Type = TypeList[-2] + TypedefDict = GetTypedefDict(FullFileName) + Type = GetRealType(Type, TypedefDict, TargetType) + return Type + + # search global variable next + SqlStatement = """ select Modifier, ID + from %s + where Model = %d and Name = \'%s\' and BelongsToFunction = -1 + """ % (FileTable, DataClass.MODEL_IDENTIFIER_VARIABLE, PredVar) + ResultSet = Db.TblFile.Exec(SqlStatement) + + for Result in ResultSet: + if len(PredVarList) > 1: + Type = GetTypeInfo(PredVarList[1:], Result[0], FullFileName, TargetType) + return Type + else: + TypeList = GetDataTypeFromModifier(Result[0]).split() + Type = TypeList[-1] + if len(TypeList) > 1 and StarList != None: + for Star in StarList: + Type = Type.strip() + Type = Type.rstrip(Star) + # Get real type after de-reference pointers. + if len(Type.strip()) == 0: + Type = TypeList[-2] + TypedefDict = GetTypedefDict(FullFileName) + Type = GetRealType(Type, TypedefDict, TargetType) + return Type + + IncludeFileList = GetAllIncludeFiles(FullFileName) + for F in IncludeFileList: + FileID = GetTableID(F) + if FileID < 0: + continue + + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, ID + from %s + where Model = %d and BelongsToFunction = -1 and Name = \'%s\' + """ % (FileTable, DataClass.MODEL_IDENTIFIER_VARIABLE, PredVar) + ResultSet = Db.TblFile.Exec(SqlStatement) + + for Result in ResultSet: + if len(PredVarList) > 1: + Type = GetTypeInfo(PredVarList[1:], Result[0], FullFileName, TargetType) + return Type + else: + TypeList = GetDataTypeFromModifier(Result[0]).split() + Type = TypeList[-1] + if len(TypeList) > 1 and StarList != None: + for Star in StarList: + Type = Type.strip() + Type = Type.rstrip(Star) + # Get real type after de-reference pointers. + if len(Type.strip()) == 0: + Type = TypeList[-2] + TypedefDict = GetTypedefDict(FullFileName) + Type = GetRealType(Type, TypedefDict, TargetType) + return Type + +def CheckFuncLayoutReturnType(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, ID, StartLine, StartColumn, EndLine, Value + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + ReturnType = GetDataTypeFromModifier(Result[0]) + TypeStart = ReturnType.split()[0] + FuncName = Result[5] + if EccGlobalData.gException.IsException(ERROR_C_FUNCTION_LAYOUT_CHECK_RETURN_TYPE, FuncName): + continue + Index = Result[0].find(TypeStart) + if Index != 0 or Result[3] != 0: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_RETURN_TYPE, '[%s] Return Type should appear at the start of line' % FuncName, FileTable, Result[1]) + + if Result[2] == Result[4]: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_RETURN_TYPE, '[%s] Return Type should appear on its own line' % FuncName, FileTable, Result[1]) + + SqlStatement = """ select Modifier, ID, StartLine, StartColumn, FunNameStartLine, Name + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + ReturnType = GetDataTypeFromModifier(Result[0]) + TypeStart = ReturnType.split()[0] + FuncName = Result[5] + if EccGlobalData.gException.IsException(ERROR_C_FUNCTION_LAYOUT_CHECK_RETURN_TYPE, FuncName): + continue + Index = Result[0].find(ReturnType) + if Index != 0 or Result[3] != 0: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_RETURN_TYPE, '[%s] Return Type should appear at the start of line' % FuncName, 'Function', Result[1]) + + if Result[2] == Result[4]: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_RETURN_TYPE, '[%s] Return Type should appear on its own line' % FuncName, 'Function', Result[1]) + +def CheckFuncLayoutModifier(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + ReturnType = GetDataTypeFromModifier(Result[0]) + TypeStart = ReturnType.split()[0] +# if len(ReturnType) == 0: +# continue + Index = Result[0].find(TypeStart) + if Index != 0: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_OPTIONAL_FUNCTIONAL_MODIFIER, '', FileTable, Result[1]) + + SqlStatement = """ select Modifier, ID + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + ReturnType = GetDataTypeFromModifier(Result[0]) + TypeStart = ReturnType.split()[0] +# if len(ReturnType) == 0: +# continue + Index = Result[0].find(TypeStart) + if Index != 0: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_OPTIONAL_FUNCTIONAL_MODIFIER, '', 'Function', Result[1]) + +def CheckFuncLayoutName(FullFileName): + ErrorMsgList = [] + # Parameter variable format pattern. + Pattern = re.compile(r'^[A-Z]+\S*[a-z]\S*$') + ParamIgnoreList = ('VOID', '...') + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Name, ID, EndColumn, Value + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + FuncName = Result[3] + if EccGlobalData.gException.IsException(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, FuncName): + continue + if Result[2] != 0: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, 'Function name [%s] should appear at the start of a line' % FuncName, FileTable, Result[1]) + ParamList = GetParamList(Result[0]) + if len(ParamList) == 0: + continue + StartLine = 0 + for Param in ParamList: + if Param.StartLine <= StartLine: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, 'Parameter %s should be in its own line.' % Param.Name, FileTable, Result[1]) + if Param.StartLine - StartLine > 1: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, 'Empty line appears before Parameter %s.' % Param.Name, FileTable, Result[1]) + if not Pattern.match(Param.Name) and not Param.Name in ParamIgnoreList and not EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, Param.Name): + PrintErrorMsg(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, 'Parameter [%s] NOT follow naming convention.' % Param.Name, FileTable, Result[1]) + StartLine = Param.StartLine + + if not Result[0].endswith('\n )') and not Result[0].endswith('\r )'): + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, '\')\' should be on a new line and indented two spaces', FileTable, Result[1]) + + SqlStatement = """ select Modifier, ID, FunNameStartColumn, Name + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + FuncName = Result[3] + if EccGlobalData.gException.IsException(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, FuncName): + continue + if Result[2] != 0: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, 'Function name [%s] should appear at the start of a line' % FuncName, 'Function', Result[1]) + ParamList = GetParamList(Result[0]) + if len(ParamList) == 0: + continue + StartLine = 0 + for Param in ParamList: + if Param.StartLine <= StartLine: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, 'Parameter %s should be in its own line.' % Param.Name, 'Function', Result[1]) + if Param.StartLine - StartLine > 1: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, 'Empty line appears before Parameter %s.' % Param.Name, 'Function', Result[1]) + if not Pattern.match(Param.Name) and not Param.Name in ParamIgnoreList and not EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, Param.Name): + PrintErrorMsg(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, 'Parameter [%s] NOT follow naming convention.' % Param.Name, FileTable, Result[1]) + StartLine = Param.StartLine + if not Result[0].endswith('\n )') and not Result[0].endswith('\r )'): + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_NAME, '\')\' should be on a new line and indented two spaces', 'Function', Result[1]) + +def CheckFuncLayoutPrototype(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + FileTable = 'Identifier' + str(FileID) + Db = GetDB() + SqlStatement = """ select Modifier, Header, Name, ID + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + return ErrorMsgList + + FuncDefList = [] + for Result in ResultSet: + FuncDefList.append(Result) + + SqlStatement = """ select Modifier, Name, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION) + ResultSet = Db.TblFile.Exec(SqlStatement) + FuncDeclList = [] + for Result in ResultSet: + FuncDeclList.append(Result) + + UndeclFuncList = [] + for FuncDef in FuncDefList: + FuncName = FuncDef[2].strip() + FuncModifier = FuncDef[0] + FuncDefHeader = FuncDef[1] + for FuncDecl in FuncDeclList: + LBPos = FuncDecl[1].find('(') + DeclName = FuncDecl[1][0:LBPos].strip() + DeclModifier = FuncDecl[0] + if DeclName == FuncName: + if DiffModifier(FuncModifier, DeclModifier) and not EccGlobalData.gException.IsException(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE, FuncName): + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE, 'Function [%s] modifier different with prototype.' % FuncName, 'Function', FuncDef[3]) + ParamListOfDef = GetParamList(FuncDefHeader) + ParamListOfDecl = GetParamList(FuncDecl[1]) + if len(ParamListOfDef) != len(ParamListOfDecl): + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE, 'Parameter number different.', 'Function', FuncDef[3]) + break + + Index = 0 + while Index < len(ParamListOfDef): + if DiffModifier(ParamListOfDef[Index].Modifier, ParamListOfDecl[Index].Modifier): + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE, 'Parameter %s has different modifier with prototype.' % ParamListOfDef[Index].Name, 'Function', FuncDef[3]) + Index += 1 + break + else: + UndeclFuncList.append(FuncDef) + + IncludeFileList = GetAllIncludeFiles(FullFileName) + FuncDeclList = [] + for F in IncludeFileList: + FileID = GetTableID(F, ErrorMsgList) + if FileID < 0: + continue + + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, Name, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION) + ResultSet = Db.TblFile.Exec(SqlStatement) + + for Result in ResultSet: + FuncDeclList.append(Result) + + for FuncDef in UndeclFuncList: + FuncName = FuncDef[2].strip() + FuncModifier = FuncDef[0] + FuncDefHeader = FuncDef[1] + for FuncDecl in FuncDeclList: + LBPos = FuncDecl[1].find('(') + DeclName = FuncDecl[1][0:LBPos].strip() + DeclModifier = FuncDecl[0] + if DeclName == FuncName: + if DiffModifier(FuncModifier, DeclModifier) and not EccGlobalData.gException.IsException(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE, FuncName): + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE, 'Function [%s] modifier different with prototype.' % FuncName, 'Function', FuncDef[3]) + ParamListOfDef = GetParamList(FuncDefHeader) + ParamListOfDecl = GetParamList(FuncDecl[1]) + if len(ParamListOfDef) != len(ParamListOfDecl): + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE, 'Parameter number different.', 'Function', FuncDef[3]) + break + + Index = 0 + while Index < len(ParamListOfDef): + if DiffModifier(ParamListOfDef[Index].Modifier, ParamListOfDecl[Index].Modifier): + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_PROTO_TYPE, 'Parameter %s has different modifier with prototype.' % ParamListOfDef[Index].Name, 'Function', FuncDef[3]) + Index += 1 + break + +def CheckFuncLayoutBody(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + FileTable = 'Identifier' + str(FileID) + Db = GetDB() + SqlStatement = """ select BodyStartColumn, EndColumn, ID + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + return ErrorMsgList + for Result in ResultSet: + if Result[0] != 0: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_BODY, 'open brace should be at the very beginning of a line.', 'Function', Result[2]) + if Result[1] != 0: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_FUNCTION_BODY, 'close brace should be at the very beginning of a line.', 'Function', Result[2]) + +def CheckFuncLayoutLocalVariable(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select ID + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + return ErrorMsgList + FL = [] + for Result in ResultSet: + FL.append(Result) + + for F in FL: + SqlStatement = """ select Name, Value, ID + from %s + where Model = %d and BelongsToFunction = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_VARIABLE, F[0]) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + continue + + for Result in ResultSet: + if len(Result[1]) > 0: + PrintErrorMsg(ERROR_C_FUNCTION_LAYOUT_CHECK_NO_INIT_OF_VARIABLE, 'Variable Name: %s' % Result[0], FileTable, Result[2]) + +def CheckMemberVariableFormat(Name, Value, FileTable, TdId, ModelId): + ErrMsgList = [] + # Member variable format pattern. + Pattern = re.compile(r'^[A-Z]+\S*[a-z]\S*$') + + LBPos = Value.find('{') + RBPos = Value.rfind('}') + if LBPos == -1 or RBPos == -1: + return ErrMsgList + + Fields = Value[LBPos + 1 : RBPos] + Fields = StripComments(Fields).strip() + NestPos = Fields.find ('struct') + if NestPos != -1 and (NestPos + len('struct') < len(Fields)): + if not Fields[NestPos + len('struct') + 1].isalnum(): + if not EccGlobalData.gException.IsException(ERROR_DECLARATION_DATA_TYPE_CHECK_NESTED_STRUCTURE, Name): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_NESTED_STRUCTURE, 'Nested struct in [%s].' % (Name), FileTable, TdId) + return ErrMsgList + NestPos = Fields.find ('union') + if NestPos != -1 and (NestPos + len('union') < len(Fields)): + if not Fields[NestPos + len('union') + 1].isalnum(): + if not EccGlobalData.gException.IsException(ERROR_DECLARATION_DATA_TYPE_CHECK_NESTED_STRUCTURE, Name): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_NESTED_STRUCTURE, 'Nested union in [%s].' % (Name), FileTable, TdId) + return ErrMsgList + NestPos = Fields.find ('enum') + if NestPos != -1 and (NestPos + len('enum') < len(Fields)): + if not Fields[NestPos + len('enum') + 1].isalnum(): + if not EccGlobalData.gException.IsException(ERROR_DECLARATION_DATA_TYPE_CHECK_NESTED_STRUCTURE, Name): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_NESTED_STRUCTURE, 'Nested enum in [%s].' % (Name), FileTable, TdId) + return ErrMsgList + + if ModelId == DataClass.MODEL_IDENTIFIER_ENUMERATE: + FieldsList = Fields.split(',') + # deal with enum is pre-assigned a value by function call ( , , , ...) + QuoteCount = 0 + Index = 0 + RemoveCurrentElement = False + while Index < len(FieldsList): + Field = FieldsList[Index] + + if Field.find('(') != -1: + QuoteCount += 1 + RemoveCurrentElement = True + Index += 1 + continue + + if Field.find(')') != -1 and QuoteCount > 0: + QuoteCount -= 1 + + if RemoveCurrentElement: + FieldsList.remove(Field) + if QuoteCount == 0: + RemoveCurrentElement = False + continue + + if QuoteCount == 0: + RemoveCurrentElement = False + + Index += 1 + else: + FieldsList = Fields.split(';') + + for Field in FieldsList: + Field = Field.strip() + if Field == '': + continue + # For the condition that the field in struct is an array with [] sufixes... + if Field[-1] == ']': + LBPos = Field.find('[') + Field = Field[0:LBPos] + # For the condition that bit field ": Number" + if Field.find(':') != -1: + ColonPos = Field.find(':') + Field = Field[0:ColonPos] + + Field = Field.strip() + if Field == '': + continue + # Enum could directly assign value to variable + Field = Field.split('=')[0].strip() + TokenList = Field.split() + # Remove pointers before variable + if not Pattern.match(TokenList[-1].lstrip('*')): + ErrMsgList.append(TokenList[-1].lstrip('*')) + + return ErrMsgList + +def CheckDeclTypedefFormat(FullFileName, ModelId): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Name, StartLine, EndLine, ID, Value + from %s + where Model = %d + """ % (FileTable, ModelId) + ResultSet = Db.TblFile.Exec(SqlStatement) + ResultList = [] + for Result in ResultSet: + ResultList.append(Result) + + ErrorType = ERROR_DECLARATION_DATA_TYPE_CHECK_ALL + if ModelId == DataClass.MODEL_IDENTIFIER_STRUCTURE: + ErrorType = ERROR_DECLARATION_DATA_TYPE_CHECK_STRUCTURE_DECLARATION + elif ModelId == DataClass.MODEL_IDENTIFIER_ENUMERATE: + ErrorType = ERROR_DECLARATION_DATA_TYPE_CHECK_ENUMERATED_TYPE + elif ModelId == DataClass.MODEL_IDENTIFIER_UNION: + ErrorType = ERROR_DECLARATION_DATA_TYPE_CHECK_UNION_TYPE + + SqlStatement = """ select Modifier, Name, Value, StartLine, EndLine, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_TYPEDEF) + TdSet = Db.TblFile.Exec(SqlStatement) + TdList = [] + for Td in TdSet: + TdList.append(Td) + # Check member variable name format that from typedefs of ONLY this file. + for Td in TdList: + Name = Td[1].strip() + Value = Td[2].strip() + if Value.startswith('enum'): + ValueModelId = DataClass.MODEL_IDENTIFIER_ENUMERATE + elif Value.startswith('struct'): + ValueModelId = DataClass.MODEL_IDENTIFIER_STRUCTURE + elif Value.startswith('union'): + ValueModelId = DataClass.MODEL_IDENTIFIER_UNION + else: + continue + + if ValueModelId != ModelId: + continue + # Check member variable format. + ErrMsgList = CheckMemberVariableFormat(Name, Value, FileTable, Td[5], ModelId) + for ErrMsg in ErrMsgList: + if EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, Name+'.'+ErrMsg): + continue + PrintErrorMsg(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, 'Member variable [%s] NOT follow naming convention.' % (Name+'.'+ErrMsg), FileTable, Td[5]) + + # First check in current file to see whether struct/union/enum is typedef-ed. + UntypedefedList = [] + for Result in ResultList: + # Check member variable format. + Name = Result[0].strip() + Value = Result[4].strip() + if Value.startswith('enum'): + ValueModelId = DataClass.MODEL_IDENTIFIER_ENUMERATE + elif Value.startswith('struct'): + ValueModelId = DataClass.MODEL_IDENTIFIER_STRUCTURE + elif Value.startswith('union'): + ValueModelId = DataClass.MODEL_IDENTIFIER_UNION + else: + continue + + if ValueModelId != ModelId: + continue + ErrMsgList = CheckMemberVariableFormat(Name, Value, FileTable, Result[3], ModelId) + for ErrMsg in ErrMsgList: + if EccGlobalData.gException.IsException(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, Result[0]+'.'+ErrMsg): + continue + PrintErrorMsg(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, 'Member variable [%s] NOT follow naming convention.' % (Result[0]+'.'+ErrMsg), FileTable, Result[3]) + # Check whether it is typedefed. + Found = False + for Td in TdList: + # skip function pointer + if len(Td[0]) > 0: + continue + if Result[1] >= Td[3] and Td[4] >= Result[2]: + Found = True + if not Td[1].isupper(): + PrintErrorMsg(ErrorType, 'Typedef should be UPPER case', FileTable, Td[5]) + if Result[0] in Td[2].split(): + Found = True + if not Td[1].isupper(): + PrintErrorMsg(ErrorType, 'Typedef should be UPPER case', FileTable, Td[5]) + if Found: + break + + if not Found: + UntypedefedList.append(Result) + continue + + if len(UntypedefedList) == 0: + return + + IncludeFileList = GetAllIncludeFiles(FullFileName) + TdList = [] + for F in IncludeFileList: + FileID = GetTableID(F, ErrorMsgList) + if FileID < 0: + continue + + IncludeFileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, Name, Value, StartLine, EndLine, ID + from %s + where Model = %d + """ % (IncludeFileTable, DataClass.MODEL_IDENTIFIER_TYPEDEF) + ResultSet = Db.TblFile.Exec(SqlStatement) + TdList.extend(ResultSet) + + for Result in UntypedefedList: + + # Check whether it is typedefed. + Found = False + for Td in TdList: + + if len(Td[0]) > 0: + continue + if Result[1] >= Td[3] and Td[4] >= Result[2]: + Found = True + if not Td[1].isupper(): + PrintErrorMsg(ErrorType, 'Typedef should be UPPER case', FileTable, Td[5]) + if Result[0] in Td[2].split(): + Found = True + if not Td[1].isupper(): + PrintErrorMsg(ErrorType, 'Typedef should be UPPER case', FileTable, Td[5]) + if Found: + break + + if not Found: + PrintErrorMsg(ErrorType, 'No Typedef for %s' % Result[0], FileTable, Result[3]) + continue + +def CheckDeclStructTypedef(FullFileName): + CheckDeclTypedefFormat(FullFileName, DataClass.MODEL_IDENTIFIER_STRUCTURE) + +def CheckDeclEnumTypedef(FullFileName): + CheckDeclTypedefFormat(FullFileName, DataClass.MODEL_IDENTIFIER_ENUMERATE) + +def CheckDeclUnionTypedef(FullFileName): + CheckDeclTypedefFormat(FullFileName, DataClass.MODEL_IDENTIFIER_UNION) + +def CheckDeclArgModifier(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, Name, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_VARIABLE) + ResultSet = Db.TblFile.Exec(SqlStatement) + ModifierTuple = ('IN', 'OUT', 'OPTIONAL', 'UNALIGNED') + MAX_MODIFIER_LENGTH = 100 + for Result in ResultSet: + for Modifier in ModifierTuple: + if PatternInModifier(Result[0], Modifier) and len(Result[0]) < MAX_MODIFIER_LENGTH: + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_IN_OUT_MODIFIER, 'Variable Modifier %s' % Result[0], FileTable, Result[2]) + break + + SqlStatement = """ select Modifier, Name, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + for Modifier in ModifierTuple: + if PatternInModifier(Result[0], Modifier): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_IN_OUT_MODIFIER, 'Return Type Modifier %s' % Result[0], FileTable, Result[2]) + break + + SqlStatement = """ select Modifier, Header, ID + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + for Modifier in ModifierTuple: + if PatternInModifier(Result[0], Modifier): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_IN_OUT_MODIFIER, 'Return Type Modifier %s' % Result[0], FileTable, Result[2]) + break + +def CheckDeclNoUseCType(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Modifier, Name, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_VARIABLE) + ResultSet = Db.TblFile.Exec(SqlStatement) + CTypeTuple = ('int', 'unsigned', 'char', 'void', 'static', 'long') + for Result in ResultSet: + for Type in CTypeTuple: + if PatternInModifier(Result[0], Type): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_NO_USE_C_TYPE, 'Variable type %s' % Type, FileTable, Result[2]) + break + + SqlStatement = """ select Modifier, Name, ID, Value + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + ParamList = GetParamList(Result[1]) + FuncName = Result[3] + if EccGlobalData.gException.IsException(ERROR_DECLARATION_DATA_TYPE_CHECK_NO_USE_C_TYPE, FuncName): + continue + for Type in CTypeTuple: + if PatternInModifier(Result[0], Type): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_NO_USE_C_TYPE, '%s Return type %s' % (FuncName, Result[0]), FileTable, Result[2]) + + for Param in ParamList: + if PatternInModifier(Param.Modifier, Type): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_NO_USE_C_TYPE, 'Parameter %s' % Param.Name, FileTable, Result[2]) + + SqlStatement = """ select Modifier, Header, ID, Name + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + ParamList = GetParamList(Result[1]) + FuncName = Result[3] + if EccGlobalData.gException.IsException(ERROR_DECLARATION_DATA_TYPE_CHECK_NO_USE_C_TYPE, FuncName): + continue + for Type in CTypeTuple: + if PatternInModifier(Result[0], Type): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_NO_USE_C_TYPE, '[%s] Return type %s' % (FuncName, Result[0]), FileTable, Result[2]) + + for Param in ParamList: + if PatternInModifier(Param.Modifier, Type): + PrintErrorMsg(ERROR_DECLARATION_DATA_TYPE_CHECK_NO_USE_C_TYPE, 'Parameter %s' % Param.Name, FileTable, Result[2]) + + +def CheckPointerNullComparison(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + # cache the found function return type to accelerate later checking in this file. + FuncReturnTypeDict = {} + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Value, StartLine, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_PREDICATE_EXPRESSION) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + return + PSL = [] + for Result in ResultSet: + PSL.append([Result[0], Result[1], Result[2]]) + + SqlStatement = """ select BodyStartLine, EndLine, Header, Modifier, ID + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + FL = [] + for Result in ResultSet: + FL.append([Result[0], Result[1], Result[2], Result[3], Result[4]]) + + p = GetFuncDeclPattern() + for Str in PSL: + FuncRecord = GetFuncContainsPE(Str[1], FL) + if FuncRecord == None: + continue + + for Exp in GetPredicateListFromPredicateExpStr(Str[0]): + PredInfo = SplitPredicateStr(Exp) + if PredInfo[1] == None: + PredVarStr = PredInfo[0][0].strip() + IsFuncCall = False + SearchInCache = False + # PredVarStr may contain '.' or '->' + TmpStr = PredVarStr.replace('.', '').replace('->', '') + if p.match(TmpStr): + PredVarStr = PredVarStr[0:PredVarStr.find('(')] + SearchInCache = True + # Only direct function call using IsFuncCall branch. Multi-level ref. function call is considered a variable. + if TmpStr.startswith(PredVarStr): + IsFuncCall = True + + if PredVarStr.strip() in IgnoredKeywordList: + continue + StarList = [] + PredVarList = GetCNameList(PredVarStr, StarList) + # No variable found, maybe value first? like (0 == VarName) + if len(PredVarList) == 0: + continue + if SearchInCache: + Type = FuncReturnTypeDict.get(PredVarStr) + if Type != None: + if Type.find('*') != -1: + PrintErrorMsg(ERROR_PREDICATE_EXPRESSION_CHECK_COMPARISON_NULL_TYPE, 'Predicate Expression: %s' % Exp, FileTable, Str[2]) + continue + + if PredVarStr in FuncReturnTypeDict: + continue + + Type = GetVarInfo(PredVarList, FuncRecord, FullFileName, IsFuncCall, None, StarList) + if SearchInCache: + FuncReturnTypeDict[PredVarStr] = Type + if Type == None: + continue + if Type.find('*') != -1: + PrintErrorMsg(ERROR_PREDICATE_EXPRESSION_CHECK_COMPARISON_NULL_TYPE, 'Predicate Expression: %s' % Exp, FileTable, Str[2]) + +def CheckNonBooleanValueComparison(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + # cache the found function return type to accelerate later checking in this file. + FuncReturnTypeDict = {} + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Value, StartLine, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_PREDICATE_EXPRESSION) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + return + PSL = [] + for Result in ResultSet: + PSL.append([Result[0], Result[1], Result[2]]) + + SqlStatement = """ select BodyStartLine, EndLine, Header, Modifier, ID + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + FL = [] + for Result in ResultSet: + FL.append([Result[0], Result[1], Result[2], Result[3], Result[4]]) + + p = GetFuncDeclPattern() + for Str in PSL: + FuncRecord = GetFuncContainsPE(Str[1], FL) + if FuncRecord == None: + continue + + for Exp in GetPredicateListFromPredicateExpStr(Str[0]): +# if p.match(Exp): +# continue + PredInfo = SplitPredicateStr(Exp) + if PredInfo[1] == None: + PredVarStr = PredInfo[0][0].strip() + IsFuncCall = False + SearchInCache = False + # PredVarStr may contain '.' or '->' + TmpStr = PredVarStr.replace('.', '').replace('->', '') + if p.match(TmpStr): + PredVarStr = PredVarStr[0:PredVarStr.find('(')] + SearchInCache = True + # Only direct function call using IsFuncCall branch. Multi-level ref. function call is considered a variable. + if TmpStr.startswith(PredVarStr): + IsFuncCall = True + + if PredVarStr.strip() in IgnoredKeywordList: + continue + StarList = [] + PredVarList = GetCNameList(PredVarStr, StarList) + # No variable found, maybe value first? like (0 == VarName) + if len(PredVarList) == 0: + continue + + if SearchInCache: + Type = FuncReturnTypeDict.get(PredVarStr) + if Type != None: + if Type.find('BOOLEAN') == -1: + PrintErrorMsg(ERROR_PREDICATE_EXPRESSION_CHECK_NO_BOOLEAN_OPERATOR, 'Predicate Expression: %s' % Exp, FileTable, Str[2]) + continue + + if PredVarStr in FuncReturnTypeDict: + continue + + Type = GetVarInfo(PredVarList, FuncRecord, FullFileName, IsFuncCall, 'BOOLEAN', StarList) + if SearchInCache: + FuncReturnTypeDict[PredVarStr] = Type + if Type == None: + continue + if Type.find('BOOLEAN') == -1: + PrintErrorMsg(ERROR_PREDICATE_EXPRESSION_CHECK_NO_BOOLEAN_OPERATOR, 'Predicate Expression: %s' % Exp, FileTable, Str[2]) + + +def CheckBooleanValueComparison(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + # cache the found function return type to accelerate later checking in this file. + FuncReturnTypeDict = {} + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Value, StartLine, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_PREDICATE_EXPRESSION) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + return + PSL = [] + for Result in ResultSet: + PSL.append([Result[0], Result[1], Result[2]]) + + SqlStatement = """ select BodyStartLine, EndLine, Header, Modifier, ID + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + FL = [] + for Result in ResultSet: + FL.append([Result[0], Result[1], Result[2], Result[3], Result[4]]) + + p = GetFuncDeclPattern() + for Str in PSL: + FuncRecord = GetFuncContainsPE(Str[1], FL) + if FuncRecord == None: + continue + + for Exp in GetPredicateListFromPredicateExpStr(Str[0]): + PredInfo = SplitPredicateStr(Exp) + if PredInfo[1] in ('==', '!=') and PredInfo[0][1] in ('TRUE', 'FALSE'): + PredVarStr = PredInfo[0][0].strip() + IsFuncCall = False + SearchInCache = False + # PredVarStr may contain '.' or '->' + TmpStr = PredVarStr.replace('.', '').replace('->', '') + if p.match(TmpStr): + PredVarStr = PredVarStr[0:PredVarStr.find('(')] + SearchInCache = True + # Only direct function call using IsFuncCall branch. Multi-level ref. function call is considered a variable. + if TmpStr.startswith(PredVarStr): + IsFuncCall = True + + if PredVarStr.strip() in IgnoredKeywordList: + continue + StarList = [] + PredVarList = GetCNameList(PredVarStr, StarList) + # No variable found, maybe value first? like (0 == VarName) + if len(PredVarList) == 0: + continue + + if SearchInCache: + Type = FuncReturnTypeDict.get(PredVarStr) + if Type != None: + if Type.find('BOOLEAN') != -1: + PrintErrorMsg(ERROR_PREDICATE_EXPRESSION_CHECK_BOOLEAN_VALUE, 'Predicate Expression: %s' % Exp, FileTable, Str[2]) + continue + + if PredVarStr in FuncReturnTypeDict: + continue + + Type = GetVarInfo(PredVarList, FuncRecord, FullFileName, IsFuncCall, 'BOOLEAN', StarList) + if SearchInCache: + FuncReturnTypeDict[PredVarStr] = Type + if Type == None: + continue + if Type.find('BOOLEAN') != -1: + PrintErrorMsg(ERROR_PREDICATE_EXPRESSION_CHECK_BOOLEAN_VALUE, 'Predicate Expression: %s' % Exp, FileTable, Str[2]) + + +def CheckHeaderFileData(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select ID, Modifier + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_VARIABLE) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + if not Result[1].startswith('extern'): + PrintErrorMsg(ERROR_INCLUDE_FILE_CHECK_DATA, 'Variable definition appears in header file', FileTable, Result[0]) + + SqlStatement = """ select ID + from Function + where BelongsToFile = %d + """ % FileID + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + PrintErrorMsg(ERROR_INCLUDE_FILE_CHECK_DATA, 'Function definition appears in header file', 'Function', Result[0]) + + return ErrorMsgList + +def CheckHeaderFileIfndef(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Value, StartLine + from %s + where Model = %d order by StartLine + """ % (FileTable, DataClass.MODEL_IDENTIFIER_MACRO_IFNDEF) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + PrintErrorMsg(ERROR_INCLUDE_FILE_CHECK_IFNDEF_STATEMENT_1, '', 'File', FileID) + return ErrorMsgList + for Result in ResultSet: + SqlStatement = """ select Value, EndLine + from %s + where EndLine < %d + """ % (FileTable, Result[1]) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + if not Result[0].startswith('/*') and not Result[0].startswith('//'): + PrintErrorMsg(ERROR_INCLUDE_FILE_CHECK_IFNDEF_STATEMENT_2, '', 'File', FileID) + break + + SqlStatement = """ select Value + from %s + where StartLine > (select max(EndLine) from %s where Model = %d) + """ % (FileTable, FileTable, DataClass.MODEL_IDENTIFIER_MACRO_ENDIF) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + if not Result[0].startswith('/*') and not Result[0].startswith('//'): + PrintErrorMsg(ERROR_INCLUDE_FILE_CHECK_IFNDEF_STATEMENT_3, '', 'File', FileID) + return ErrorMsgList + +def CheckDoxygenCommand(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Value, ID + from %s + where Model = %d or Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_COMMENT, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER) + ResultSet = Db.TblFile.Exec(SqlStatement) + DoxygenCommandList = ['bug', 'todo', 'example', 'file', 'attention', 'param', 'post', 'pre', 'retval', 'return', 'sa', 'since', 'test', 'note', 'par'] + for Result in ResultSet: + CommentStr = Result[0] + CommentPartList = CommentStr.split() + for Part in CommentPartList: + if Part.upper() == 'BUGBUG': + PrintErrorMsg(ERROR_DOXYGEN_CHECK_COMMAND, 'Bug should be marked with doxygen tag @bug', FileTable, Result[1]) + if Part.upper() == 'TODO': + PrintErrorMsg(ERROR_DOXYGEN_CHECK_COMMAND, 'ToDo should be marked with doxygen tag @todo', FileTable, Result[1]) + if Part.startswith('@'): + if EccGlobalData.gException.IsException(ERROR_DOXYGEN_CHECK_COMMAND, Part): + continue + if Part.lstrip('@').isalpha(): + if Part.lstrip('@') not in DoxygenCommandList: + PrintErrorMsg(ERROR_DOXYGEN_CHECK_COMMAND, 'Unknown doxygen command %s' % Part, FileTable, Result[1]) + else: + Index = Part.find('[') + if Index == -1: + PrintErrorMsg(ERROR_DOXYGEN_CHECK_COMMAND, 'Unknown doxygen command %s' % Part, FileTable, Result[1]) + RealCmd = Part[1:Index] + if RealCmd not in DoxygenCommandList: + PrintErrorMsg(ERROR_DOXYGEN_CHECK_COMMAND, 'Unknown doxygen command %s' % Part, FileTable, Result[1]) + + +def CheckDoxygenTripleForwardSlash(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + + SqlStatement = """ select ID, BodyStartLine, BodyStartColumn, EndLine, EndColumn + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + return + + FuncDefSet = [] + for Result in ResultSet: + FuncDefSet.append(Result) + + + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Value, ID, StartLine, StartColumn, EndLine, EndColumn + from %s + where Model = %d + + """ % (FileTable, DataClass.MODEL_IDENTIFIER_COMMENT) + ResultSet = Db.TblFile.Exec(SqlStatement) + CommentSet = [] + try: + for Result in ResultSet: + CommentSet.append(Result) + except: + print 'Unrecognized chars in comment of file %s', FullFileName + + + for Result in CommentSet: + CommentStr = Result[0] + StartLine = Result[2] + StartColumn = Result[3] + EndLine = Result[4] + EndColumn = Result[5] + if not CommentStr.startswith('///<'): + continue + + Found = False + for FuncDef in FuncDefSet: + if StartLine == FuncDef[1] and StartColumn > FuncDef[2] and EndLine == FuncDef[3] and EndColumn < FuncDef[4]: + Found = True + break + if StartLine > FuncDef[1] and EndLine < FuncDef[3]: + Found = True + break + if StartLine == FuncDef[1] and StartColumn > FuncDef[2] and EndLine < FuncDef[3]: + Found = True + break + if StartLine > FuncDef[1] and EndLine == FuncDef[3] and EndColumn < FuncDef[4]: + Found = True + break + if Found: + PrintErrorMsg(ERROR_DOXYGEN_CHECK_COMMENT_FORMAT, '', FileTable, Result[1]) + + +def CheckFileHeaderDoxygenComments(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Value, ID + from %s + where Model = %d and StartLine = 1 and StartColumn = 0 + """ % (FileTable, DataClass.MODEL_IDENTIFIER_COMMENT) + ResultSet = Db.TblFile.Exec(SqlStatement) + if len(ResultSet) == 0: + PrintErrorMsg(ERROR_HEADER_CHECK_FILE, 'No Comment appear at the very beginning of file.', 'File', FileID) + return ErrorMsgList + + for Result in ResultSet: + CommentStr = Result[0] + if not CommentStr.startswith('/** @file'): + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FILE_HEADER, 'File header comment should begin with ""/** @file""', FileTable, Result[1]) + if not CommentStr.endswith('**/'): + PrintErrorMsg(ERROR_HEADER_CHECK_FILE, 'File header comment should end with **/', FileTable, Result[1]) + if CommentStr.find('.') == -1: + PrintErrorMsg(ERROR_DOXYGEN_CHECK_COMMENT_DESCRIPTION, 'Comment description should end with period \'.\'', FileTable, Result[1]) + +def CheckFuncHeaderDoxygenComments(FullFileName): + ErrorMsgList = [] + + FileID = GetTableID(FullFileName, ErrorMsgList) + if FileID < 0: + return ErrorMsgList + + Db = GetDB() + FileTable = 'Identifier' + str(FileID) + SqlStatement = """ select Value, StartLine, EndLine, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_COMMENT) + + ResultSet = Db.TblFile.Exec(SqlStatement) + CommentSet = [] + try: + for Result in ResultSet: + CommentSet.append(Result) + except: + print 'Unrecognized chars in comment of file %s', FullFileName + + # Func Decl check + SqlStatement = """ select Modifier, Name, StartLine, ID, Value + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_DECLARATION) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + FuncName = Result[4] + FunctionHeaderComment = CheckCommentImmediatelyPrecedeFunctionHeader(Result[1], Result[2], CommentSet) + if FunctionHeaderComment: + CheckFunctionHeaderConsistentWithDoxygenComment(Result[0], Result[1], Result[2], FunctionHeaderComment[0], FunctionHeaderComment[1], ErrorMsgList, FunctionHeaderComment[3], FileTable) + else: + if EccGlobalData.gException.IsException(ERROR_HEADER_CHECK_FUNCTION, FuncName): + continue + ErrorMsgList.append('Line %d :Function %s has NO comment immediately preceding it.' % (Result[2], Result[1])) + PrintErrorMsg(ERROR_HEADER_CHECK_FUNCTION, 'Function [%s] has NO comment immediately preceding it.' % (FuncName), FileTable, Result[3]) + + # Func Def check + SqlStatement = """ select Value, StartLine, EndLine, ID + from %s + where Model = %d + """ % (FileTable, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER) + + ResultSet = Db.TblFile.Exec(SqlStatement) + CommentSet = [] + try: + for Result in ResultSet: + CommentSet.append(Result) + except: + print 'Unrecognized chars in comment of file %s', FullFileName + + SqlStatement = """ select Modifier, Header, StartLine, ID, Name + from Function + where BelongsToFile = %d + """ % (FileID) + ResultSet = Db.TblFile.Exec(SqlStatement) + for Result in ResultSet: + FuncName = Result[4] + FunctionHeaderComment = CheckCommentImmediatelyPrecedeFunctionHeader(Result[1], Result[2], CommentSet) + if FunctionHeaderComment: + CheckFunctionHeaderConsistentWithDoxygenComment(Result[0], Result[1], Result[2], FunctionHeaderComment[0], FunctionHeaderComment[1], ErrorMsgList, FunctionHeaderComment[3], FileTable) + else: + if EccGlobalData.gException.IsException(ERROR_HEADER_CHECK_FUNCTION, FuncName): + continue + ErrorMsgList.append('Line %d :Function [%s] has NO comment immediately preceding it.' % (Result[2], Result[1])) + PrintErrorMsg(ERROR_HEADER_CHECK_FUNCTION, 'Function [%s] has NO comment immediately preceding it.' % (FuncName), 'Function', Result[3]) + return ErrorMsgList + +def CheckCommentImmediatelyPrecedeFunctionHeader(FuncName, FuncStartLine, CommentSet): + + for Comment in CommentSet: + if Comment[2] == FuncStartLine - 1: + return Comment + return None + +def GetDoxygenStrFromComment(Str): + DoxygenStrList = [] + ParamTagList = Str.split('@param') + if len(ParamTagList) > 1: + i = 1 + while i < len(ParamTagList): + DoxygenStrList.append('@param' + ParamTagList[i]) + i += 1 + + Str = ParamTagList[0] + + RetvalTagList = ParamTagList[-1].split('@retval') + if len(RetvalTagList) > 1: + if len(ParamTagList) > 1: + DoxygenStrList[-1] = '@param' + RetvalTagList[0] + i = 1 + while i < len(RetvalTagList): + DoxygenStrList.append('@retval' + RetvalTagList[i]) + i += 1 + + ReturnTagList = RetvalTagList[-1].split('@return') + if len(ReturnTagList) > 1: + if len(RetvalTagList) > 1: + DoxygenStrList[-1] = '@retval' + ReturnTagList[0] + elif len(ParamTagList) > 1: + DoxygenStrList[-1] = '@param' + ReturnTagList[0] + i = 1 + while i < len(ReturnTagList): + DoxygenStrList.append('@return' + ReturnTagList[i]) + i += 1 + + if len(DoxygenStrList) > 0: + DoxygenStrList[-1] = DoxygenStrList[-1].rstrip('--*/') + + return DoxygenStrList + +def CheckGeneralDoxygenCommentLayout(Str, StartLine, ErrorMsgList, CommentId = -1, TableName = ''): + #/** --*/ @retval after @param + if not Str.startswith('/**'): + ErrorMsgList.append('Line %d : Comment does NOT have prefix /** ' % StartLine) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'Comment does NOT have prefix /** ', TableName, CommentId) + if not Str.endswith('**/'): + ErrorMsgList.append('Line %d : Comment does NOT have tail **/ ' % StartLine) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'Comment does NOT have tail **/ ', TableName, CommentId) + FirstRetvalIndex = Str.find('@retval') + LastParamIndex = Str.rfind('@param') + if (FirstRetvalIndex > 0) and (LastParamIndex > 0) and (FirstRetvalIndex < LastParamIndex): + ErrorMsgList.append('Line %d : @retval appear before @param ' % StartLine) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'in Comment, @retval appear before @param ', TableName, CommentId) + +def CheckFunctionHeaderConsistentWithDoxygenComment(FuncModifier, FuncHeader, FuncStartLine, CommentStr, CommentStartLine, ErrorMsgList, CommentId = -1, TableName = ''): + + ParamList = GetParamList(FuncHeader) + CheckGeneralDoxygenCommentLayout(CommentStr, CommentStartLine, ErrorMsgList, CommentId, TableName) + DescriptionStr = CommentStr + DoxygenStrList = GetDoxygenStrFromComment(DescriptionStr) + if DescriptionStr.find('.') == -1: + PrintErrorMsg(ERROR_DOXYGEN_CHECK_COMMENT_DESCRIPTION, 'Comment description should end with period \'.\'', TableName, CommentId) + DoxygenTagNumber = len(DoxygenStrList) + ParamNumber = len(ParamList) + for Param in ParamList: + if Param.Name.upper() == 'VOID' and ParamNumber == 1: + ParamNumber -= 1 + Index = 0 + if ParamNumber > 0 and DoxygenTagNumber > 0: + while Index < ParamNumber and Index < DoxygenTagNumber: + ParamModifier = ParamList[Index].Modifier + ParamName = ParamList[Index].Name.strip() + Tag = DoxygenStrList[Index].strip(' ') + if (not Tag[-1] == ('\n')) and (not Tag[-1] == ('\r')): + ErrorMsgList.append('Line %d : in Comment, \"%s\" does NOT end with new line ' % (CommentStartLine, Tag.replace('\n', '').replace('\r', ''))) + PrintErrorMsg(ERROR_HEADER_CHECK_FUNCTION, 'in Comment, \"%s\" does NOT end with new line ' % (Tag.replace('\n', '').replace('\r', '')), TableName, CommentId) + TagPartList = Tag.split() + if len(TagPartList) < 2: + ErrorMsgList.append('Line %d : in Comment, \"%s\" does NOT contain doxygen contents ' % (CommentStartLine, Tag.replace('\n', '').replace('\r', ''))) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'in Comment, \"%s\" does NOT contain doxygen contents ' % (Tag.replace('\n', '').replace('\r', '')), TableName, CommentId) + Index += 1 + continue + LBPos = Tag.find('[') + RBPos = Tag.find(']') + ParamToLBContent = Tag[len('@param'):LBPos].strip() + if LBPos > 0 and len(ParamToLBContent)==0 and RBPos > LBPos: + InOutStr = '' + ModifierPartList = ParamModifier.split() + for Part in ModifierPartList: + if Part.strip() == 'IN': + InOutStr += 'in' + if Part.strip() == 'OUT': + if InOutStr != '': + InOutStr += ', out' + else: + InOutStr = 'out' + + if InOutStr != '': + if Tag.find('['+InOutStr+']') == -1: + ErrorMsgList.append('Line %d : in Comment, \"%s\" does NOT have %s ' % (CommentStartLine, (TagPartList[0] + ' ' +TagPartList[1]).replace('\n', '').replace('\r', ''), '['+InOutStr+']')) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'in Comment, \"%s\" does NOT have %s ' % ((TagPartList[0] + ' ' +TagPartList[1]).replace('\n', '').replace('\r', ''), '['+InOutStr+']'), TableName, CommentId) + if Tag.find(ParamName) == -1 and ParamName != 'VOID' and ParamName != 'void': + ErrorMsgList.append('Line %d : in Comment, \"%s\" does NOT consistent with parameter name %s ' % (CommentStartLine, (TagPartList[0] + ' ' +TagPartList[1]).replace('\n', '').replace('\r', ''), ParamName)) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'in Comment, \"%s\" does NOT consistent with parameter name %s ' % ((TagPartList[0] + ' ' +TagPartList[1]).replace('\n', '').replace('\r', ''), ParamName), TableName, CommentId) + Index += 1 + + if Index < ParamNumber: + ErrorMsgList.append('Line %d : Number of doxygen tags in comment less than number of function parameters' % CommentStartLine) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'Number of doxygen tags in comment less than number of function parameters ', TableName, CommentId) + # VOID return type, NOT VOID*. VOID* should be matched with a doxygen tag. + if (FuncModifier.find('VOID') != -1 or FuncModifier.find('void') != -1) and FuncModifier.find('*') == -1: + + # assume we allow a return description tag for void func. return. that's why 'DoxygenTagNumber - 1' is used instead of 'DoxygenTagNumber' + if Index < DoxygenTagNumber - 1 or (Index < DoxygenTagNumber and DoxygenStrList[Index].startswith('@retval')): + ErrorMsgList.append('Line %d : VOID return type need NO doxygen tags in comment' % CommentStartLine) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'VOID return type need no doxygen tags in comment ', TableName, CommentId) + else: + if Index < DoxygenTagNumber and not DoxygenStrList[Index].startswith('@retval') and not DoxygenStrList[Index].startswith('@return'): + ErrorMsgList.append('Line %d : Number of @param doxygen tags in comment does NOT match number of function parameters' % CommentStartLine) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'Number of @param doxygen tags in comment does NOT match number of function parameters ', TableName, CommentId) + else: + if ParamNumber == 0 and DoxygenTagNumber != 0 and ((FuncModifier.find('VOID') != -1 or FuncModifier.find('void') != -1) and FuncModifier.find('*') == -1): + ErrorMsgList.append('Line %d : VOID return type need NO doxygen tags in comment' % CommentStartLine) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'VOID return type need NO doxygen tags in comment ', TableName, CommentId) + if ParamNumber != 0 and DoxygenTagNumber == 0: + ErrorMsgList.append('Line %d : No doxygen tags in comment' % CommentStartLine) + PrintErrorMsg(ERROR_DOXYGEN_CHECK_FUNCTION_HEADER, 'No doxygen tags in comment ', TableName, CommentId) + +if __name__ == '__main__': + +# EdkLogger.Initialize() +# EdkLogger.SetLevel(EdkLogger.QUIET) +# CollectSourceCodeDataIntoDB(sys.argv[1]) + MsgList = CheckFuncHeaderDoxygenComments('C:\\Combo\\R9\\LakeportX64Dev\\FlashDevicePkg\\Library\\SpiFlashChipM25P64\\SpiFlashChipM25P64.c') + for Msg in MsgList: + print Msg + print 'Done!' diff --git a/BaseTools/Source/Python/Ecc/config.ini b/BaseTools/Source/Python/Ecc/config.ini new file mode 100644 index 0000000000..a3215aedaa --- /dev/null +++ b/BaseTools/Source/Python/Ecc/config.ini @@ -0,0 +1,242 @@ +## @file +# This file is used to set configuration of ECC tool +# For the items listed below, 1 means valid, 0 means invalid +# +# Copyright (c) 2007, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +# +# Identify the version of current configuration +# +Version = 0.1 + +# +# Identify to if check all items +# 1 - Check all items and ignore all other detailed items +# 0 - Not check all items, the tool will go through all other detailed items to decide to check or not +# +CheckAll = 0 + +# +# Identify to if automatically correct mistakes +# 1 - Automatically correct +# 0 - Not automatically correct +# Only the following check points can be automatically corrected, others not listed below are not supported even it is 1 +# +# GeneralCheckTab +# GeneralCheckIndentation +# GeneralCheckLine +# GeneralCheckCarriageReturn +# SpaceCheckAll +# +AutoCorrect = 1 + +# +# List customized Modifer here, split with ',' +# +ModifierList = IN, OUT, OPTIONAL, UNALIGNED, EFI_RUNTIMESERVICE, EFI_BOOTSERVICE, EFIAPI, TPMINTERNALAPI + +# +# General Checking +# +GeneralCheckAll = 0 + +# Check whether NO Tab is used, replaced with spaces +GeneralCheckNoTab = 1 +# The width of Tab +GeneralCheckTabWidth = 2 +# Check whether the indentation is followed coding style +GeneralCheckIndentation = 1 +# The width of indentation +GeneralCheckIndentationWidth = 2 +# Check whether no line is exceeding defined widty +GeneralCheckLine = 1 +# The width of a line +GeneralCheckLineWidth = 120 +# Check whether no use of _asm in the source file +GeneralCheckNo_Asm = 1 +# Check whether no use of "#progma" in source file except "#pragma pack(#)". +GeneralCheckNoProgma = 1 +# Check whether there is a carriage return at the end of the file +GeneralCheckCarriageReturn = 1 +# Check whether the file exists +GeneralCheckFileExistence = 1 + +# +# Space Checking +# +SpaceCheckAll = 1 + +# +# Predicate Expression Checking +# +PredicateExpressionCheckAll = 0 + +# Check whether Boolean values, variable type BOOLEAN not use explicit comparisons to TRUE or FALSE +PredicateExpressionCheckBooleanValue = 1 +# Check whether Non-Boolean comparisons use a compare operator (==, !=, >, < >=, <=). +PredicateExpressionCheckNonBooleanOperator = 1 +# Check whether a comparison of any pointer to zero must be done via the NULL type +PredicateExpressionCheckComparisonNullType = 1 + +# +# Headers Checking +# +HeaderCheckAll = 0 + +# Check whether File header exists +HeaderCheckFile = 1 +# Check whether Function header exists +HeaderCheckFunction = 1 + +# +# C Function Layout Checking +# +CFunctionLayoutCheckAll = 0 + +# Check whether return type exists and in the first line +CFunctionLayoutCheckReturnType = 1 +# Check whether any optional functional modifiers exist and next to the return type +CFunctionLayoutCheckOptionalFunctionalModifier = 1 +# Check whether the next line contains the function name, left justified, followed by the beginning of the parameter list +# Check whether the closing parenthesis is on its own line and also indented two spaces +CFunctionLayoutCheckFunctionName = 1 +# Check whether the function prototypes in include files have the same form as function definitions +CFunctionLayoutCheckFunctionPrototype = 1 +# Check whether the body of a function is contained by open and close braces that must be in the first column +CFunctionLayoutCheckFunctionBody = 1 +# Check whether the data declarations is the first code in a module. +CFunctionLayoutCheckDataDeclaration = 1 +# Check whether no initialization of a variable as part of its declaration +CFunctionLayoutCheckNoInitOfVariable = 1 +# Check whether no use of STATIC for functions +CFunctionLayoutCheckNoStatic = 1 + +# +# Include Files Checking +# +IncludeFileCheckAll = 0 + +#Check whether having include files with same name +IncludeFileCheckSameName = 1 +# Check whether all include file contents is guarded by a #ifndef statement. +# the #ifndef must be the first line of code following the file header comment +# the #endif must appear on the last line in the file +IncludeFileCheckIfndefStatement = 1 +# Check whether include files contain only public or only private data +# Check whether include files NOT contain code or define data variables +IncludeFileCheckData = 1 + +# +# Declarations and Data Types Checking +# +DeclarationDataTypeCheckAll = 0 + +# Check whether no use of int, unsigned, char, void, static, long in any .c, .h or .asl files. +DeclarationDataTypeCheckNoUseCType = 1 +# Check whether the modifiers IN, OUT, OPTIONAL, and UNALIGNED are used only to qualify arguments to a function and should not appear in a data type declaration +DeclarationDataTypeCheckInOutModifier = 1 +# Check whether the EFIAPI modifier should be used at the entry of drivers, events, and member functions of protocols +DeclarationDataTypeCheckEFIAPIModifier = 1 +# Check whether Enumerated Type has a 'typedef' and the name is capital +DeclarationDataTypeCheckEnumeratedType = 1 +# Check whether Structure Type has a 'typedef' and the name is capital +DeclarationDataTypeCheckStructureDeclaration = 1 +# Check whether having same Structure +DeclarationDataTypeCheckSameStructure = 1 +# Check whether Union Type has a 'typedef' and the name is capital +DeclarationDataTypeCheckUnionType = 1 + + +# +# Naming Conventions Checking +# +NamingConventionCheckAll = 0 + +# Check whether only capital letters are used for #define declarations +NamingConventionCheckDefineStatement = 1 +# Check whether only capital letters are used for typedef declarations +NamingConventionCheckTypedefStatement = 1 +# Check whether the #ifndef at the start of an include file uses both prefix and postfix underscore characters, '_'. +NamingConventionCheckIfndefStatement = 1 +# Rule for path name, variable name and function name +# 1. First character should be upper case +# 2. Existing lower case in a word +# 3. No space existence +# 4. Global variable name must start by a 'g' +# Check whether the path name followed the rule +NamingConventionCheckPathName = 1 +# Check whether the variable name followed the rule +NamingConventionCheckVariableName = 1 +# Check whether the function name followed the rule +NamingConventionCheckFunctionName = 1 +# Check whether NO use short variable name with single character +NamingConventionCheckSingleCharacterVariable = 1 + +# +# Doxygen Checking +# +DoxygenCheckAll = 0 + +# Check whether the file headers are followed Doxygen special documentation blocks in section 2.3.5 +DoxygenCheckFileHeader = 1 +# Check whether the function headers are followed Doxygen special documentation blocks in section 2.3.5 +DoxygenCheckFunctionHeader = 1 +# Check whether the first line of text in a comment block is a brief description of the element being documented. +# The brief description must end with a period. +DoxygenCheckCommentDescription = 1 +# Check whether comment lines with '///< ... text ...' format, if it is used, it should be after the code section. +DoxygenCheckCommentFormat = 1 +# Check whether only Doxygen commands allowed to mark the code are @bug and @todo. +DoxygenCheckCommand = 1 + +# +# Meta-Data File Processing Checking +# +MetaDataFileCheckAll = 0 + +# Check whether each file defined in meta-data exists +MetaDataFileCheckPathName = 1 +# Generate a list for all files defined in meta-data files +MetaDataFileCheckGenerateFileList = 1 +# The path of log file +MetaDataFileCheckPathOfGenerateFileList = File.log +# Check whether all Library Instances defined for a given module (or dependent library instance) match the module's type. +# Each Library Instance must specify the Supported Module Types in its INF file, +# and any module specifying the library instance must be one of the supported types. +MetaDataFileCheckLibraryInstance = 1 +# Check whether a Library Instance has been defined for all dependent library classes +MetaDataFileCheckLibraryInstanceDependent = 1 +# Check whether the Library Instances specified by the LibraryClasses sections are listed in order of dependencies +MetaDataFileCheckLibraryInstanceOrder = 1 +# Check whether the unnecessary inclusion of library classes in the INF file +MetaDataFileCheckLibraryNoUse = 1 +# Check whether an INF file is specified in the FDF file, but not in the DSC file, then the INF file must be for a Binary module only +MetaDataFileCheckBinaryInfInFdf = 1 +# Not to report error and warning related OS include file such as "windows.h" and "stdio.h". +# Check whether a PCD is set in a DSC file or the FDF file, but not in both. +MetaDataFileCheckPcdDuplicate = 1 +# Check whether PCD settings in the FDF file can only be related to flash. +MetaDataFileCheckPcdFlash = 1 +# Check whether PCDs used in INF files but not specified in DSC or FDF files +MetaDataFileCheckPcdNoUse = 1 +# Check whether having duplicate guids defined for Guid/Protocol/Ppi +MetaDataFileCheckGuidDuplicate = 1 +# Check whether all files under module directory are described in INF files +MetaDataFileCheckModuleFileNoUse = 1 +# Check whether the PCD is correctly used in C function via its type +MetaDataFileCheckPcdType = 1 + +# +# The check points in this section are reserved +# +# GotoStatementCheckAll = 0 +# SpellingCheckAll = 0 +# diff --git a/BaseTools/Source/Python/Ecc/exception.xml b/BaseTools/Source/Python/Ecc/exception.xml new file mode 100644 index 0000000000..0dc67527b5 --- /dev/null +++ b/BaseTools/Source/Python/Ecc/exception.xml @@ -0,0 +1,310 @@ + + + __debugbreak + 4002 + + + __readmsr + 4002 + + + __writemsr + 4002 + + + _InterlockedCompareExchange + 4002 + + + _InterlockedCompareExchange64 + 4002 + + + _InterlockedDecrement + 4002 + + + _InterlockedIncrement + 4002 + + + _break + 4002 + + + _inp + 4002 + + + _inpw + 4002 + + + _inpd + 4002 + + + _outp + 4002 + + + _outpw + 4002 + + + _outpd + 4002 + + + _ReadWriteBarrier + 4002 + + + InternalX86DisablePaging32 + 4002 + + + InternalX86EnablePaging32 + 4002 + + + InternalLongJump + 4002 + + + SetJump + 4002 + + + __debugbreak + 5001 + + + __readmsr + 5001 + + + __writemsr + 5001 + + + _InterlockedCompareExchange + 5001 + + + _InterlockedCompareExchange64 + 5001 + + + _InterlockedDecrement + 5001 + + + _InterlockedIncrement + 5001 + + + _inp + 5001 + + + _inpw + 5001 + + + _inpd + 5001 + + + _outp + 5001 + + + _outpw + 5001 + + + _outpd + 5001 + + + _ReadWriteBarrier + 5001 + + + IoRead8 + 5001 + + + IoWrite8 + 5001 + + + IoRead16 + 5001 + + + IoWrite16 + 5001 + + + IoRead32 + 5001 + + + IoWrite32 + 5001 + + + __debugbreak + 5003 + + + __readmsr + 5003 + + + __writemsr + 5003 + + + _InterlockedCompareExchange + 5003 + + + _InterlockedCompareExchange64 + 5003 + + + _InterlockedDecrement + 5003 + + + _InterlockedIncrement + 5003 + + + _inp + 5003 + + + _inpw + 5003 + + + _inpd + 5003 + + + _outp + 5003 + + + _outpw + 5003 + + + _outpd + 5003 + + + _ReadWriteBarrier + 5003 + + + __debugbreak + 7001 + + + __readmsr + 7001 + + + __writemsr + 7001 + + + _InterlockedCompareExchange + 7001 + + + _InterlockedCompareExchange64 + 7001 + + + _InterlockedDecrement + 7001 + + + _InterlockedIncrement + 7001 + + + _inp + 7001 + + + _inpw + 7001 + + + _inpd + 7001 + + + _outp + 7001 + + + _outpw + 7001 + + + _outpd + 7001 + + + _ReadWriteBarrier + 7001 + + + @ + 9005 + + + @R1 + 9005 + + + @R2 + 9005 + + + @Rx + 9005 + + + @R2. + 9005 + + + _DriverUnloadHandler + 8006 + + + ASSERT + 10015 + + + REPORT_STATUS_CODE + 10015 + + + REPORT_STATUS_CODE_WITH_EXTENDED_DATA + 10015 + + + REPORT_STATUS_CODE_WITH_DEVICE_PATH + 10015 + + \ No newline at end of file -- cgit v1.2.3